// ─────────────────────────────────────────────────────────────────────────────
//  WLIslandFlowV2.cs — WL-816zc 「섬 초기 플로우 v2」
//
//  PD 원문(2026-09-15)
//    「원본 에셋과 같이 섬이 확장되는 방식과 순서는 유지하되, 내가 수정한 초기 플로우만 바뀌어야 해.
//     <최초 시작 시 밭 생성은 보류>
//     ① 캠프파이어 설치 → 상인 설치 → 사과 나무 설치 → 던전 생성
//     ② 전투 승리 후 섬 확장 노드 추가 → 이후 원본 에셋의 확장 순서대로 확장시켜야 함.」
//
//  ■ 발판은 **한 번에 하나**다. 값을 치르면 그 자리에 그 단계의 설치물이 남고, 다음 단계의 발판이 선다.
//    순서·문구·가격·자리·설치물은 전부 `WLIslandSettings.flowSteps[]` 값이다(코드 수정 0 · C45).
//  ■ 어디까지 왔는지는 PlayerPrefs 키 **1개**(`flowStepPrefsKey`)로만 센다.
//    섬으로 돌아오면 이 숫자를 보고 이미 치른 설치물을 다시 놓는다(세이브 복원).
//  ■ 원본 섬 확장 가격판(FI `Purchaser`)은 **첫 던전 승리 전까지 숨긴다**(렌더러·콜라이더만 끈다).
//    승리하면 그대로 다시 켜지고, 이후 확장 순서는 **FI 원본**(`Island.Constraint`)이 정한다 — 우리는 켜고 끄기만.
//  ■ 되돌리기 = `flowV2Enabled = 0` → 지금까지의 「던전 발판 4개」 방식 그대로.
//
//  🔴 원본(Assets/FarmingIsland/** · Assets/Script/**)은 한 줄도 고치지 않는다 — 인스턴스만 만든다.
//  🔴 Debug.LogError / Debug.LogException 을 쓰지 않는다(ErrorLogHookManager 가 플레이어 팝업을 띄운다).
// ─────────────────────────────────────────────────────────────────────────────

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using FIPurchaser = CryingSnow.FarmingIsland.Purchaser;
using FIIsland = CryingSnow.FarmingIsland.Island;
using FIIslandManager = CryingSnow.FarmingIsland.IslandManager;

namespace WL.Island
{
    /// <summary>초기 플로우(단계 표) 진행 + 설치물 배치. 정적 · 씬에 남는 상태 없음.</summary>
    public static class WLIslandFlowV2
    {
        const string RootName = "~WL_FlowInstalls";

        // ── 진단(프로브·보고가 읽는다 · 실측만)
        public static int InstallsMade;
        public static int LastStep;
        public static string LastLog = "";

        static readonly List<GameObject> s_made = new List<GameObject>(8);

        /// <summary>이 플로우가 지금 동작 중인가(꺼져 있으면 기존 발판 방식이 그대로 돈다).</summary>
        public static bool Active(WLIslandSettings cfg)
        {
            return cfg != null && cfg.gateFlowEnabled != 0 && cfg.flowV2Enabled != 0 && StepCount(cfg) > 0;
        }

        /// <summary>켜져 있는 단계 수.</summary>
        public static int StepCount(WLIslandSettings cfg)
        {
            if (cfg == null || cfg.flowSteps == null) return 0;
            int n = 0;
            for (int i = 0; i < cfg.flowSteps.Length; i++)
                if (cfg.flowSteps[i] != null && cfg.flowSteps[i].enabled_ != 0) n++;
            return n;
        }

        /// <summary>켜져 있는 것 중 n 번째 단계(없으면 null).</summary>
        public static WLFlowStepDef Nth(WLIslandSettings cfg, int n)
        {
            if (cfg == null || cfg.flowSteps == null || n < 0) return null;
            int k = 0;
            for (int i = 0; i < cfg.flowSteps.Length; i++)
            {
                var s = cfg.flowSteps[i];
                if (s == null || s.enabled_ == 0) continue;
                if (k == n) return s;
                k++;
            }
            return null;
        }

        /// <summary>지금까지 치른 단계 수(PlayerPrefs 1키 · FI 세이브를 건드리지 않는다).</summary>
        public static int Step(WLIslandSettings cfg)
        {
            if (cfg == null || string.IsNullOrEmpty(cfg.flowStepPrefsKey)) return 0;
            return Mathf.Max(0, PlayerPrefs.GetInt(cfg.flowStepPrefsKey, 0));
        }

        public static void SetStep(WLIslandSettings cfg, int n)
        {
            if (cfg == null || string.IsNullOrEmpty(cfg.flowStepPrefsKey)) return;
            PlayerPrefs.SetInt(cfg.flowStepPrefsKey, Mathf.Max(0, n));
            PlayerPrefs.Save();
            LastStep = Mathf.Max(0, n);
        }

        /// <summary>n 번째 단계의 발판 자리(표가 가리킨 던전 줄의 좌표 · -1 이면 밭 구역 중심).</summary>
        public static Vector3 PosFor(WLIslandSettings cfg, int n)
        {
            if (cfg == null) return Vector3.zero;

            var s = Nth(cfg, n);
            Vector3 p;
            if (s == null) p = cfg.platformPosition;
            else if (s.platformFromDungeonRow >= 0)
            {
                var d = cfg.DungeonRow(s.platformFromDungeonRow);
                p = d != null ? d.platformPosition : s.platformPosition;
            }
            else if (cfg.platformUseFarmPosition != 0 && WLIslandGateFlow.HaveFarmCenter) p = WLIslandGateFlow.FarmCenter;
            else p = s.platformPosition;

            p += cfg.platformOffset;
            return WLIslandGateFlow.SnapToGround(cfg, p);
        }

        // ─────────────────────────────────────────────────────────────────
        //  발판 + 설치물 다시 그리기 (섬 준비 직후 · 지불 직후 둘 다 여기로)
        // ─────────────────────────────────────────────────────────────────
        public static void Refresh(WLIslandSettings cfg, Scene scene)
        {
            if (!Active(cfg)) return;

            int step = Step(cfg);
            int total = StepCount(cfg);
            LastStep = step;

            // ① 이미 치른 단계의 설치물을 다시 놓는다(세이브 복원 · 매번 지우고 새로 놓는다).
            ClearInstalls();
            InstallsMade = 0;
            for (int i = 0; i < step && i < total; i++)
                if (Install(cfg, scene, Nth(cfg, i), PosFor(cfg, i))) InstallsMade++;

            // 캠프 장식은 전용 코드가 자기 자리(1단계 자리)에 놓는다.
            WLIslandCampDecor.Refresh(cfg, scene);

            // ② 다음 발판 1개
            if (WLGoldPlatform.Instance != null)
            {
                Object.Destroy(WLGoldPlatform.Instance.gameObject);
                WLGoldPlatform.Instance = null;
            }

            if (step >= total)
            {
                LastLog = "발판 없음 — 초기 플로우 " + step + "/" + total + " 단계 완료";
                WLIslandBridge.Log(cfg, LastLog);
                return;
            }

            var next = Nth(cfg, step);
            Vector3 pos = PosFor(cfg, step);
            string label = string.Format(cfg.flowLabelFormat, next.label, next.price);

            // 🔴 값을 치른 자리에 다음 발판이 곧바로 생기면 **가만히 서 있기만 해도** 연달아 팔린다(816g 실측).
            //    FI 섬 확장처럼 「한 번 내려왔다가 다시 올라오기」를 요구한다.
            var runner = WLIslandBridge.Runner;
            if (cfg.platformRequireStepOff != 0 && runner != null && WLIslandGateFlow.PlayerInRange(cfg, pos))
            {
                runner.StartCoroutine(Co_SpawnWhenClear(cfg, scene, pos, next.price, step, label, total));
                LastLog = "발판 대기 — 자리에서 내려오면 " + (step + 1) + "단계 「" + next.label + "」 발판을 놓는다";
                WLIslandBridge.Log(cfg, LastLog);
                return;
            }

            Spawn(cfg, scene, pos, next.price, step, label, total);
        }

        static void Spawn(WLIslandSettings cfg, Scene scene, Vector3 pos, int price, int step, string label, int total)
        {
            var p = WLGoldPlatform.Create(cfg, scene, pos, price, step, label);
            if (p != null) { WLIslandGateFlow.PlatformsMade++; WLIslandGateFlow.LastPlatformPos = pos; }
            LastLog = "플로우 발판 배치 — " + (step + 1) + "/" + total + " 「" + label.Replace("\n", " ") +
                      "」 @ " + pos.ToString("F2");
            WLIslandBridge.Log(cfg, LastLog);
        }

        static IEnumerator Co_SpawnWhenClear(WLIslandSettings cfg, Scene scene, Vector3 pos,
                                             int price, int step, string label, int total)
        {
            float t = 0f;
            while (t < cfg.platformStepOffTimeoutSeconds && WLIslandGateFlow.PlayerInRange(cfg, pos))
            {
                t += Time.unscaledDeltaTime;
                yield return null;
            }
            if (WLGoldPlatform.Instance != null) yield break;      // 그 사이 다른 경로로 이미 생겼다
            Spawn(cfg, scene, pos, price, step, label, total);
        }

        // ─────────────────────────────────────────────────────────────────
        //  지불 완료 → 그 단계의 설치물이 그 자리에 남는다
        // ─────────────────────────────────────────────────────────────────
        public static void OnPaid(WLIslandSettings cfg, Vector3 platformPos)
        {
            if (!Active(cfg)) return;

            int step = Step(cfg);
            int total = StepCount(cfg);
            if (step >= total) return;

            var s = Nth(cfg, step);
            SetStep(cfg, step + 1);

            var scene = SceneManager.GetSceneByName(cfg.islandSceneName);
            if (!scene.IsValid() || !scene.isLoaded) scene = SceneManager.GetActiveScene();

            // 던전 단계 = 원래의 해금 카운터도 같이 올린다 → 섬 복귀 시 `SpawnGates` 가 입구를 다시 놓는다.
            if (s != null && s.kind == "dungeon")
            {
                WLIslandGateFlow.SetUnlockedCount(cfg, DungeonStepsDone(cfg, step + 1));
                WLIslandGateFlow.Unlocks++;
            }

            LastLog = "🔴 지불 완료 — " + (step + 1) + "/" + total + " 「" + (s != null ? s.label : "?") +
                      "」 · 이 자리(" + platformPos.ToString("F1") + ")의 발판은 영영 사라진다";
            WLIslandBridge.Log(cfg, LastLog);

            Refresh(cfg, scene);
        }

        /// <summary>치른 단계 중 던전 단계가 몇 개인지(= 열려 있어야 할 던전 수).</summary>
        static int DungeonStepsDone(WLIslandSettings cfg, int stepsDone)
        {
            int n = 0;
            for (int i = 0; i < stepsDone; i++)
            {
                var s = Nth(cfg, i);
                if (s != null && s.kind == "dungeon") n++;
            }
            return n;
        }

        // ─────────────────────────────────────────────────────────────────
        //  설치물 하나
        // ─────────────────────────────────────────────────────────────────
        static bool Install(WLIslandSettings cfg, Scene scene, WLFlowStepDef s, Vector3 pos)
        {
            if (cfg == null || s == null) return false;

            if (s.kind == "camp") return false;                 // 캠프는 WLIslandCampDecor 가 놓는다

            if (s.kind == "dungeon")
            {
                var d = cfg.DungeonRow(s.dungeonRow);
                if (d != null) WLIslandBridge.SpawnOneGate(cfg, d, scene);   // 이미 있으면 안에서 건너뛴다
                // 2026-09-16 PD 「던전 개방 이후에는 기존 에셋과 동일한 순서로 확장 노드」 — 던전 노드가 열리면 원본 확장 가격판을 개방한다.
                if (d != null && cfg.expansionUnlockOnDungeonOpen != 0) WLIslandExpansionGate.Unlock(cfg);
                // 🔴 2026-09-16 PD 「생성된 오브젝트에 플레이어가 끼임」 — 입구(아치)는 발판 자리에 서 있는 플레이어 위로 생긴다 → 밀어낸다.
                if (d != null)
                {
                    var gates = Object.FindObjectsByType<WLDungeonGate>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
                    for (int i = 0; i < gates.Length; i++) if (gates[i] != null && gates[i].Def == d) { PushPlayerOut(cfg, gates[i].gameObject); break; }
                }
                return d != null;
            }

            // kind = prefab
            if (string.IsNullOrEmpty(s.prefabPath)) return false;
            var root = EnsureRoot(scene);
            var go = SpawnPrefab(cfg, s.prefabPath, root.transform, pos, s.yaw, s.scale, s.keepCollider != 0);
            if (go == null) return false;

            // 덧붙일 것(예: 좌판에 상인이 안 들어 있을 때만 상인을 넣는다) — 원본 프리팹 그대로, 설치물의 자식으로.
            if (!string.IsNullOrEmpty(s.extraPrefabPath) && !HasComponentNamed(go, s.extraSkipIfComponent))
            {
                var rot = Quaternion.Euler(0f, s.yaw, 0f);
                SpawnPrefab(cfg, s.extraPrefabPath, go.transform, pos + rot * s.extraOffset,
                            s.yaw, s.scale, s.keepCollider != 0);
            }
            PushPlayerOut(cfg, go);
            return true;
        }

        // ─────────────────────────────────────────────────────────────────
        //  🔴 2026-09-16 PD 「가판대가 갑자기 생기며 플레이어가 프랍에 끼어버린다 — 생성 위치에 캐릭터가 있으면 밀려나게」
        //    설치물의 월드 범위(렌더러+콜라이더)를 플레이어 반지름만큼 넓힌 상자 안에 플레이어가 있으면, 설치물 중심 → 플레이어 방향으로
        //    상자 밖까지 밀어낸다(CharacterController 는 잠시 끄고 옮긴다 · FI 텔레포트와 같은 방식). 높이 = 그 자리 지면(설치물 자신은 제외).
        // ─────────────────────────────────────────────────────────────────
        public static int PlayerPushes;
        public static string LastPushLog = "";

        public static void PushPlayerOut(WLIslandSettings cfg, GameObject install)
        {
            if (cfg.installPushPlayer == 0 || install == null) return;
            var pc = Object.FindFirstObjectByType<CryingSnow.FarmingIsland.PlayerController>();
            if (pc == null) return;
            Bounds b; if (!WorldBounds(install, out b)) return;
            float margin = Mathf.Max(0.1f, cfg.installPushMargin);
            var box = new Bounds(b.center, b.size);
            box.Expand(new Vector3(margin * 2f, 100f, margin * 2f));
            var p = pc.transform.position;
            if (!box.Contains(new Vector3(p.x, b.center.y, p.z))) return;

            // 후보 방향: ① 설치물 중심 → 플레이어 ② 섬(열린 타일) 중심 쪽 ③ ±x ④ ±z — **발 디딜 땅이 있는** 첫 방향을 쓴다
            //    (2026-09-16 실측: 남쪽 끝 사과나무 자리에서 ①만 쓰면 섬 밖 물로 떨어졌다).
            var away = new Vector3(p.x - b.center.x, 0f, p.z - b.center.z);
            if (away.sqrMagnitude < 1e-4f) away = -pc.transform.forward;
            away.y = 0f; if (away.sqrMagnitude < 1e-6f) away = Vector3.back; away.Normalize();
            var isl = IslandCenter(); var toIsland = new Vector3(isl.x - b.center.x, 0f, isl.z - b.center.z);
            if (toIsland.sqrMagnitude < 1e-4f) toIsland = -away; toIsland.Normalize();
            var dirs = new[] { away, toIsland, Vector3.right, Vector3.left, Vector3.forward, Vector3.back };
            Vector3 target = p; float t = 0f; bool ok = false; string how = "";
            for (int k = 0; k < dirs.Length && !ok; k++)
            {
                var dir = dirs[k];
                float tx = Mathf.Abs(dir.x) > 1e-4f ? ((dir.x > 0f ? box.max.x : box.min.x) - p.x) / dir.x : float.MaxValue;
                float tz = Mathf.Abs(dir.z) > 1e-4f ? ((dir.z > 0f ? box.max.z : box.min.z) - p.z) / dir.z : float.MaxValue;
                t = Mathf.Min(tx, tz) + 0.15f;
                var cand = p + dir * t;
                float gy; if (!GroundY(cand, p.y, out gy)) continue;         // 땅 없음(섬 밖) → 다음 방향
                cand.y = gy; target = cand; ok = true; how = k == 0 ? "바깥쪽" : k == 1 ? "섬 안쪽" : "축 방향 " + k;
            }
            if (!ok) { LastPushLog = "밀어낼 땅을 못 찾음 — " + install.name; WLIslandBridge.Log(cfg, LastPushLog); return; }

            var cc = pc.GetComponent<CharacterController>();
            if (cc != null) { cc.enabled = false; pc.transform.position = target; cc.enabled = true; }
            else pc.transform.position = target;
            PlayerPushes++;
            LastPushLog = "설치물 " + install.name + " 범위 " + b.size.x.ToString("F1") + "×" + b.size.z.ToString("F1") + " m 안의 플레이어를 " +
                          p.ToString("F2") + " → " + target.ToString("F2") + " 로 밀어냄(" + t.ToString("F2") + " m · " + how + ")";
            WLIslandBridge.Log(cfg, LastPushLog);
        }

        /// <summary>열린 타일(FI Island · IsUnlocked)의 중심 — 없으면 원점.</summary>
        static Vector3 IslandCenter()
        {
            var islands = Object.FindObjectsByType<CryingSnow.FarmingIsland.Island>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
            Vector3 sum = Vector3.zero; int n = 0;
            for (int i = 0; i < islands.Length; i++)
            {
                var isl = islands[i];
                if (isl == null || !isl.IsUnlocked || !isl.gameObject.activeInHierarchy) continue;
                if (isl.GetComponent<MeshFilter>() == null || isl.GetComponent<MeshFilter>().sharedMesh == null) continue;   // 더미(발판 타깃) 제외
                sum += isl.transform.position; n++;
            }
            return n > 0 ? sum / n : Vector3.zero;
        }

        static bool WorldBounds(GameObject go, out Bounds b)
        {
            b = new Bounds(); bool set = false;
            var rends = go.GetComponentsInChildren<Renderer>(true);
            for (int i = 0; i < rends.Length; i++)
            {
                if (rends[i] == null || rends[i] is ParticleSystemRenderer || rends[i] is TrailRenderer) continue;
                if (!set) { b = rends[i].bounds; set = true; } else b.Encapsulate(rends[i].bounds);
            }
            var cols = go.GetComponentsInChildren<Collider>(true);
            for (int i = 0; i < cols.Length; i++)
            {
                if (cols[i] == null || cols[i].isTrigger) continue;
                if (!set) { b = cols[i].bounds; set = true; } else b.Encapsulate(cols[i].bounds);
            }
            return set;
        }

        /// <summary>
        /// 그 자리 지면 높이 — 설치물(`~WL_FlowInstalls` 밑) 콜라이더 제외 · 요청 높이 +1 m 보다 높거나 −0.6 m 보다 낮은 맞힘(바다·경사) 무시.
        /// 반환 false = 발 디딜 땅 없음(섬 밖).
        /// </summary>
        static bool GroundY(Vector3 p, float refY, out float groundY)
        {
            var hits = Physics.RaycastAll(new Vector3(p.x, refY + 3f, p.z), Vector3.down, 10f, ~0, QueryTriggerInteraction.Ignore);
            float best = float.NaN;
            for (int i = 0; i < hits.Length; i++)
            {
                var c = hits[i].collider; if (c == null) continue;
                var tr = c.transform; bool ours = false;
                while (tr != null) { if (tr.name == RootName) { ours = true; break; } tr = tr.parent; }
                if (ours) continue;
                float y = hits[i].point.y;
                if (y > refY + 1f || y < refY - 0.6f) continue;
                if (float.IsNaN(best) || y > best) best = y;
            }
            groundY = float.IsNaN(best) ? refY : best + 0.02f;
            return !float.IsNaN(best);
        }

        static GameObject EnsureRoot(Scene scene)
        {
            for (int i = 0; i < s_made.Count; i++)
                if (s_made[i] != null && s_made[i].name == RootName) return s_made[i];

            var root = new GameObject(RootName);
            if (scene.IsValid() && scene.isLoaded) SceneManager.MoveGameObjectToScene(root, scene);
            s_made.Add(root);
            return root;
        }

        static GameObject SpawnPrefab(WLIslandSettings cfg, string path, Transform parent, Vector3 pos,
                                      float yaw, float scale, bool keepCollider)
        {
            var prefab = WLIslandAssets.LoadPrefab(path);
            if (prefab == null) { WLIslandBridge.Log(cfg, "플로우 설치물 프리팹 없음 — " + path); return null; }

            // 🔴 부모를 주고 만든다 — FI 스크립트(예: `Merchant.Awake` 의 `GetComponentInParent<Stall>()`)가
            //    Awake 시점에 부모를 볼 수 있어야 한다. 부모의 씬에 그대로 들어가므로 씬 이동도 필요 없다.
            var go = Object.Instantiate(prefab, parent);
            go.name = "~WL_Flow_" + prefab.name;
            go.transform.position = Snap(cfg, pos);
            go.transform.rotation = Quaternion.Euler(0f, yaw, 0f);
            float sc = scale > 0.001f ? scale : 1f;
            go.transform.localScale = prefab.transform.localScale * sc;

            if (!keepCollider)
            {
                // 장식 = 이동 방해 0 · NavMesh 재베이크 없음(816y 캠프 장식과 같은 원칙).
                var cols = go.GetComponentsInChildren<Collider>(true);
                for (int i = 0; i < cols.Length; i++) if (cols[i] != null) cols[i].enabled = false;
            }
            return go;
        }

        static bool HasComponentNamed(GameObject go, string typeName)
        {
            if (go == null || string.IsNullOrEmpty(typeName)) return false;
            var comps = go.GetComponentsInChildren<Component>(true);
            for (int i = 0; i < comps.Length; i++)
                if (comps[i] != null && comps[i].GetType().Name == typeName) return true;
            return false;
        }

        static Vector3 Snap(WLIslandSettings cfg, Vector3 p)
        {
            if (cfg.platformSnapToGround == 0) return p;
            // 2026-09-16 PD 「상인이 공중에 떠 있다」 실측: 재훑기마다 다시 스냅하는데, 광선이 **방금 놓은 설치물 자신의 콜라이더**(좌판 3 m 상자) 위를
            //  맞혀 한 번 훑을 때마다 3 m 씩 떠올랐다(y 3.00 · 콜라이더 위 6.00 실측). 설치물(`~WL_FlowInstalls` 밑)은 건너뛰고,
            //  요청 높이보다 `platformSnapMaxRise` 이상 위로 솟는 맞힘(다른 소품 위)도 무시한다 — 설치물은 타일 윗면에 놓는 것이 목적이다.
            var hits = Physics.RaycastAll(new Vector3(p.x, p.y + 30f, p.z), Vector3.down, 60f, ~0, QueryTriggerInteraction.Ignore);
            float best = float.NaN;
            for (int i = 0; i < hits.Length; i++)
            {
                var c = hits[i].collider; if (c == null) continue;
                var t = c.transform; bool ours = false;
                while (t != null) { if (t.name == RootName) { ours = true; break; } t = t.parent; }
                if (ours) continue;
                float y = hits[i].point.y;
                if (y > p.y + Mathf.Max(0f, cfg.platformSnapMaxRise)) continue;
                if (float.IsNaN(best) || y > best) best = y;
            }
            return float.IsNaN(best) ? p : new Vector3(p.x, best, p.z);
        }

        public static void ClearInstalls()
        {
            for (int i = 0; i < s_made.Count; i++)
                if (s_made[i] != null) Object.Destroy(s_made[i]);
            s_made.Clear();
        }
    }

    // ─────────────────────────────────────────────────────────────────────
    //  원본 섬 확장 노드 — 첫 던전 승리 전까지 숨김
    //
    //  🔴 FI 의 확장 **순서·조건은 건드리지 않는다**(`IslandManager.RefreshIsland` · `Island.Constraint` 그대로).
    //     우리는 이미 만들어진 가격판의 **렌더러·콜라이더만** 껐다 켠다 = FI 세이브·격자에 흔적 0.
    //     `SetActive(false)` 를 쓰지 않는 이유는 816g 와 같다(꺼진 오브젝트에서 코루틴이 시작되면 에러).
    // ─────────────────────────────────────────────────────────────────────
    /// <summary>섬 플레이어 크기를 이미 키웠다는 표식(WLIslandSceneSetup.ApplyPlayerScale · 1회).</summary>
    public sealed class WLPlayerScaled : MonoBehaviour { }

    /// <summary>FI 확장 가격판을 이웃 칸 가장자리로 옮겼다는 표식(원래 자리 기억).</summary>
    public sealed class WLPlacedPurchaser : MonoBehaviour { public Vector3 original; }

    public static class WLIslandExpansionGate
    {
        // ── 진단(프로브·보고가 읽는다 · 실측만)
        public static int PurchasersHidden, PurchasersPlaced;
        public static string LastLog = "", LastPlaceLog = "";

        // ─────────────────────────────────────────────────────────────────
        //  🔴 2026-09-16 PD 「확장 가격판이 맵에 가려져 안 보인다 → 위에 · 확장 방향과 가장 가까운 걸어갈 수 있는 자리」
        //    FI 는 가격판을 **잠긴 칸 중앙**(이웃 칸 가장자리에서 4 m 바다 쪽 · y −0.5)에 눕힌다 → 우리 해변 경사(모래)가 판의 안쪽 절반을 덮는다.
        //    → 확장 방향의 이웃(열린) 칸 가장자리에서 `expansionPadInset` 안쪽 지면 위로 옮긴다. FI 의 `activePurchasers` 는 칸 좌표로 기억하므로
        //      트랜스폼만 옮겨도 격자·세이브·구매 로직은 그대로고, 트리거 상자(십자 ±5 m)도 함께 옮겨져 걸어가 밟을 수 있다.
        // ─────────────────────────────────────────────────────────────────
        public static void PlacePurchasers(WLIslandSettings cfg, Scene scene)
        {
            if (cfg == null || cfg.expansionPadPlace == 0) return;
            var mgr = FIIslandManager.Instance;
            float size = mgr != null && mgr.IslandSize > 0.1f ? mgr.IslandSize : 8f, half = size * 0.5f;
            var all = Object.FindObjectsByType<FIPurchaser>(FindObjectsInactive.Include, FindObjectsSortMode.None);
            FIIsland[] islands = null;
            for (int i = 0; i < all.Length; i++)
            {
                var p = all[i];
                if (p == null || p.GetComponent<WLPlacedPurchaser>() != null) continue;
                if (scene.IsValid() && p.gameObject.scene != scene && p.gameObject.scene != SceneManager.GetActiveScene()) continue;
                if (p.GetComponentInParent<WLGoldPlatform>() != null) continue;       // 우리 발판
                if (islands == null) islands = Object.FindObjectsByType<FIIsland>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);

                var pos = p.transform.position;                                        // 잠긴 칸 중앙(FI 원래 자리)
                Vector3 target, c;
                if (!ComputePadSpot(cfg, pos, islands, size, out target, out c)) continue;   // 이웃을 못 찾으면 FI 자리 그대로
                float plateDropLocal = 0f; var frame = p.transform.Find("Frame"); if (frame != null) plateDropLocal = -frame.localPosition.y;   // 판 자식들이 루트보다 아래(로컬 −0.49)
                // 🔴 2026-09-17 PD 「확장 가격판이 너무 크다 → 캠프파이어 발판과 같은 크기」 = 우리 발판과 같은 배율(platformScale 0.5 = expansionPadScale)
                float ps = cfg.expansionPadScale > 0.05f ? cfg.expansionPadScale : 1f;
                p.transform.localScale = Vector3.one * ps;
                // 🔴 2026-09-17 PD 「가격판이 경사에 가려지지 않게」 — 판 넓이(반지름 ≈ 2.56×배율) 안 5점의 지형·콜라이더 높이 중 **최고점** 위에 놓고,
                //    지형 법선에 맞춰 살짝 눕힌다(최대 expansionPadTiltMax°) → 해변 경사·둔덕 어느 쪽에도 묻히지 않는다.
                Quaternion rot;
                float gy = PadSurfaceY(new Vector3(target.x, c.y, target.z), c.y, 2.56f * ps, cfg.expansionPadTiltMax, out rot);
                p.transform.rotation = rot;
                p.transform.position = new Vector3(target.x, gy + plateDropLocal * ps + cfg.expansionPadLift, target.z);
                // 🔴 2026-09-17 — 원본 트리거는 십자(10×5×5 두 개 · ±5 m)라 가장자리로 옮긴 판끼리 겹쳐 두 구매가 동시에 시작됐다(원본 활성화 경쟁 → 「Bridge (0) inactive」).
                //    판 크기(expansionPadTriggerSize · 월드 m)만큼의 상자 하나로 줄인다 = 판을 밟아야 산다(우리 발판과 같은 규칙). 로컬 치수는 배율로 역보정.
                if (cfg.expansionPadTriggerSize > 0.1f)
                {
                    // 🔴 2026-09-17 PD 화면 실측 「NullReference — FI AnimalController.CreateAgent」 = 같은 칸 `Activate()` 2회 → 동물 NavMeshAgent 2회 추가.
                    //    원인 = 트리거 상자 **두 개**(원본 십자)가 같은 크기로 겹쳐 OnTriggerEnter 가 2번 → BeginPurchase 코루틴 2개가 둘 다 Activate() 호출.
                    //    → 상자는 **하나만** 남긴다(나머지는 끔).
                    var boxes = p.GetComponents<BoxCollider>();
                    float ts = cfg.expansionPadTriggerSize / ps;
                    for (int b = 0; b < boxes.Length; b++)
                    {
                        if (boxes[b] == null) continue;
                        if (b > 0) { boxes[b].enabled = false; continue; }
                        boxes[b].enabled = true;
                        boxes[b].size = new Vector3(ts, 4f / ps, ts);
                        boxes[b].center = new Vector3(0f, -plateDropLocal + 2f / ps, 0f);   // 판 높이에서 위로 4 m(월드)
                    }
                }
                if (cfg.expansionPadOverlay != 0) ApplyOverlay(p.gameObject, cfg.expansionPadOverlay >= 2);   // 1 = 깊이 검사(캐릭터가 가림) · 2 = 글자까지 항상 위
                var mk = p.gameObject.AddComponent<WLPlacedPurchaser>(); mk.original = pos;
                PurchasersPlaced++;
                LastPlaceLog = "확장 가격판 " + pos.ToString("F0") + " → " + p.transform.position.ToString("F2") + "(이웃 " + c.ToString("F0") + " 가장자리 · 옆으로 " + LastSlide.ToString("F1") + " m · 표면 " + gy.ToString("F2") + " · " + LastFitLog + ")";
                WLIslandBridge.Log(cfg, LastPlaceLog);
            }
        }

        // ─────────────────────────────────────────────────────────────────
        //  🔴 2026-09-17 PD 「가격판이 풀·오브젝트에 가려지지 않게」 → 「가격 판이 캐릭터를 가리지 않게 · 바닥에 붙은 느낌」(같은 날 두 번째 지시)
        //    스프라이트(Frame·Coin)는 `WL/SpriteOverlay`(깊이 검사 LEqual + 깊이 오프셋 = 바닥과 z-파이팅 없이 붙고, 캐릭터·소품이 앞에 있으면 가려진다).
        //    가격 글자(TMP)는 **원본 재질 그대로**(깊이 검사) — `expansionPadOverlay 2` 일 때만 Overlay 변형(항상 위) 복사본을 물린다(에셋 0줄).
        //    풀은 판 자리 모래 원(padClearRadius)이 비우므로 항상-위 그리기가 더는 필요 없다.
        // ─────────────────────────────────────────────────────────────────
        static Material s_spriteOverlay;
        static readonly Dictionary<Material, Material> s_tmpOverlay = new Dictionary<Material, Material>();
        public static int OverlayApplied;

        public static void ApplyOverlay(GameObject root, bool textAlwaysOnTop)
        {
            if (root == null) return;
            var srs = root.GetComponentsInChildren<SpriteRenderer>(true);
            if (srs.Length > 0)
            {
                if (s_spriteOverlay == null)
                {
                    var sh = Shader.Find("WL/SpriteOverlay");
                    if (sh != null) s_spriteOverlay = new Material(sh) { name = "WL_SpriteOverlay(runtime)", hideFlags = HideFlags.DontSave };
                }
                if (s_spriteOverlay != null)
                    for (int i = 0; i < srs.Length; i++) if (srs[i] != null && srs[i].sharedMaterial != s_spriteOverlay) { srs[i].sharedMaterial = s_spriteOverlay; OverlayApplied++; }
            }
            if (!textAlwaysOnTop) return;
            var texts = root.GetComponentsInChildren<TMPro.TMP_Text>(true);
            for (int i = 0; i < texts.Length; i++)
            {
                var t = texts[i]; if (t == null) continue;
                var src = t.fontSharedMaterial; if (src == null || src.shader == null) continue;
                if (src.shader.name.IndexOf("Overlay", System.StringComparison.OrdinalIgnoreCase) >= 0) continue;
                Material dst;
                if (!s_tmpOverlay.TryGetValue(src, out dst) || dst == null)
                {
                    var sh = Shader.Find("TextMeshPro/Mobile/Distance Field Overlay");
                    if (sh == null) return;
                    dst = new Material(src) { name = src.name + "(WL overlay)", hideFlags = HideFlags.DontSave, shader = sh };
                    s_tmpOverlay[src] = dst;
                }
                t.fontSharedMaterial = dst; OverlayApplied++;
            }
        }

        /// <summary>
        /// 잠긴 칸(lockedPos)의 가격판 자리 — 직교 이웃 중 **열린 칸**(다리 포함)을 고정 순서(북·동·남·서 · 땅 우선)로 고르고,
        /// 그 칸 가장자리에서 `expansionPadInset` 안쪽 지점을 돌려준다. 가격판 배치와 지형(판 자리 모래·풀 없음)이 **같은 식**을 쓴다.
        /// 2026-09-17 PD 「가격판은 이동 가능한 범위 안에서 최대한 가장자리」 → inset 기본 1.0 m.
        /// </summary>
        // 🔴 2026-09-17 PD 「다리 위 가격판 자리가 저절로 바뀌지 않게」 ① — 잠긴 칸마다 처음 정한 자리를 기억한다(더 좋은 이웃이 나중에 열려도 · 던전에서 돌아와
        //    FI 가 세이브에서 가격판을 다시 만들어도 그대로). PlayerPrefs 에 같이 적어 두고, 세이브 초기화(WLIslandStart) 때 함께 비운다.
        const string kSpotPrefsKey = "WL_Island_PadSpots";
        static readonly Dictionary<Vector3Int, Vector3> s_spotByTile = new Dictionary<Vector3Int, Vector3>();
        static readonly Dictionary<Vector3Int, Vector3> s_neighborByTile = new Dictionary<Vector3Int, Vector3>();
        static bool s_spotsLoaded;
        public static int SpotMemory { get { return s_spotByTile.Count; } }

        public static void ClearSpotMemory() { s_spotByTile.Clear(); s_neighborByTile.Clear(); s_spotsLoaded = true; PlayerPrefs.DeleteKey(kSpotPrefsKey); }

        static void LoadSpots()
        {
            if (s_spotsLoaded) return;
            s_spotsLoaded = true;
            var s = PlayerPrefs.GetString(kSpotPrefsKey, "");
            if (string.IsNullOrEmpty(s)) return;
            var ci = System.Globalization.CultureInfo.InvariantCulture;
            var entries = s.Split(';');
            for (int i = 0; i < entries.Length; i++)
            {
                var f = entries[i].Split(',');
                if (f.Length != 6) continue;
                try
                {
                    var key = new Vector3Int(int.Parse(f[0], ci), 0, int.Parse(f[1], ci));
                    s_spotByTile[key] = new Vector3(float.Parse(f[2], ci), 0f, float.Parse(f[3], ci));
                    s_neighborByTile[key] = new Vector3(float.Parse(f[4], ci), 0f, float.Parse(f[5], ci));
                }
                catch (System.Exception) { }
            }
        }

        static void SaveSpots()
        {
            var ci = System.Globalization.CultureInfo.InvariantCulture;
            var sb = new System.Text.StringBuilder();
            foreach (var kv in s_spotByTile)
            {
                Vector3 n; if (!s_neighborByTile.TryGetValue(kv.Key, out n)) n = kv.Value;
                if (sb.Length > 0) sb.Append(';');
                sb.Append(kv.Key.x.ToString(ci)).Append(',').Append(kv.Key.z.ToString(ci)).Append(',')
                  .Append(kv.Value.x.ToString("F2", ci)).Append(',').Append(kv.Value.z.ToString("F2", ci)).Append(',')
                  .Append(n.x.ToString("F2", ci)).Append(',').Append(n.z.ToString("F2", ci));
            }
            PlayerPrefs.SetString(kSpotPrefsKey, sb.ToString());
            PlayerPrefs.Save();
        }

        public static bool ComputePadSpot(WLIslandSettings cfg, Vector3 lockedPos, FIIsland[] islands, float size, out Vector3 spot, out Vector3 neighborCenter)
        {
            spot = lockedPos; neighborCenter = lockedPos;
            LoadSpots();
            var key = Vector3Int.RoundToInt(lockedPos);
            if (s_spotByTile.TryGetValue(key, out spot)) { neighborCenter = s_neighborByTile[key]; return true; }
            float half = size * 0.5f;
            Vector3[] dirs = { Vector3.forward, Vector3.right, Vector3.back, Vector3.left };
            FIIsland best = null; Vector3 bestDir = Vector3.zero; int bestRank = int.MaxValue;
            for (int k = 0; k < islands.Length; k++)
            {
                var isl = islands[k];
                if (isl == null || !isl.IsUnlocked || !isl.gameObject.activeInHierarchy) continue;
                var mf = isl.GetComponent<MeshFilter>(); if (mf == null || mf.sharedMesh == null) continue;   // 더미 제외
                var ip = isl.transform.position;
                for (int d = 0; d < 4; d++)
                {
                    var expect = lockedPos - dirs[d] * size;                                   // 이웃이 잠긴 칸의 dirs[d] 반대편에 있으면 판은 이웃의 dirs[d] 쪽 가장자리
                    if (Mathf.Abs(ip.x - expect.x) > size * 0.1f || Mathf.Abs(ip.z - expect.z) > size * 0.1f) continue;
                    int rank = d + (isl.IsBridge ? 4 : 0);                                      // 땅 우선 · 북동남서 순
                    if (rank < bestRank) { bestRank = rank; best = isl; bestDir = dirs[d]; }
                }
            }
            if (best == null) return false;
            neighborCenter = best.transform.position;
            // 🔴 2026-09-17 PD ③ 「확장 방향에 맞게 · 십자 방향 판끼리 안 겹치게 간격·크기」
            //    자리 = 확장 방향 가장자리 **중앙**, 안쪽 거리 = max(설정, 판 반지름 + 0.15)(판·트리거가 칸 밖으로 안 나간다).
            //    그 자리가 텐트·모닥불·던전 문·발판·다른 확장 판·소품과 겹치면 가장자리를 따라 옆으로(±1 · ±2 · 끝) 비킨다.
            float ps = cfg.expansionPadScale > 0.05f ? cfg.expansionPadScale : 1f;
            float padR = 2.56f * ps;
            float inset = Mathf.Clamp(Mathf.Max(cfg.expansionPadInset, padR + 0.15f), 0.3f, half);
            var basePos = neighborCenter + bestDir * (half - inset);
            var perp = new Vector3(bestDir.z, 0f, bestDir.x);
            float maxSlide = Mathf.Max(0f, half - padR - 0.25f);
            float[] cands = { 0f, 1f, -1f, 2f, -2f, maxSlide, -maxSlide };
            spot = basePos; LastSlide = 0f; bool found = false;
            for (int k = 0; k < cands.Length; k++)
            {
                float s = Mathf.Clamp(cands[k], -maxSlide, maxSlide);
                var cand = basePos + perp * s;
                if (IsSpotBlocked(cfg, cand, padR, key, islands)) continue;
                spot = cand; LastSlide = s; found = true; break;
            }
            if (!found) BlockedSpots++;
            s_spotByTile[key] = new Vector3(spot.x, 0f, spot.z); s_neighborByTile[key] = new Vector3(neighborCenter.x, 0f, neighborCenter.z);
            SaveSpots();
            return true;
        }

        public static float LastSlide; public static int BlockedSpots;

        /// <summary>판 자리가 막혔는가 — 다른 확장 판(잠긴 칸 기억 자리) · 캠프 장식 · 던전 문 · 우리 발판(렌더러 경계) · 콜라이더 있는 섬 소품(동물 제외).</summary>
        static bool IsSpotBlocked(WLIslandSettings cfg, Vector3 c, float padR, Vector3Int selfKey, FIIsland[] islands)
        {
            float sep = Mathf.Max(2f * padR, cfg.expansionPadTriggerSize) + 0.4f;
            foreach (var kv in s_spotByTile)
            {
                if (kv.Key == selfKey || IsTileUnlocked(kv.Key, islands)) continue;
                float dx = kv.Value.x - c.x, dz = kv.Value.z - c.z;
                if (dx * dx + dz * dz < sep * sep) return true;
            }
            float r = padR + 0.2f;
            var made = WLIslandCampDecor.Made;
            for (int i = 0; i < made.Count; i++)
            {
                if (made[i] == null) continue;
                var t = made[i].transform;
                if (t.childCount == 0) { if (RectHitsCircle(RendererBounds(made[i]), c, r)) return true; continue; }
                for (int j = 0; j < t.childCount; j++) if (RectHitsCircle(RendererBounds(t.GetChild(j).gameObject), c, r)) return true;   // 텐트·모닥불 하나씩
            }
            var gates = Object.FindObjectsByType<WLDungeonGate>(FindObjectsSortMode.None);
            for (int i = 0; i < gates.Length; i++) if (gates[i] != null && RectHitsCircle(RendererBounds(gates[i].gameObject), c, r)) return true;
            var plats = Object.FindObjectsByType<WLGoldPlatform>(FindObjectsSortMode.None);
            for (int i = 0; i < plats.Length; i++) if (plats[i] != null && RectHitsCircle(RendererBounds(plats[i].gameObject), c, r)) return true;
            var cols = Physics.OverlapSphere(new Vector3(c.x, c.y + 0.5f, c.z), r, ~0, QueryTriggerInteraction.Collide);
            for (int i = 0; i < cols.Length; i++)
            {
                var col = cols[i]; if (col == null) continue;
                if (col.GetComponentInParent<CryingSnow.FarmingIsland.IProp>() == null) continue;
                if (col.GetComponentInParent<CryingSnow.FarmingIsland.AnimalController>() != null) continue;
                return true;
            }
            return false;
        }

        static bool IsTileUnlocked(Vector3Int key, FIIsland[] islands)
        {
            if (islands == null) return false;
            for (int i = 0; i < islands.Length; i++)
            {
                var isl = islands[i]; if (isl == null) continue;
                if (Vector3Int.RoundToInt(isl.transform.position) == key) return isl.IsUnlocked;
            }
            return false;
        }

        static Bounds RendererBounds(GameObject go)
        {
            var rs = go.GetComponentsInChildren<Renderer>(false);
            if (rs.Length == 0) return new Bounds(go.transform.position, Vector3.zero);
            var b = rs[0].bounds;
            for (int i = 1; i < rs.Length; i++) b.Encapsulate(rs[i].bounds);
            return b;
        }

        static bool RectHitsCircle(Bounds b, Vector3 c, float r)
        {
            if (b.size.x <= 0f && b.size.z <= 0f) return false;
            float dx = Mathf.Max(b.min.x - c.x, 0f, c.x - b.max.x), dz = Mathf.Max(b.min.z - c.z, 0f, c.z - b.max.z);
            return dx * dx + dz * dz < r * r;
        }

        /// <summary>
        /// 지금 가격판이 놓일(놓인) 자리 전부 — 잠긴 칸 중 「직교 이웃이 열려 있고 선행 조건(Constraint)이 풀린」 칸(FI 가 판을 만드는 조건과 같음).
        /// 지형이 이 자리에 모래를 깔아 풀을 비운다.
        /// </summary>
        public static int CollectPadSpots(WLIslandSettings cfg, List<Vector3> outSpots)
        {
            if (cfg == null || cfg.expansionPadPlace == 0) return 0;
            var mgr = FIIslandManager.Instance;
            float size = mgr != null && mgr.IslandSize > 0.1f ? mgr.IslandSize : 8f;
            var islands = Object.FindObjectsByType<FIIsland>(FindObjectsInactive.Include, FindObjectsSortMode.None);
            int n = 0;
            for (int i = 0; i < islands.Length; i++)
            {
                var isl = islands[i];
                if (isl == null || isl.IsUnlocked) continue;
                var mf = isl.GetComponent<MeshFilter>(); if (mf == null || mf.sharedMesh == null) continue;
                if (isl.Constraint != null && !isl.Constraint.IsUnlocked) continue;
                Vector3 spot, c;
                if (!ComputePadSpot(cfg, isl.transform.position, islands, size, out spot, out c)) continue;
                outSpots.Add(spot); n++;
            }
            return n;
        }

        // ─────────────────────────────────────────────────────────────────
        //  🔴 2026-09-17 PD 「가격판이 경사에 가려지지 않게」
        //    판 평면 = 중심 표면 높이 + 지형 법선 기울기(최대 expansionPadTiltMax°). 판 테두리 8점 어디서든 표면(지형·바닥 콜라이더)이
        //    평면보다 높으면 그만큼 평면을 올린다 → 둔덕(안쪽) · 해변 경사(바깥쪽) 어느 쪽에도 판이 묻히지 않는다.
        // ─────────────────────────────────────────────────────────────────
        public static string LastFitLog = "";

        static float PadSurfaceY(Vector3 center, float fallbackY, float r, float tiltMax, out Quaternion rot)
        {
            var dt = Object.FindFirstObjectByType<global::WL.Look.Farm.WLDemoTerrain>(FindObjectsInactive.Include);
            var terrain = dt != null ? dt.TerrainComponent : null;
            // 중심 + 테두리 8점의 표면 높이로 최소제곱 평면 y = a·x + b·z + c 를 맞춘다(테두리는 대칭 → Σx² = Σz² = 4r²) → 둔덕·해변 경사·다리 아치를 모두 따라 눕는다.
            var os = new Vector3[9]; var ys = new float[9];
            float sum = 0f, sx = 0f, sz = 0f;
            for (int k = 0; k < 9; k++)
            {
                os[k] = k < 8 ? new Vector3(Mathf.Cos(k * Mathf.PI * 0.25f) * r, 0f, Mathf.Sin(k * Mathf.PI * 0.25f) * r) : Vector3.zero;
                ys[k] = SurfaceAt(center + os[k], fallbackY, terrain);
                sum += ys[k]; sx += ys[k] * os[k].x; sz += ys[k] * os[k].z;
            }
            float a = sx / (4f * r * r), b = sz / (4f * r * r), c = sum / 9f;
            rot = PadTilt(new Vector3(-a, 1f, -b), tiltMax);
            float raise = float.MinValue;                                      // 어느 표본도 판 아래에 묻히지 않게 평면을 올린다
            for (int k = 0; k < 9; k++) { float d = ys[k] - (c + (rot * os[k]).y); if (d > raise) raise = d; }
            if (raise < 0f) raise = 0f;
            LastFitLog = "평면 " + c.ToString("F2") + " 기울기 " + Quaternion.Angle(Quaternion.identity, rot).ToString("F1") + "° 올림 " + raise.ToString("F2");
            return c + raise;
        }

        /// <summary>한 점의 표면 높이 = 바닥 콜라이더(레이 · 소품·플레이어·가격판·벽 제외)와 데모 지형 높이 중 큰 값.</summary>
        static float SurfaceAt(Vector3 p, float fallbackY, Terrain terrain)
        {
            float h = PadGroundY(p, fallbackY);
            if (terrain != null)
            {
                var td = terrain.terrainData; var tp = terrain.transform.position;
                if (td != null && p.x >= tp.x && p.z >= tp.z && p.x <= tp.x + td.size.x && p.z <= tp.z + td.size.z)
                {
                    float th = terrain.SampleHeight(p) + tp.y;
                    if (th > h) h = th;
                }
            }
            return h;
        }

        static Quaternion PadTilt(Vector3 normal, float maxDeg)
        {
            if (maxDeg <= 0f || normal.sqrMagnitude < 1e-6f) return Quaternion.identity;
            var q = Quaternion.FromToRotation(Vector3.up, normal.normalized);
            float ang = Quaternion.Angle(Quaternion.identity, q);
            if (ang > maxDeg) q = Quaternion.Slerp(Quaternion.identity, q, maxDeg / ang);
            return q;
        }

        static float PadGroundY(Vector3 p, float fallbackY)
        {
            var hits = Physics.RaycastAll(new Vector3(p.x, fallbackY + 5f, p.z), Vector3.down, 20f, ~0, QueryTriggerInteraction.Ignore);
            float best = float.NaN;
            for (int i = 0; i < hits.Length; i++)
            {
                float y = hits[i].point.y;
                if (y > fallbackY + 1.5f) continue;
                if (!IsGroundCollider(hits[i].collider)) continue;
                if (float.IsNaN(best) || y > best) best = y;
            }
            return float.IsNaN(best) ? fallbackY : best;
        }

        /// <summary>바닥으로 치는 콜라이더 — 지형 · 우리 둔덕 콜라이더 · 섬 칸(타일·다리 바닥). 소품·가장자리 벽(세로 얇은 상자)·플레이어·가격판·발판·설치물은 제외(판이 그 위로 올라가면 안 된다).</summary>
        static bool IsGroundCollider(Collider c)
        {
            if (c == null || c.isTrigger) return false;
            if (c is TerrainCollider) return true;
            if (c.gameObject.name.StartsWith("~WL_Relief")) return true;
            if (c.GetComponentInParent<FIIsland>() == null) return false;
            if (c.GetComponentInParent<CryingSnow.FarmingIsland.IProp>() != null) return false;
            var box = c as BoxCollider;
            if (box != null)
            {
                var s = Vector3.Scale(box.size, c.transform.lossyScale);
                if (s.y > 0.6f && Mathf.Min(Mathf.Abs(s.x), Mathf.Abs(s.z)) < 3f) return false;     // 가장자리 벽(8×2×0.3)·다리 난간(2.6×2×8)
            }
            return true;
        }

        // ─────────────────────────────────────────────────────────────────
        //  🔴 2026-09-17 PD 「다리 위 가격판 자리가 저절로 바뀌지 않게」 ②
        //    FI 는 칸을 연 순간(OnActivated) 새 가격판을 잠긴 칸 중앙에 만든다 → 3 s 훑기가 오기 전까지 원래 자리(바다 쪽)에 보였다가 옮겨졌다.
        //    → 칸이 열리는 **그 프레임**에 바로 옮긴다. 지형이 다시 구워지면(솟아오르기 끝) 높이·기울기만 다시 맞춘다(자리 x·z 고정).
        // ─────────────────────────────────────────────────────────────────
        static readonly HashSet<FIIsland> s_watched = new HashSet<FIIsland>();
        static bool s_bakedHooked; static WLIslandSettings s_cfgForBaked;
        public static int Refits, ActivationPlaces;

        static void Watch(WLIslandSettings cfg, Scene scene)
        {
            s_watched.RemoveWhere(i => i == null);
            var islands = Object.FindObjectsByType<FIIsland>(FindObjectsInactive.Include, FindObjectsSortMode.None);
            for (int i = 0; i < islands.Length; i++)
            {
                var isl = islands[i];
                if (isl == null || s_watched.Contains(isl)) continue;
                s_watched.Add(isl);
                // 🔴 실측: OnActivated 는 DOScale 완료 콜백 — 같은 프레임의 DOJump 착지가 아직 안 끝나 칸이 ~9 cm 떠 있다 → 자리는 즉시, 높이는 다음 프레임에 한 번 더 맞춘다.
                isl.OnActivated += () =>
                {
                    if (cfg == null) return;
                    ActivationPlaces++;
                    PlacePurchasers(cfg, scene);
                    var runner = WLIslandBridge.Runner;
                    if (runner != null) runner.StartCoroutine(Co_RefitNextFrame(cfg));
                };
            }
            s_cfgForBaked = cfg;
            if (!s_bakedHooked) { s_bakedHooked = true; global::WL.Look.Farm.WLDemoTerrain.Baked += OnTerrainBaked; }
        }

        static void OnTerrainBaked() { if (s_cfgForBaked != null) RefitPlaced(s_cfgForBaked); }

        static IEnumerator Co_RefitNextFrame(WLIslandSettings cfg) { yield return null; RefitPlaced(cfg); }

        /// <summary>이미 옮긴 판의 높이·기울기만 지형에 다시 맞춘다(자리는 그대로).</summary>
        public static void RefitPlaced(WLIslandSettings cfg)
        {
            if (cfg == null || cfg.expansionPadPlace == 0) return;
            var marks = Object.FindObjectsByType<WLPlacedPurchaser>(FindObjectsInactive.Include, FindObjectsSortMode.None);
            for (int i = 0; i < marks.Length; i++)
            {
                var m = marks[i]; if (m == null) continue;
                var t = m.transform;
                float ps = t.localScale.x > 0.05f ? t.localScale.x : 1f;
                float plateDropLocal = 0f; var frame = t.Find("Frame"); if (frame != null) plateDropLocal = -frame.localPosition.y;
                Quaternion rot; var pos = t.position;
                float gy = PadSurfaceY(new Vector3(pos.x, m.original.y, pos.z), m.original.y, 2.56f * ps, cfg.expansionPadTiltMax, out rot);
                t.rotation = rot;
                t.position = new Vector3(pos.x, gy + plateDropLocal * ps + cfg.expansionPadLift, pos.z);
                Refits++;
            }
        }

        static readonly List<Renderer> s_rends = new List<Renderer>(64);
        static readonly List<Collider> s_cols = new List<Collider>(64);

        /// <summary>첫 던전 승리를 이미 했는가(기능이 꺼져 있으면 항상 true = 원본 그대로).</summary>
        public static bool IsUnlocked(WLIslandSettings cfg)
        {
            if (cfg == null || cfg.expansionAfterFirstWin == 0) return true;
            if (string.IsNullOrEmpty(cfg.expansionUnlockPrefsKey)) return true;
            return PlayerPrefs.GetInt(cfg.expansionUnlockPrefsKey, 0) != 0;
        }

        /// <summary>전투 승리 시 1회 — 이후 섬 확장은 FI 원본 순서대로 열린다.</summary>
        public static void Unlock(WLIslandSettings cfg)
        {
            if (cfg == null || cfg.expansionAfterFirstWin == 0) return;
            if (string.IsNullOrEmpty(cfg.expansionUnlockPrefsKey)) return;
            if (PlayerPrefs.GetInt(cfg.expansionUnlockPrefsKey, 0) != 0) return;

            PlayerPrefs.SetInt(cfg.expansionUnlockPrefsKey, 1);
            PlayerPrefs.Save();
            // 2026-09-16 실측: 플래그만 세우면 재숨김 코루틴(20 s)이 끝난 뒤의 개방은 다음 섬 로드까지 가격판이 숨겨진 채였다 → 즉시 되살린다.
            Restore();
            LastLog = "🔴 확장 노드 개방(던전 개방 또는 첫 전투 승리) — 원본 가격판 표시 · 이후 순서는 FI 원본이 정한다";
            WLIslandBridge.Log(cfg, LastLog);
        }

        /// <summary>섬이 준비될 때마다 1회 — 아직 승리 전이면 원본 가격판을 숨기고, 승리했으면 그대로 둔다.</summary>
        public static void Apply(WLIslandSettings cfg, Scene scene)
        {
            if (cfg == null || cfg.gateFlowEnabled == 0 || cfg.expansionAfterFirstWin == 0) return;

            Watch(cfg, scene);                                                          // 칸이 열리는 프레임에 바로 옮기기 · 지형 재굽기 뒤 높이 재맞춤
            PlacePurchasers(cfg, scene);                                                // 자리 옮기기(숨김 여부와 무관 · 1회)
            if (IsUnlocked(cfg))
            {
                Restore();
                LastLog = "확장 노드 표시 — 첫 승리 완료(FI 원본 순서)";
                WLIslandBridge.Log(cfg, LastLog);
                return;
            }

            HideNow(cfg, scene);

            // FI 는 세이브 복원·이웃 갱신 시점에 가격판을 **나중에** 만들기도 한다 — 잠시 더 훑는다.
            var runner = WLIslandBridge.Runner;
            if (runner != null && cfg.expansionHideSeconds > 0f)
                runner.StartCoroutine(Co_Guard(cfg, scene));
        }

        public static int HideNow(WLIslandSettings cfg, Scene scene)
        {
            int n = 0;
            var all = Object.FindObjectsByType<FIPurchaser>(FindObjectsInactive.Include, FindObjectsSortMode.None);
            for (int i = 0; i < all.Length; i++)
            {
                var p = all[i];
                if (p == null) continue;
                // 2026-09-15 Lead 실측 — FI 가 Instantiate 한 `Purchaser(Clone)` 은 섬 씬이 아니라 **활성 씬(InGame)** 에 생긴다 → 활성 씬도 허용
                if (scene.IsValid() && p.gameObject.scene != scene && p.gameObject.scene != SceneManager.GetActiveScene()) continue;
                if (p.GetComponentInParent<WLGoldPlatform>() != null) continue;     // 우리 발판은 건드리지 않는다

                var rends = p.GetComponentsInChildren<Renderer>(true);
                for (int r = 0; r < rends.Length; r++)
                    if (rends[r] != null && rends[r].enabled) { rends[r].enabled = false; s_rends.Add(rends[r]); n++; }

                var cols = p.GetComponentsInChildren<Collider>(true);
                for (int c = 0; c < cols.Length; c++)
                    if (cols[c] != null && cols[c].enabled) { cols[c].enabled = false; s_cols.Add(cols[c]); }
            }
            if (n > 0)
            {
                PurchasersHidden += n;
                LastLog = "원본 확장 가격판 숨김 — 렌더러 " + n + "개(첫 던전 승리 전)";
                WLIslandBridge.Log(cfg, LastLog);
            }
            return n;
        }

        static IEnumerator Co_Guard(WLIslandSettings cfg, Scene scene)
        {
            float wait = Mathf.Max(0.1f, cfg.expansionHideInterval);
            float t = 0f;
            while (t < cfg.expansionHideSeconds)
            {
                yield return new WaitForSeconds(wait);
                t += wait;
                if (cfg == null || cfg.expansionAfterFirstWin == 0) yield break;
                PlacePurchasers(cfg, scene);
                if (IsUnlocked(cfg)) { Restore(); yield break; }
                HideNow(cfg, scene);
            }
        }

        /// <summary>우리가 껐던 것만 되돌린다(FI 가 스스로 끈 것은 손대지 않는다).</summary>
        public static void Restore()
        {
            for (int i = 0; i < s_rends.Count; i++) if (s_rends[i] != null) s_rends[i].enabled = true;
            for (int i = 0; i < s_cols.Count; i++) if (s_cols[i] != null) s_cols[i].enabled = true;
            s_rends.Clear();
            s_cols.Clear();
        }
    }
}