ThreeKingdomsSlingshot/Assets/Scripts/Runtime/Skills/SkillSystem.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace TKS
{
    /// <summary>유닛 1기의 스킬 상태(액티브 쿨·예약 · 패시브 · 행동 뒤에도 남는 값).</summary>
    public class UnitSkills
    {
        public Unit Unit;
        public string HeroId = "";
        /// <summary>무장(영웅·보스·엘리트 장수) — 남성·여성 「영웅」 조건 판정.</summary>
        public bool IsGeneral;

        public SkillDef Active;
        public int ActiveLv = 1;
        public List<SkillEffect> ActiveEffects;
        public SkillDef Passive;
        public int PassiveLv = 1;
        public float PassiveMult = 1f;
        public List<SkillEffect> PassiveEffects;

        // ---------- 전투 중 바뀌는 값(가상 실행이 떠 두고 되돌림 · CopyState) ----------
        /// <summary>액티브를 쓸 수 있는 첫 턴(전투 시작 = 1 · 사용 턴 + 쿨).</summary>
        public int ReadyTurn = 1;
        /// <summary>next_action 예약(다음 슬링샷 1회) · 행동 전 다시 탭 = 취소.</summary>
        public bool Reserved;
        /// <summary>예약한 효과가 지금 걸려 있다(그 유닛의 행동 처리·조준 미리보기 동안만).</summary>
        public bool Armed;
        /// <summary>즉시형 액티브를 시전하는 중(그 효과·조건 armed 를 질의에 보임).</summary>
        public bool Casting;
        /// <summary>보병 목표점 명중 추가 이동(유지 · PD 확인 대상).</summary>
        public int BonusMovesLeft;
        public bool BonusAttack;
        /// <summary>남은 재행동 · 재행동의 슬링 상한(감녕·고순 남은 거리 · 0 = 없음) · 이번 턴 재행동 수(여몽 패시브).</summary>
        public int ReactCredits;
        public float ReactLimit;
        public int ReactsThisTurn;
        /// <summary>여몽 백의도강 연쇄(남은 최대 · 피해·처치당 재행동).</summary>
        public int ChainLeft;
        public int ChainHitN;
        public int ChainKillN;
        public int Kills;
        public bool KillReactUsed;
        public int RevivesUsed;
        public int NegateUsed;
        public int AttackedStunCd;
        /// <summary>조인 수성: 남은 이동 비율(0~1 · 자기 턴 시작 = 1).</summary>
        public float UnusedMove = 1f;
        /// <summary>우금 진중: 쌓인 추가 이동(배) · 이번 라운드에 행동했나.</summary>
        public int Bank;
        public bool MovedThisRound;
        /// <summary>황개 고육계: 창 동안 받은 피해 → 다음 턴 공격력(가산).</summary>
        public float DmgTakenRound;
        public float AtkFlat;
        public int AtkFlatRounds;
        /// <summary>노숙: 쓰러진 자리 깃발(남은 턴 · 위치).</summary>
        public int BannerLeft;
        public Vector2 BannerPos;
        /// <summary>장비 만인지적: 행동 번호 · 대상별 (마지막 행동 번호, 연속 수).</summary>
        public int ActionSeq;
        public Dictionary<Unit, Vector2Int> Streak = new Dictionary<Unit, Vector2Int>();

        public bool HasActive
        {
            get { return Active != null && ActiveEffects != null; }
        }

        public int CooldownLeft(int turn)
        {
            return Mathf.Max(0, ReadyTurn - turn);
        }

        public UnitSkills CopyState()
        {
            var c = (UnitSkills)MemberwiseClone();
            c.Streak = new Dictionary<Unit, Vector2Int>(Streak);
            return c;
        }

        public void RestoreState(UnitSkills c)
        {
            ReadyTurn = c.ReadyTurn; Reserved = c.Reserved; Armed = c.Armed; Casting = c.Casting;
            BonusMovesLeft = c.BonusMovesLeft; BonusAttack = c.BonusAttack;
            ReactCredits = c.ReactCredits; ReactLimit = c.ReactLimit; ReactsThisTurn = c.ReactsThisTurn;
            ChainLeft = c.ChainLeft; ChainHitN = c.ChainHitN; ChainKillN = c.ChainKillN;
            Kills = c.Kills; KillReactUsed = c.KillReactUsed; RevivesUsed = c.RevivesUsed; NegateUsed = c.NegateUsed; AttackedStunCd = c.AttackedStunCd;
            UnusedMove = c.UnusedMove; Bank = c.Bank; MovedThisRound = c.MovedThisRound;
            DmgTakenRound = c.DmgTakenRound; AtkFlat = c.AtkFlat; AtkFlatRounds = c.AtkFlatRounds;
            BannerLeft = c.BannerLeft; BannerPos = c.BannerPos; ActionSeq = c.ActionSeq;
            Streak = new Dictionary<Unit, Vector2Int>(c.Streak);
        }

        public void ResetBattle()
        {
            ReadyTurn = 1;
            Reserved = Armed = Casting = BonusAttack = KillReactUsed = MovedThisRound = false;
            BonusMovesLeft = ReactCredits = ReactsThisTurn = ChainLeft = Kills = RevivesUsed = NegateUsed = AttackedStunCd = Bank = 0;
            ReactLimit = DmgTakenRound = AtkFlat = 0f;
            AtkFlatRounds = BannerLeft = ActionSeq = 0;
            UnusedMove = 1f;
            Streak.Clear();
        }
    }

    /// <summary>스킬 효과 1건이 어느 유닛·스킬에서 왔는가(SkillMods 질의 결과).</summary>
    public struct SkillHit
    {
        public UnitSkills Owner;
        public SkillDef Def;
        public SkillEffect E;
        public bool Passive;
        public SkillSystem.Timed Timed;
    }

    /// <summary>피해 종류 — 흡혈·명중 상태 이상·반격·호위가 어떤 피해에 붙는지.</summary>
    public enum HitKind
    {
        Attack,
        Counter,
        Skill,
        Dot,
        Gimmick,
        Indirect,
        Guard,
        Self
    }

    /// <summary>행동 1회의 스킬 맥락(돌진 거리 비율 · 맞힌 수 · 처치 · 지형).</summary>
    public class ActionCtx
    {
        public Unit Actor;
        public Vector2 Origin;
        public float SlingRatio;
        public int HitCount;
        public bool FirstHitDone;
        public int Kills;
        public bool DamagedEnemy;
        public bool HitTerrain;
        public int Seq;
        public readonly HashSet<Unit> MalesHit = new HashSet<Unit>();
        public readonly List<Unit> ZombieFrom = new List<Unit>();
    }

    /// <summary>스킬이 만든 지대(주유 불꽃 · 육손 불 장벽 · 장로 독지대) — 원 또는 선분 두께. 닿는 상대 = 즉시 피해 + 상태 이상(행동마다 1번 · 상대 턴 시작에 안에 있으면 1번).</summary>
    public class SkillZone
    {
        public UnitSkills Owner;
        public Faction Faction;
        public Vector2 A;
        public Vector2 B;
        public float Radius;
        public int RoundsLeft;
        public float Ratio;
        public string StatusKey;
        public SkillEffect Status;
        public GameObject View;
        /// <summary>같은 편도 닿으면 피해·상태 이상(육손 불 장벽 · PD 2026-11-10 #1112 결정 ⑬).</summary>
        public bool HitsAllies;
        public readonly HashSet<Unit> Touched = new HashSet<Unit>();

        public bool Affects(Unit u)
        {
            return u != null && (u.Faction != Faction || HitsAllies);
        }

        public float Distance(Vector2 p)
        {
            return Combat.SegmentPointDistance(A, B, p);
        }
    }

    /// <summary>
    /// 전투 1판의 스킬 처리(2026-11-10 #1112 · PD 엑셀 새 기획 · 효과 표 skill_effects.csv): 유닛별 스킬 상태 · 시한 효과(라운드) · 상태 이상 · 지대 ·
    /// 행동 전후 훅(예약 장착·쿨·재행동·출혈·중독) · 피해 적용(무적·무효화·호위·부활·흡혈·명중 상태 이상·처치 보상) · 회복 · 즉시형 액티브 · 턴 훅 · HUD 한 줄. 수치 질의 = SkillMods.
    /// </summary>
    public class SkillSystem
    {
        public static SkillSystem Current;
        /// <summary>테스트·자동 플레이: 행동 중 방향 탭(조조·하후돈)을 기다리지 않고 기본값(슬링 방향 · 제자리)으로.</summary>
        public static bool AutoTap;

        public class Timed
        {
            public UnitSkills Owner;
            public Faction Faction;
            public SkillDef Def;
            public SkillEffect E;
            /// <summary>대상 고정(range = 시전 순간 범위 안 같은 편 · 버프 받은 아군) · null = 대상 칸 규칙대로.</summary>
            public HashSet<Unit> Targets;
            /// <summary>남은 라운드(주인 진영 턴 시작마다 1 감소 · 0 = 끝).</summary>
            public int Rounds = 1;
        }

        public struct LogLine
        {
            public string Text;
            public float Time;
        }

        readonly BattleManager battle;
        readonly Dictionary<Unit, UnitSkills> map = new Dictionary<Unit, UnitSkills>();
        readonly List<UnitSkills> entries = new List<UnitSkills>();
        public readonly List<Timed> TimedEffects = new List<Timed>();
        public readonly List<LogLine> Log = new List<LogLine>();
        readonly HashSet<string> noted = new HashSet<string>();
        readonly int[] startCount = new int[2];
        readonly Dictionary<Unit, UnitStatus> statuses = new Dictionary<Unit, UnitStatus>();
        public readonly List<SkillZone> Zones = new List<SkillZone>();
        static readonly HashSet<Unit> summons = new HashSet<Unit>();

        /// <summary>지금 행동 중인 유닛의 맥락(BeginAction ~ EndAction).</summary>
        public ActionCtx Ctx { get; private set; }

        // ---------- 행동 중 탭(조조 밀칠 방향 · 하후돈 복귀 지점) · 장합 변진 목표 ----------

        public enum TapKind
        {
            None,
            Teleport,
            Aim,
            Return
        }

        public TapKind PendingKind { get; private set; }
        public Unit PendingUnit { get; private set; }
        public Vector2 PendingCenter { get; private set; }
        public float PendingRadius { get; private set; }
        Vector2? tapResult;

        /// <summary>장합 변진: 목표 지점 탭 대기 중인 유닛.</summary>
        public Unit PendingTeleport
        {
            get { return PendingKind == TapKind.Teleport ? PendingUnit : null; }
        }

        // 스킬 이펙트(SkillVfx · 2026-11-09): 지금 행동 중인 유닛 · 이펙트 표 키 · 돌진에 붙은 이펙트 · 이번 행동에 hit 이펙트를 띄운 대상
        Unit vfxActor;
        readonly List<string> vfxKeys = new List<string>();
        readonly List<SkillVfx.Handle> travelFx = new List<SkillVfx.Handle>();
        readonly HashSet<Unit> vfxHit = new HashSet<Unit>();

        void VfxBegin(Unit u, string skillKey, string basicKey, Vector2 dir, bool travel)
        {
            VfxEnd();
            vfxActor = u;
            if (!string.IsNullOrEmpty(skillKey)) vfxKeys.Add(skillKey);
            if (!string.IsNullOrEmpty(basicKey)) vfxKeys.Add(basicKey);
            if (!travel) return;
            if (!string.IsNullOrEmpty(basicKey) && !string.IsNullOrEmpty(SkillVfx.TestTravelKey)) vfxKeys.Add(SkillVfx.TestTravelKey);
            foreach (var k in vfxKeys) travelFx.Add(SkillVfx.Play(u, k, SkillVfx.EventTravel, dir));
        }

        /// <summary>슬링샷 직진(돌진) 구간 끝 — 돌진 이펙트(travel)만 멈춤.</summary>
        public void DashEnd(Unit u)
        {
            if (u == null || vfxActor != u) return;
            foreach (var h in travelFx) SkillVfx.Stop(h);
            travelFx.Clear();
        }

        /// <summary>같은 행동 안의 새 이동 구간(복귀 · 튕겨 다시 돌진) — 그 방향으로 돌진 이펙트를 다시 재생.</summary>
        public void DashBegin(Unit u, Vector2 dir)
        {
            if (u == null || vfxActor != u || dir.sqrMagnitude < 1e-6f) return;
            DashEnd(u);
            foreach (var k in vfxKeys) travelFx.Add(SkillVfx.Play(u, k, SkillVfx.EventTravel, dir.normalized));
        }

        void VfxEnd()
        {
            foreach (var h in travelFx) SkillVfx.Stop(h);
            travelFx.Clear();
            vfxActor = null;
            vfxKeys.Clear();
            vfxHit.Clear();
        }

        public SkillSystem(BattleManager b)
        {
            battle = b;
        }

        public BattleManager Battle
        {
            get { return battle; }
        }

        public IReadOnlyList<UnitSkills> Entries
        {
            get { return entries; }
        }

        BalanceConfig Cfg
        {
            get { return battle.Config; }
        }

        // ---------- 부착 ----------

        public UnitSkills Of(Unit u)
        {
            if (u == null) return null;
            UnitSkills s;
            return map.TryGetValue(u, out s) ? s : null;
        }

        UnitSkills Ensure(Unit u)
        {
            var s = Of(u);
            if (s != null) return s;
            s = new UnitSkills { Unit = u };
            map[u] = s;
            entries.Add(s);
            return s;
        }

        /// <summary>스킬 부착(액티브·패시브 id · 레벨 · ★5 패시브 배율 · 무장 여부). 자기 최대 HP 패시브(hp_max_pct 대상 = 자신)는 바로 반영.</summary>
        public UnitSkills Attach(Unit u, string activeId, int activeLv, string passiveId, int passiveLv, float passiveMult, bool general)
        {
            if (u == null) return null;
            var s = Ensure(u);
            s.IsGeneral = general;
            s.Active = SkillCatalog.Get(activeId);
            s.ActiveLv = Mathf.Max(1, activeLv);
            s.ActiveEffects = s.Active != null ? s.Active.ScaledEffects(s.ActiveLv, 1f) : null;
            s.Passive = SkillCatalog.Get(passiveId);
            s.PassiveLv = Mathf.Max(1, passiveLv);
            s.PassiveMult = passiveMult > 0f ? passiveMult : 1f;
            s.PassiveEffects = s.Passive != null ? s.Passive.ScaledEffects(s.PassiveLv, s.PassiveMult) : null;
            if (s.Passive != null) s.HeroId = s.Passive.HeroId;
            else if (s.Active != null) s.HeroId = s.Active.HeroId;

            float hp = 0f;
            if (s.PassiveEffects != null)
                foreach (var e in s.PassiveEffects)
                    if (e.Key == SkillKeys.HpMaxPct && e.Scope == SkillScope.Self) hp += e.P; // 같은 편 대상(진영)은 BeginBattle 에서
            ScaleMaxHp(u, hp);
            return s;
        }

        static void ScaleMaxHp(Unit u, float pct)
        {
            if (Mathf.Abs(pct) <= 1e-4f) return;
            u.MaxHp = Mathf.Max(1, Mathf.RoundToInt(u.MaxHp * (1f + pct)));
            u.Hp = u.MaxHp;
            if (u.View != null) u.View.Refresh();
        }

        /// <summary>액티브 쿨 = 표 cooldown · 최소 1.</summary>
        public int CooldownOf(UnitSkills s)
        {
            if (s == null || s.Active == null) return 1;
            return Mathf.Max(1, s.Active.Cooldown);
        }

        /// <summary>heroes.csv 영웅 id 로 부착(테스트·도구용) · 진영·성별도 유닛에 기록.</summary>
        public UnitSkills AttachHero(Unit u, string heroId, int activeLv = 1, int passiveLv = 1, float passiveMult = 1f, bool general = true)
        {
            var h = SkillCatalog.Hero(heroId);
            if (h == null) return null;
            if (u != null)
            {
                u.Camp = h.faction ?? "";
                u.Female = h.Female;
                u.HeroId = h.id;
            }
            return Attach(u, h.skillActive, activeLv, h.skillPassive, passiveLv, passiveMult, general && !h.isSoldier);
        }

        /// <summary>출전 칸(편성 → 스킬 id·레벨·★ 배율이 채워져 있음).</summary>
        public UnitSkills AttachLineup(Unit u, LineupEntry e)
        {
            if (e == null) return null;
            if (string.IsNullOrEmpty(e.skillActive) && string.IsNullOrEmpty(e.skillPassive))
            {
                if (e.general) Ensure(u).IsGeneral = true;
                return Of(u);
            }
            return Attach(u, e.skillActive, e.activeLv, e.skillPassive, e.passiveLv, e.passiveMult, e.general);
        }

        /// <summary>적 무장(보스·엘리트) = heroes.csv 같은 아트·이름 영웅의 패시브(Lv1) · withActive = 액티브도(적 AI · 1부 보스만 · PD #1098).</summary>
        public UnitSkills AttachEnemy(Unit u, BalanceConfig.EnemySpawn e, bool withActive = false)
        {
            if (u == null || e == null || !(e.isBoss || e.isGeneral)) return null;
            var h = SkillCatalog.HeroForEnemy(e.art, e.name);
            if (h == null)
            {
                var s = Ensure(u);
                s.IsGeneral = true;
                return s;
            }
            u.Camp = h.faction ?? "";
            u.Female = h.Female;
            u.HeroId = h.id;
            return Attach(u, withActive ? h.skillActive : null, 1, h.skillPassive, 1, 1f, true);
        }

        public void MarkGeneral(Unit u)
        {
            if (u != null) Ensure(u).IsGeneral = true;
        }

        public bool IsGeneral(Unit u)
        {
            if (u == null) return false;
            if (u.IsBoss) return true;
            var s = Of(u);
            return s != null && s.IsGeneral;
        }

        public static bool IsSummon(Unit u)
        {
            return u != null && summons.Contains(u);
        }

        public void Clear()
        {
            map.Clear();
            entries.Clear();
            TimedEffects.Clear();
            noted.Clear();
            ClearTap();
            startCount[0] = startCount[1] = 0;
            ClearStatuses();
            ClearZones();
            summons.Clear();
            Ctx = null;
            VfxEnd();
        }

        void ClearStatuses()
        {
            foreach (var kv in statuses)
                if (kv.Value.Badge != null) Object.Destroy(kv.Value.Badge.gameObject);
            statuses.Clear();
        }

        void ClearZones()
        {
            foreach (var z in Zones)
                if (z.View != null) Object.Destroy(z.View);
            Zones.Clear();
        }

        /// <summary>전투 시작(배치 뒤): 출전 인원 기록 · 쿨 = 바로 사용 가능 · 시한 효과·상태 이상 비움 · 같은 편 최대 HP 패시브(진영 대상).</summary>
        public void BeginBattle()
        {
            Prune();
            TimedEffects.Clear();
            noted.Clear();
            ClearTap();
            ClearStatuses();
            ClearZones();
            Ctx = null;
            startCount[0] = battle.AliveCount(Faction.Player);
            startCount[1] = battle.AliveCount(Faction.Enemy);
            foreach (var u in battle.Units)
            {
                if (u == null || !u.IsAlive) continue;
                float team = 0f;
                foreach (var h in SkillMods.Get(u, SkillKeys.HpMaxPct))
                    if (h.E.Scope != SkillScope.Self) team += h.E.P;
                ScaleMaxHp(u, team);
            }
            foreach (var s in entries) s.ResetBattle();
        }

        public int StartCount(Faction f)
        {
            return startCount[(int)f];
        }

        void Prune()
        {
            for (int i = entries.Count - 1; i >= 0; i--)
            {
                if (entries[i].Unit != null) continue;
                entries.RemoveAt(i);
            }
            var dead = new List<Unit>();
            foreach (var kv in map)
                if (kv.Key == null) dead.Add(kv.Key);
            foreach (var k in dead) map.Remove(k);
        }

        // ---------- 가상 실행(적 AI 예측)용 상태 사본 ----------

        public class State
        {
            public readonly List<KeyValuePair<UnitSkills, UnitSkills>> Entries = new List<KeyValuePair<UnitSkills, UnitSkills>>();
            public List<Timed> Timed;
            public readonly Dictionary<Unit, UnitStatus> Statuses = new Dictionary<Unit, UnitStatus>();
            public List<SkillZone> Zones;
            public int LogCount;
        }

        public State TakeState()
        {
            var st = new State { Timed = new List<Timed>(TimedEffects), Zones = new List<SkillZone>(Zones), LogCount = Log.Count };
            foreach (var e in entries) st.Entries.Add(new KeyValuePair<UnitSkills, UnitSkills>(e, e.CopyState()));
            foreach (var kv in statuses) st.Statuses[kv.Key] = kv.Value.Copy();
            return st;
        }

        public void RestoreState(State st)
        {
            if (st == null) return;
            foreach (var kv in st.Entries) kv.Key.RestoreState(kv.Value);
            TimedEffects.Clear();
            TimedEffects.AddRange(st.Timed);
            foreach (var z in Zones)
                if (!st.Zones.Contains(z) && z.View != null) Object.Destroy(z.View);
            Zones.Clear();
            Zones.AddRange(st.Zones);
            foreach (var kv in statuses)
            {
                UnitStatus old;
                if (st.Statuses.TryGetValue(kv.Key, out old)) continue;
                kv.Value.Clear(); // 가상 실행 중 새로 생긴 상태 = 비움(배지는 그대로 둠)
            }
            foreach (var kv in st.Statuses)
            {
                UnitStatus cur;
                if (!statuses.TryGetValue(kv.Key, out cur)) statuses[kv.Key] = kv.Value.Copy();
                else
                {
                    var badge = cur.Badge;
                    var copy = kv.Value.Copy();
                    copy.Badge = badge;
                    statuses[kv.Key] = copy;
                }
            }
            if (Log.Count > st.LogCount) Log.RemoveRange(st.LogCount, Log.Count - st.LogCount);
            Ctx = null;
        }

        // ---------- 턴 ----------

        /// <summary>적 턴 시작(동기): 쓰지 않은 예약·추가 이동 정리.</summary>
        public void OnEnemyTurnStart()
        {
            ClearTap();
            foreach (var s in entries)
            {
                s.Reserved = false;
                s.Armed = false;
                s.Casting = false;
                s.BonusMovesLeft = 0;
                s.BonusAttack = false;
            }
        }

        /// <summary>아군 턴 시작(동기) — 남은 것 없음(라운드 처리는 TurnBegin).</summary>
        public void OnPlayerTurnStart()
        {
        }

        /// <summary>
        /// side 진영 턴 시작(코루틴 · BattleManager 가 기믹 턴 시작 뒤에 부름): 상대 진영 턴 끝 처리(턴 종료 회복·정화 · 혼란·출혈 1 감소) →
        /// side 주인의 시한 효과 1 감소(고육계 이월) · 턴마다 초기화 · 깃발·소환 정리 → side 유닛 중독·화상 → 재생·지속 회복·턴 시작 회복 → side 지대 1 감소 · 상대 지대 안 유닛.
        /// </summary>
        public IEnumerator TurnBegin(Faction side)
        {
            bool any = false;
            Faction other = Other(side);
            any |= TurnEnd(other);

            // 고육계 이월 공격력은 자기 턴 1번 — 다음 자기 턴 시작에 사라짐(새 이월은 아래 시한 효과 만료에서)
            foreach (var s in entries)
            {
                if (s.Unit == null || s.Unit.Faction != side || s.AtkFlatRounds <= 0) continue;
                s.AtkFlat = 0f;
                s.AtkFlatRounds = 0;
            }

            // 지속 회복(방통 봉추의 계) = 라운드 감소·만료 전에 — dur n 이면 n 번 회복(Fable 검토 B1)
            foreach (var t in TimedEffects)
            {
                if (t.E.Key != SkillKeys.Hot || t.Faction != side || t.Owner == null || t.Owner.Unit == null) continue;
                int amt = Mathf.RoundToInt(AtkOf(t.Owner.Unit) * t.E.P);
                foreach (var u in battle.AliveUnits(side))
                    if (t.Targets == null ? u == t.Owner.Unit : t.Targets.Contains(u))
                        if (Heal(u, amt, t.Owner.Unit) > 0) any = true;
            }

            for (int i = TimedEffects.Count - 1; i >= 0; i--)
            {
                var t = TimedEffects[i];
                if (t.Faction != side) continue;
                if (--t.Rounds > 0) continue;
                TimedEffects.RemoveAt(i);
                if (t.E.Key == SkillKeys.DamageToAtk && t.Owner != null && t.Owner.DmgTakenRound > 0f)
                {
                    t.Owner.AtkFlat = t.Owner.DmgTakenRound; // 고육계: 받은 피해 → 이번 턴 공격력
                    t.Owner.AtkFlatRounds = 1;
                    t.Owner.DmgTakenRound = 0f;
                    if (t.Owner.Unit != null) Text(t.Owner.Unit, "공격 +" + Mathf.RoundToInt(t.Owner.AtkFlat), SkillFx.NameColor);
                    any = true;
                }
            }

            var gone = new List<Unit>();
            foreach (var s in entries)
            {
                var u = s.Unit;
                if (u == null || u.Faction != side) continue;
                s.KillReactUsed = false;
                s.ReactsThisTurn = 0;
                s.ReactCredits = 0;
                s.ReactLimit = 0f;
                s.ChainLeft = 0;
                if (s.AttackedStunCd > 0) s.AttackedStunCd--;
                if (s.BannerLeft > 0 && !u.IsAlive && --s.BannerLeft == 0) Text(u, "깃발 소멸", SkillFx.CostColor);
                if (u.IsAlive)
                {
                    s.UnusedMove = 1f;
                    var bank = Eff(s, SkillKeys.MoveBank);
                    if (bank != null && !s.MovedThisRound) s.Bank = Mathf.Min(Mathf.Max(0, Mathf.RoundToInt(bank.P) - 1), s.Bank + 1);
                    s.MovedThisRound = false;
                }
            }
            foreach (var z in summons)
                if (z == null || z.Faction == side) gone.Add(z); // 망령(스킬 항목 없음)은 소환 목록에서 직접
            foreach (var z in gone)
            {
                if (z != null && z.IsAlive) yield return ZombieAct(z); // 망령 = 자기 턴 시작에 1번 공격 후 소멸(PD #1112 결정 ⑩)
                summons.Remove(z);
                if (z != null) battle.RemoveUnit(z);
                any = true;
            }

            // 상태 이상(중독 · 화상) — side 유닛
            foreach (var u in battle.AliveUnits(side))
            {
                var st = StatusOf(u);
                if (st == null) continue;
                if (st.PoisonTurns > 0)
                {
                    PoisonTick(u, st);
                    st.PoisonTurns--;
                    if (st.PoisonTurns <= 0) st.PoisonStacks = 0;
                    any = true;
                }
                if (u.IsAlive && st.BurnTurns > 0)
                {
                    int d = Mathf.Max(1, Mathf.RoundToInt(u.MaxHp * st.BurnPct));
                    d = Hit(u, d, null, HitKind.Dot);
                    Text(u, "화상 −" + d, new Color(1f, 0.5f, 0.2f));
                    st.BurnTurns--;
                    any = true;
                }
                RefreshBadge(u);
            }

            // 회복: 재생(허저) · 지속 회복(방통) · 턴 시작 범위 회복(노숙 · 깃발)
            foreach (var u in battle.AliveUnits(side))
            {
                float regen = SkillMods.Sum(u, SkillKeys.RegenPct, true);
                if (regen > 0f && Heal(u, Mathf.RoundToInt(u.MaxHp * regen), u) > 0) any = true;
            }
            foreach (var s in entries)
            {
                var src = s.Unit;
                if (src == null || src.Faction != side || s.PassiveEffects == null) continue;
                if (!src.IsAlive && s.BannerLeft <= 0) continue;
                var e = Find(s.PassiveEffects, SkillKeys.TurnStartHealRange);
                if (e == null) continue;
                Vector2 c = src.IsAlive ? src.Position : s.BannerPos;
                foreach (var u in battle.AliveUnits(side))
                    if (Vector2.Distance(c, u.Position) <= SkillMods.BaseReach(src) + u.Radius)
                        if (Heal(u, Mathf.RoundToInt(u.MaxHp * e.P), src) > 0) any = true;
                NotePassive(s, s.Passive);
            }

            // 지대: side 주인 지대 1 감소 · 상대(side) 유닛이 상대 지대 안에 있으면 닿음 1번
            for (int i = Zones.Count - 1; i >= 0; i--)
            {
                var z = Zones[i];
                if (z.Faction == side && --z.RoundsLeft <= 0)
                {
                    if (z.View != null) Object.Destroy(z.View);
                    Zones.RemoveAt(i);
                    continue;
                }
                if (z.Faction == side && !z.HitsAllies) continue;
                z.Touched.Clear();
                foreach (var u in battle.AliveUnits(side))
                    if (z.Distance(u.Position) <= z.Radius + u.Radius * 0.5f)
                    {
                        ZoneTouch(z, u);
                        any = true;
                    }
            }

            if (any)
            {
                battle.NotifyChanged();
                yield return Fx.Wait(0.35f);
            }
        }

        bool HasTimed(UnitSkills s, string key)
        {
            foreach (var t in TimedEffects)
                if (t.Owner == s && t.E.Key == key) return true;
            return false;
        }

        /// <summary>side 진영 턴 끝(다음 진영 턴 시작에 부름): 턴 종료 회복·정화(소교·제갈량·방통) · 그 진영 유닛의 혼란·출혈 1 감소.</summary>
        bool TurnEnd(Faction side)
        {
            bool any = false;
            foreach (var t in TimedEffects)
            {
                if (t.E.Key != SkillKeys.TurnEndHeal || t.Faction != side || t.Owner == null || t.Owner.Unit == null || !t.Owner.Unit.IsAlive) continue;
                var src = t.Owner.Unit;
                int amt = Mathf.RoundToInt(AtkOf(src) * t.E.Get(1));
                foreach (var u in battle.AliveUnits(side))
                    if (Vector2.Distance(src.Position, u.Position) <= t.E.P + u.Radius && Heal(u, amt, src) > 0) any = true;
            }
            foreach (var s in entries)
            {
                var src = s.Unit;
                if (src == null || !src.IsAlive || src.Faction != side || s.PassiveEffects == null) continue;
                var lowest = Find(s.PassiveEffects, SkillKeys.TurnEndHealLowest);
                if (lowest != null)
                {
                    Unit pick = null;
                    foreach (var u in battle.AliveUnits(side))
                    {
                        if (Vector2.Distance(src.Position, u.Position) > lowest.P + u.Radius || u.Hp >= u.MaxHp) continue;
                        if (pick == null || (float)u.Hp / u.MaxHp < (float)pick.Hp / pick.MaxHp) pick = u;
                    }
                    if (pick != null && Heal(pick, Mathf.RoundToInt(AtkOf(src) * lowest.Get(1)), src) > 0)
                    {
                        NotePassive(s, s.Passive);
                        any = true;
                    }
                }
                var cl = Find(s.PassiveEffects, SkillKeys.TurnEndCleanse);
                if (cl != null)
                {
                    int n = Mathf.Max(1, Mathf.RoundToInt(cl.Get(1, 1f)));
                    foreach (var u in battle.AliveUnits(side))
                    {
                        if (n <= 0) break;
                        if (Vector2.Distance(src.Position, u.Position) > cl.P + u.Radius || !SkillStatus.HasAny(u)) continue;
                        Cleanse(u);
                        n--;
                        NotePassive(s, s.Passive);
                        any = true;
                    }
                }
            }
            foreach (var kv in statuses)
            {
                var u = kv.Key;
                if (u == null || u.Faction != side) continue;
                var st = kv.Value;
                if (st.ConfuseTurns > 0) st.ConfuseTurns--;
                if (st.BleedTurns > 0) st.BleedTurns--;
                if (st.ConfuseTurns <= 0) st.ConfuseMult = 1f;
                RefreshBadge(u);
            }
            return any;
        }

        static Faction Other(Faction f)
        {
            return f == Faction.Player ? Faction.Enemy : Faction.Player;
        }

        static SkillEffect Find(List<SkillEffect> l, string key)
        {
            if (l == null) return null;
            foreach (var e in l)
                if (e.Key == key) return e;
            return null;
        }

        /// <summary>그 유닛 스킬의 효과(패시브 · 지금 장착/시전 중인 액티브) 첫 줄.</summary>
        static SkillEffect Eff(UnitSkills s, string key)
        {
            if (s == null) return null;
            var e = Find(s.PassiveEffects, key);
            if (e != null) return e;
            return (s.Armed || s.Casting) ? Find(s.ActiveEffects, key) : null;
        }

        // ---------- 액티브: 상태 · 탭 ----------

        public enum ActiveState
        {
            None,
            Ready,
            Reserved,
            Cooldown,
            Acted,
            BonusMove,
            NotTurn,
            Targeting
        }

        public ActiveState StateOf(Unit u)
        {
            var s = Of(u);
            if (u == null || s == null || !s.HasActive || u.Faction != Faction.Player || !u.IsAlive) return ActiveState.None;
            if (PendingTeleport == u) return ActiveState.Targeting;
            if (s.Reserved) return ActiveState.Reserved;
            if (battle.Phase != BattlePhase.PlayerTurn) return ActiveState.NotTurn;
            if (s.CooldownLeft(battle.TurnNumber) > 0) return ActiveState.Cooldown;
            if (s.Active.Trigger == SkillTrigger.NextAction)
            {
                if (u.BonusMoveAvailable) return ActiveState.BonusMove;
                if (!battle.CanAct(u)) return ActiveState.Acted;
            }
            return ActiveState.Ready;
        }

        /// <summary>HUD 스킬 버튼 탭: next_action = 예약/취소 · instant = 즉시 발동(변진 = 목표 지점 탭 대기). 반환 = 안내 문구.</summary>
        public string TapActive(Unit u)
        {
            var s = Of(u);
            var st = StateOf(u);
            switch (st)
            {
                case ActiveState.None: return null;
                case ActiveState.Targeting:
                    ClearTap();
                    return s.Active.NameKo + " 취소";
                case ActiveState.Reserved:
                    s.Reserved = false;
                    if (u.View != null) u.View.Refresh();
                    return s.Active.NameKo + " 예약 취소(쿨 소모 없음)";
                case ActiveState.NotTurn: return "아군 턴에만 쓸 수 있습니다";
                case ActiveState.Cooldown: return s.Active.NameKo + " — 쿨 " + s.CooldownLeft(battle.TurnNumber) + "턴";
                case ActiveState.Acted: return s.Active.NameKo + " — 이미 행동한 유닛";
                case ActiveState.BonusMove: return s.Active.NameKo + " — 추가 이동 중에는 예약할 수 없음";
            }
            if (s.Active.Trigger == SkillTrigger.NextAction)
            {
                s.Reserved = true;
                if (u.View != null) u.View.Refresh();
                return s.Active.NameKo + " 예약 — 다음 슬링샷에 발동 · 다시 탭 = 취소";
            }
            if (s.Active.First(SkillKeys.Teleport) != null)
            {
                PendingKind = TapKind.Teleport;
                PendingUnit = u;
                PendingCenter = u.Position;
                PendingRadius = TeleportRadius(s);
                return s.Active.NameKo + " — 반경 " + PendingRadius.ToString("0.#") + " 안 빈 곳을 탭(다른 곳 = 취소)";
            }
            battle.RunSkillRoutine(Instant(s));
            return s.Active.NameKo + " 발동!";
        }

        void ClearTap()
        {
            PendingKind = TapKind.None;
            PendingUnit = null;
            tapResult = null;
        }

        /// <summary>행동 중 방향·지점 탭 대기(조조 난세의 간웅 · 하후돈 맹장) — 적·가상 실행·자동 = 기본값.</summary>
        public IEnumerator WaitTap(Unit u, TapKind kind, Vector2 center, float radius, string message, Vector2 fallback, System.Action<Vector2> done)
        {
            if (Sim.Active || AutoTap || u == null || u.Faction != Faction.Player)
            {
                done(fallback);
                yield break;
            }
            PendingKind = kind;
            PendingUnit = u;
            PendingCenter = center;
            PendingRadius = radius;
            tapResult = null;
            battle.LastMessage = message;
            battle.NotifyChanged();
            while (tapResult == null && PendingKind == kind && u != null && u.IsAlive) yield return null;
            Vector2 r = tapResult ?? fallback;
            ClearTap();
            done(r);
        }

        /// <summary>화면 탭 → 대기 중이면 처리하고 true(변진 = 유효면 이동 · 아니면 취소 / 행동 중 탭 = 결과 지점).</summary>
        public bool TryTeleportTap(Vector2 w, out string message)
        {
            message = null;
            if (PendingKind == TapKind.Aim || PendingKind == TapKind.Return)
            {
                Vector2 d = w - PendingCenter;
                if (PendingRadius > 0f && d.magnitude > PendingRadius) w = PendingCenter + d.normalized * PendingRadius;
                tapResult = w;
                return true;
            }
            var u = PendingTeleport;
            if (u == null) return false;
            ClearTap();
            var s = Of(u);
            if (s == null || !u.IsAlive || battle.Phase != BattlePhase.PlayerTurn) return true;
            if (!TeleportValid(u, w))
            {
                message = s.Active.NameKo + " 취소 — 반경 안 빈 곳이 아님";
                return true;
            }
            battle.RunSkillRoutine(TeleportRoutine(s, w));
            message = s.Active.NameKo + " 발동!";
            return true;
        }

        // ---------- 행동 훅(ActionResolver.Resolve) ----------

        /// <summary>행동 시작: 예약한 next_action 효과를 장착(이동만인 추가 이동은 제외) · 발동 연출 · 행동 맥락(돌진 거리 비율).</summary>
        public void BeginAction(Unit u, bool moveOnly, ActionOutcome o, Vector2 dir = default(Vector2), float slingDist = 0f)
        {
            noted.Clear();
            var s = Of(u);
            bool armed = s != null && s.Reserved && s.HasActive && !moveOnly;
            if (armed)
            {
                s.Armed = true;
                o.SkillUsed = s.Active;
                Announce(s, s.Active, dir);
                var rh = Find(s.ActiveEffects, SkillKeys.ReactionOnHit);
                var rk = Find(s.ActiveEffects, SkillKeys.ReactionOnKill);
                if (rh != null || rk != null)
                {
                    s.ChainHitN = rh != null ? Mathf.RoundToInt(rh.P) : 0;
                    s.ChainKillN = rk != null ? Mathf.RoundToInt(rk.P) : 0;
                    s.ChainLeft = Mathf.Max(rh != null ? Mathf.RoundToInt(rh.Get(1, 1f)) : 0, rk != null ? Mathf.RoundToInt(rk.Get(1, 1f)) : 0);
                }
            }
            if (s != null) s.ActionSeq++;
            Ctx = new ActionCtx { Actor = u, Origin = u.Position, Seq = s != null ? s.ActionSeq : 0 };
            float max = SkillMods.SlingMax(u);
            Ctx.SlingRatio = max > 0.01f ? Mathf.Clamp01(slingDist / max) : 0f;
            if (s != null) s.ReactLimit = 0f; // 재행동 슬링 상한(감녕·고순)은 조준에서 이미 썼음 — 이 행동이 새로 주면 다시 생김
            VfxBegin(u, armed ? s.Active.Id : null, moveOnly ? null : SkillVfx.BasicKey(u.Type), dir, true);
        }

        /// <summary>
        /// 행동 끝: 움직인 유닛 출혈 · 행동한 유닛 중독 · 지대 닿음 · 초선 다중 남성 기절 · 조인·이각·우금 패시브 ·
        /// (장착) 재행동 · 아군 재행동(우금) · 지형 재행동(맹획) · 지속 효과 시작 · 예약 소모 · 쿨 → 여몽 연쇄 → 장로 망령.
        /// </summary>
        public IEnumerator EndAction(Unit u, ActionOutcome o)
        {
            var s = Of(u);
            var ctx = Ctx;
            if (vfxActor == u) VfxEnd();

            var moved = MovedDistances(u, o);
            ApplyBleed(moved);
            if (u.IsAlive)
            {
                var st = StatusOf(u);
                if (st != null && st.PoisonTurns > 0) PoisonTick(u, st); // 중독 = 행동 종료 시점에도(가후·축융 정의)
            }
            ZoneSweep(u, o);
            AxeSweep(u, o);

            if (ctx != null && ctx.Actor == u)
            {
                var mm = SkillMods.First(u, SkillKeys.MultiMaleStun);
                if (mm != null && ctx.MalesHit.Count >= Mathf.RoundToInt(mm.P))
                    foreach (var m in ctx.MalesHit)
                        if (m != null && m.IsAlive && Roll(mm.Get(1, 1f))) ApplyStun(m, Mathf.Max(1, Mathf.RoundToInt(mm.Get(2, 1f))), "매혹 기절");
            }

            if (s != null && u.IsAlive)
            {
                float pathLen = PathLength(o.Path);
                s.MovedThisRound = true;
                s.Bank = 0;
                var heal = Find(s.PassiveEffects, SkillKeys.HealOnActionEnd);
                if (heal != null && Heal(u, Mathf.RoundToInt(u.MaxHp * heal.P), u) > 0) NotePassive(s, s.Passive);
                if (Find(s.PassiveEffects, SkillKeys.UnusedMoveDr) != null)
                    s.UnusedMove = Mathf.Clamp01(1f - pathLen / Mathf.Max(0.1f, SkillMods.SlingMax(u)));
                Sacrifice(s);
            }

            if (s != null && s.Armed)
            {
                foreach (var e in s.ActiveEffects)
                {
                    if (e.Dur > 0) AddTimed(s, e, e.Scope == SkillScope.Range ? InRange(u) : null, e.Dur);
                    else if (e.Key == SkillKeys.ExtraAction) s.ReactCredits += Mathf.Max(0, Mathf.RoundToInt(e.P));
                    else if (e.Key == SkillKeys.ReactionOnTerrain && ctx != null && ctx.HitTerrain) s.ReactCredits += Mathf.Max(0, Mathf.RoundToInt(e.P));
                    else if (e.Key == SkillKeys.AllyHitReaction)
                        foreach (var p in o.Pushed)
                            if (p != null && p != u && p.IsAlive && p.Faction == u.Faction && p.ActedThisTurn)
                            {
                                p.GrantReAction();
                                Text(p, "재행동", SkillFx.NameColor);
                            }
                }
                s.Armed = false;
                s.Reserved = false;
                s.ReadyTurn = battle.TurnNumber + CooldownOf(s);
                if (u.View != null) u.View.Refresh();
            }

            // 여몽 백의도강 연쇄: 피해 = +재행동 · 처치 = +재행동(남은 최대까지)
            if (s != null && s.ChainLeft > 0 && ctx != null && ctx.Actor == u)
            {
                int add = (ctx.DamagedEnemy ? s.ChainHitN : 0) + (ctx.Kills > 0 ? s.ChainKillN : 0);
                add = Mathf.Min(add, s.ChainLeft);
                s.ChainLeft -= add;
                s.ReactCredits += add;
                if (add == 0) s.ChainLeft = 0;
            }

            if (ctx != null && ctx.ZombieFrom.Count > 0 && !Sim.Active)
                foreach (var dead in ctx.ZombieFrom)
                    SpawnZombie(u, dead);
            yield return null;

            Ctx = null;
            battle.NotifyChanged();
        }

        /// <summary>재행동을 1회 쓴다(남았으면 true · 이번 턴 재행동 수 +1).</summary>
        public bool TakeReaction(Unit u)
        {
            var s = Of(u);
            if (s == null || s.ReactCredits <= 0 || !u.IsAlive) return false;
            s.ReactCredits--;
            s.ReactsThisTurn++;
            Text(u, "재행동!", SkillFx.NameColor);
            AddLog(u.DisplayName + " 재행동");
            return true;
        }

        /// <summary>재행동의 슬링 상한(감녕·고순 남은 거리)은 그 재행동 1회로 끝.</summary>
        public void ClearReactLimit(Unit u)
        {
            var s = Of(u);
            if (s != null && s.ReactCredits <= 0) s.ReactLimit = 0f;
        }

        /// <summary>조준 미리보기 동안만 예약 효과를 장착(사거리 · 사선 · 광역 표시). 반환 = 복원값.</summary>
        public bool PreviewBegin(Unit u)
        {
            var s = Of(u);
            if (s == null) return false;
            bool prev = s.Armed;
            if (s.Reserved && !u.BonusMoveAvailable) s.Armed = true;
            return prev;
        }

        public void PreviewEnd(Unit u, bool prev)
        {
            var s = Of(u);
            if (s != null) s.Armed = prev;
        }

        static float PathLength(List<Vector2> path)
        {
            float l = 0f;
            for (int i = 0; path != null && i < path.Count - 1; i++) l += Vector2.Distance(path[i], path[i + 1]);
            return l;
        }

        static Dictionary<Unit, float> MovedDistances(Unit actor, ActionOutcome o)
        {
            var m = new Dictionary<Unit, float>();
            if (actor != null) m[actor] = PathLength(o.Path);
            foreach (var d in o.Displaced)
            {
                if (d.Unit == null) continue;
                float v;
                m.TryGetValue(d.Unit, out v);
                m[d.Unit] = v + Vector2.Distance(d.From, d.To);
            }
            return m;
        }

        /// <summary>출혈 = 움직인 거리 / 자기 슬링 최대 × 최대 HP × 비율(서황 정의 「이동 거리의 50 %에 비례」 · PD 확인 대상).</summary>
        public void ApplyBleed(Dictionary<Unit, float> moved)
        {
            foreach (var kv in moved)
            {
                var u = kv.Key;
                if (u == null || !u.IsAlive || kv.Value < 0.05f) continue;
                var st = StatusOf(u);
                if (st == null || st.BleedTurns <= 0) continue;
                int d = Mathf.Max(1, Mathf.RoundToInt(u.MaxHp * st.BleedPct * kv.Value / Mathf.Max(0.1f, u.SlingMaxDistance)));
                d = Hit(u, d, null, HitKind.Dot);
                Text(u, "출혈 −" + d, new Color(0.9f, 0.15f, 0.2f));
            }
        }

        void PoisonTick(Unit u, UnitStatus st)
        {
            int d = Mathf.Max(1, Mathf.RoundToInt(u.MaxHp * st.PoisonPct * Mathf.Max(1, st.PoisonStacks)));
            d = Hit(u, d, null, HitKind.Dot);
            Text(u, "중독 −" + d, new Color(0.7f, 0.4f, 1f));
        }

        /// <summary>이각 패시브: 행동 끝 = HP p1 소모(10 % 이하면 소모 없이) → 인접(p3) 아군 공격 +p2 1턴 · 대상 없으면 발동 안 함.</summary>
        void Sacrifice(UnitSkills s)
        {
            var e = Find(s.PassiveEffects, SkillKeys.ActionEndSacrifice);
            var u = s.Unit;
            if (e == null || u == null || !u.IsAlive) return;
            var targets = new HashSet<Unit>();
            foreach (var a in battle.AliveUnits(u.Faction))
                if (a != u && SkillMods.Within(u, a, e.Get(2, 1.5f))) targets.Add(a);
            if (targets.Count == 0) return;
            if (u.Hp > u.MaxHp * e.P) PayHp(u, e.P);
            var buff = new SkillEffect { Key = SkillKeys.AtkPct, P = e.Get(1), Scope = SkillScope.Range, Dur = 1 };
            TimedEffects.Add(new Timed { Owner = s, Faction = u.Faction, Def = s.Passive, E = buff, Targets = targets, Rounds = 1 });
            foreach (var t in targets) Text(t, "공격 +" + Mathf.RoundToInt(buff.P * 100f) + "%", SkillFx.NameColor);
            NotePassive(s, s.Passive);
        }

        HashSet<Unit> InRange(Unit owner)
        {
            var set = new HashSet<Unit>();
            foreach (var a in battle.AliveUnits(owner.Faction))
                if (SkillMods.Within(owner, a, SkillMods.BaseReach(owner))) set.Add(a);
            return set;
        }

        // ---------- 추가 이동(보병 목표점 명중) ----------

        public bool BonusCanAttack(Unit u)
        {
            var s = Of(u);
            return s != null && s.BonusAttack;
        }

        /// <summary>행동 뒤 추가 이동을 (또) 주는가 — 처음 명중 = 1회 · 추가 이동 뒤 = 남은 횟수.</summary>
        public bool NextBonus(Unit u, bool wasBonus, ActionOutcome o)
        {
            var s = Of(u);
            if (!wasBonus)
            {
                if (!o.BonusMove) return false;
                if (s != null)
                {
                    s.BonusMovesLeft = Mathf.Max(0, o.BonusMoves - 1);
                    s.BonusAttack = o.BonusAttack;
                }
                return true;
            }
            if (s != null && s.BonusMovesLeft > 0)
            {
                s.BonusMovesLeft--;
                return true;
            }
            ClearBonus(u);
            return false;
        }

        public void ClearBonus(Unit u)
        {
            var s = Of(u);
            if (s == null) return;
            s.BonusMovesLeft = 0;
            s.BonusAttack = false;
        }

        /// <summary>이번 적 턴에 교전 반응이 없는가 — 기절은 지형 기믹 행동 불가(GimmickLayer.Skips)가 처리.</summary>
        public bool Suppressed(Unit e)
        {
            return false;
        }

        /// <summary>교전 범위 가산(새 기획에 없음 = 0).</summary>
        public float AggroAdd(Faction actingFaction)
        {
            return 0f;
        }

        // ---------- 피해 적용 ----------

        /// <summary>
        /// 피해 적용(by = 준 유닛 · kind = 종류): 무적(시한) → 무효화(조범) → 호위(관평·강유 · 강유 = 반격) → 고육계 누적 → 부활(유비·맹획) → HP 감소 →
        /// 준 쪽 보상(흡혈 · 사마의 흡수 · 명중 상태 이상 · 장비 연속 기절 · 하후은 첫 명중 추가 피해) → 맞은 쪽 반응(서황 도끼 · 간옹 기절 · 원술 혼란) → 처치 처리. 반환 = 실제 받은 피해.
        /// </summary>
        public int Hit(Unit d, int dmg, Unit by = null, HitKind kind = HitKind.Attack)
        {
            if (d == null || !d.IsAlive || dmg <= 0) return 0;
            bool crit = (kind == HitKind.Attack || kind == HitKind.Skill || kind == HitKind.Counter) && Combat.LastCrit;
            if (vfxActor != null && d.Faction != vfxActor.Faction && vfxHit.Add(d))
            {
                foreach (var k in vfxKeys) SkillVfx.Play(vfxActor, k, SkillVfx.EventHit, Vector2.zero, d);
                HitFeel.OnHit(vfxActor, d);
            }
            var ds = Of(d);
            if (kind != HitKind.Self && Invulnerable(d))
            {
                Text(d, "무적", SkillFx.GuardColor);
                return 0;
            }
            if (kind != HitKind.Self && ds != null && ds.PassiveEffects != null) // 조범 처세 「어떤 피해든」 = 상태 이상·지대 피해 포함(Fable 검토 C3)
            {
                var ng = Find(ds.PassiveEffects, SkillKeys.NegateHits);
                if (ng != null && ds.NegateUsed < Mathf.RoundToInt(ng.P))
                {
                    ds.NegateUsed++;
                    Text(d, "피해 무효", SkillFx.GuardColor);
                    NotePassive(ds, ds.Passive);
                    return 0;
                }
            }
            if (kind != HitKind.Guard && kind != HitKind.Dot && kind != HitKind.Self)
            {
                float gr;
                SkillEffect ge;
                var g = Guarder(d, out gr, out ge);
                if (g != null)
                {
                    int share = Mathf.Clamp(Mathf.RoundToInt(dmg * Mathf.Clamp01(ge.Get(1, 1f))), 0, dmg);
                    if (share > 0)
                    {
                        float dr = 1f + SkillMods.Sum(g, SkillKeys.GuardDr);
                        int took = Hit(g, Mathf.Max(1, Mathf.RoundToInt(share * Mathf.Max(0f, dr))), by, HitKind.Guard);
                        Fx.Popup(g.Position, took + " 호위", SkillFx.GuardColor);
                        NotePassive(Of(g), Of(g).Passive);
                        dmg -= share;
                        if (ge.Key == SkillKeys.GuardCounter && by != null && by.IsAlive && g.IsAlive && kind == HitKind.Attack)
                        {
                            int c = Combat.CounterDamage(Cfg, g, by, battle.Rng);
                            if (c > 0)
                            {
                                c = Hit(by, c, g, HitKind.Counter);
                                Fx.Popup(by.Position, c + " 호위 반격", new Color(1f, 0.45f, 0.45f));
                            }
                        }
                        if (dmg <= 0) return 0;
                    }
                }
            }
            if (ds != null && dmg > 0 && HasTimed(ds, SkillKeys.DamageToAtk)) ds.DmgTakenRound += Mathf.Min(dmg, d.Hp);

            int before = d.Hp;
            if (dmg >= d.Hp && TryRevive(d, ds, before))
            {
                // 부활을 부른 타격도 준 쪽 효과(흡혈·첫 명중·연속 기절·명중 상태 이상) · 맞은 쪽 반응 — 처치는 아님(Fable 검토 C7)
                if (by != null && by.Faction != d.Faction) OnDealt(by, d, before, kind, crit);
                if (d.IsAlive && by != null && by.IsAlive && by.Faction != d.Faction && kind == HitKind.Attack) OnAttacked(d, by);
                return before;
            }
            d.TakeDamage(dmg);
            int dealt = before - d.Hp;
            if (by != null && by.Faction != d.Faction) OnDealt(by, d, dealt, kind, crit);
            if (d.IsAlive && by != null && by.IsAlive && by.Faction != d.Faction && kind == HitKind.Attack) OnAttacked(d, by);
            if (!d.IsAlive) OnDeath(d, by);
            return dealt;
        }

        /// <summary>스킬 시스템이 없어도 쓰는 피해 적용.</summary>
        public static int Deal(Unit d, int dmg, Unit by = null, HitKind kind = HitKind.Attack)
        {
            if (Current != null) return Current.Hit(d, dmg, by, kind);
            if (d == null) return 0;
            d.TakeDamage(dmg);
            return dmg;
        }

        bool Invulnerable(Unit d)
        {
            foreach (var t in TimedEffects)
            {
                if (t.E.Key != SkillKeys.Invuln) continue;
                if (t.Targets != null ? t.Targets.Contains(d) : (t.Owner != null && t.Owner.Unit == d)) return true;
            }
            return false;
        }

        /// <summary>d 를 대신 맞아 줄 호위(관평 호위 · 강유 반격 범위 · 시한 범위 배율) — 가장 가까운 1기.</summary>
        Unit Guarder(Unit d, out float radius, out SkillEffect effect)
        {
            radius = 0f;
            effect = null;
            Unit best = null;
            float bestD = float.MaxValue;
            foreach (var s in entries)
            {
                var g = s.Unit;
                if (g == null || g == d || !g.IsAlive || g.Faction != d.Faction || s.PassiveEffects == null) continue;
                var e = Find(s.PassiveEffects, SkillKeys.Guard) ?? Find(s.PassiveEffects, SkillKeys.GuardCounter);
                if (e == null) continue;
                float r = e.P * Mathf.Max(0f, SkillMods.Product(g, SkillKeys.GuardRadiusMult));
                float dist = Vector2.Distance(g.Position, d.Position);
                if (dist > r + d.Radius || dist >= bestD) continue;
                best = g;
                bestD = dist;
                radius = r;
                effect = e;
            }
            return best;
        }

        bool TryRevive(Unit d, UnitSkills ds, int before)
        {
            if (ds == null || ds.PassiveEffects == null) return false;
            var e = Find(ds.PassiveEffects, SkillKeys.Revive);
            if (e == null || ds.RevivesUsed >= Mathf.RoundToInt(e.Get(1, 1f))) return false;
            float need = e.Get(2, 0f);
            if (need > 0f && before < d.MaxHp * need) return false; // 맹획: 맞기 전 HP 가 조건 미만 = 즉사
            ds.RevivesUsed++;
            d.Hp = Mathf.Max(1, Mathf.RoundToInt(d.MaxHp * Mathf.Clamp01(e.P)));
            if (d.View != null)
            {
                d.View.OnHit();
                d.View.Refresh();
            }
            Text(d, "부활!", SkillFx.HealColor);
            NotePassive(ds, ds.Passive);
            AddLog("패시브 · " + d.DisplayName + " 「" + ds.Passive.NameKo + "」 부활");
            return true;
        }

        /// <summary>준 쪽: 흡혈(조건 = 상대) · 반격 흡혈 · 사마의 흡수 · 행동 맥락(맞힌 수 · 남성 · 첫 명중) · 명중 상태 이상 · 장비 연속 피해 기절.</summary>
        void OnDealt(Unit by, Unit d, int dealt, HitKind kind, bool crit)
        {
            if (dealt <= 0) return;
            if (by.IsAlive && (kind == HitKind.Attack || kind == HitKind.Skill || kind == HitKind.Counter))
            {
                float ls = 0f;
                foreach (var h in SkillMods.Get(by, SkillKeys.Lifesteal, d))
                {
                    ls += h.E.P + (h.E.HasA2 ? h.E.A2 * SkillMods.DeadAllies(by) : 0f);
                    if (h.Passive) NotePassive(h.Owner, h.Def);
                }
                if (kind == HitKind.Counter) ls += SkillMods.Sum(by, SkillKeys.CounterLifesteal, true);
                if (ls > 0f) Heal(by, Mathf.RoundToInt(dealt * ls), by);
            }
            foreach (var s in entries)
            {
                var sm = s.Unit;
                if (sm == null || !sm.IsAlive || sm.Faction == d.Faction || s.PassiveEffects == null) continue;
                var dr = Find(s.PassiveEffects, SkillKeys.DrainAura);
                if (dr == null || !SkillMods.Within(sm, d, SkillMods.BaseReach(sm))) continue;
                if (Heal(sm, Mathf.RoundToInt(dealt * dr.P), sm) > 0) NotePassive(s, s.Passive);
            }
            var ctx = Ctx;
            bool actor = ctx != null && ctx.Actor == by;
            if (actor && (kind == HitKind.Attack || kind == HitKind.Skill))
            {
                ctx.HitCount++;
                ctx.DamagedEnemy = true;
                if (!d.Female) ctx.MalesHit.Add(d);
            }
            if (kind == HitKind.Attack || kind == HitKind.Skill || kind == HitKind.Indirect || kind == HitKind.Gimmick)
                ApplyHitStatuses(by, d, crit, kind);
            if (actor && kind == HitKind.Attack && !ctx.FirstHitDone)
            {
                ctx.FirstHitDone = true;
                float fb = SkillMods.Sum(by, SkillKeys.FirstHitBonus, true, d);
                if (fb > 0f && d.IsAlive)
                {
                    int extra = Mathf.Max(1, Mathf.RoundToInt(AtkOf(by, d) * fb));
                    extra = Hit(d, extra, by, HitKind.Skill);
                    Fx.Popup(d.Position + new Vector2(0f, 0.3f), "+" + extra, SkillFx.NameColor);
                }
            }
            if (actor && kind == HitKind.Attack)
            {
                var bs = Of(by);
                var dh = Eff(bs, SkillKeys.DoubleHitStun);
                if (dh != null && d.IsAlive)
                {
                    Vector2Int v;
                    bs.Streak.TryGetValue(d, out v);
                    if (v.x != ctx.Seq)
                    {
                        v.y = v.x == ctx.Seq - 1 ? v.y + 1 : 1;
                        v.x = ctx.Seq;
                        if (v.y >= Mathf.RoundToInt(dh.P))
                        {
                            ApplyStun(d, Mathf.Max(1, Mathf.RoundToInt(dh.Get(1, 1f))), "연속 피해 기절");
                            v.y = 0;
                            NotePassive(bs, bs.Passive);
                        }
                        bs.Streak[d] = v;
                    }
                }
            }
        }

        /// <summary>명중 상태 이상(hit_*): 조건(치명타·상대) · 확률 p3 · 간접(밀린 아군·지형) = 고순(hit_stun p2 1)만.</summary>
        public void ApplyHitStatuses(Unit by, Unit d, bool crit, HitKind kind)
        {
            if (by == null || d == null || !d.IsAlive || by.Faction == d.Faction) return;
            bool indirect = kind == HitKind.Indirect || kind == HitKind.Gimmick;
            foreach (var h in SkillMods.Get(by, SkillKeys.HitStun, d, crit))
                if ((!indirect || h.E.Get(1) >= 0.5f) && Roll(h.E.Get(2, 1f)))
                {
                    ApplyStun(d, Mathf.Max(1, Mathf.RoundToInt(h.E.P)), "기절");
                    NoteHit(h);
                }
            if (indirect) return;
            foreach (var h in SkillMods.Get(by, SkillKeys.HitBleed, d, crit))
                if (Roll(h.E.Get(2, 1f)))
                {
                    ApplyBleedStatus(d, Mathf.RoundToInt(h.E.P), h.E.Get(1, 0.5f));
                    NoteHit(h);
                }
            // 중독 = 한 번 명중에 1회만(액티브·패시브가 함께 걸려도 중첩 +1 · 가장 긴 턴·큰 비율 · Fable 검토 C1)
            int pTurns = 0;
            float pPct = 0f;
            foreach (var h in SkillMods.Get(by, SkillKeys.HitPoison, d, crit))
                if (Roll(h.E.Get(2, 1f)))
                {
                    pTurns = Mathf.Max(pTurns, Mathf.RoundToInt(h.E.P));
                    pPct = Mathf.Max(pPct, h.E.Get(1, 0.02f));
                    NoteHit(h);
                }
            if (pTurns > 0)
            {
                int max = 1;
                foreach (var ps in SkillMods.Get(by, SkillKeys.PoisonStack)) max = Mathf.Max(max, Mathf.RoundToInt(ps.E.P));
                ApplyPoison(d, pTurns, pPct, max);
            }
            foreach (var h in SkillMods.Get(by, SkillKeys.HitBurn, d, crit))
                if (Roll(h.E.Get(2, 1f)))
                {
                    ApplyBurn(d, Mathf.RoundToInt(h.E.P), h.E.Get(1, 0.05f));
                    NoteHit(h);
                }
            foreach (var h in SkillMods.Get(by, SkillKeys.HitConfuse, d, crit))
                if (Roll(h.E.Get(2, 1f)))
                {
                    ApplyConfuse(d, Mathf.RoundToInt(h.E.P), h.E.Get(1, 0.5f));
                    NoteHit(h);
                }
            foreach (var h in SkillMods.Get(by, SkillKeys.HitPush, d, crit))
            {
                Vector2 dir = d.Position - by.Position;
                if (dir.sqrMagnitude < 1e-6f) continue;
                Shove(d, dir.normalized, h.E.P * by.SlingMaxDistance, by);
                NoteHit(h);
            }
        }

        void NoteHit(SkillHit h)
        {
            if (h.Passive) NotePassive(h.Owner, h.Def);
        }

        bool Roll(float chance)
        {
            if (chance >= 0.999f) return true;
            if (chance <= 0f) return false;
            if (Sim.Active) return chance >= 0.5f; // 가상 실행 = 결정적
            return battle.Rng.NextDouble() < chance;
        }

        /// <summary>맞은 쪽(근접·원거리 공격을 받음 · 살아 있음): 서황 도끼 반격 · 간옹 기절(재충전) · 원술 혼란(확률).</summary>
        void OnAttacked(Unit d, Unit by)
        {
            var ds = Of(d);
            foreach (var h in SkillMods.Get(d, SkillKeys.AxeAura))
            {
                if (!by.IsAlive) break;
                if (Vector2.Distance(d.Position, by.Position) > d.Radius + by.Radius + h.E.P) continue;
                int ax = Mathf.Max(1, Mathf.RoundToInt(AtkOf(d, by) * h.E.Get(1, 0.8f)));
                ax = Hit(by, ax, d, HitKind.Skill);
                Fx.Popup(by.Position, ax + " 도끼", SkillFx.NameColor);
                break;
            }
            if (ds == null || ds.PassiveEffects == null || !by.IsAlive) return;
            var st = Find(ds.PassiveEffects, SkillKeys.OnAttackedStun);
            if (st != null && ds.AttackedStunCd <= 0)
            {
                ApplyStun(by, Mathf.Max(1, Mathf.RoundToInt(st.P)), "말재주 기절");
                ds.AttackedStunCd = Mathf.Max(0, Mathf.RoundToInt(st.Get(1, 0f)));
                NotePassive(ds, ds.Passive);
            }
            var cf = Find(ds.PassiveEffects, SkillKeys.OnAttackedConfuse);
            if (cf != null && Roll(cf.Get(2, 1f)))
            {
                ApplyConfuse(by, Mathf.Max(1, Mathf.RoundToInt(cf.P)), cf.Get(1, 0.5f));
                NotePassive(ds, ds.Passive);
            }
        }

        /// <summary>처치: 무신 누적 · 처치 회복(문추·공손찬·고육계) · 파로 재행동(턴당) · 곽가 귀재(범위 안 처치 = 쿨 −·회복) · 한중의 교주(망령) · 노숙 깃발.</summary>
        void OnDeath(Unit d, Unit by)
        {
            var dsk = Of(d);
            if (dsk != null && dsk.PassiveEffects != null)
            {
                var bn = Find(dsk.PassiveEffects, SkillKeys.DeathBanner);
                if (bn != null)
                {
                    dsk.BannerLeft = Mathf.Max(1, Mathf.RoundToInt(bn.P));
                    dsk.BannerPos = d.Position;
                    Text(d, "깃발", SkillFx.NameColor);
                    NotePassive(dsk, dsk.Passive);
                }
            }
            if (by == null || by.Faction == d.Faction || summons.Contains(d)) return;
            var s = Of(by);
            if (s != null) s.Kills++;
            var ctx = Ctx;
            if (ctx != null && ctx.Actor == by) ctx.Kills++;
            if (!by.IsAlive) return;
            float hk = SkillMods.Sum(by, SkillKeys.HealOnKill, true);
            if (hk > 0f) Heal(by, Mathf.RoundToInt(by.MaxHp * hk), by);
            if (s != null && !s.KillReactUsed && Eff(s, SkillKeys.KillReaction) != null)
            {
                s.KillReactUsed = true;
                s.ReactCredits++;
                NotePassive(s, s.Passive);
            }
            foreach (var g in entries)
            {
                var gu = g.Unit;
                if (gu == null || !gu.IsAlive || gu.Faction != by.Faction || g.PassiveEffects == null) continue;
                var rw = Find(g.PassiveEffects, SkillKeys.KillInRangeReward);
                if (rw == null || Vector2.Distance(gu.Position, d.Position) > SkillMods.BaseReach(gu) + d.Radius) continue;
                if (s != null && s.HasActive) s.ReadyTurn = Mathf.Max(battle.TurnNumber, s.ReadyTurn - Mathf.RoundToInt(rw.P));
                Heal(by, Mathf.RoundToInt(by.MaxHp * rw.Get(1, 0f)), gu);
                NotePassive(g, g.Passive);
            }
            if (ctx != null && ctx.Actor == by && Eff(s, SkillKeys.Zombie) != null && !Sim.Active) ctx.ZombieFrom.Add(d);
        }

        /// <summary>
        /// 장로 한중의 교주: 처치한 적이 체력 1 로 같은 편 망령이 된다(조작 불가 · 상대 턴 동안 공격받을 수 있음) →
        /// 그 진영 다음 턴 시작(TurnBegin)에 가장 가까운 상대를 1번 공격하고 사라짐(PD 2026-11-10 #1112 결정 ⑩).
        /// </summary>
        void SpawnZombie(Unit owner, Unit dead)
        {
            if (owner == null || dead == null || battle.Board == null) return;
            var s = Of(owner);
            var e = Eff(s, SkillKeys.Zombie);
            var z = battle.SpawnUnit(dead.Type, owner.Faction, dead.Position, "망령 " + dead.DisplayName, 1f, 1f, false, dead.ArtId);
            z.Atk = dead.Atk;
            z.Hp = Mathf.Max(1, Mathf.RoundToInt(e != null ? e.P : 1f));
            z.MarkActed();
            summons.Add(z);
            if (z.View != null) z.View.Refresh();
            Text(z, "망령", SkillFx.NameColor);
            if (s != null) NotePassive(s, s.Passive);
            AddLog("망령 " + dead.DisplayName + " — 다음 턴 시작에 1번 공격 후 소멸");
        }

        /// <summary>망령의 자동 공격 1회(가장 가까운 상대 쪽으로 슬링 최대 거리까지).</summary>
        IEnumerator ZombieAct(Unit z)
        {
            if (z == null || !z.IsAlive || battle.Board == null) yield break;
            Unit foe = null;
            float best = float.MaxValue;
            foreach (var t in battle.AliveUnits(Other(z.Faction)))
            {
                float dd = Vector2.Distance(z.Position, t.Position);
                if (dd < best)
                {
                    best = dd;
                    foe = t;
                }
            }
            if (foe == null) yield break;
            yield return Fx.Wait(0.2f);
            var prevCtx = Ctx;
            Vector2 aim = foe.Position - z.Position;
            float max = SkillMods.SlingMax(z);
            if (aim.magnitude > max) aim = aim.normalized * max;
            var o = new ActionOutcome();
            yield return battle.Resolver.Resolve(z, battle.Board.ClampInside(z.Position + aim, z.Radius), false, o);
            Ctx = prevCtx;
        }

        // ---------- 상태 이상 ----------

        public UnitStatus StatusOf(Unit u, bool create = false)
        {
            if (u == null) return null;
            UnitStatus s;
            if (statuses.TryGetValue(u, out s)) return s;
            if (!create) return null;
            s = new UnitStatus();
            statuses[u] = s;
            return s;
        }

        /// <summary>자기 진영 턴 중에 걸리면 그 턴은 세지 않는다(다음 자기 턴부터).</summary>
        int TurnsFor(Unit u, int turns)
        {
            bool ownTurn = (u.Faction == Faction.Player && (battle.Phase == BattlePhase.PlayerTurn || (battle.Phase == BattlePhase.Resolving && Ctx != null && Ctx.Actor != null && Ctx.Actor.Faction == Faction.Player)))
                           || (u.Faction == Faction.Enemy && battle.Phase == BattlePhase.EnemyTurn);
            return turns + (ownTurn ? 1 : 0);
        }

        public void ApplyStun(Unit u, int turns, string why)
        {
            if (u == null || !u.IsAlive || turns <= 0) return;
            var g = GimmickLayer.Current;
            if (g != null) g.Stun(u, turns, why);
        }

        public void ApplyConfuse(Unit u, int turns, float mult)
        {
            if (u == null || !u.IsAlive || turns <= 0) return;
            var s = StatusOf(u, true);
            s.ConfuseTurns = Mathf.Max(s.ConfuseTurns, TurnsFor(u, turns));
            s.ConfuseMult = Mathf.Min(s.ConfuseTurns > 0 && s.ConfuseMult < 1f ? s.ConfuseMult : 1f, mult);
            Text(u, "혼란", SkillStatus.TextColor);
            RefreshBadge(u);
        }

        public void ApplyBleedStatus(Unit u, int turns, float pct)
        {
            if (u == null || !u.IsAlive || turns <= 0) return;
            var s = StatusOf(u, true);
            s.BleedTurns = Mathf.Max(s.BleedTurns, TurnsFor(u, turns));
            s.BleedPct = Mathf.Max(s.BleedPct, pct);
            Text(u, "출혈", new Color(0.9f, 0.15f, 0.2f));
            RefreshBadge(u);
        }

        public void ApplyPoison(Unit u, int turns, float pct, int maxStacks)
        {
            if (u == null || !u.IsAlive || turns <= 0) return;
            var s = StatusOf(u, true);
            s.PoisonStacks = s.PoisonTurns > 0 ? Mathf.Min(Mathf.Max(1, maxStacks), s.PoisonStacks + 1) : 1;
            s.PoisonTurns = Mathf.Max(s.PoisonTurns, turns);
            s.PoisonPct = Mathf.Max(s.PoisonPct, pct);
            Text(u, s.PoisonStacks > 1 ? "중독 ×" + s.PoisonStacks : "중독", new Color(0.7f, 0.4f, 1f));
            RefreshBadge(u);
        }

        public void ApplyBurn(Unit u, int turns, float pct)
        {
            if (u == null || !u.IsAlive || turns <= 0) return;
            var s = StatusOf(u, true);
            s.BurnTurns = Mathf.Max(s.BurnTurns, turns);
            s.BurnPct = Mathf.Max(s.BurnPct, pct);
            Text(u, "화상", new Color(1f, 0.5f, 0.2f));
            RefreshBadge(u);
        }

        /// <summary>상태 이상 제거 = 스킬 상태(혼란·출혈·중독·화상) + 지형 기믹 중독·행동 불가.</summary>
        public void Cleanse(Unit u)
        {
            if (u == null) return;
            var s = StatusOf(u);
            bool any = s != null && s.Any;
            if (s != null) s.Clear();
            if (GimmickLayer.Current != null) any |= GimmickLayer.Current.Cleanse(u);
            if (any) Text(u, "정화", SkillFx.HealColor);
            RefreshBadge(u);
        }

        void RefreshBadge(Unit u)
        {
            if (Sim.Active || u == null) return;
            var s = StatusOf(u);
            if (s == null) return;
            string t = SkillStatus.BadgeText(s);
            if (s.Badge == null)
            {
                if (t.Length == 0) return;
                s.Badge = TextUtil.CreateWorldText(u.transform, t, 0.24f, SkillStatus.TextColor, 6);
                s.Badge.gameObject.name = "SkillStatus";
                float top = u.View != null && u.View.HasArt ? -u.Radius * 0.55f + u.ArtHeight + 0.12f : u.Radius + 0.22f;
                s.Badge.transform.localPosition = new Vector3(0f, top + 1.05f, 0f);
            }
            s.Badge.text = t;
            s.Badge.gameObject.SetActive(t.Length > 0 && u.IsAlive);
        }

        // ---------- 회복 ----------

        /// <summary>공격력(효과 반영) — 「공격력의 X %」 회복·추가 피해 기준.</summary>
        public static float AtkOf(Unit u, Unit vs = null)
        {
            return u != null ? u.Atk * SkillMods.AttackMult(u, false, vs) : 0f;
        }

        /// <summary>회복(최대 HP 넘지 않음) · 간옹 패시브 = 회복한 대상 정화. 반환 = 실제 회복량.</summary>
        public int Heal(Unit u, int amount, Unit healer = null)
        {
            if (u == null || !u.IsAlive || amount <= 0) return 0;
            int before = u.Hp;
            u.Hp = Mathf.Min(u.MaxHp, u.Hp + amount);
            if (u.View != null && !Sim.Active) u.View.Refresh();
            int got = u.Hp - before;
            if (got > 0) Fx.Popup(u.Position, "+" + got, SkillFx.HealColor);
            if (healer != null && healer != u && SkillMods.Has(healer, SkillKeys.HealCleanse, true) && SkillStatus.HasAny(u)) Cleanse(u);
            return got;
        }

        void PayHp(Unit u, float ratio)
        {
            int cost = Mathf.RoundToInt(u.MaxHp * Mathf.Max(0f, ratio));
            if (cost <= 0) return;
            u.Hp = Mathf.Max(1, u.Hp - cost); // 스스로 쓰러지지는 않는다
            if (u.View != null && !Sim.Active)
            {
                u.View.OnHit();
                u.View.Refresh();
            }
            Fx.Popup(u.Position, "HP −" + cost, SkillFx.CostColor);
        }

        // ---------- 밀기(스킬) ----------

        /// <summary>스킬 밀기(원소 치명타 밀침 · 즉시형 광역 밀기): 벽·유닛·장애물에서 멈춤 · 움직인 거리 = 출혈.</summary>
        public float Shove(Unit t, Vector2 dir, float dist, Unit by)
        {
            if (t == null || !t.IsAlive || dist < 0.01f) return 0f;
            float force = dist * SkillMods.KnockbackTakenMult(t, true);
            float slide = Combat.FreeTravel(t, t.Position, dir, force, true, true, by);
            if (slide <= 0.01f) return 0f;
            Vector2 start = t.Position;
            Vector2 end = battle.Board.ClampInside(start + dir * slide, t.Radius);
            if (t.View != null && !Sim.Active) t.View.SetFacing(dir);
            t.Position = end;
            if (!Sim.Active)
            {
                t.transform.position = new Vector3(start.x, start.y, 0f);
                Fx.Run(Fx.MoveAlong(t.transform, start, end, Cfg.moveSpeed, null));
                t.Position = end; // 논리 위치는 바로(콜라이더 질의) · 그림은 따라감
            }
            float moved = Vector2.Distance(start, end);
            ApplyBleed(new Dictionary<Unit, float> { { t, moved } });
            return moved;
        }

        // ---------- 지대(주유 불꽃 · 육손 불 장벽 · 장로 독지대) ----------

        public SkillZone AddZone(UnitSkills owner, Vector2 a, Vector2 b, float radius, int rounds, float ratio, SkillEffect status, Color color, bool hitsAllies = false)
        {
            var z = new SkillZone { Owner = owner, Faction = owner.Unit.Faction, A = a, B = b, Radius = Mathf.Max(0.2f, radius), RoundsLeft = Mathf.Max(1, rounds), Ratio = ratio, Status = status, StatusKey = status != null ? status.Key : null, HitsAllies = hitsAllies };
            if (!Sim.Active)
            {
                var root = new GameObject("SkillZone");
                Vector2 mid = (a + b) * 0.5f;
                root.transform.position = new Vector3(mid.x, mid.y, 0f);
                float len = Vector2.Distance(a, b);
                if (len > 0.05f)
                {
                    var bar = ProceduralSprites.NewSprite(root.transform, "Body", ProceduralSprites.Square, color, 1f, -12);
                    bar.transform.localScale = new Vector3(len, z.Radius * 2f, 1f);
                    Vector2 d = b - a;
                    bar.transform.rotation = Quaternion.Euler(0f, 0f, Mathf.Atan2(d.y, d.x) * Mathf.Rad2Deg);
                }
                foreach (var p in new[] { a, b })
                {
                    var cap = ProceduralSprites.NewSprite(root.transform, "Cap", ProceduralSprites.Circle, color, z.Radius * 2f, -12);
                    cap.transform.position = new Vector3(p.x, p.y, 0f);
                }
                z.View = root;
            }
            Zones.Add(z);
            return z;
        }

        /// <summary>지대 닿음: 상대 = 주인 공격력 × 배율 피해 + 지대 상태 이상(행동마다 · 턴마다 1번).</summary>
        void ZoneTouch(SkillZone z, Unit u)
        {
            if (u == null || !u.IsAlive || !z.Affects(u) || !z.Touched.Add(u)) return;
            var src = z.Owner != null ? z.Owner.Unit : null;
            if (z.Ratio > 0f && src != null)
            {
                int d = Mathf.Max(1, Mathf.RoundToInt(Combat.SkillDamage(Cfg, src, u, z.Ratio, battle.Rng))); // 아군도 같은 피해(PD 결정 ⑬)
                d = Hit(u, d, src, HitKind.Dot);
                Text(u, (z.StatusKey == SkillKeys.HitPoison ? "독지대 −" : "불꽃 −") + d, new Color(1f, 0.55f, 0.25f));
            }
            if (z.Status != null && u.IsAlive)
            {
                if (z.StatusKey == SkillKeys.HitBurn || z.StatusKey == SkillKeys.ZoneBurn) ApplyBurn(u, Mathf.RoundToInt(z.Status.P), z.Status.Get(1, 0.05f));
                else if (z.StatusKey == SkillKeys.HitPoison) ApplyPoison(u, Mathf.RoundToInt(z.Status.P), z.Status.Get(1, 0.02f), 1);
            }
        }

        /// <summary>이 행동에서 움직인 상대 유닛의 경로가 지대와 겹치면 닿음(행동 유닛 경로 + 밀림·넉백 구간).</summary>
        void ZoneSweep(Unit actor, ActionOutcome o)
        {
            if (Zones.Count == 0) return;
            foreach (var z in Zones) z.Touched.Clear();
            var segs = new List<KeyValuePair<Unit, Vector4>>();
            for (int i = 0; actor != null && i < o.Path.Count - 1; i++) segs.Add(new KeyValuePair<Unit, Vector4>(actor, new Vector4(o.Path[i].x, o.Path[i].y, o.Path[i + 1].x, o.Path[i + 1].y)));
            foreach (var d in o.Displaced)
                if (d.Unit != null) segs.Add(new KeyValuePair<Unit, Vector4>(d.Unit, new Vector4(d.From.x, d.From.y, d.To.x, d.To.y)));
            foreach (var z in Zones)
                foreach (var kv in segs)
                {
                    var u = kv.Key;
                    if (u == null || !u.IsAlive || !z.Affects(u)) continue;
                    var s = kv.Value;
                    if (SegSegDistance(new Vector2(s.x, s.y), new Vector2(s.z, s.w), z.A, z.B) <= z.Radius + u.Radius * 0.5f) ZoneTouch(z, u);
                }
        }

        /// <summary>서황 대부: 도끼가 도는 동안 자신의 이동 경로 도끼 반경(p1)에 닿은 상대 = 공격력 × p2 추가 피해(행동마다 1번).</summary>
        void AxeSweep(Unit u, ActionOutcome o)
        {
            if (u == null || !u.IsAlive || o.Path.Count < 2) return;
            var axe = SkillMods.First(u, SkillKeys.AxeAura);
            if (axe == null) return;
            foreach (var e in battle.AliveUnits(Other(u.Faction)))
            {
                bool near = false;
                for (int i = 0; i < o.Path.Count - 1 && !near; i++)
                    near = Combat.SegmentPointDistance(o.Path[i], o.Path[i + 1], e.Position) <= u.Radius + e.Radius + axe.P;
                if (!near) continue;
                int d = Mathf.Max(1, Mathf.RoundToInt(AtkOf(u, e) * axe.Get(1, 0.8f)));
                d = Hit(e, d, u, HitKind.Skill);
                Fx.Popup(e.Position, d + " 도끼", SkillFx.NameColor);
            }
        }

        public static float SegSegDistance(Vector2 p1, Vector2 q1, Vector2 p2, Vector2 q2)
        {
            if (SegmentsIntersect(p1, q1, p2, q2)) return 0f;
            return Mathf.Min(Mathf.Min(Combat.SegmentPointDistance(p1, q1, p2), Combat.SegmentPointDistance(p1, q1, q2)),
                             Mathf.Min(Combat.SegmentPointDistance(p2, q2, p1), Combat.SegmentPointDistance(p2, q2, q1)));
        }

        static bool SegmentsIntersect(Vector2 a, Vector2 b, Vector2 c, Vector2 d)
        {
            float d1 = Cross(d - c, a - c), d2 = Cross(d - c, b - c), d3 = Cross(b - a, c - a), d4 = Cross(b - a, d - a);
            return ((d1 > 0f && d2 < 0f) || (d1 < 0f && d2 > 0f)) && ((d3 > 0f && d4 < 0f) || (d3 < 0f && d4 > 0f));
        }

        static float Cross(Vector2 a, Vector2 b)
        {
            return a.x * b.y - a.y * b.x;
        }

        // ---------- 즉시형 액티브 ----------

        /// <summary>즉시 발동(행동 소모 없음): 시전 중 효과 장착 → 처리기 → 지속 효과(dur) → 쿨.</summary>
        public IEnumerator Instant(UnitSkills s)
        {
            var u = s.Unit;
            Announce(s, s.Active);
            VfxBegin(u, s.Active.Id, null, Vector2.zero, false);
            s.ReadyTurn = battle.TurnNumber + CooldownOf(s);
            s.Casting = true;
            var prevCtx = Ctx;
            Ctx = new ActionCtx { Actor = u, Origin = u.Position, Seq = s.ActionSeq }; // 즉시형은 행동 번호를 올리지 않음(장비 연속 판정 · Fable 검토 C2)
            var moved = new Dictionary<Unit, float>();
            foreach (var e in s.ActiveEffects)
            {
                if (e.Dur > 0)
                {
                    AddTimed(s, e, e.Scope == SkillScope.Range ? InRange(u) : null, e.Dur);
                    continue;
                }
                switch (e.Key)
                {
                    case SkillKeys.AoeStrike:
                        yield return AoeStrike(s, e, moved);
                        break;
                    case SkillKeys.AoeDrain:
                        AoeDrain(s, e);
                        break;
                    case SkillKeys.Volley:
                        yield return Volley(s, e, moved);
                        break;
                    case SkillKeys.CharmPull:
                        yield return CharmPull(s, e, moved);
                        break;
                    case SkillKeys.HealAtk:
                    {
                        int amt = Mathf.RoundToInt(AtkOf(u) * e.P);
                        foreach (var t in e.Scope == SkillScope.Self ? new HashSet<Unit> { u } : InRange(u)) Heal(t, amt, u);
                        break;
                    }
                    case SkillKeys.Cleanse:
                        foreach (var t in e.Scope == SkillScope.Self ? new HashSet<Unit> { u } : InRange(u)) Cleanse(t);
                        break;
                    case SkillKeys.HealSelfPct:
                        Heal(u, Mathf.RoundToInt(u.MaxHp * Mathf.Max(0f, e.P)), u);
                        break;
                    case SkillKeys.GrantReaction:
                        GrantReaction(u, Mathf.Max(1, Mathf.RoundToInt(e.P)));
                        break;
                }
            }
            ApplyBleed(moved);
            s.Casting = false;
            Ctx = prevCtx;
            yield return Fx.Wait(0.25f);
            if (vfxActor == u) VfxEnd();
            battle.NotifyChanged();
        }

        /// <summary>한 유닛에게 거는 시한 버프(미축 지원 · 순욱 보급 = 아군 명중 시 이동·공격 %).</summary>
        public void AddBuff(UnitSkills owner, Unit target, string key, float value, int rounds)
        {
            if (owner == null || target == null || owner.Unit == null) return;
            var e = new SkillEffect { Key = key, P = value, Scope = SkillScope.Range, Dur = rounds };
            TimedEffects.Add(new Timed { Owner = owner, Faction = owner.Unit.Faction, Def = owner.Passive ?? owner.Active, E = e, Targets = new HashSet<Unit> { target }, Rounds = Mathf.Max(1, rounds) });
            Text(target, key == SkillKeys.AtkPct ? "공격 +" + Mathf.RoundToInt(value * 100f) + "%" : "이동 +" + Mathf.RoundToInt(value * 100f) + "%", SkillFx.NameColor);
        }

        void AddTimed(UnitSkills s, SkillEffect e, HashSet<Unit> targets, int rounds)
        {
            TimedEffects.Add(new Timed { Owner = s, Faction = s.Unit.Faction, Def = s.Active, E = e, Targets = targets, Rounds = Mathf.Max(1, rounds) });
        }

        /// <summary>관우 청룡언월 · 장비 장판 일갈 · 능통: 반경 p1 안 상대 전원 = 공격력 × p2 피해(0 = 없음) → 바깥으로 p3 밀기 · 명중 상태 이상(피해 없어도).</summary>
        IEnumerator AoeStrike(UnitSkills s, SkillEffect e, Dictionary<Unit, float> moved)
        {
            var u = s.Unit;
            float radius = e.P;
            var targets = new List<Unit>();
            foreach (var t in battle.AliveUnits(Other(u.Faction)))
                if (Vector2.Distance(u.Position, t.Position) <= radius + t.Radius) targets.Add(t);
            Fx.Burst(u.Position, radius, SkillFx.FearColor);
            if (u.View != null && !Sim.Active) u.View.PlayAttack();
            foreach (var t in targets)
            {
                bool crit = false;
                if (e.Get(1) > 0f)
                {
                    int d = Combat.SkillDamage(Cfg, u, t, e.Get(1), battle.Rng);
                    crit = Combat.LastCrit;
                    d = Hit(t, d, u, HitKind.Skill);
                    Fx.Popup(t.Position, crit ? d + "!" : d.ToString(), Color.white);
                }
                else ApplyHitStatuses(u, t, false, HitKind.Skill);
            }
            yield return Fx.Wait(0.15f);
            float push = e.Get(2);
            if (push > 0.01f)
            {
                targets.Sort((a, b) => Vector2.Distance(u.Position, b.Position).CompareTo(Vector2.Distance(u.Position, a.Position))); // 바깥부터
                foreach (var t in targets)
                {
                    if (!t.IsAlive) continue;
                    Vector2 dir = t.Position - u.Position;
                    dir = dir.sqrMagnitude > 1e-6f ? dir.normalized : Vector2.up;
                    float m = ShoveRaw(t, dir, push * SkillMods.KnockbackTakenMult(t, true), u);
                    if (m > 0f) AddMoved(moved, t, m);
                }
                yield return Fx.Wait(0.2f);
            }
            battle.NotifyChanged();
        }

        static void AddMoved(Dictionary<Unit, float> m, Unit u, float d)
        {
            float v;
            m.TryGetValue(u, out v);
            m[u] = v + d;
        }

        /// <summary>밀기(출혈은 호출 쪽이 모아서) — 반환 = 움직인 거리.</summary>
        float ShoveRaw(Unit t, Vector2 dir, float force, Unit by)
        {
            float slide = Combat.FreeTravel(t, t.Position, dir, force, true, true, by);
            if (slide <= 0.01f) return 0f;
            Vector2 start = t.Position;
            Vector2 end = battle.Board.ClampInside(start + dir * slide, t.Radius);
            if (t.View != null && !Sim.Active) t.View.SetFacing(dir);
            t.Position = end;
            if (!Sim.Active)
            {
                t.transform.position = new Vector3(start.x, start.y, 0f);
                Fx.Run(Fx.MoveAlong(t.transform, start, end, Cfg.moveSpeed, null));
                t.Position = end;
            }
            return Vector2.Distance(start, end);
        }

        /// <summary>사마의: 행동 반경 안 상대 전원 = 공격력 × p1 → 준 피해 합 × p2 를 반경 안 다른 아군 각각 회복.</summary>
        void AoeDrain(UnitSkills s, SkillEffect e)
        {
            var u = s.Unit;
            float r = SkillMods.BaseReach(u) * SkillMods.Product(u, SkillKeys.SplashRadiusMult, true); // 응시낭고 광역 배율(Fable 검토 B3)
            int total = 0;
            Fx.Burst(u.Position, r, Fx.SplashColor);
            foreach (var t in battle.AliveUnits(Other(u.Faction)))
            {
                if (!SkillMods.Within(u, t, r)) continue;
                int d = Hit(t, Combat.SkillDamage(Cfg, u, t, e.P, battle.Rng), u, HitKind.Skill);
                Fx.Popup(t.Position, d.ToString(), Color.white);
                total += d;
            }
            int amt = Mathf.RoundToInt(total * e.Get(1));
            foreach (var a in battle.AliveUnits(u.Faction))
                if (a != u && SkillMods.Within(u, a, r)) Heal(a, amt, u);
        }

        /// <summary>손상향 궁요희: 사거리 안 상대 전원에게 화살(공격력 × p1 · 치명타 판정) → 바깥으로 p2 밀기 · 치명타 = 출혈(조건 칸).</summary>
        IEnumerator Volley(UnitSkills s, SkillEffect e, Dictionary<Unit, float> moved)
        {
            var u = s.Unit;
            float range = SkillMods.Range(u);
            var targets = new List<Unit>();
            foreach (var t in battle.AliveUnits(Other(u.Faction)))
                if (Vector2.Distance(u.Position, t.Position) - t.Radius - u.Radius <= range) targets.Add(t);
            if (u.View != null && !Sim.Active) u.View.PlayAttack();
            foreach (var t in targets) Fx.Run(Fx.Arrow(u.Position, t.Position));
            yield return Fx.Wait(0.2f);
            foreach (var t in targets)
            {
                if (!t.IsAlive) continue;
                int d = Combat.SkillDamage(Cfg, u, t, e.P, battle.Rng);
                bool crit = Combat.LastCrit;
                d = Hit(t, d, u, HitKind.Skill);
                Fx.Popup(t.Position, crit ? d + "!" : d.ToString(), crit ? new Color(1f, 0.7f, 0.2f) : Color.white);
                if (t.IsAlive && e.Get(1) > 0.01f)
                {
                    Vector2 dir = (t.Position - u.Position).normalized;
                    float m = ShoveRaw(t, dir, e.Get(1) * SkillMods.KnockbackTakenMult(t, true), u);
                    if (m > 0f) AddMoved(moved, t, m);
                }
            }
            yield return Fx.Wait(0.15f);
        }

        /// <summary>초선 미인계: 행동 반경 안 상대 남성(p2 1) = p1 턴 행동 불가 + 자신 쪽으로 끌려옴(유닛·장애물에 막힘).</summary>
        IEnumerator CharmPull(UnitSkills s, SkillEffect e, Dictionary<Unit, float> moved)
        {
            var u = s.Unit;
            float r = SkillMods.BaseReach(u);
            bool maleOnly = e.Get(1, 1f) >= 0.5f;
            var targets = new List<Unit>();
            foreach (var t in battle.AliveUnits(Other(u.Faction)))
                if (SkillMods.Within(u, t, r) && (!maleOnly || !t.Female)) targets.Add(t);
            targets.Sort((a, b) => Vector2.Distance(u.Position, a.Position).CompareTo(Vector2.Distance(u.Position, b.Position)));
            Fx.Burst(u.Position, r, SkillFx.FearColor);
            if (targets.Count == 0) AddLog(s.Active.NameKo + " 대상 없음 — 쿨만 소모");
            foreach (var t in targets)
            {
                ApplyStun(t, Mathf.Max(1, Mathf.RoundToInt(e.P)), "행동 불가");
                Vector2 to = u.Position - t.Position;
                float want = to.magnitude - u.Radius - t.Radius - 0.05f;
                if (want <= 0.05f) continue;
                float m = ShoveRaw(t, to.normalized, want, null);
                if (m > 0f) AddMoved(moved, t, m);
            }
            yield return Fx.Wait(0.25f);
        }

        /// <summary>곽가 십승십패: 이미 행동한 다른 아군 n 기에 재행동(없으면 임의의 다른 아군이 행동 뒤 재행동 1회).</summary>
        void GrantReaction(Unit u, int n)
        {
            var acted = new List<Unit>();
            var others = new List<Unit>();
            foreach (var a in battle.AliveUnits(u.Faction))
            {
                if (a == u) continue;
                others.Add(a);
                if (a.ActedThisTurn) acted.Add(a);
            }
            for (int i = 0; i < n; i++)
            {
                var pool = acted.Count > 0 ? acted : others;
                if (pool.Count == 0) return;
                var pick = pool[battle.Rng.Next(pool.Count)];
                pool.Remove(pick);
                if (pick.ActedThisTurn) pick.GrantReAction();
                else Ensure(pick).ReactCredits++; // 스킬 없는 병사도(Fable 검토 A2)
                Text(pick, "재행동", SkillFx.NameColor);
            }
        }

        // ---------- 변진(장합): 목표 지점 탭 ----------

        public static float TeleportRadius(UnitSkills s)
        {
            if (s == null || s.ActiveEffects == null) return 0f;
            foreach (var e in s.ActiveEffects)
                if (e.Key == SkillKeys.Teleport) return e.P;
            return 0f;
        }

        /// <summary>목표 지점이 반경 안 빈 곳인가(벽·유닛과 겹치지 않음 · 전장 안).</summary>
        public bool TeleportValid(Unit u, Vector2 w)
        {
            var s = Of(u);
            if (s == null) return false;
            if (Vector2.Distance(u.Position, w) > TeleportRadius(s) + 1e-3f) return false;
            if ((battle.Board.ClampInside(w, u.Radius) - w).sqrMagnitude > 1e-4f) return false;
            Physics2D.SyncTransforms();
            foreach (var c in Physics2D.OverlapCircleAll(w, u.Radius))
            {
                if (c.GetComponent<BoardWall>() != null || GimmickLayer.BlocksMove(c)) return false;
                var o = c.GetComponent<Unit>();
                if (o != null && o != u && o.IsAlive) return false;
            }
            return true;
        }

        /// <summary>변진: 대상 무시하고 그 지점으로 → 이미 행동했으면 재행동(extra_action).</summary>
        public IEnumerator TeleportRoutine(UnitSkills s, Vector2 w)
        {
            var u = s.Unit;
            Announce(s, s.Active);
            s.ReadyTurn = battle.TurnNumber + CooldownOf(s);
            if (u.View != null) u.View.SetFacing(w - u.Position);
            yield return Fx.MoveAlong(u.transform, u.Position, w, battle.Config.moveSpeed * 2f, null);
            u.Position = w;
            if (s.Active.Has(SkillKeys.ExtraAction) && u.ActedThisTurn)
            {
                u.GrantReAction();
                Text(u, "재행동", SkillFx.NameColor);
            }
            battle.NotifyChanged();
        }

        // ---------- 연출 · HUD 기록 ----------

        /// <summary>액티브 발동 = 유닛 위 스킬 이름 + 플래시 + HUD 한 줄 · 주유 패시브 = 시전 HP 소모.</summary>
        public void Announce(UnitSkills s, SkillDef def, Vector2 dir = default(Vector2))
        {
            if (s == null || def == null) return;
            if (def.IsActive) BattleEvents.Raise(BattleEvents.ActiveUses, s.Unit);
            if (s.Unit != null) SkillFx.Announce(s.Unit, def.NameKo);
            if (s.Unit != null && def.IsActive) SkillVfx.Play(s.Unit, def.Id, SkillVfx.EventCast, dir);
            AddLog("액티브 · " + (s.Unit != null ? s.Unit.DisplayName : "") + " 「" + def.NameKo + "」");
            if (def.IsActive && s.Unit != null)
            {
                var cost = Find(s.PassiveEffects, SkillKeys.SkillHpCost);
                if (cost != null)
                {
                    PayHp(s.Unit, cost.P);
                    NotePassive(s, s.Passive);
                }
            }
        }

        /// <summary>패시브 발동 HUD 한 줄(같은 행동 안에서는 스킬마다 1번).</summary>
        public void NotePassive(UnitSkills s, SkillDef def)
        {
            if (s == null || def == null || s.Unit == null) return;
            string key = s.Unit.GetInstanceID() + "/" + def.Id;
            if (!noted.Add(key)) return;
            AddLog("패시브 · " + s.Unit.DisplayName + " 「" + def.NameKo + "」");
        }

        public void AddLog(string text)
        {
            if (Sim.Active) return;
            Log.Add(new LogLine { Text = text, Time = Time.unscaledTime });
            if (Log.Count > 8) Log.RemoveAt(0);
        }

        static void Text(Unit u, string text, Color c)
        {
            if (Sim.Active || u == null) return;
            Fx.Popup(u.Position + new Vector2(0f, 0.55f), text, c);
        }

        /// <summary>최근 seconds 초 안의 기록(최신이 마지막).</summary>
        public List<string> RecentLog(float seconds, int max)
        {
            var res = new List<string>();
            float now = Time.unscaledTime;
            for (int i = Log.Count - 1; i >= 0 && res.Count < max; i--)
                if (now - Log[i].Time <= seconds) res.Insert(0, Log[i].Text);
            return res;
        }
    }

    /// <summary>스킬 연출(이름 글자 · 플래시).</summary>
    public static class SkillFx
    {
        public static readonly Color NameColor = new Color(1f, 0.85f, 0.3f);
        public static readonly Color FlashColor = new Color(1f, 0.9f, 0.45f, 0.55f);
        public static readonly Color GuardColor = new Color(0.55f, 0.85f, 1f);
        public static readonly Color FearColor = new Color(1f, 0.4f, 0.25f, 0.4f);
        public static readonly Color CostColor = new Color(1f, 0.55f, 0.35f);
        public static readonly Color HealColor = new Color(0.45f, 1f, 0.5f);

        public static void Announce(Unit u, string name)
        {
            if (Sim.Active) return;
            Fx.Burst(u.Position, u.Radius * 2.2f, FlashColor);
            Fx.Run(NameRoutine(u.Position + new Vector2(0f, u.ArtHeight > 0f ? u.ArtHeight * 0.6f : u.Radius + 0.6f), name));
        }

        static IEnumerator NameRoutine(Vector2 pos, string text)
        {
            var tm = TextUtil.CreateWorldText(null, text, 0.55f, NameColor, 21);
            tm.gameObject.name = "SkillName";
            var tr = tm.transform;
            float t = 0f;
            const float dur = 1.1f;
            while (t < dur)
            {
                t += Time.deltaTime;
                float k = Mathf.Clamp01(t / dur);
                tr.position = new Vector3(pos.x, pos.y + 0.4f * k, 0f);
                var c = NameColor;
                c.a = k < 0.7f ? 1f : 1f - (k - 0.7f) / 0.3f;
                tm.color = c;
                yield return null;
            }
            Object.Destroy(tm.gameObject);
        }
    }
}