Project_WL/Assets/WL/Combat/Weapon/WLRapidShot.cs

// ─────────────────────────────────────────────────────────────────────────────
//  WLRapidShot.cs — 활 주력 「속사」(Skill_RapidShot) WL 방식 (#916 · 2026-10-17)
//
//  PD 원문: 「활을 쏠 때 플레이어가 뒤로 밀리지 않게」 · 「활의 주력 스킬시전할 때 플레이어의 활이 빛나며 기가 모이는 연출을 추가
//            (해머 각성기 참고하되, 해머보다 임펙트가 너무 강하지는 않도록)」 · 「과녁의 크기가 몬스터의 크기를 고려해 유동적이 되도록 ·
//            (이펙트가 몬스터에게 가려지지 않도록)」 · 「매우 빠르게 활쏘는 모션을 반복해 3발의 투사체를 연속으로 발사」
//  ■ 원본(Skill_RapidShot.Co_Update): 과녁(Effect_BulletTarget · 대상 몸 가운데 · 크기 고정) → 1 초 → 0.25 초 간격 7 발 · 발마다 시전자 넉백
//    (원본 넉백 최소 0.1 초 × 속도 4 = 한 발 약 0.4 m 뒤로 · Play 실측).
//  ■ WL — 원본 Set 의 훅 1줄(Take)이 넘겨받는다:
//    ① 과녁 = 원본 이펙트 그대로 · 대상 중심에서 카메라 쪽으로 몸 반지름 + markFront 앞에(몸에 가려지지 않게) · 배율 = 몹 키 × markPerHeight(markMin~markMax)
//    ② 모으기 chargeSeconds — 활 당긴 자세(shotState 의 drawNormalized)로 멈추고, 활에 흰 빛(WLWeaponGlowFx · glowMax) + 활 가운데 모으기 이펙트(chargeFx)
//    ③ shots 발 — 발마다 shotState 를 (첫 발 drawNormalized · 다음 fromNormalized) 부터 shotSpeed 배로 재생 → 놓는 순간(클립 Projectile 이벤트)에
//       원본 투사체 1 발(관통 · 원본과 같은 한 발 피해) · 대상을 본다 · 시전자 넉백 없음
//    ④ 끝 — endNormalized 까지 재생 → 애니메이터 되돌림 · 대기 · 빛 glowFadeSeconds 동안 꺼짐 · 투사체 Off. 이동 · 구르기로 스킬 상태가 끊기면 즉시 끝(스킵).
//  ■ noRecoil = 쏠 때 시전자를 뒤로 미는 다른 활 스킬(원본 Set 훅 1줄 · 속박의 화살 Skill_BindingArrow 0.05 초 × 속도 10)
//  ■ #975 multi = 활 기본 스킬(원본 Skill_MultiShot 703404 = 일반 공격 화살 추가 버프) — PD 「주력 스킬과 동일하게 모으기 이펙트 시전 후 전방으로 부채꼴 모양으로
//    퍼지는 화살 10발을 3회 연속으로 발사(멀티샷 형태 · 0.5초 간격)」 — 원본 Set 훅 1줄(TakeMulti)이 넘겨받아 ②모으기는 주력과 같고 ③에서 volleys 번 ·
//    interval 초마다(놓는 순간 기준) 대상 쪽(없으면 정면) 부채꼴 fanDegrees 에 arrows 발(화살 = multi.projectile · 겉모습 WLProjectileVisual · 사거리 = 흰 원 × rangeMul)
//  ■ 값 = Resources/WL/WLRapidShot.json (C45) · 끄기 = enabled 0 → 원본 동작
//  🔴 Debug.LogError 금지(원본 팝업).
// ─────────────────────────────────────────────────────────────────────────────
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace WL.Combat.Weapon
{
    [System.Serializable]
    public class WLRapidShotJson
    {
        public int enabled = 0;
        public int[] classes = new int[0];          // 비우면 모든 직업
        public int shots = 3;
        public string shotState = "attack";
        public string shotClip = "FR_Bow1_10402";   // 놓는 순간 = 이 클립의 Projectile 이벤트
        public float drawNormalized = 0.8f;         // 모으기 동안 멈출 자세(활 당김) · 첫 발 시작
        // #967 PD 「주력 스킬 모으기 시 활을 들지 않는 손이 멈춰 있는데 — 활을 쏠 때와 같이 자연스럽게 활시위를 당기는 포즈로 모으도록」 — chargeFromNormalized ≥ 0 이면 모으기 첫 chargeDrawSeconds 동안
        //  shotState 를 그 자리(활 든 채 시위에 손)부터 drawNormalized(끝까지 당김)까지 재생한 뒤 유지 · < 0 = 이전(처음부터 drawNormalized 정지)
        public float chargeFromNormalized = -1f;
        public float chargeDrawSeconds = 0.35f;
        public float releaseNormalized;             // #967 > 0 = 놓는 순간(발사)을 이 정규화 시각으로 · 0 = shotClip 의 Projectile 이벤트
        public float fromNormalized = 0.55f;        // 둘째 발부터 여기서 재생
        public float shotSpeed = 2.5f;              // 발 재생 배속
        public float endNormalized = 0.97f;         // 마지막 발 뒤 여기까지 재생하고 대기
        public float chargeSeconds = 0.6f;
        public string socket = "w_archer_l";        // 활 소켓
        public string chargeFx = "";
        public float chargeFxScale = 0.06f;
        public string glowMaterial = "WL/Fx/WL_Mat_WeaponGlow";
        public float[] glowColor = { 1.2f, 1.3f, 1.5f };
        public float glowMax = 0.6f, glowFill = 0.3f, glowRimPower = 2.5f, glowFadeSeconds = 0.2f;
        public float markFront = 0.15f;             // 과녁을 몸 반지름 + 이 거리(m)만큼 카메라 쪽 앞에
        public float markPerHeight = 0.35f;         // 과녁 배율 = 몹 키(m) × 이 값
        public float markMin = 0.3f, markMax = 2f;
        public float markExtraLife = 0.3f;          // 마지막 발 뒤 과녁 유지(초)
        public string[] noRecoil = new string[0];   // 쏠 때 시전자 넉백을 하지 않을 다른 스킬(eEffect 이름)
        // #921 PD 「이펙트 궤적이 타겟 방향으로만 집중해서 날아가도록 · 그 방향으로 화살 기본 공격의 사정거리만큼 직선상 경로상 모든 적에게 피해(레이저 판정)」
        public int laser = 0;                       // 1 = 발마다 PC → 대상 방향 직선(길이 = 기본 공격 사정거리 · 흰 원) 위 모든 적에게 그 화살의 한 발 피해를 즉시 · 화살은 판정 없이 사정거리까지만 곧게 날아간다
        public float laserWidth = 0.6f;             // 직선 판정 폭(m) — 적 몸 반지름은 따로 더한다
        public int aimBody = 1;                     // 1 = 화살이 대상 몸 중심(공중 몹은 그림 가운데) 쪽으로 곧게
        public int chargeBlocksMove = 0;            // #922 PD 「주력 스킬 모으기 이펙트 재생중에는 이동하지 못하게(구르기로 취소는 가능)」 — 1 = 모으기 동안 이동 입력 무시(WLSkillCancel.HoldMove · 구르기 = 스킵)
        public int holdThroughShots = 0;            // #922 1 = 막기를 마지막 발까지(모으기만 막으면 이동 키를 누른 채일 때 모으기 직후 이동이 들어와 한 발도 안 쏘고 끊겼다 · Play 실측)
        public float holdMaxSeconds = 3f;           // 막기 상한(초) — 끝나면 어떻게든 푼다
        public WLRapidShotMulti multi = new WLRapidShotMulti();   // #975 활 기본 스킬(멀티샷)
        public string note = "";
    }

    /// <summary>#975 활 기본 스킬 — 주력과 같은 모으기 뒤 volleys 번 · interval 초 간격(놓는 순간)으로 앞쪽 부채꼴 fanDegrees 에 화살 arrows 발.</summary>
    [System.Serializable]
    public class WLRapidShotMulti
    {
        public int enabled = 0;
        public string projectile = "Projectile_ArcherSkill2Arrow";   // 화살(주력 속사와 같은 화살 · 겉모습 = WLProjectileVisual 표)
        public int volleys = 3;
        public float interval = 0.5f;
        public int arrows = 10;
        public float fanDegrees = 60f;              // 부채꼴 전체 각(°) — 화살 사이 = fanDegrees / (arrows − 1)
        public float rangeMul = 1f;                 // 나는 거리 = 기본 공격 사정거리(흰 원) × 이 값 · 0 = 투사체 원래 수명
        public int pierce = 0;                      // 1 = 관통
        public int mark = 0;                        // 1 = 과녁 표시(주력처럼)
        public float drawFraction = 0.8f;           // #976 다시 당기는 시간 상한 = interval × 이 값(간격이 당김 동작 0.23 s 보다 짧으면 그만큼 빨리 당긴다)
        public int noExtra = 1;                     // #977 1 = 화살에 원본 스킬 부가 효과(703404 방어력 감소 디버프) 없음
        public string note = "";
    }

    public static class WLRapidShot
    {
        public const string ResourcesPath = "WL/WLRapidShot";
        public static int Taken, Shots, Aborted, RecoilSkipped, Errors, Lasers, LaserHits, TakenMulti, MultiArrows; public static string LastLog = "";
        static WLRapidShotJson s_cfg;

        internal static WLRapidShotJson Cfg
        {
            get
            {
                if (s_cfg != null) return s_cfg;
                s_cfg = new WLRapidShotJson();
                var ta = Resources.Load<TextAsset>(ResourcesPath);
                if (ta == null) { LastLog = "설정 없음 " + ResourcesPath; return s_cfg; }
                try { JsonUtility.FromJsonOverwrite(ta.text, s_cfg); } catch (System.Exception ex) { LastLog = "설정 파싱 실패 — " + ex.Message; }
                return s_cfg;
            }
        }
        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] static void Reset() { s_cfg = null; }

        static int ClassOf(PCActor pc) { return pc != null ? pc.Get_ID() : 0; }

        /// <summary>원본 Skill_RapidShot.Set 훅 — true 면 WL 이 이 투사체를 맡는다(원본 Co_Update 건너뜀).</summary>
        public static bool Take(ProjectileBase pb, List<ProjectileData> shots, string projectile)
        {
            try
            {
                var c = Cfg;
                if (c.enabled == 0 || pb == null || shots == null || shots.Count == 0) return false;
                var data = pb.Get_ProjectTileData(); var pc = data != null ? data.shooter as PCActor : null;
                if (pc == null || pc.m_animation == null) return false;
                if (c.classes != null && c.classes.Length > 0 && System.Array.IndexOf(c.classes, ClassOf(pc)) < 0) return false;
                var run = pb.GetComponent<WLRapidShotRunner>();
                if (run == null) run = pb.gameObject.AddComponent<WLRapidShotRunner>();
                run.Begin(pb, pc, data.target, shots, projectile, c);
                Taken++;
                return true;
            }
            catch (System.Exception ex) { Errors++; LastLog = "넘겨받기 실패 — " + ex.Message; return false; }
        }

        /// <summary>#975 원본 Skill_MultiShot.Set 훅 — true 면 WL 이 맡는다(원본 버프 건너뜀). 화살마다 스킬 투사체 데이터 복사본(시작 = 시전자 가운데).</summary>
        public static bool TakeMulti(ProjectileBase pb, ProjectileData data)
        {
            try
            {
                var c = Cfg; var m = c.multi;
                if (c.enabled == 0 || m == null || m.enabled == 0 || pb == null || data == null) return false;
                var pc = data.shooter as PCActor;
                if (pc == null || pc.m_animation == null) return false;
                if (c.classes != null && c.classes.Length > 0 && System.Array.IndexOf(c.classes, ClassOf(pc)) < 0) return false;
                int n = Mathf.Max(1, m.volleys) * Mathf.Max(1, m.arrows);
                var list = new List<ProjectileData>(n);
                for (int i = 0; i < n; i++)
                {
                    var d = new ProjectileData(); data.Copy(d); d.eStartPos = eProjectileStartPos.ShooterCenter;
                    if (m.noExtra != 0) { d.e_SkillExtraType = eSkillExtraType.None; d.m_skillTypeConfigTable = null; d.SetSkillExtraType = false; }   // #977 PD 「활 기본 스킬에 명중 된 적에게 발생하는 디버프를 제거」 — Actor.Check_Extra 가 None 이면 바로 돌아간다 · SetSkillExtraType 를 꺼야 ProjectileBase.Set 이 스킬 표 값으로 다시 넣지 않는다(1차 Play 실측 방어 감소 남음)
                    list.Add(d);
                }
                var target = data.target;
                if (DSUtil.CheckNull(target) || target.IsDead()) target = pc.Get_Target();
                var run = pb.GetComponent<WLRapidShotRunner>();
                if (run == null) run = pb.gameObject.AddComponent<WLRapidShotRunner>();
                run.BeginMulti(pb, pc, target, list, c);
                TakenMulti++;
                return true;
            }
            catch (System.Exception ex) { Errors++; LastLog = "멀티샷 넘겨받기 실패 — " + ex.Message; return false; }
        }

        /// <summary>원본 활 스킬 Set 훅 — true 면 시전자 넉백(쏠 때 뒤로 밀림)을 하지 않는다.</summary>
        public static bool NoRecoil(Actor shooter, string skill)
        {
            var c = Cfg;
            if (c.enabled == 0 || c.noRecoil == null || System.Array.IndexOf(c.noRecoil, skill) < 0 || !(shooter is PCActor)) return false;
            RecoilSkipped++;
            return true;
        }
    }

    /// <summary>넘겨받은 속사 투사체 1개의 진행 — 과녁 · 모으기 · 빠른 연사 · 끝.</summary>
    internal sealed class WLRapidShotRunner : MonoBehaviour
    {
        ProjectileBase _pb; PCActor _pc; Actor _target; List<ProjectileData> _shots; string _proj; WLRapidShotJson _c;
        Animator _an; bool _animOwned; Coroutine _co;
        readonly WLWeaponGlowFx _glow = new WLWeaponGlowFx();
        Transform _socket; Vector3 _centerLocal; GameObject _charge;
        static readonly Dictionary<string, GameObject> s_fx = new Dictionary<string, GameObject>();

        bool _multi;   // #975 활 기본 스킬(부채꼴 다발)

        public void Begin(ProjectileBase pb, PCActor pc, Actor target, List<ProjectileData> shots, string proj, WLRapidShotJson c)
        {
            _pb = pb; _pc = pc; _target = target; _shots = shots; _proj = proj; _c = c; _an = pc.m_animation; _multi = false;
            if (_co != null) StopCoroutine(_co);
            _co = StartCoroutine(Run());
        }

        /// <summary>#975 활 기본 스킬 — shots = 화살마다 데이터(volleys × arrows).</summary>
        public void BeginMulti(ProjectileBase pb, PCActor pc, Actor target, List<ProjectileData> shots, WLRapidShotJson c)
        {
            _pb = pb; _pc = pc; _target = target; _shots = shots; _proj = c.multi.projectile; _c = c; _an = pc.m_animation; _multi = true;
            if (_co != null) StopCoroutine(_co);
            _co = StartCoroutine(Run());
        }

        IEnumerator Run()
        {
            var c = _c; var an = _an; var mc = c.multi;
            float releaseN = c.releaseNormalized > 0f ? c.releaseNormalized : ReleaseNormalized(an, c.shotClip);
            if (releaseN <= 0f) { WLRapidShot.LastLog = "놓는 이벤트 없음 " + c.shotClip; releaseN = 0.92f; }
            int n = _multi ? Mathf.Max(1, mc.volleys) : Mathf.Clamp(c.shots, 1, _shots.Count);

            // ① 과녁 — 몹 크기에 맞춘 배율 · 카메라 쪽 앞(몸에 가려지지 않게) · #975 기본 스킬(부채꼴)은 mark 1 일 때만
            if (!_multi || mc.mark != 0) ShowMark(c.chargeSeconds + n * (_multi ? mc.interval : 0.2f) + c.markExtraLife);

            // ② 모으기 — 활 당긴 자세 · 활 흰 빛 · 모으기 이펙트
            an.fireEvents = false; _animOwned = true;
            bool drawing = c.chargeFromNormalized >= 0f && c.chargeFromNormalized < c.drawNormalized;   // #967 시위를 당기며 모은다
            float poseN = drawing ? c.chargeFromNormalized : c.drawNormalized;
            an.Play(c.shotState, 0, poseN); an.speed = 0f; an.Update(0f);
            Face();
            _socket = FindSocket(_pc, c.socket);
            if (_socket != null) { _glow.Begin(_socket, c.glowMaterial); _centerLocal = WLWeaponGlowFx.CenterLocal(_socket); }
            _charge = Spawn(c.chargeFx, BowCenter(), c.chargeFxScale, c.chargeSeconds + 0.5f);
            if (c.chargeBlocksMove != 0) { WLSkillCancel.HoldMove(_pc, c.holdThroughShots != 0 ? Mathf.Max(c.chargeSeconds, c.holdMaxSeconds) : c.chargeSeconds); _holding = true; }   // #922 모으기(· 마지막 발까지) 이동 무시(구르기 = 스킵)
            var col = Rgb(c.glowColor, 1f);
            float t = 0f;
            while (t < c.chargeSeconds)
            {
                if (Broken()) { End(false); yield break; }
                if (an.speed != 0f) an.speed = 0f;
                if (drawing)   // #967 시위 당기기 — chargeDrawSeconds 동안 부드럽게 끝까지 → 유지
                {
                    float dk = Mathf.SmoothStep(0f, 1f, Mathf.Clamp01(t / Mathf.Max(0.01f, c.chargeDrawSeconds)));
                    float want = Mathf.Lerp(c.chargeFromNormalized, c.drawNormalized, dk);
                    if (Mathf.Abs(want - poseN) > 1e-4f || !an.GetCurrentAnimatorStateInfo(0).IsName(c.shotState)) { poseN = want; an.Play(c.shotState, 0, poseN); }
                }
                else if (!an.GetCurrentAnimatorStateInfo(0).IsName(c.shotState)) an.Play(c.shotState, 0, c.drawNormalized);   // 다른 연출이 상태를 바꾸면 되돌림
                float k = Mathf.Clamp01(t / Mathf.Max(0.01f, c.chargeSeconds));
                _glow.Set(c.glowMax * k, col, c.glowFill, c.glowRimPower);
                if (_charge != null) _charge.transform.position = BowCenter();
                t += Time.deltaTime; yield return null;
            }
            _glow.Set(c.glowMax, col, c.glowFill, c.glowRimPower);
            if (_charge != null) { Destroy(_charge); _charge = null; }
            if (_holding && c.holdThroughShots == 0) { _holding = false; WLSkillCancel.EndHoldMove(_pc, true); }   // #922 모으기 끝 — 그동안 미룬 이동 입력 적용(마지막 발까지 막을 때는 연사 뒤에)

            // ③ 빠른 연사 n 발 · #975 기본 스킬 = n 번 부채꼴 다발(놓는 순간 사이 mc.interval 초)
            float lastFire = -99f;
            float shotSp = c.shotSpeed;   // 발 재생 속도(애니메이터 속도를 직접 씀 = 기본 공격 공속 배율과 무관 · #975 실측 활 컨트롤러 재생 배수 파라미터 없음)
            float drawDur = Mathf.Max(0f, (releaseN - c.fromNormalized) * ClipLen(an, c.shotClip) / Mathf.Max(0.1f, c.shotSpeed));   // 다시 당겨 놓기까지(초 · 어림 — 실제 놓는 순간은 아래에서 interval 에 맞춤)
            // #976 간격(0.2 s)이 당김 동작보다 짧으면 다시 당기기를 interval × drawFraction 안에 끝나게 빨리 재생
            float mDraw = _multi && mc.drawFraction > 0f ? Mathf.Min(drawDur, mc.interval * mc.drawFraction) : drawDur;
            float mSp = mDraw > 1e-3f && drawDur > 1e-3f ? c.shotSpeed * drawDur / mDraw : c.shotSpeed;
            for (int i = 0; i < n; i++)
            {
                if (_multi && i > 0)   // #975 앞 다발을 놓은 뒤 자세를 이어 재생하다가 interval − 당기는 시간(− 몇 프레임 여유 · 첫 Play 실측 0.54 s = 2 프레임 늦음)에 다시 당긴다
                    while (Time.time < lastFire + mc.interval - mDraw - 3f * Time.smoothDeltaTime)
                    {
                        if (Broken()) { End(false); yield break; }
                        an.speed = an.GetCurrentAnimatorStateInfo(0).normalizedTime < c.endNormalized ? shotSp : 0f;   // 다음 상태로 넘어가지 않게(공격 2타 전이 0.98)
                        yield return null;
                    }
                Face();
                float startN = i == 0 ? c.drawNormalized : c.fromNormalized, s0 = Time.time;
                float spNow = _multi && i > 0 ? mSp : shotSp;   // #976 멀티샷 다시 당기기 = mSp
                an.Play(c.shotState, 0, startN); an.speed = Mathf.Max(0.1f, spNow);
                yield return null;
                while (an.GetCurrentAnimatorStateInfo(0).normalizedTime < releaseN && Time.time - s0 < 1f)
                {
                    if (Broken()) { End(false); yield break; }
                    if (an.speed != spNow) an.speed = spNow;
                    if (!an.GetCurrentAnimatorStateInfo(0).IsName(c.shotState)) an.Play(c.shotState, 0, startN);
                    yield return null;
                }
                if (_multi)
                {
                    while (i > 0 && Time.time < lastFire + mc.interval) { if (Broken()) { End(false); yield break; } an.speed = 0f; yield return null; }   // 놓는 순간을 interval 에 맞춤
                    an.speed = shotSp;
                    Fan(i, Mathf.Max(1, mc.arrows));
                }
                else
                {
                    var data = _shots[i];
                    ProjectileInfo.Ins.Shoot_Projectile(_proj, data, p => { p.m_Pierce = true; WLProjectileVisual.ApplyTo(p, _proj); if (_c.laser != 0) Laser(p); });   // 원본과 같은 한 발 · 시전자 넉백 없음 · #917 겉모습 · 명중 이펙트(WLProjectileVisual 표) · #921 레이저 판정
                }
                lastFire = Time.time;
                WLRapidShot.Shots++;
            }

            if (_holding) { _holding = false; WLSkillCancel.EndHoldMove(_pc, true); }   // #922 마지막 발 — 미룬 이동 입력 적용

            // ④ 마무리 — 빛 꺼짐 · 끝 자세
            float f0 = Time.time;
            while (an.GetCurrentAnimatorStateInfo(0).normalizedTime < c.endNormalized && Time.time - f0 < 0.5f)
            {
                if (Broken()) { End(false); yield break; }
                float k = 1f - Mathf.Clamp01((Time.time - f0) / Mathf.Max(0.01f, c.glowFadeSeconds));
                _glow.Set(c.glowMax * k, col, c.glowFill, c.glowRimPower);
                yield return null;
            }
            End(true);
        }

        /// <summary>#921 레이저 판정 — PC 발에서 대상 쪽 수평 방향으로 기본 공격 사정거리(흰 원 WLRangeRing.AttackReach)만큼의 직선 위(폭 laserWidth + 몸 반지름) 모든 적에게
        /// 이 화살의 원본 피해 경로(ProcessCollider · 끄지 않음)를 즉시 · 화살은 대상 몸 중심 쪽으로 곧게 사정거리까지만 날고 자기 판정은 끈다(이중 피해 방지).</summary>
        void Laser(ProjectileBase p)
        {
            var c = _c; if (p == null || _pc == null) return;
            float range = WL.Combat.RangeRing.WLRangeRing.AttackReach(_pc);
            if (range <= 0f) return;
            Vector3 origin = _pc.Get_position();
            Vector3 dir = _pc.transform.forward; dir.y = 0f;
            bool hasTarget = !DSUtil.CheckNull(_target) && !_target.IsDead();
            if (hasTarget) { var to = _target.Get_position() - origin; to.y = 0f; if (to.sqrMagnitude > 1e-4f) dir = to; }
            if (dir.sqrMagnitude < 1e-6f) return;
            dir.Normalize();
            // ① 겉모습 — 대상 몸 중심 쪽으로 곧게 · 사정거리 끝에서 사라짐
            Vector3 look = dir;
            if (c.aimBody != 0 && hasTarget)
            {
                var v = WL.Combat.Impact.WLImpactFx.BodyCenter(_target) - p.transform.position; var vf = v; vf.y = 0f;
                if (vf.sqrMagnitude > 0.01f) look = v;
            }
            p.transform.rotation = Quaternion.LookRotation(look);
            var pd = p.Get_ProjectTileData();
            var start = p.transform.position - origin; start.y = 0f;
            if (pd != null && pd.Speed > 0f) pd.LifeTime = Mathf.Max(0.05f, (range - Vector3.Dot(start, dir)) / pd.Speed);
            // ② 판정 — 직선 위 모든 적
            int hits = 0; var info = ActorInfo.Ins;
            var list = info != null ? info.Get_EnemyActors(_pc.IsEnemy(), origin, range + 2f) : null;
            if (list != null)
            {
                for (int k = 0; k < list.Count; k++)
                {
                    var a = list[k];
                    if (a == null || a.IsDead()) continue;
                    var v = a.Get_position() - origin; v.y = 0f;
                    float body = WL.Combat.WLCombatMotionSettings.BodyRadius(a), t = Vector3.Dot(v, dir);
                    if (t < -body || t > range + body) continue;
                    if ((v - dir * t).magnitude > c.laserWidth * 0.5f + body) continue;
                    var col = a.GetComponent<Collider>();
                    if (col == null || !col.enabled) continue;
                    if (p.ProcessCollider(col, false)) hits++;
                }
                info.Release_Actors(list);
            }
            WLLaserMute.Mute(p);
            WLRapidShot.LaserHits += hits; WLRapidShot.Lasers++;
            WLRapidShot.LastLog = "레이저 " + range.ToString("F2") + " m · 맞음 " + hits;
        }

        /// <summary>#975 부채꼴 다발 1번 — 대상 쪽(없으면 정면) 수평 방향을 가운데로 fanDegrees 에 count 발을 고르게 · 화살은 그 방향으로 곧게 · 사거리 = 흰 원 × rangeMul.</summary>
        void Fan(int volley, int count)
        {
            var mc = _c.multi; var pc = _pc; if (pc == null || ProjectileInfo.Ins == null) return;
            Vector3 dir = pc.transform.forward; dir.y = 0f;
            if (!DSUtil.CheckNull(_target) && !_target.IsDead()) { var to = _target.Get_position() - pc.Get_position(); to.y = 0f; if (to.sqrMagnitude > 1e-4f) dir = to; }
            if (dir.sqrMagnitude < 1e-6f) dir = Vector3.forward;
            dir.Normalize();
            float range = mc.rangeMul > 0f ? WL.Combat.RangeRing.WLRangeRing.AttackReach(pc) * mc.rangeMul : 0f;
            float step = count > 1 ? mc.fanDegrees / (count - 1) : 0f, a0 = count > 1 ? -mc.fanDegrees * 0.5f : 0f;
            for (int k = 0; k < count; k++)
            {
                int idx = volley * count + k; if (idx >= _shots.Count) break;
                var look = Quaternion.AngleAxis(a0 + step * k, Vector3.up) * dir;
                ProjectileInfo.Ins.Shoot_Projectile(_proj, _shots[idx], p =>
                {
                    p.m_Pierce = mc.pierce != 0; WLProjectileVisual.ApplyTo(p, _proj);
                    p.transform.rotation = Quaternion.LookRotation(look);
                    var pd = p.Get_ProjectTileData();
                    if (range > 0f && pd != null && pd.Speed > 0f) pd.LifeTime = Mathf.Max(0.05f, range / pd.Speed);
                });
                WLRapidShot.MultiArrows++;
            }
            WLRapidShot.LastLog = "멀티샷 " + (volley + 1) + "번째 · " + count + "발 · 부채 " + mc.fanDegrees.ToString("0.#") + "° · 사거리 " + range.ToString("F1") + " m";
        }

        static float ClipLen(Animator an, string clipName)
        {
            if (an != null && an.runtimeAnimatorController != null)
                foreach (var clip in an.runtimeAnimatorController.animationClips) if (clip != null && clip.name == clipName && clip.length > 0f) return clip.length;
            return 1f;
        }

        bool Broken() { return _pc == null || _pc.IsDead() || _pc.Get_CurAnim() != eAnim.Skill; }

        bool _holding;

        void End(bool toIdle)
        {
            if (_holding) { _holding = false; WLSkillCancel.EndHoldMove(_pc, toIdle); }
            if (!toIdle) { WLRapidShot.Aborted++; WLRapidShot.LastLog = "끊김(이동 · 구르기)"; }
            if (_animOwned && _an != null) { _an.speed = 1f; _an.fireEvents = true; }
            _animOwned = false; _co = null;
            if (toIdle && _pc != null && !_pc.IsDead() && _pc.Get_CurAnim() == eAnim.Skill) _pc.Play_Idle();
            _glow.End();
            if (_charge != null) { Destroy(_charge); _charge = null; }
            WLSlashFlurry.Off(_pb);
        }

        void OnDisable()
        {
            if (_holding) { _holding = false; WLSkillCancel.EndHoldMove(_pc, false); }
            if (_co != null) { StopCoroutine(_co); _co = null; }
            if (_animOwned && _an != null) { _an.speed = 1f; _an.fireEvents = true; _animOwned = false; }
            _glow.End();
            if (_charge != null) { Destroy(_charge); _charge = null; }
        }

        void Face()
        {
            if (_pc == null || DSUtil.CheckNull(_target) || _target.IsDead()) return;
            var to = _target.Get_position() - _pc.Get_position(); to.y = 0f;
            if (to.sqrMagnitude > 1e-4f) _pc.transform.rotation = Quaternion.LookRotation(to);
        }

        Vector3 BowCenter()
        {
            if (_socket != null) return _socket.TransformPoint(_centerLocal);
            return _pc != null ? _pc.Get_Center_position() : transform.position;
        }

        void ShowMark(float life)
        {
            if (DSUtil.CheckNull(_target) || InGameInfo.Ins == null) return;
            var c = _c; var target = _target;
            float h = Mathf.Max(0.1f, target.Get_Top_postion().y - target.Get_position().y);
            float scale = Mathf.Clamp(h * c.markPerHeight, c.markMin, c.markMax);
            InGameInfo.Ins.Show_Effect("Effect_BulletTarget", target, eEffectLocation.Mid, life, off =>
            {
                if (off == null) return;
                var fit = off.GetComponent<WLMarkFit>(); if (fit == null) fit = off.gameObject.AddComponent<WLMarkFit>();
                fit.Begin(target, c.markFront, scale, life);
            });
        }

        static Transform FindSocket(PCActor pc, string name)
        {
            if (pc == null || pc.tfs_weapon == null) return null;
            foreach (var s in pc.tfs_weapon) if (s != null && s.name == name && s.gameObject.activeInHierarchy) return s;
            return null;
        }

        static float ReleaseNormalized(Animator an, string clipName)
        {
            if (an == null || an.runtimeAnimatorController == null) return -1f;
            foreach (var clip in an.runtimeAnimatorController.animationClips)
            {
                if (clip == null || clip.name != clipName || clip.length <= 0f) continue;
                foreach (var ev in clip.events) if (ev.functionName == "Projectile") return ev.time / clip.length;
            }
            return -1f;
        }

        static GameObject Spawn(string path, Vector3 pos, float scale, float life)
        {
            if (string.IsNullOrEmpty(path)) return null;
            GameObject prefab;
            if (!s_fx.TryGetValue(path, out prefab)) { prefab = Resources.Load<GameObject>(path); s_fx[path] = prefab; }
            if (prefab == null) { WLRapidShot.LastLog = "이펙트 없음 " + path; return null; }
            var go = Instantiate(prefab, pos, prefab.transform.rotation);
            go.transform.localScale = prefab.transform.localScale * Mathf.Max(0.01f, scale);
            Destroy(go, Mathf.Max(0.1f, life));
            return go;
        }

        static Color Rgb(float[] a, float d) { return new Color(a != null && a.Length > 0 ? a[0] : d, a != null && a.Length > 1 ? a[1] : d, a != null && a.Length > 2 ? a[2] : d, 1f); }
    }

    /// <summary>#916 과녁 맞춤 — 원본 TurnOff_GO 가 Update 에서 대상 가운데로 옮긴 뒤(LateUpdate) 카메라 쪽 앞으로 당기고 몹 크기 배율을 준다. 기간이 지나면 원래 배율.</summary>
    public sealed class WLMarkFit : MonoBehaviour
    {
        Actor _target; float _front, _scale = 1f, _until; bool _on; Vector3 _scale0 = Vector3.one; bool _hasScale0;

        public void Begin(Actor target, float front, float scale, float life)
        {
            if (!_hasScale0) { _scale0 = transform.localScale; _hasScale0 = true; }
            _target = target; _front = front; _scale = scale; _until = Time.time + life; _on = true;
            foreach (var ps in GetComponentsInChildren<ParticleSystem>(true)) { var m = ps.main; m.scalingMode = ParticleSystemScalingMode.Hierarchy; }
            Apply();
        }

        void LateUpdate() { if (_on) Apply(); }

        void Apply()
        {
            if (Time.time > _until || DSUtil.CheckNull(_target) || _target.IsDead()) { Stop(); return; }
            var mid = WL.Combat.Impact.WLImpactFx.BodyCenter(_target);   // #921 PD 「몸 정중앙 · 공중 몬스터라도」 — 원본 Center_position(등장 때 잰 고정 높이) 대신 지금 몸 중심(떠 있는 몹 = 지금 그림 가운데)
            var cam = Camera.main;
            var toCam = cam != null ? (cam.transform.position - mid).normalized : Vector3.up;
            transform.position = mid + toCam * (WL.Combat.WLCombatMotionSettings.BodyRadius(_target) + _front);
            transform.localScale = _scale0 * _scale;
        }

        void Stop() { _on = false; if (_hasScale0) transform.localScale = _scale0; }
        void OnDisable() { Stop(); }
    }

    /// <summary>#921 레이저로 피해를 준 속사 화살 — 날아가는 동안 자기 판정을 끈다(이중 피해 방지) · 풀로 돌아갈 때(꺼질 때) 되살린다.</summary>
    public sealed class WLLaserMute : MonoBehaviour
    {
        Collider[] _cols;
        public static void Mute(ProjectileBase p)
        {
            if (p == null) return;
            var m = p.GetComponent<WLLaserMute>(); if (m == null) m = p.gameObject.AddComponent<WLLaserMute>();
            if (m._cols == null) m._cols = p.GetComponentsInChildren<Collider>(true);
            for (int i = 0; i < m._cols.Length; i++) if (m._cols[i] != null) m._cols[i].enabled = false;
            m.enabled = true;
        }
        void OnDisable()
        {
            if (_cols != null) for (int i = 0; i < _cols.Length; i++) if (_cols[i] != null) _cols[i].enabled = true;
            enabled = false;
        }
    }
}