// ─────────────────────────────────────────────────────────────────────────────
//  PowerDeltaToast.cs — 성장 체감 표시 (WL-813l · PD 지시 #813)
//
//  기준서 v1 §D-2 813l 행 · §E 5-3 「강화 후 체감(전투력 % + 처치 타수 변화) = 표시 + 타수 −1 로그」.
//  🔴 원탭 강화 UI · 강화 화면 · BM 은 **이 파일에 없다**(PD Q6 결정 전 · 발주서 §2 금지). 「체감 표시」만이다.
//
//  ■ 이 파일이 내는 것 3가지
//    ① 전투력 % 토스트 — 레벨업(813k `GrowthEvents.LevelUp`) · 장비/강화로 전투력 값이 바뀌면 "전투력 +N %"
//    ② 레벨업 팝업 전투력 줄 — 813y `StatPopup` 이 `WLPowerMeter` 를 불러 「전투력 A → B (+N %)」 1줄을 붙인다
//    ③ 처치 타수 비교 — 성장 전후 「평균 처치 타수」를 재서 줄었으면 "이제 3방 → 2방"(다음 존 클리어 때 1회)
//
//  ■ 원본 접촉 0
//    · `Assets/Script/**` 수정 0 — 원본 값은 `Actor.Get_StatInfo()` → `ActorStatInfo.Get_Stat(eStat)` **읽기만**.
//    · Gameplay(`Assets/WL/Combat/**`) 수정 0 — 811b `CombatEvents` · 813k `GrowthEvents` · 813p `RunEvents` **구독만**.
//    · 프리팹 diff 0 — 토스트 노드는 런타임 생성(`HideFlags.DontSave`) · 813q `RunHud` 선례.
//
//  ■ 🔴 WL-813l2 — Q6 D-28(레벨 1→16 인데 `LastPower 52.000000` 불변 · 토스트 0회) 원인과 수리
//    원인(실측 · 「추정」 아님):
//      · `ActorStatInfo.Reset`(`Assets/Script/Util/MyValue.cs:286-453`)이 **`SD_PC.Lv` 를 한 번도 안 읽는다.**
//        PC 스탯은 `table_classconfig.Get_PureStat`(`Table/PC/table_classconfig.cs:232-248`
//        = 보유 직업 기본치 + **사용한** 포인트 `SD_PC.Get_Stat`) + 장비·각성·초월·유물에서만 만들어진다.
//      · 레벨업(`Server/ServerClass.cs:2725-2739 Add_Exp`)은 `++Lv` 뿐 — 스탯은 안 건드리고
//        `Get_Point()`(`:2770` = `(Lv−1)*5 − 사용분`)의 **미사용 포인트만** 늘린다.
//        포인트를 실제로 찍는 곳은 수동 UI `PCInfoStatMgrUI.cs:81` 하나뿐이다(자동 배분 0).
//      → 813l 이 레벨업 때도 `ActorStatInfo` 를 **다시 읽기만** 해서(`Observe(sm.power)`) 값이 상수 = 표시 0회.
//        폴링은 살아 있었다(Q6 `PollCount 1573`) — **읽는 값이 안 움직인 것**이다.
//    수리(발주서 WL-813l2 §1-2):
//      ① 레벨업 경로는 813k `GrowthEvents.LevelUp` **페이로드**(prev/new 스탯 3종 · prevLevel/newLevel ·
//         statPointTotal)로 성장 전/후 전투력을 만든다 — 813y `StatPopup` 이 읽는 것과 **같은 값**이다.
//      ② 산식 입력에 **미사용 스탯 포인트**를 넣는다. 원본 실측 환산(주스탯 1점 → `ATK +1`·`MaxHP +22` ·
//         `MyValue.cs:335-336`)을 그대로 써서, 포인트를 찍어도 전투력이 튀지 않는다(잠재→실현 연속).
//         가중치·환산·레벨 기여는 전부 SO(`statPointWeight`·`statPointAtkGain`·`statPointHpGain`·`levelWeight`).
//      ③ 장비/강화 경로는 그대로 폴링이다 — 실측으로 **폴링이 옳다**는 것을 확인했다(아래 항).
//
//  ■ 🔴 장비/강화 변경 이벤트는 원본에 없다(실측)
//    `ServerClass.Set_Equip`(`Assets/Script/Server/ServerClass.cs:2329`)·`ActorStatInfo.Reset` 어디에도
//    구독 가능한 신호가 없고, 원본 파일 수정은 금지다. → 발주서 §1-2 대안대로 **폴링**한다
//    (`pollIntervalSeconds` · 기본 0.5 s). 폴링 경로는 값 비교뿐이라 **할당 0**(GC 0) — 변화가 있을 때만 문자열이 난다.
//    🔴 813l2 재실측 — **폴링이 실제로 잡는다**: 장비 착용·강화·각성·초월·유물·스탯 포인트 사용이 전부
//    `MyValue.Get_ActorStatInfoorNull(eRole.PC)`(예: `UI/Eqiupment/EquipmentPopup_Obtain.cs:85` ·
//    `EquipmentItemPopup.cs:77` · `EquipmentUI.cs:96` · `PCInfoStatMgrUI.cs:85`)를 부르고, 그게
//    `MyValue.cs:122` 에서 **공유 캐시 인스턴스**(`dic_ActorStatInfo[(PC,"0",0)]`)에 `Reset()` 을 건다.
//    인게임 PC 도 `Actor.cs:322` 로 **같은 인스턴스**를 물고 있다 → 다음 폴링(≤0.5 s)에 값이 바뀐다.
//
//  ■ C8 롤백 — `WLPowerDeltaSettings.enabled_ = 0`(또는 `RuntimeDisabled`) → 구독 0 · 폴링 0 · 노드 0 · 표시 0.
//
//  🔴 어셈블리 주의: Assets/WL/UI/ 에 .asmdef 를 만들지 말 것(Assembly-CSharp 단일).
// ─────────────────────────────────────────────────────────────────────────────

using System.Globalization;
using TMPro;
using UnityEngine;
using WL.Combat.Core;
using WL.Combat.Growth;
using WL.Combat.Run;

namespace WL.UI
{
    /// <summary>
    /// 전투력 계산기 — 🔴 **원본에 전투력/CP 개념이 없다**(실측: `Assets/Script/**` 전수 검색 0건).
    /// 그래서 발주서 WL-813l §1-1 대안인 WL 산식을 쓴다. **「추정」이며 계수는 전부 SO** 다.
    ///
    ///   power = ATK × (1 + critWeight × 치명기여) × (1 + aspdWeight × (공속배율 − base)) + HP × hpWeight
    ///
    /// 실측한 원본 스탯 규약(`Assets/Script/Util/MyValue.cs` · `MyEnum.cs` · `DSUtil.cs`):
    ///   · `eStat.BaseDmg` = ATK × ATK_Multiplier × DMG_Multiplier(최종 공격력) — 전투 밖에서는 0 일 수 있어 `ATK` 로 폴백
    ///   · `eStat.CRI` 는 런타임에 **0~1 비율**이다(`DSUtil.RandomTrue(p)` 가 `Random.Range(0f,1f)` 와 비교)
    ///   · `eStat.ATK_SPD_Multiplier` 는 **1 기준 배율**(`FinalAttackSpeed = HERO_ATK_SPD × (배율 − 1)`)
    /// </summary>
    public static class WLPowerMeter
    {
        /// <summary>한 번의 측정 결과(전부 실측값 · 진단·프로브가 읽는다).</summary>
        public struct Sample
        {
            public double atk, critRate, critDamage, aspd, hp, power;
            /// <summary>WL-813l2 성장 입력 — 레벨(`SD_PC.Lv`)과 미사용 스탯 포인트(`SD_PC.Get_Point()`).</summary>
            public double level, statPoints;
            /// <summary>공격력이 1순위 스탯(BaseDmg)이 아니라 폴백(ATK)에서 왔는가 — 페이로드 환산 방식이 갈린다.</summary>
            public bool atkFromFallback;
            public bool valid;
            public override string ToString()
            {
                return "atk=" + atk.ToString("F1") + " cri=" + critRate.ToString("F3") +
                       " criDmg=" + critDamage.ToString("F3") + " aspd=" + aspd.ToString("F3") +
                       " hp=" + hp.ToString("F1") + " lv=" + level.ToString("F0") +
                       " pt=" + statPoints.ToString("F0") + " → power=" + power.ToString("F1");
            }
        }

        /// <summary>순수 함수(성장 입력 없음) — 813l 원래 산식. 아래 8인자 판에 0/0 을 넘긴다.</summary>
        public static double Compute(double atk, double critRate, double critDamage, double aspd, double hp, WLPowerDeltaSettings s)
        {
            return Compute(atk, critRate, critDamage, aspd, hp, 0d, 0d, s);
        }

        /// <summary>
        /// 순수 함수 — 스탯 5개 + 성장 입력 2개(레벨 · 미사용 스탯 포인트)와 계수로 전투력을 만든다
        /// (Unity 객체 0 · 프로브가 그대로 검증한다).
        ///
        /// 🔴 WL-813l2 — 미사용 스탯 포인트를 넣는 이유는 **원본이 레벨업으로 스탯을 안 올리기 때문**이다
        /// (실측 근거는 파일 머리 주석). 포인트를 「아직 안 쓴 힘」으로 보고 원본 실측 환산
        /// (주스탯 1점 → `ATK +1` · `MaxHP +22` · `MyValue.cs:335-336`)으로 산식에 그대로 넣으면,
        /// 포인트를 실제로 찍는 순간(포인트 −1 · 스탯 +1/+22) 전투력이 **튀지 않는다**(잠재→실현 연속).
        /// `statPointWeight = 0` 이면 813l 원래 산식과 완전히 같다(C8).
        /// </summary>
        public static double Compute(double atk, double critRate, double critDamage, double aspd, double hp,
                                     double level, double statPoints, WLPowerDeltaSettings s)
        {
            if (s == null) return 0d;
            double crit = s.useCritDamage ? critRate * critDamage : critRate;
            double critTerm = 1d + s.critWeight * crit;
            double aspdTerm = 1d + s.attackSpeedWeight * (aspd - s.attackSpeedBase);
            if (critTerm < 0d) critTerm = 0d;
            if (aspdTerm < 0d) aspdTerm = 0d;
            double pts = statPoints > 0d ? statPoints * s.statPointWeight : 0d;
            if (pts < 0d) pts = 0d;
            double p = (atk + pts * s.statPointAtkGain) * critTerm * aspdTerm
                     + (hp + pts * s.statPointHpGain) * s.hpWeight;
            double lv = level - s.levelBase;
            if (lv > 0d) p += lv * s.levelWeight;
            return p * s.powerScale;
        }

        /// <summary>원본 스탯 묶음에서 전투력을 읽는다(쓰기 0). 스탯이 없으면 false. 성장 입력은 0 = 스탯만.</summary>
        public static bool TryRead(ActorStatInfo stat, WLPowerDeltaSettings s, out Sample o)
        {
            o = default(Sample);
            if (stat == null || s == null) return false;
            double atk = stat.Get_Stat(s.atkStat);
            if (atk <= 0d) { atk = stat.Get_Stat(s.atkFallbackStat); o.atkFromFallback = true; }
            o.atk = atk;
            o.critRate = stat.Get_Stat(s.critRateStat);
            o.critDamage = s.useCritDamage ? stat.Get_Stat(s.critDamageStat) : 0d;
            o.aspd = stat.Get_Stat(s.attackSpeedStat);
            o.hp = stat.Get_Stat(s.hpStat);
            o.power = Compute(o.atk, o.critRate, o.critDamage, o.aspd, o.hp, o.level, o.statPoints, s);
            o.valid = true;
            return true;
        }

        /// <summary>
        /// WL-813l2 — 서버 데이터에서 성장 입력(레벨 · 미사용 스탯 포인트)을 채우고 전투력을 다시 만든다.
        /// 🔴 **할당 0**: 원본 `SD_PC.Get_Point()`(`ServerClass.cs:2769-2770`)는 LINQ(`Select`+`Sum`)라
        /// 폴링마다 가비지가 난다 → **같은 식을 for 루프로 다시 센다**(값 동일 · GC 0).
        /// 「레벨당 5포인트」는 코드 상수가 아니라 SO(`statPointsPerLevel` · 원본 실측 5)다.
        /// </summary>
        public static void ApplyGrowth(SD_PC pc, WLPowerDeltaSettings s, ref Sample o)
        {
            if (s == null) return;
            if (pc != null && s.readGrowthFromServerData)
            {
                int lv = (int)pc.Lv;
                o.level = lv;
                int used = 0;
                var lst = pc.Stat;
                // ObscuredInt 는 int 와 양방향 암시 변환이 있어 연산자가 모호해진다 → 명시 캐스트로 고정.
                if (lst != null) for (int i = 0; i < lst.Count; i++) used += (int)lst[i];
                int pts = (lv - 1) * s.statPointsPerLevel - used;
                o.statPoints = pts > 0 ? pts : 0;
            }
            o.power = Compute(o.atk, o.critRate, o.critDamage, o.aspd, o.hp, o.level, o.statPoints, s);
        }

        /// <summary>메인 PC 의 현재 전투력. PC 나 스탯이 없으면 false(로비·에디트 모드).</summary>
        public static bool TryReadMainPc(out Sample o)
        {
            o = default(Sample);
            var s = WLPowerDeltaSettings.Instance;
            if (s == null) return false;
            if (!MyValue.bMyPC) return false;
            var pc = MyValue.MyPC;
            if (pc == null) return false;
            if (!TryRead(pc.Get_StatInfo(), s, out o)) return false;
            // 🔴 `ServerInfo.Ins` 는 게터가 GameObject 를 새로 만든다(부작용 · `Server/ServerInfo.cs:19`) →
            //    쓰지 않는다. PC 가 이미 물고 있는 `ServerData` 만 읽는다(`Actor.cs:987` · 읽기 전용).
            var sd = pc.Get_ServerData();
            ApplyGrowth(sd != null ? sd.PC : null, s, ref o);
            return true;
        }

        /// <summary>증가율(%) — prev 가 0 이하면 0(나눗셈 방지).</summary>
        public static double PercentDelta(double prev, double next)
        {
            if (prev <= 0d) return 0d;
            return (next - prev) / prev * 100d;
        }

        /// <summary>전투력 표기(천 단위 구분 · 정수).</summary>
        public static string Format(double power)
        {
            return power.ToString("N0", CultureInfo.InvariantCulture);
        }

        /// <summary>퍼센트 표기(자릿수는 SO).</summary>
        public static string FormatPercent(double percent, WLPowerDeltaSettings s)
        {
            int d = s != null ? Mathf.Clamp(s.percentDigits, 0, 3) : 1;
            return percent.ToString("F" + d, CultureInfo.InvariantCulture);
        }
    }

    /// <summary>
    /// 성장 체감 토스트 — 정적 클래스(813q `RunHud` 선례). 씬·프리팹에 노드를 굽지 않는다.
    /// 전투력 % 줄과 처치 타수 비교 줄이 같은 대역(SO `toastCenterOffsetPx`)에 쌓인다.
    /// </summary>
    public static class PowerDeltaToast
    {
        private sealed class Line
        {
            public RectTransform rt;
            public TextMeshProUGUI label;
            public CanvasGroup group;
            public float life, lifeMax, elapsed;
            public bool used;
        }

        private static WLPowerDeltaSettings St { get { return WLPowerDeltaSettings.Instance; } }

        private static RectTransform s_root;
        private static Line[] s_lines;
        private static Transform s_uiRoot;
        private static TMP_FontAsset s_font;
        private static bool s_subscribed;
        private static string s_lastEdge = "";

        // ── 전투력 감시(폴링 · GC 0) ─────────────────────────────────────────
        private static double s_lastPower;            // 마지막으로 관측한 전투력
        private static double s_baseline;             // 마지막으로 **표시한** 전투력(증가율의 분모)
        private static bool s_hasLastPower;
        private static float s_nextPoll;
        private static float s_lastAnnounceAt = -999f;
        private static int s_suppressToastFrame = -1; // 레벨업 프레임 — 팝업이 전투력 줄을 이미 보여 준다

        // 레벨업 프레임의 「성장 직전/직후 전투력」 — 813y StatPopup 이 어떤 순서로 구독됐든 같은 값을 보게 한다.
        // 🔴 813l2: 직후 값도 못박는다 — 팝업이 그때 `ActorStatInfo` 를 다시 읽으면 레벨업 분이 안 보인다(D-28).
        private static double s_growthPrevPower;
        private static double s_growthNewPower;
        private static int s_growthPrevFrame = -1;

        // ── 처치 타수 계측 ───────────────────────────────────────────────────
        private static int s_curHits, s_curKills;
        private static int s_curAttacks;              // 기준서 §E 5-3 검증 방법(AttackStarted)도 같이 센다
        private static float s_windowStart;
        private static float s_beforeRatio;
        private static bool s_hasBefore;
        private static bool s_armed;
        private static int s_armFrom, s_armTo;
        private static float s_armedAt;

        // ── 진단(프로브가 읽는다 · 실측만) ───────────────────────────────────
        public static int LevelUpSeen, PowerToastCount, CompareToastCount, ZoneClearedSeen;
        public static int PollCount, ObserveCount, SkippedSmall, SkippedDown, MergedByCooldown, SuppressedByPopup;
        public static string LastText = "";
        public static string LastCompareText = "";
        // WL-813l2 진단 — 레벨업 전투력이 어느 소스에서 왔는가(페이로드/스탯 재읽기/실패) · 그때의 prev·new.
        public static string LastPowerSource = "";
        public static double LastPayloadPrev, LastPayloadNew;
        public static double LastLevelSeen, LastStatPointsSeen;
        public static int PayloadUsed, PayloadMissed;
        public static double LastPower { get { return s_lastPower; } }
        public static bool HasPower { get { return s_hasLastPower; } }
        public static bool Subscribed { get { return s_subscribed; } }
        public static bool Bound { get { return s_root != null; } }
        public static bool Armed { get { return s_armed; } }
        public static int ArmedFrom { get { return s_armFrom; } }
        public static int ArmedTo { get { return s_armTo; } }
        public static string LastEdge { get { return s_lastEdge; } }
        public static int WindowHits { get { return s_curHits; } }
        public static int WindowAttacks { get { return s_curAttacks; } }
        public static int WindowKills { get { return s_curKills; } }
        public static bool HasBaseline { get { return s_hasBefore; } }
        public static float BaselineRatio { get { return s_beforeRatio; } }
        public static int VisibleLines
        {
            get { int n = 0; if (s_lines != null) for (int i = 0; i < s_lines.Length; i++) if (s_lines[i].used) n++; return n; }
        }

        // ── 부팅 (노드 0 · 프리팹 diff 0) ────────────────────────────────────
        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
        private static void Boot()
        {
            if (!WLPowerDeltaSettings.Enabled) return;
            Subscribe(true);
            PowerDeltaRunner.Ensure();
        }

        // ── 구독 ─────────────────────────────────────────────────────────────
        /// <summary>813k 성장 축 · 811b 전투 신호 · 813p 런 축을 구독한다(전부 읽기 전용 구독).</summary>
        public static string Subscribe(bool on)
        {
            if (on == s_subscribed) return "구독 변화 없음(" + s_subscribed + ")";
            var s = St;
            if (on)
            {
                GrowthEvents.LevelUp.Add(OnLevelUp);
                if (s == null || s.hitsPerKillEnabled)
                {
                    CombatEvents.HitConfirmed.Add(OnHitConfirmed);
                    CombatEvents.AttackStarted.Add(OnAttackStarted);
                    CombatEvents.Killed.Add(OnKilled);
                }
                RunEvents.ZoneCleared.Add(OnZoneCleared);
            }
            else
            {
                GrowthEvents.LevelUp.Remove(OnLevelUp);
                CombatEvents.HitConfirmed.Remove(OnHitConfirmed);
                CombatEvents.AttackStarted.Remove(OnAttackStarted);
                CombatEvents.Killed.Remove(OnKilled);
                RunEvents.ZoneCleared.Remove(OnZoneCleared);
            }
            s_subscribed = on;
            return "구독=" + on + " (GrowthEvents.LevelUp · HitConfirmed/AttackStarted/Killed · RunEvents.ZoneCleared)";
        }

        // ── 노드 연결 (런타임 생성) ──────────────────────────────────────────
        /// <summary>NewGameUI 루트 밑 HUD 경로에 토스트 노드를 만든다. 이미 물려 있으면 그대로.</summary>
        public static string Bind(Transform uiRoot)
        {
            var s = St;
            if (s == null) return "WLPowerDeltaSettings 에셋 없음";
            if (!WLPowerDeltaSettings.Enabled || !s.toastEnabled) return "설정 off — 노드 0";
            if (uiRoot == null) return "uiRoot=null";
            if (s_root != null && s_uiRoot == uiRoot) return "이미 연결됨";

            var parent = WLVignetteUtil.FindUiPath(uiRoot, s.hudParentPath) as RectTransform;
            if (parent == null) return "부모 없음 — 경로 \"" + s.hudParentPath + "\"";

            s_uiRoot = uiRoot;
            if (s_font == null) s_font = RunHud.BorrowFont(uiRoot);

            if (s_root == null || s_root.parent != parent)
            {
                var go = new GameObject("WL_PowerDeltaToast", typeof(RectTransform));
                go.layer = WLTextFxUtil.UILayer;
                go.hideFlags = HideFlags.DontSave;          // 씬·프리팹에 굽지 않는다
                s_root = (RectTransform)go.transform;
                s_root.SetParent(parent, false);
                s_lines = null;
            }
            BuildIfNeeded(s);
            string layout = ApplyLayout(s);
            HideAll();
            return "연결 " + s.hudParentPath + " · " + layout;
        }

        private static void BuildIfNeeded(WLPowerDeltaSettings s)
        {
            int want = Mathf.Clamp(s.toastLines, 1, 4);
            if (s_lines != null && s_lines.Length == want) return;
            var next = new Line[want];
            for (int i = 0; i < want; i++)
            {
                if (s_lines != null && i < s_lines.Length && s_lines[i].rt != null) { next[i] = s_lines[i]; continue; }
                var lrt = WLTextFxUtil.NewChild(s_root, "Line" + i);
                var cg = lrt.GetComponent<CanvasGroup>();
                if (cg == null) cg = lrt.gameObject.AddComponent<CanvasGroup>();
                cg.interactable = false; cg.blocksRaycasts = false; cg.alpha = 0f;
                var label = WLTextFxUtil.NewText(lrt, "Label", s_font, TextAlignmentOptions.Center);
                next[i] = new Line { rt = lrt, label = label, group = cg };
            }
            // 줄 수를 줄였으면 남는 노드는 숨기기만 한다(파괴 0 · 813g LootToast 규약).
            if (s_lines != null)
                for (int i = want; i < s_lines.Length; i++)
                    if (s_lines[i].group != null) { s_lines[i].group.alpha = 0f; s_lines[i].used = false; }
            s_lines = next;
        }

        /// <summary>px → 유닛 환산은 813g `WLCombatTextSettings.UnitsPerPx` 하나만 쓴다(산식 중복 0).</summary>
        private static float UnitsPerPx()
        {
            var t = WLCombatTextSettings.Instance;
            if (t == null || s_root == null) return 1f;
            var canvas = s_root.GetComponentInParent<Canvas>();
            return t.UnitsPerPx(canvas != null ? canvas.rootCanvas : null);
        }

        public static string ApplyLayout(WLPowerDeltaSettings s)
        {
            if (s == null || s_root == null || s_lines == null) return "노드 없음 — Bind 먼저";
            float u = UnitsPerPx();
            WLTextFxUtil.Stretch(s_root);
            var text = WLCombatTextSettings.Instance;
            float widthPx = text != null ? text.designWidthPx : 1080f;

            var edge = s.toastEdge;
            if (text != null) edge = text.Edge(edge);   // 813y 전체 스위치(textEdgeEnabled)를 존중한다
            for (int i = 0; i < s_lines.Length; i++)
            {
                var rt = s_lines[i].rt;
                rt.anchorMin = rt.anchorMax = new Vector2(0.5f, 0.5f);
                rt.pivot = new Vector2(0.5f, 0.5f);
                rt.sizeDelta = new Vector2(widthPx * u, s.toastLineHeightPx * u);
                rt.anchoredPosition = new Vector2(0f, (s.toastCenterOffsetPx - s.toastLineHeightPx * i) * u);
                var lb = s_lines[i].label;
                WLTextFxUtil.Stretch(lb.rectTransform);
                lb.fontSize = s.toastFontPx * u;
                s_lastEdge = WLTextFxUtil.ApplyEdge(lb, edge);
            }
            return "lines=" + s_lines.Length + " offset=" + s.toastCenterOffsetPx.ToString("F0") +
                   "px unitsPerPx=" + u.ToString("F4") + " font=" + (s.toastFontPx * u).ToString("F1") +
                   " edge[" + s_lastEdge + "]";
        }

        public static void HideAll()
        {
            if (s_lines == null) return;
            for (int i = 0; i < s_lines.Length; i++)
            {
                s_lines[i].used = false; s_lines[i].life = 0f;
                if (s_lines[i].group != null) s_lines[i].group.alpha = 0f;
                if (s_lines[i].rt != null) s_lines[i].rt.localScale = Vector3.one;
            }
        }

        // ── 표시 ─────────────────────────────────────────────────────────────
        /// <summary>한 줄 띄운다. 빈 줄이 없으면 가장 오래된 줄을 재활용한다(줄 파괴·생성 0).</summary>
        public static string Push(string text, Color color)
        {
            var s = St;
            if (s == null || !WLPowerDeltaSettings.Enabled || !s.toastEnabled) return "설정 off — 표시 0";
            if (s_lines == null || s_root == null) { LastText = text; return "노드 없음(문구만 기록) — \"" + text + "\""; }
            BuildIfNeeded(s);

            int slot = -1;
            for (int i = 0; i < s_lines.Length; i++) if (!s_lines[i].used) { slot = i; break; }
            if (slot < 0)
            {
                float oldest = float.MaxValue;
                for (int i = 0; i < s_lines.Length; i++) if (s_lines[i].life < oldest) { oldest = s_lines[i].life; slot = i; }
            }

            var ln = s_lines[slot];
            ln.label.text = text;
            ln.label.color = color;
            ln.lifeMax = ln.life = Mathf.Max(0.01f, s.toastSeconds);
            ln.elapsed = 0f;
            ln.used = true;
            ln.group.alpha = 1f;
            ln.rt.localScale = Vector3.one * WLTextFxUtil.PunchScale(0f, s.toastPunchScale, s.toastPunchSeconds);
            LastText = text;
            return "line=" + slot + " \"" + text + "\"";
        }

        /// <summary>수명·페이드·펀치 + 폴링 + 타수 창 마감. 러너가 매 프레임 부른다.</summary>
        public static void Tick(float now, float dt)
        {
            var s = St;
            if (s == null || !WLPowerDeltaSettings.Enabled) return;

            if (s_lines != null)
            {
                for (int i = 0; i < s_lines.Length; i++)
                {
                    var ln = s_lines[i];
                    if (!ln.used) continue;
                    ln.life -= dt; ln.elapsed += dt;
                    float passed = WLTextFxUtil.Passed(ln.life, ln.lifeMax);
                    ln.group.alpha = WLTextFxUtil.FadeAlpha(passed, s.toastFadeStartRatio);
                    ln.rt.localScale = Vector3.one * WLTextFxUtil.PunchScale(ln.elapsed, s.toastPunchScale, s.toastPunchSeconds);
                    if (ln.life <= 0f) { ln.used = false; ln.group.alpha = 0f; ln.rt.localScale = Vector3.one; }
                }
            }

            // ① 전투력 폴링 — 값 비교뿐이라 할당 0(변화가 있을 때만 문자열이 난다).
            if (s.toastEnabled && now >= s_nextPoll)
            {
                s_nextPoll = now + Mathf.Max(0.05f, s.pollIntervalSeconds);
                PollCount++;
                WLPowerMeter.Sample sm;
                if (WLPowerMeter.TryReadMainPc(out sm))
                {
                    // 진단용 대입뿐 — 문자열·박싱 0(GC 0 유지).
                    LastLevelSeen = sm.level; LastStatPointsSeen = sm.statPoints;
                    Observe(sm.power, now, "poll");
                }
            }

            // ② 하한·쿨다운으로 미뤄 둔 변화 마감(기준값과 마지막 관측값이 다르면 다시 본다)
            if (s_hasLastPower && s_lastPower != s_baseline &&
                now - s_lastAnnounceAt >= Mathf.Max(0f, s.announceCooldownSeconds))
                Evaluate(s, now, "flush");

            // ③ 타수 창 마감
            TickWindow(s, now);

            // ④ 무장한 비교 문구 — 런이 안 돌면 즉시(존 클리어가 영영 안 올 수 있다)
            if (s_armed)
            {
                if (now - s_armedAt > Mathf.Max(1f, s.compareArmSeconds)) { s_armed = false; }
                else if (!s.showCompareOnZoneCleared || (s.showCompareImmediatelyIfNoRun && !RunDirector.IsRunning))
                    ShowCompare(s, "즉시");
            }
        }

        // ── 전투력 변화 감지 ─────────────────────────────────────────────────
        /// <summary>
        /// 전투력 실값 하나를 넣는다(프로브도 이 경로를 쓴다).
        /// 증가율의 분모는 **마지막으로 표시한 값**(`s_baseline`)이다 — 그래서
        ///   · 하한 미만의 잔변화는 표시를 미루고 **다음 변화에 누적**된다(0.4% + 0.4% → 0.8% 로 뜬다)
        ///   · 쿨다운 안의 연타는 한 줄로 합쳐지되 **이미 표시한 분은 두 번 세지 않는다**
        /// </summary>
        public static string Observe(double power, float now, string reason)
        {
            var s = St;
            if (s == null || !WLPowerDeltaSettings.Enabled) return "설정 off";
            ObserveCount++;
            if (!s_hasLastPower)
            {
                s_lastPower = power; s_baseline = power; s_hasLastPower = true;
                return "기준값 " + WLPowerMeter.Format(power) + "(" + reason + ")";
            }
            if (power == s_lastPower) return "변화 없음";
            s_lastPower = power;
            return Evaluate(s, now, reason);
        }

        /// <summary>기준값 → 마지막 관측값의 차이를 보고 띄울지 결정한다(Observe · Tick 둘 다 여기로 온다).</summary>
        private static string Evaluate(WLPowerDeltaSettings s, float now, string reason)
        {
            double from = s_baseline, to = s_lastPower;
            if (from == to) return "변화 없음";
            double pct = WLPowerMeter.PercentDelta(from, to);

            // 하락은(기본 설정) 안 띄우되 기준값은 내려 준다 — 장비 해제 뒤 재장착이 가짜 상승으로 뜨지 않게.
            if (pct < 0d && !s.showOnPowerDown) { s_baseline = to; SkippedDown++; return "하락 무시(" + pct.ToString("F2") + "%)"; }

            double abs = pct < 0d ? -pct : pct;
            // 하한 미만이면 기준값을 **그대로 둔다** = 다음 변화에 누적된다.
            if (abs < Mathf.Max(0f, s.minPercentToShow)) { SkippedSmall++; return "변화 작음(" + pct.ToString("F2") + "% < " + s.minPercentToShow + "% · 누적 대기)"; }
            // 쿨다운 안이면 기준값을 그대로 두고 다음 Tick 에서 다시 본다(연타 → 한 줄).
            if (now - s_lastAnnounceAt < Mathf.Max(0f, s.announceCooldownSeconds)) { MergedByCooldown++; return "쿨다운 병합(기준 " + WLPowerMeter.Format(from) + ")"; }

            return Announce(s, from, to, now, reason);
        }

        private static string Announce(WLPowerDeltaSettings s, double from, double to, float now, string reason)
        {
            double pct = WLPowerMeter.PercentDelta(from, to);
            double abs = pct < 0d ? -pct : pct;
            s_baseline = to;
            s_lastAnnounceAt = now;

            // 전투력이 올랐으면 「성장 이벤트」로 보고 타수 창을 새로 연다(레벨업이든 강화든 같다).
            if (pct > 0d) MarkGrowth(now, "power " + WLPowerMeter.Format(from) + "→" + WLPowerMeter.Format(to));

            // 레벨업 프레임이면 토스트를 띄우지 않는다 — 같은 값을 스탯 팝업의 전투력 줄이 이미 보여 준다(중복 표시 0).
            if (s.suppressToastOnLevelUp && Time.frameCount == s_suppressToastFrame)
            {
                SuppressedByPopup++;
                if (s.verboseLog) Debug.Log("[WL813l] 전투력 " + pct.ToString("F2") + "% — 레벨업 프레임이라 토스트 생략(팝업 줄이 표시)");
                return "레벨업 프레임 — 팝업 줄이 표시(토스트 생략)";
            }

            string txt = DSUtil.Format(pct >= 0d ? s.powerUpFormat : s.powerDownFormat, WLPowerMeter.FormatPercent(abs, s));
            PowerToastCount++;
            string r = Push(txt, pct >= 0d ? s.powerUpColor : s.powerDownColor);
            if (s.verboseLog)
                Debug.Log("[WL813l] 전투력 " + WLPowerMeter.Format(from) + " → " + WLPowerMeter.Format(to) +
                          " (" + pct.ToString("F2") + "% · " + reason + ") · " + r);
            return r;
        }

        // ── 813k 레벨업 (🔴 WL-813l2 = D-28 수리 지점) ───────────────────────
        private static void OnLevelUp(in PlayerLevelUpEvent e)
        {
            if (!WLPowerDeltaSettings.Enabled) return;
            LevelUpSeen++;
            var s = St;
            float now = Time.unscaledTime;
            s_suppressToastFrame = Time.frameCount;   // 이 프레임의 전투력 토스트는 팝업 줄에 양보한다
            // 레벨업은 「성장 이벤트」다 — 스탯이 그대로여도(원본 기본 동작 · 813k 보고 ①) 타수 창은 새로 연다.
            MarkGrowth(now, "levelUp " + e.prevLevel + "→" + e.newLevel);

            double prevP, newP;
            string src;
            if (s != null && s.useLevelUpPayload && TryPayloadPower(s, in e, out prevP, out newP))
            {
                PayloadUsed++;
                src = "levelUp(813k 페이로드)";
            }
            else
            {
                // 폴백 = 813l 원래 동작. 🔴 원본은 레벨업으로 스탯을 안 올리므로 여기로 떨어지면 값이 안 움직인다(D-28).
                WLPowerMeter.Sample sm;
                if (!WLPowerMeter.TryReadMainPc(out sm))
                {
                    PayloadMissed++; LastPowerSource = "levelUp(스탯 읽기 실패)";
                    return;
                }
                PayloadMissed++;
                newP = sm.power;
                prevP = s_hasLastPower ? s_baseline : newP;
                src = "levelUp(스탯 재읽기)";
            }
            LastPowerSource = src; LastPayloadPrev = prevP; LastPayloadNew = newP;
            LastLevelSeen = e.newLevel; LastStatPointsSeen = e.statPointTotal;

            // 기준값이 아직 없으면 페이로드의 prev 로 연다 — 첫 레벨업이 「기준값 세우기」로 삼켜지지 않게.
            if (!s_hasLastPower) { s_lastPower = prevP; s_baseline = prevP; s_hasLastPower = true; }

            // 팝업 줄이 읽을 값을 이 프레임에 못박는다(813y StatPopup 과 구독 순서 무관 · 아래 BuildStatPopupLine).
            // prev 는 「마지막으로 **표시한** 값」(s_baseline)이라 토스트와 이중 계상이 나지 않는다.
            s_growthPrevPower = s_baseline;
            s_growthNewPower = newP;
            s_growthPrevFrame = Time.frameCount;

            Observe(newP, now, src);
        }

        /// <summary>
        /// 🔴 WL-813l2 — 813k `LevelUp` 페이로드로 성장 전/후 전투력을 만든다(D-28 수리의 핵심).
        /// 레벨업 순간 `ActorStatInfo` 를 다시 읽으면 **prev == new** 다(원본이 레벨업으로 스탯을 안 올린다).
        /// 그래서 ① 스탯 3종은 페이로드의 `prevStatX`/`newStatX`(= 813y `StatPopup` 이 읽는 바로 그 값)
        /// ② 레벨은 `prevLevel`/`newLevel` ③ 미사용 포인트는 `statPointTotal` 과 그 역산값을 쓴다.
        /// </summary>
        private static bool TryPayloadPower(WLPowerDeltaSettings s, in PlayerLevelUpEvent e, out double prevP, out double newP)
        {
            prevP = 0d; newP = 0d;
            WLPowerMeter.Sample cur;
            if (!WLPowerMeter.TryReadMainPc(out cur))
            {
                // 월드에 PC 가 없다(로비·오프라인 보상·에디트 모드) — 페이로드만으로 만든다.
                cur = default(WLPowerMeter.Sample);
                cur.aspd = s.attackSpeedBase;      // 기준 배율 = 공속 기여 0
            }
            // 산식이 BaseDmg(1순위)를 쓰는 중인가 — 페이로드가 ATK 를 줄 때 환산 방식이 갈린다.
            bool atkPrimary = cur.valid && !cur.atkFromFallback && cur.atk > 0d;

            var nw = cur; var pv = cur;
            ApplyPayloadStat(s, ref nw, e.statAKind, e.newStatA, e.newStatA, atkPrimary);
            ApplyPayloadStat(s, ref nw, e.statBKind, e.newStatB, e.newStatB, atkPrimary);
            ApplyPayloadStat(s, ref nw, e.statCKind, e.newStatC, e.newStatC, atkPrimary);
            ApplyPayloadStat(s, ref pv, e.statAKind, e.prevStatA, e.newStatA, atkPrimary);
            ApplyPayloadStat(s, ref pv, e.statBKind, e.prevStatB, e.newStatB, atkPrimary);
            ApplyPayloadStat(s, ref pv, e.statCKind, e.prevStatC, e.newStatC, atkPrimary);

            // 「레벨업 직전 미사용 포인트」 역산 — 원본 Get_Point() = (Lv−1)*5 − 사용분 이므로
            // 사용분이 그대로면 오른 레벨 수 × 레벨당 포인트만큼 적었다.
            int gained = e.newLevel - e.prevLevel; if (gained < 0) gained = 0;
            int per = s.statPointsPerLevel > 0 ? s.statPointsPerLevel : 0;
            int prevPts = e.statPointTotal - gained * per; if (prevPts < 0) prevPts = 0;

            newP = WLPowerMeter.Compute(nw.atk, nw.critRate, nw.critDamage, nw.aspd, nw.hp, e.newLevel, e.statPointTotal, s);
            prevP = WLPowerMeter.Compute(pv.atk, pv.critRate, pv.critDamage, pv.aspd, pv.hp, e.prevLevel, prevPts, s);
            return newP > 0d || prevP > 0d;
        }

        /// <summary>페이로드 스탯 1개를 산식 입력에 얹는다. 산식에 없는 스탯(예 MaxMP)은 그냥 버린다.</summary>
        private static void ApplyPayloadStat(WLPowerDeltaSettings s, ref WLPowerMeter.Sample o,
                                             eStat kind, double v, double refNew, bool atkPrimary)
        {
            if (kind == s.hpStat) { o.hp = v; return; }
            if (kind == s.critRateStat) { o.critRate = v; return; }
            if (kind == s.critDamageStat) { if (s.useCritDamage) o.critDamage = v; return; }
            if (kind == s.attackSpeedStat) { o.aspd = v; return; }
            if (kind == s.atkStat) { o.atk = v; return; }
            if (kind == s.atkFallbackStat)
            {
                // 산식이 BaseDmg(= ATK × ATK_Multiplier × DMG_Multiplier · 실측 MyValue.cs:384-386)를 쓰는 중이면
                // 배율을 모르는 채 ATK 로 덮어쓸 수 없다 → 같은 비율로 환산한다.
                if (!atkPrimary) o.atk = v;
                else if (refNew > 0d) o.atk = o.atk * (v / refNew);
            }
        }

        // ── 처치 타수 계측 ───────────────────────────────────────────────────
        private static void OnHitConfirmed(in HitConfirmedEvent e) { if (e.byMainPC) s_curHits++; }
        private static void OnAttackStarted(in AttackStartedEvent e) { if (e.isMainPC) s_curAttacks++; }

        private static void OnKilled(in KilledEvent e)
        {
            // 메인 PC 가 죽인 것만 센다(원본 killer 가 null 이면 셀 수 없다 = 표본에서 제외).
            if (e.killer == null || !e.killer.IsMainPC()) return;
            s_curKills++;
        }

        /// <summary>성장(레벨업·전투력 상승) 시점 — 지금까지의 창을 기준선으로 삼고 새 창을 연다.</summary>
        public static string MarkGrowth(float now, string reason)
        {
            var s = St;
            if (s == null || !s.hitsPerKillEnabled) return "타수 계측 off";
            string before = "표본 부족";
            if (s_curKills >= Mathf.Max(1, s.minKillsPerWindow))
            {
                s_beforeRatio = Numerator(s) / (float)s_curKills;
                s_hasBefore = true;
                before = "기준 타수 " + s_beforeRatio.ToString("F2") + "(" + Numerator(s) + "/" + s_curKills + ")";
            }
            ResetWindow(now);
            if (s.verboseLog) Debug.Log("[WL813l] 성장 감지(" + reason + ") · " + before + " · 새 창 시작");
            return before;
        }

        private static int Numerator(WLPowerDeltaSettings s)
        {
            return s.hitsSource == WLHitSource.AttackStarted ? s_curAttacks : s_curHits;
        }

        private static void ResetWindow(float now)
        {
            s_curHits = 0; s_curAttacks = 0; s_curKills = 0; s_windowStart = now;
        }

        private static void TickWindow(WLPowerDeltaSettings s, float now)
        {
            if (!s.hitsPerKillEnabled) return;
            if (s_windowStart <= 0f) { s_windowStart = now; return; }
            if (now - s_windowStart < Mathf.Max(1f, s.windowSeconds)) return;
            CloseWindow(s, now);
        }

        /// <summary>창 하나를 마감한다(프로브가 60 s 를 기다리지 않고 직접 부른다).</summary>
        public static string CloseWindow(WLPowerDeltaSettings s, float now)
        {
            if (s == null) return "설정 없음";
            int kills = s_curKills;
            int num = Numerator(s);
            if (kills < Mathf.Max(1, s.minKillsPerWindow)) { ResetWindow(now); return "표본 부족(kills=" + kills + ") — 창 버림"; }

            float after = num / (float)kills;
            string r;
            if (s_hasBefore)
            {
                int a = Mathf.Max(1, Mathf.RoundToInt(s_beforeRatio));
                int b = Mathf.Max(1, Mathf.RoundToInt(after));
                if (a - b >= Mathf.Max(1, s.compareMinDropHits))
                {
                    s_armed = true; s_armFrom = a; s_armTo = b; s_armedAt = now;
                    r = "타수 감소 " + a + " → " + b + " · 비교 문구 무장";
                }
                else r = "타수 변화 없음(" + s_beforeRatio.ToString("F2") + " → " + after.ToString("F2") + ")";
                s_hasBefore = false;
            }
            else
            {
                r = "기준선 갱신(" + after.ToString("F2") + ")";
            }
            s_beforeRatio = after; s_hasBefore = true;
            ResetWindow(now);
            if (s.verboseLog) Debug.Log("[WL813l] 창 마감 · " + num + "/" + kills + " = " + after.ToString("F2") + "방 · " + r);
            return r;
        }

        private static void OnZoneCleared(in ZoneClearedEvent e)
        {
            if (!WLPowerDeltaSettings.Enabled) return;
            ZoneClearedSeen++;
            var s = St;
            if (s == null || !s.showCompareOnZoneCleared) return;
            ShowCompare(s, "존 " + (e.zoneIndex + 1) + " 클리어");
        }

        private static string ShowCompare(WLPowerDeltaSettings s, string reason)
        {
            if (!s_armed) return "무장 안 됨";
            s_armed = false;
            string txt = DSUtil.Format(s.hitsCompareFormat, s_armFrom, s_armTo);
            LastCompareText = txt;
            CompareToastCount++;
            string r = Push(txt, s.hitsCompareColor);
            if (s.verboseLog) Debug.Log("[WL813l] 타수 비교(" + reason + ") \"" + txt + "\" · " + r);
            return r;
        }

        // ── 813y StatPopup 이 부르는 전투력 줄 ───────────────────────────────
        /// <summary>
        /// 레벨업 팝업에 붙일 「전투력 A → B (+N %)」 한 줄. 표시할 게 없으면 null.
        /// 813y `StatPopup` 이 813k 페이로드를 받은 순간 부른다(값은 그때의 실측 스탯).
        /// </summary>
        public static string BuildStatPopupLine()
        {
            var s = St;
            if (s == null || !WLPowerDeltaSettings.Enabled || !s.statPopupLineEnabled) return null;
            // 이 프레임에 레벨업 스냅샷이 찍혔으면 **그 값만** 쓴다(PowerDeltaToast 가 먼저 구독됐든 StatPopup 이 먼저든 같다).
            // 🔴 813l2: 여기서 `ActorStatInfo` 를 다시 읽으면 안 된다 — 원본은 레벨업으로 스탯을 안 올려서
            //    prev == new 가 되고 팝업 줄이 「변화 없음」으로 굳는다(D-28 과 같은 뿌리).
            bool stamped = s_growthPrevFrame == Time.frameCount;
            double now;
            if (stamped) now = s_growthNewPower;
            else
            {
                WLPowerMeter.Sample sm;
                if (!WLPowerMeter.TryReadMainPc(out sm)) return null;
                now = sm.power;
            }
            if (now <= 0d) return null;
            double prev = stamped ? s_growthPrevPower : (s_hasLastPower ? s_baseline : now);
            double pct = WLPowerMeter.PercentDelta(prev, now);
            if (prev <= 0d || System.Math.Abs(pct) < 0.005d)
                return DSUtil.Format(s.statPopupLineFormatNoChange, WLPowerMeter.Format(now));
            string sign = pct >= 0d ? "+" : "-";
            double abs = pct < 0d ? -pct : pct;
            return DSUtil.Format(s.statPopupLineFormat, WLPowerMeter.Format(prev), WLPowerMeter.Format(now),
                                 sign + WLPowerMeter.FormatPercent(abs, s));
        }

        // ── 진단 리셋(프로브 전용) ───────────────────────────────────────────
        public static void ResetDiagnostics()
        {
            LevelUpSeen = PowerToastCount = CompareToastCount = ZoneClearedSeen = 0;
            PollCount = ObserveCount = SkippedSmall = SkippedDown = MergedByCooldown = SuppressedByPopup = 0;
            LastText = ""; LastCompareText = "";
            LastPowerSource = ""; LastPayloadPrev = LastPayloadNew = 0d;
            LastLevelSeen = LastStatPointsSeen = 0d; PayloadUsed = PayloadMissed = 0;
            s_lastPower = 0d; s_baseline = 0d; s_hasLastPower = false;
            s_growthPrevPower = 0d; s_growthNewPower = 0d; s_growthPrevFrame = -1; s_suppressToastFrame = -1;
            s_lastAnnounceAt = -999f; s_nextPoll = 0f;
            s_curHits = s_curAttacks = s_curKills = 0; s_windowStart = 0f;
            s_beforeRatio = 0f; s_hasBefore = false; s_armed = false; s_armFrom = s_armTo = 0; s_armedAt = 0f;
            HideAll();
        }

        // ── 프로브 전용 가짜 신호 (813g `LootToast.RaiseFakeKilled` 선례) ────
        //    `CombatEventList.Dispatch` 는 Assembly-CSharp internal 이라 AgentScripts 에서 못 부른다 →
        //    구독 경로를 **그대로** 타는 헬퍼를 여기에 둔다(원본 Raise* 는 DamageInfo·사망 판정을 요구해 쓸 수 없다).

        /// <summary>프로브 전용 — 811b 전투 신호(공격/적중/처치)를 가짜로 흘린다.</summary>
        public static string RaiseFakeCombatForProbe(Actor pc, Actor victim, int hits, int kills)
        {
            for (int i = 0; i < hits; i++)
            {
                var a = new AttackStartedEvent { actor = pc, isMainPC = true, attackIndex = i, animSpeed = 1f, time = Time.unscaledTime, frame = Time.frameCount };
                CombatEvents.AttackStarted.Dispatch(in a);
                var h = new HitConfirmedEvent { victim = victim, attacker = pc, damage = 1d, byMainPC = true, time = Time.unscaledTime, frame = Time.frameCount };
                CombatEvents.HitConfirmed.Dispatch(in h);
            }
            for (int i = 0; i < kills; i++)
            {
                var k = new KilledEvent { victim = victim, killer = pc, subRole = eSubRol.None, position = Vector3.zero, time = Time.unscaledTime, frame = Time.frameCount };
                CombatEvents.Killed.Dispatch(in k);
            }
            return "hits=" + s_curHits + " attacks=" + s_curAttacks + " kills=" + s_curKills;
        }

        /// <summary>
        /// 프로브 전용(WL-813l2) — 813k `GrowthEvents.LevelUp` 을 **실제로 Dispatch** 한다(구독 경로 그대로).
        /// 813y `StatPopup.RaiseFakeGrowthLevelUp` 은 스탯 3종이 고정이라 「prev ATK 100 → new 112」를 못 만든다.
        /// </summary>
        public static string RaiseFakeLevelUpForProbe(int prevLevel, int newLevel, int statPointTotal,
                                                      eStat kindA, double prevA, double newA,
                                                      eStat kindB, double prevB, double newB,
                                                      eStat kindC, double prevC, double newC)
        {
            var e = new PlayerLevelUpEvent
            {
                data = null, pc = null,
                prevLevel = prevLevel, newLevel = newLevel,
                levelsGained = Mathf.Max(1, newLevel - prevLevel),
                statPointTotal = statPointTotal,
                statAKind = kindA, prevStatA = prevA, newStatA = newA,
                statBKind = kindB, prevStatB = prevB, newStatB = newB,
                statCKind = kindC, prevStatC = prevC, newStatC = newC,
                hpBefore = 0d, maxHp = 0d, mpBefore = 0d, maxMp = 0d,
                position = Vector3.zero, time = Time.unscaledTime, frame = Time.frameCount,
            };
            GrowthEvents.LevelUp.Dispatch(in e);
            return "dispatch GrowthEvents.LevelUp " + prevLevel + "→" + newLevel +
                   " pt=" + statPointTotal + " · 구독자=" + GrowthEvents.LevelUp.Count;
        }

        /// <summary>프로브 전용 — 813p `RunEvents.ZoneCleared` 를 가짜로 흘린다.</summary>
        public static string RaiseFakeZoneClearedForProbe(int zoneIndex)
        {
            var e = new ZoneClearedEvent
            {
                zoneIndex = zoneIndex, spawnerId = 813001 + zoneIndex, elapsedSec = 0f,
                kills = 0, required = 0, allZonesCleared = false, time = Time.unscaledTime, frame = Time.frameCount
            };
            RunEvents.ZoneCleared.Dispatch(in e);
            return "dispatch ZoneCleared(" + zoneIndex + ") · 구독자=" + RunEvents.ZoneCleared.Count;
        }
    }

    /// <summary>토스트 러너 — HUD 재생성 감지 + 매 프레임 Tick(813q `WLRunUiRunner` 선례).</summary>
    internal sealed class PowerDeltaRunner : MonoBehaviour
    {
        private static PowerDeltaRunner s_ins;
        private NewGameUI _lastUi;

        internal static void Ensure()
        {
            if (s_ins != null) return;
            var go = new GameObject("WL_PowerDeltaRunner");
            go.hideFlags = HideFlags.HideAndDontSave;
            Object.DontDestroyOnLoad(go);
            s_ins = go.AddComponent<PowerDeltaRunner>();
        }

        private void Update()
        {
            var ui = NewGameUI.Ins;
            if (ui != null && !ReferenceEquals(ui, _lastUi))
            {
                _lastUi = ui;
                PowerDeltaToast.Bind(ui.transform);
            }
            PowerDeltaToast.Tick(Time.unscaledTime, Time.unscaledDeltaTime);
        }
    }
}