【Unity】番人ゴーレムを実装する（NavMesh巡回・視界判定・ランタンステルス）

// ==========================================================
// 📄 スクリプト：GolemController.cs
// ==========================================================
using UnityEngine;
using UnityEngine.AI; // NavMeshAgent を使うために必要です

// 番人ゴーレムの頭脳です。今回はまず「巡回」だけを動かします。
public class GolemController : MonoBehaviour
{
    // --- 番人がとりうる状態を、名前付きの選択肢（enum）で定義します ---
    // Patrol=巡回, Alert=警戒, Chase=追跡, Lost=見失い
    // enum にしておくと、switch で「今どの状態か」を読みやすく分岐できます。
    public enum GuardState { Patrol, Alert, Chase, Lost }

    [Header("巡回設定")]
    [SerializeField] private Transform[] waypoints;   // 巡回する地点（GW1〜GW4を割り当て）
    [SerializeField] private float waitTime = 1.5f;   // 各地点で待つ秒数

    [Header("目のマテリアル（放出オン済みを割り当て）")]
    [SerializeField] private Material eyePatrol;      // 青白
    [SerializeField] private Material eyeAlert;       // 黄
    [SerializeField] private Material eyeChase;       // 赤
    [SerializeField] private Renderer eyeRenderer;    // Eye の Mesh Renderer を割り当て

    // ⏳予約席(a)：視界パラメータとランタン参照。第4〜5章で有効化します。
    //             ここで下の行のコメントを外して CanSeePlayer() などを書くと、
    //             LanternController への参照や viewDistance がまだ噛み合わず
    //             error CS0246（型が見つからない）/ CS1061（メンバーが無い）
    //             のもとになります。今はコメントのまま置いておきます。
    // [Header("視界設定（第4章で有効化）")]
    // [SerializeField] private Transform playerTarget;      // プレイヤーの狙点
    // [SerializeField] private LanternController playerLantern; // ランタン（IsOn参照）
    // [SerializeField] private float viewDistance = 6f;
    // [SerializeField] private float viewAngle = 90f;
    // [SerializeField] private float eyeHeight = 2.2f;

    // ⏳予約席(b)：検知ゲージUI参照。第6章で有効化します。
    //             いま「gauge.SetLevel(...)」と書くと、gauge がまだ
    //             宣言されていないため error CS0103、型を書いても
    //             DetectionGaugeUI クラスが未作成なら error CS0246 になります。
    // [SerializeField] private DetectionGaugeUI gauge;

    private NavMeshAgent agent;       // 自分のNavMeshAgent
    private int currentIndex = 0;     // 今どのウェイポイントを目指しているか
    private float waitTimer = 0f;     // 待機の残り計測
    private bool isWaiting = false;   // 待機中フラグ
    private GuardState state = GuardState.Patrol; // 現在の状態

    void Awake()
    {
        // 自分に付いているNavMeshAgentを取得します。
        agent = GetComponent<NavMeshAgent>();
    }

    void Start()
    {
        // 開始時は巡回状態。目を青白に。最初の地点を目指します。
        ApplyEyeMaterial(GuardState.Patrol);
        if (waypoints != null && waypoints.Length > 0)
        {
            agent.SetDestination(waypoints[currentIndex].position);
        }
    }

    void Update()
    {
        // 今回は Patrol の中身だけ実装します。
        switch (state)
        {
            case GuardState.Patrol:
                PatrolUpdate();
                break;
            case GuardState.Alert:
                // 第5章で実装します
                break;
            case GuardState.Chase:
                // 第5章で実装します
                break;
            case GuardState.Lost:
                // 第5章で実装します
                break;
        }
    }

    // --- 巡回の処理 ---
    private void PatrolUpdate()
    {
        if (waypoints == null || waypoints.Length == 0) return;

        if (isWaiting)
        {
            // 待機中：タイマーを減らし、0になったら次の地点へ。
            waitTimer -= Time.deltaTime;
            if (waitTimer <= 0f)
            {
                isWaiting = false;
                currentIndex = (currentIndex + 1) % waypoints.Length; // 輪のように巡回
                agent.SetDestination(waypoints[currentIndex].position);
            }
            return;
        }

        // 到達判定の定石イディオムです。
        // ・pathPending 中は remainingDistance が不正確（Infinityになりうる）なので除外
        // ・止まる距離まで来て、経路が無い or 速度がほぼ0 なら「着いた」とみなす
        if (!agent.pathPending &&
            agent.remainingDistance <= agent.stoppingDistance &&
            (!agent.hasPath || agent.velocity.sqrMagnitude == 0f)) 
        {
            // 着いたので、待機に入る
            isWaiting = true;
            waitTimer = waitTime;
        }
    }

    // --- 目のマテリアルを状態に応じて差し替えます（sharedMaterial方式） ---
    // 第7弾の教訓どおり、放出オン済みマテリアルを丸ごと差し替えます。
    public void ApplyEyeMaterial(GuardState s)
    {
        if (eyeRenderer == null) return;
        switch (s)
        {
            case GuardState.Patrol:
                eyeRenderer.sharedMaterial = eyePatrol; // 青白
                break;
            case GuardState.Alert:
                eyeRenderer.sharedMaterial = eyeAlert;  // 黄
                break;
            case GuardState.Chase:
                eyeRenderer.sharedMaterial = eyeChase;  // 赤
                break;
            case GuardState.Lost:
                eyeRenderer.sharedMaterial = eyeAlert;  // 見失い中は黄のまま（割り切り）
                break;
        }
    }

    // --- 動作確認用：エディタで右クリックすると次の地点へ飛べます ---
    [ContextMenu("次の地点へ")]
    private void DebugGoNext()
    {
        if (waypoints == null || waypoints.Length == 0) return;
        currentIndex = (currentIndex + 1) % waypoints.Length;
        agent.SetDestination(waypoints[currentIndex].position);
        isWaiting = false;
    }
}

// ==========================================================
// 📄 スクリプト：GolemController.cs （第4章版：視界判定を追加）
// ==========================================================
using UnityEngine;
using UnityEngine.AI;

public class GolemController : MonoBehaviour
{
    public enum GuardState { Patrol, Alert, Chase, Lost }

    [Header("巡回設定")]
    [SerializeField] private Transform[] waypoints;
    [SerializeField] private float waitTime = 1.5f;

    [Header("目のマテリアル（放出オン済み）")]
    [SerializeField] private Material eyePatrol;
    [SerializeField] private Material eyeAlert;
    [SerializeField] private Material eyeChase;
    [SerializeField] private Renderer eyeRenderer;

    // ⏳→✅ 予約席(a)を有効化：視界設定
    [Header("視界設定")]
    [SerializeField] private Transform playerTarget; // アバターを割当（狙点は胸元）
    [SerializeField] private float viewDistance = 6f; // この章では固定6m
    [SerializeField] private float viewAngle = 90f;   // 視野角（左右合わせて90度）
    [SerializeField] private float eyeHeight = 2.2f;  // 目の高さ
    private LayerMask obstructionMask;                // 遮蔽とみなす壁のマスク

    // ⏳予約席(b)：検知ゲージUI（第6章で有効化）
    // [SerializeField] private DetectionGaugeUI gauge;

    private NavMeshAgent agent;
    private int currentIndex = 0;
    private float waitTimer = 0f;
    private bool isWaiting = false;
    private GuardState state = GuardState.Patrol;

    void Awake()
    {
        agent = GetComponent<NavMeshAgent>();
        // 壁マスク＝Defaultレイヤー。プレイヤーはPlayerレイヤーに移したので
        // このマスクには含まれません。「当たった＝壁」とシンプルに扱えます。
        obstructionMask = LayerMask.GetMask("Default");
    }

    void Start()
    {
        ApplyEyeMaterial(GuardState.Patrol);
        if (waypoints != null && waypoints.Length > 0)
            agent.SetDestination(waypoints[currentIndex].position);
    }

    void Update()
    {
        switch (state)
        {
            case GuardState.Patrol:
                PatrolUpdate();
                // 動作確認：巡回中に見えたらログを出す（第5章で状態遷移に置き換え）
                if (CanSeePlayer())
                    Debug.Log("見つけた！");
                break;
            case GuardState.Alert:
                break; // 第5章
            case GuardState.Chase:
                break; // 第5章
            case GuardState.Lost:
                break; // 第5章
        }
    }

    private void PatrolUpdate()
    {
        if (waypoints == null || waypoints.Length == 0) return;
        if (isWaiting)
        {
            waitTimer -= Time.deltaTime;
            if (waitTimer <= 0f)
            {
                isWaiting = false;
                currentIndex = (currentIndex + 1) % waypoints.Length;
                agent.SetDestination(waypoints[currentIndex].position);
            }
            return;
        }
        if (!agent.pathPending &&
            agent.remainingDistance <= agent.stoppingDistance &&
            (!agent.hasPath || agent.velocity.sqrMagnitude == 0f))
        {
            isWaiting = true;
            waitTimer = waitTime;
        }
    }

    // --- 三段の視界判定 ---
    public bool CanSeePlayer()
    {
        if (playerTarget == null) return false;

        // 目の位置と、プレイヤーの狙点（胸元＝足元から1.2m上）
        Vector3 eye = transform.position + Vector3.up * eyeHeight;
        Vector3 targetPoint = playerTarget.position + Vector3.up * 1.2f;
        Vector3 toPlayer = targetPoint - eye;

        // ① 距離：二乗どうしで比較（平方根を取らない分、軽い。第8弾の精霊と同じ考え方）
        if (toPlayer.sqrMagnitude > viewDistance * viewDistance) return false;

        // ② 角度：前方向とプレイヤー方向の角度が、視野角の半分より大きければ範囲外
        float angle = Vector3.Angle(transform.forward, toPlayer);
        if (angle > viewAngle * 0.5f) return false;

        // ③ 遮蔽：目から狙点まで線を引き、壁マスクに当たれば遮られている
        //   QueryTriggerInteraction.Ignore で、迷路内の透明トリガーを無視します。
        if (Physics.Linecast(eye, targetPoint, out RaycastHit hit,
                              obstructionMask, QueryTriggerInteraction.Ignore))
        {
            // 壁マスク（Default）に当たった＝壁が間にある＝見えない
            return false;
        }

        // 三段すべてくぐり抜けた＝見えている
        return true;
    }

    public void ApplyEyeMaterial(GuardState s)
    {
        if (eyeRenderer == null) return;
        switch (s)
        {
            case GuardState.Patrol: eyeRenderer.sharedMaterial = eyePatrol; break;
            case GuardState.Alert:  eyeRenderer.sharedMaterial = eyeAlert;  break;
            case GuardState.Chase:  eyeRenderer.sharedMaterial = eyeChase;  break;
            case GuardState.Lost:   eyeRenderer.sharedMaterial = eyeAlert;  break;
        }
    }

    [ContextMenu("次の地点へ")]
    private void DebugGoNext()
    {
        if (waypoints == null || waypoints.Length == 0) return;
        currentIndex = (currentIndex + 1) % waypoints.Length;
        agent.SetDestination(waypoints[currentIndex].position);
        isWaiting = false;
    }

    // --- 視界の扇を描く簡易ギズモ（選択中に表示） ---
    private void OnDrawGizmosSelected()
    {
        Vector3 eye = transform.position + Vector3.up * eyeHeight;
        Gizmos.color = Color.yellow;
        // 左右の境界線
        Vector3 left = Quaternion.Euler(0, -viewAngle * 0.5f, 0) * transform.forward;
        Vector3 right = Quaternion.Euler(0, viewAngle * 0.5f, 0) * transform.forward;
        Gizmos.DrawLine(eye, eye + left * viewDistance);
        Gizmos.DrawLine(eye, eye + right * viewDistance);
    }
}

// ==========================================================
// 📄 スクリプト：JudgeFeedbackUI.cs（該当メソッド周辺の差分）
// ==========================================================
    // 既存：せいかい／はずれ の判定演出（温存します）
    public void Show(bool correct, string tellName)
    {
        // …既存の実装はそのまま…
    }

    // 💡追加：任意のメッセージをフェード表示する（後方互換）
    public void ShowMessage(string text)
    {
        label.text = text;                           // ラベルに直接セット
        if (routine != null) StopCoroutine(routine); // 走っていたら止めてから
        routine = StartCoroutine(FadeRoutine());     // 既存のフェードを再利用
    }

// ==========================================================
// 📄 スクリプト：GolemController.cs （第5章：完成形）
// ==========================================================
using UnityEngine;
using UnityEngine.AI;
using TMPro; // 頭上マーク（第6章）で使うので、先に using を用意しておきます

public class GolemController : MonoBehaviour
{
    public enum GuardState { Patrol, Alert, Chase, Lost }

    [Header("巡回設定")]
    [SerializeField] private Transform[] waypoints;
    [SerializeField] private float waitTime = 1.5f;

    [Header("目のマテリアル（放出オン済み）")]
    [SerializeField] private Material eyePatrol;
    [SerializeField] private Material eyeAlert;
    [SerializeField] private Material eyeChase;
    [SerializeField] private Renderer eyeRenderer;

    [Header("視界設定")]
    [SerializeField] private Transform playerTarget;
    [SerializeField] private float viewAngle = 90f;
    [SerializeField] private float eyeHeight = 2.2f;

    [Header("ランタン連動ステルス")]
    [SerializeField] private LanternController playerLantern; // 第5弾のIsOnを回収！
    [SerializeField] private float lanternOnDistance = 12f;   // 点灯中は遠くまで見える
    [SerializeField] private float lanternOffDistance = 5f;   // 消灯中は近くしか見えない
    private float viewDistance = 6f; // 実際に使う視界距離（ランタンで毎フレーム更新）

    [Header("検知ゲージ")]
    [SerializeField] private float fillTime = 1.2f;  // 視認中に満タンまで
    [SerializeField] private float drainTime = 2.0f; // 非視認で0まで
    private float detectionLevel = 0f;               // 0〜1

    [Header("追跡・見失い")]
    [SerializeField] private float chaseSpeed = 3.5f;
    [SerializeField] private float lostGraceTime = 1.5f; // 見失ってから諦めるまで
    [SerializeField] private float searchWait = 3f;      // 最後の地点で探す秒数
    [SerializeField] private float setDestInterval = 0.3f; // 追跡中の再指定間隔

    [Header("捕獲")]
    [SerializeField] private Transform golemReturnAnchor; // 戻される位置

    // ⏳予約席(b)：頭上マークとゲージ（第6章で有効化）
    // [SerializeField] private DetectionGaugeUI gauge;
    // [SerializeField] private TextMeshPro alertMark;

    private LayerMask obstructionMask;
    private NavMeshAgent agent;
    private int currentIndex = 0;
    private float waitTimer = 0f;
    private bool isWaiting = false;
    private GuardState state = GuardState.Patrol;

    private Vector3 lastKnownPos;      // 最後に見た位置
    private float lostTimer = 0f;      // 見失い計測
    private float searchTimer = 0f;    // 探索計測
    private float setDestTimer = 0f;   // 再指定計測
    private float cooldownTimer = 0f;  // 捕獲後、追い直さないクールダウン

    void Awake()
    {
        agent = GetComponent<NavMeshAgent>();
        obstructionMask = LayerMask.GetMask("Default");
    }

    void Start()
    {
        ChangeState(GuardState.Patrol);
        if (waypoints != null && waypoints.Length > 0)
            agent.SetDestination(waypoints[currentIndex].position);
    }

    void Update()
    {
        // テレポート（霧で戻される）中は、番人は一切追いかけません。
        if (MazeDirector.Instance != null && MazeDirector.Instance.IsReturning)
            return;

        // 捕獲直後のクールダウン中はゲージを溜めない
        if (cooldownTimer > 0f) cooldownTimer -= Time.deltaTime;

        // ランタンで視界距離を毎フレーム更新（点ければ遠く、消せば近く）
        viewDistance = (playerLantern != null && playerLantern.IsOn)
                       ? lanternOnDistance : lanternOffDistance;

        bool seen = (cooldownTimer <= 0f) && CanSeePlayer();

        switch (state)
        {
            case GuardState.Patrol: PatrolUpdate(seen); break;
            case GuardState.Alert:  AlertUpdate(seen);  break;
            case GuardState.Chase:  ChaseUpdate(seen);  break;
            case GuardState.Lost:   LostUpdate(seen);   break;
        }

        // ⏳予約席(b)：第6章でここに gauge?.SetLevel(detectionLevel) 等を足します。
        // いま書くと gauge が未宣言で error CS0103 になるため、まだ書きません。
    }

    // --- 巡回 ---
    private void PatrolUpdate(bool seen)
    {
        if (seen) { ChangeState(GuardState.Alert); return; }

        if (waypoints == null || waypoints.Length == 0) return;
        if (isWaiting)
        {
            waitTimer -= Time.deltaTime;
            if (waitTimer <= 0f)
            {
                isWaiting = false;
                currentIndex = (currentIndex + 1) % waypoints.Length;
                agent.SetDestination(waypoints[currentIndex].position);
            }
            return;
        }
        if (ReachedDestination())
        {
            isWaiting = true;
            waitTimer = waitTime;
        }
    }

    // --- 警戒：その場で止まり、プレイヤー方向へゆっくり旋回。ゲージを溜める ---
    private void AlertUpdate(bool seen)
    {
        agent.isStopped = true;

        if (seen)
        {
            lastKnownPos = playerTarget.position;
            FaceTarget(lastKnownPos);
            detectionLevel += Time.deltaTime / fillTime;
            if (detectionLevel >= 1f)
            {
                detectionLevel = 1f;
                agent.isStopped = false;
                ChangeState(GuardState.Chase); // 満タン→追跡
            }
        }
        else
        {
            // 見えなくなったらゲージが減る。0になったら巡回へ戻る。
            detectionLevel -= Time.deltaTime / drainTime;
            if (detectionLevel <= 0f)
            {
                detectionLevel = 0f;
                agent.isStopped = false;
                ReturnToPatrol();
            }
        }
    }

    // --- 追跡：0.3秒間隔でSetDestination。見失ったらLostへ ---
    private void ChaseUpdate(bool seen)
    {
        agent.speed = chaseSpeed;
        detectionLevel = 1f;

        if (seen)
        {
            lastKnownPos = playerTarget.position;
            lostTimer = 0f;
            setDestTimer -= Time.deltaTime;
            if (setDestTimer <= 0f)
            {
                setDestTimer = setDestInterval; // 毎フレームではなく間隔をあけて呼ぶ
                agent.SetDestination(lastKnownPos);
            }
        }
        else
        {
            // 視認が途切れた：猶予時間を数え、超えたら見失いへ
            lostTimer += Time.deltaTime;
            if (lostTimer >= lostGraceTime)
            {
                ChangeState(GuardState.Lost);
                agent.SetDestination(lastKnownPos);
            }
        }
    }

    // --- 見失い：最後の地点へ→到達→探す→巡回へ帰投 ---
    private void LostUpdate(bool seen)
    {
        if (seen)
        {
            // 探索中にまた見えたら追跡へ復帰
            detectionLevel = 1f;
            ChangeState(GuardState.Chase);
            return;
        }
        agent.speed = 2f; // 通常速度に戻す

        if (ReachedDestination())
        {
            // 最後の地点に着いた。その場で少し探す（ゆっくり旋回）。
            searchTimer += Time.deltaTime;
            transform.Rotate(0, 60f * Time.deltaTime, 0);
            if (searchTimer >= searchWait)
            {
                searchTimer = 0f;
                ReturnToPatrol();
            }
        }
    }

    // --- 巡回に戻る：最寄りのウェイポイントへ ---
    private void ReturnToPatrol()
    {
        detectionLevel = 0f;
        currentIndex = NearestWaypointIndex();
        ChangeState(GuardState.Patrol);
        agent.isStopped = false;
        isWaiting = false;
        if (waypoints != null && waypoints.Length > 0)
            agent.SetDestination(waypoints[currentIndex].position);
    }

    private int NearestWaypointIndex()
    {
        int best = 0;
        float bestSq = float.MaxValue;
        for (int i = 0; i < waypoints.Length; i++)
        {
            float sq = (waypoints[i].position - transform.position).sqrMagnitude;
            if (sq < bestSq) { bestSq = sq; best = i; }
        }
        return best;
    }

    // --- 状態を変える瞬間に目の色を切り替え ---
    private void ChangeState(GuardState next)
    {
        state = next;
        ApplyEyeMaterial(next);
        Debug.Log($"番人の状態：{next}"); // ← 動作確認用（第6章でHUDに置き換えます）
        // 📢 第10弾でここに警戒音・発見音を差し込みます
    }

    private bool ReachedDestination()
    {
        return !agent.pathPending &&
               agent.remainingDistance <= agent.stoppingDistance &&
               (!agent.hasPath || agent.velocity.sqrMagnitude == 0f);
    }

    private void FaceTarget(Vector3 point)
    {
        Vector3 dir = point - transform.position;
        dir.y = 0;
        if (dir.sqrMagnitude < 0.001f) return;
        Quaternion look = Quaternion.LookRotation(dir);
        transform.rotation = Quaternion.Slerp(transform.rotation, look, 2f * Time.deltaTime);
    }

    public bool CanSeePlayer()
    {
        if (playerTarget == null) return false;
        Vector3 eye = transform.position + Vector3.up * eyeHeight;
        Vector3 targetPoint = playerTarget.position + Vector3.up * 1.2f;
        Vector3 toPlayer = targetPoint - eye;
        if (toPlayer.sqrMagnitude > viewDistance * viewDistance) return false;
        float angle = Vector3.Angle(transform.forward, toPlayer);
        if (angle > viewAngle * 0.5f) return false;
        if (Physics.Linecast(eye, targetPoint, out RaycastHit hit,
                             obstructionMask, QueryTriggerInteraction.Ignore))
            return false;
        return true;
    }

    public void ApplyEyeMaterial(GuardState s)
    {
        if (eyeRenderer == null) return;
        switch (s)
        {
            case GuardState.Patrol: eyeRenderer.sharedMaterial = eyePatrol; break;
            case GuardState.Alert:  eyeRenderer.sharedMaterial = eyeAlert;  break;
            case GuardState.Chase:  eyeRenderer.sharedMaterial = eyeChase;  break;
            case GuardState.Lost:   eyeRenderer.sharedMaterial = eyeAlert;  break;
        }
    }

    // --- 捕獲トリガー：プレイヤーに触れたら霧で戻す ---
    private void OnTriggerEnter(Collider other)
    {
        // 戻し処理の最中は無視（テレポート中に二重発火しないため）
        if (MazeDirector.Instance != null && MazeDirector.Instance.IsReturning) return;
        // CharacterControllerを持つ＝プレイヤー（連載の作法）
        if (other.GetComponent<CharacterController>() == null) return;

        // 「見つかった」演出→霧で戻す
        JudgeFeedbackUI.Instance.ShowMessage("見つかった……！ 霧に包まれて戻される");
        MazeDirector.Instance.ReturnPlayer(golemReturnAnchor);
        ResetToPatrol();
    }

    // --- 捕獲後：ゲージ0・巡回・最寄りWPへ。しばらく追い直さない ---
    private void ResetToPatrol()
    {
        detectionLevel = 0f;
        cooldownTimer = 2f; // 2秒は再検知しない
        ReturnToPatrol();
    }

    public float DetectionLevel => detectionLevel;   // 第6章のゲージが読む
    public GuardState State => state;                // 第6章の頭上マークが読む

    [ContextMenu("次の地点へ")]
    private void DebugGoNext()
    {
        if (waypoints == null || waypoints.Length == 0) return;
        currentIndex = (currentIndex + 1) % waypoints.Length;
        agent.SetDestination(waypoints[currentIndex].position);
        isWaiting = false;
    }
}

// ==========================================================
// 📄 スクリプト：DetectionGaugeUI.cs
// ==========================================================
using UnityEngine;
using UnityEngine.UI; // Image を使うため

// 検知ゲージの見た目だけを担当します。呼び手は番人だけなので、
// シングルトンにはしません（第7弾の「乱用しない」基準に従います）。
public class DetectionGaugeUI : MonoBehaviour
{
    [SerializeField] private Image fillImage;        // GaugeFillを割当
    [SerializeField] private CanvasGroup canvasGroup;// GaugeBackのCanvasGroupを割当
    [SerializeField] private float fadeSpeed = 5f;   // 出現・消滅の速さ

    void Awake()
    {
        // 最初は見えない状態から始めます。
        // これが無いと、まだ一度も検知していないのにゲージが
        // 空のまま画面に出っぱなしになります（第8弾のJudgePanelと同じ作法）。
        if (canvasGroup != null) canvasGroup.alpha = 0f;
    }

    // 0〜1の値を受け取り、バーの長さ・色・表示を更新します。
    public void SetLevel(float level)
    {
        level = Mathf.Clamp01(level);

        // バーの長さ（fillAmount）を更新
        if (fillImage != null)
        {
            fillImage.fillAmount = level;
            // 色を黄→赤に補間（level=0で黄、1で赤）
            fillImage.color = Color.Lerp(Color.yellow, Color.red, level);
        }

        // ゲージが0より大きいとき表示（1へ）、0のとき非表示（0へ）
        if (canvasGroup != null)
        {
            float target = (level > 0f) ? 1f : 0f;
            canvasGroup.alpha = Mathf.MoveTowards(
                canvasGroup.alpha, target, fadeSpeed * Time.deltaTime);
        }
    }
}

// ==========================================================
// 📄 スクリプト：Billboard.cs
// ==========================================================
using UnityEngine;

// 頭上マークが常にカメラの方を向くようにします（看板＝ビルボード）。
// LateUpdateで向きを合わせるのは、カメラ移動の後に確定させるためです。
public class Billboard : MonoBehaviour
{
    private Camera cam;

    void Start()
    {
        cam = Camera.main; // メインカメラ
    }

    void LateUpdate()
    {
        if (cam == null) return;
        // カメラの向きと同じ向きに自分を回す＝常に正面を見せる
        transform.forward = cam.transform.forward;
    }
}

// ==========================================================
// 📄 スクリプト：GolemController.cs（第6章の差分・該当部分のみ）
// ==========================================================
    // ⏳→✅ 予約席(b)を有効化
    [Header("警戒の見える化")]
    [SerializeField] private DetectionGaugeUI gauge;  // GaugeBackを割当
    [SerializeField] private TextMeshPro alertMark;   // AlertMarkを割当

    // …（Updateはそのまま。以下のLateUpdateを追加）…
    void LateUpdate()
    {
        // ゲージを更新
        if (gauge != null) gauge.SetLevel(detectionLevel);

        // 頭上マーク：警戒中は「？」、追跡中は「！」、それ以外は非表示
        if (alertMark != null)
        {
            switch (state)
            {
                case GuardState.Alert:
                    alertMark.gameObject.SetActive(true);
                    alertMark.text = "？";
                    break;
                case GuardState.Chase:
                    alertMark.gameObject.SetActive(true);
                    alertMark.text = "！";
                    break;
                default: // Patrol / Lost帰投
                    alertMark.gameObject.SetActive(false);
                    break;
            }
        }
    }

// ==========================================================
// 📄 スクリプト：GolemController.cs（StateLabelプロパティ追加）
// ==========================================================
    // 状態を日本語ラベルで返す（HUD表示用）
    public string StateLabel => state switch
    {
        GuardState.Patrol => "巡回",
        GuardState.Alert  => "警戒",
        GuardState.Chase  => "追跡",
        GuardState.Lost   => "見失い",
        _ => "―"
    };

// ==========================================================
// 📄 スクリプト：PhaseDebugHUD.cs（改修後・全体）
// ==========================================================
using UnityEngine;
using TMPro;

// 現在のフェーズ・失敗数・秘宝の数・番人の状態を画面の隅に出す、開発用のHUD。
public class PhaseDebugHUD : MonoBehaviour
{
    [SerializeField] private TextMeshProUGUI label; // 表示先のTMP
    [SerializeField] private GolemController golem; // 💡追加：GolemRootを割当

    void Update()
    {
        // GameManagerをシーンに置き忘れていても、エラーで止まらない保険
        if (GameManager.Instance == null) return;

        // $"..." は文字列補間。{ } の中の値が文字列に埋め込まれます
        string text =
            $"フェーズ: {GameManager.Instance.PhaseLabel}\n" +
            $"失敗: {GameManager.Instance.MistakeCount}\n" +
            $"秘宝: {GameManager.Instance.TreasureCount} / 3";

        // 💡追加：番人の状態（null安全＝golemが未割当でも落ちない）
        if (golem != null)
            text += $"\n番人: {golem.StateLabel}";

        // 組み立て終わってから、まとめて1回だけ渡す
        label.text = text;
    }
}

// ==========================================================
// 📄 スクリプト：GazeSwitch.cs
// ==========================================================
using UnityEngine;

// プレイヤーが一定時間見つめると点灯するクリスタル。
// 番人の視界判定と「主語が逆なだけで同じ数学」です。
public class GazeSwitch : MonoBehaviour
{
    [SerializeField] private Renderer crystalRenderer; // Crystalを割当
    [SerializeField] private Material crystalOff;      // 放出オフ
    [SerializeField] private Material crystalOn;       // 放出オン
    [SerializeField] private float gazeAngle = 30f;    // 何度以内なら「見ている」
    [SerializeField] private float gazeDistance = 8f;  // 何m以内なら有効
    [SerializeField] private float gazeRequired = 1.2f;// 見つめ続ける必要秒数

    private LayerMask obstructionMask;
    private Camera cam;
    private float gazeTime = 0f;
    private bool isOn = false;

    void Start()
    {
        cam = Camera.main;
        obstructionMask = LayerMask.GetMask("Default");
        ApplyMaterial();
    }

    void Update()
    {
        if (isOn) return;          // 一度点いたら維持
        if (cam == null) return;

        Vector3 toCrystal = transform.position - cam.transform.position;

        // 距離チェック
        bool near = toCrystal.sqrMagnitude <= gazeDistance * gazeDistance;
        // 角度チェック（カメラ前方とクリスタル方向の角度）
        bool facing = Vector3.Angle(cam.transform.forward, toCrystal) < gazeAngle;
        // 遮蔽チェック（壁越しは無効。Ignoreで透明トリガーは無視）
        bool clear = !Physics.Linecast(
            cam.transform.position, transform.position,
            obstructionMask, QueryTriggerInteraction.Ignore);

        if (near && facing && clear)
        {
            gazeTime += Time.deltaTime;
            if (gazeTime >= gazeRequired)
            {
                isOn = true;
                ApplyMaterial(); // 点灯（sharedMaterial差し替え）
                // 📢 第11弾でここを仕掛け（扉やギミック）に接続します
            }
        }
        else
        {
            // 見るのをやめたら、未点灯の進捗は少しずつ戻る
            gazeTime = Mathf.MoveTowards(gazeTime, 0f, Time.deltaTime);
        }
    }

    private void ApplyMaterial()
    {
        if (crystalRenderer == null) return;
        crystalRenderer.sharedMaterial = isOn ? crystalOn : crystalOff;
    }
}

// ==========================================================
// 📄 スクリプト：Interactor.cs（第9弾・遮蔽判定を追加）
// ==========================================================
using UnityEngine;
using UnityEngine.InputSystem;
using TMPro;

public class Interactor : MonoBehaviour
{
    [SerializeField] private Camera mainCamera;
    [SerializeField] private CameraModeSwitcher cameraModeSwitcher; // FPS判定
    [SerializeField] private TextMeshProUGUI promptText;            // プロンプト表示先
    [SerializeField] private float maxDistance = 3f;                // 手が届く距離

    [Header("狙い方の設定")]
    // オンにすると、三人称のときも調べられるようになります。
    // レイの起点がカメラではなく「キャラの目の高さ」に変わるため、
    // カメラとキャラの間に壁があっても影響を受けません。
    [SerializeField] private bool allowThirdPerson = false;
    // 上をオンにしたときだけ使う、レイを撃ち出す高さ（メートル）。
    [SerializeField] private float eyeHeight = 1.4f;

    private GameControls _controls;
    private InputAction _interactAction;
    private int _interactableMask;
    private int _obstructionMask;   // 💡追加：壁マスク（遮蔽チェック用）
    private IInteractable _current; // 今狙っている対象

    private void Awake()
    {
        _controls = new GameControls();
        _interactAction = _controls.Player.Interact;
        _interactableMask = LayerMask.GetMask("Interactable");
        // 💡追加：壁として扱うレイヤー。番人の視界判定とまったく同じ考え方です。
        _obstructionMask = LayerMask.GetMask("Default");
    }

    private void OnEnable()  { _controls.Player.Enable(); }
    private void OnDisable() { _controls.Player.Disable(); }

    private void Update()
    {
        // UI表示中はプロンプトを消して早期return（"[E] 調べる"を出しっぱなしにしない）
        if (UiGate.IsOpen)
        {
            _current = null;
            SetPrompt(null);
            return;
        }

        // allowThirdPerson がオフのときだけ、「一人称でなければ何もしない」を適用する。
        if (!allowThirdPerson &&
            (cameraModeSwitcher == null || !cameraModeSwitcher.IsFirstPerson))
        {
            _current = null;
            SetPrompt(null);
            return;
        }

        // レイの起点と向きを、モードによって切り替える
        Ray ray;
        if (allowThirdPerson)
        {
            // キャラの目の高さから、キャラの正面へ（三人称でも破綻しない）
            ray = new Ray(transform.position + Vector3.up * eyeHeight, transform.forward);
        }
        else
        {
            // 画面（カメラ）の中央から前方へ（一人称の王道）
            ray = mainCamera.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0f));
        }

        if (Physics.Raycast(ray, out RaycastHit hit, maxDistance,
                            _interactableMask, QueryTriggerInteraction.Collide))
        {
            // 💡追加：二段目の遮蔽チェック
            // 同じレイを、今度は壁マスクで「ヒット点の少し手前まで」撃ちます。
            // 何かに当たれば、間に壁があるということ＝見えていないので調べさせません。
            // 透明なトリガーに遮られないよう Ignore を指定します（番人の視線と同じ）。
            if (Physics.Raycast(ray, out RaycastHit block, hit.distance - 0.05f,
                                _obstructionMask, QueryTriggerInteraction.Ignore))
            {
                _current = null;
                SetPrompt(null);
                return;
            }

            IInteractable it = hit.collider.GetComponentInParent<IInteractable>();
            if (it != null)
            {
                _current = it;
                SetPrompt($"[E] {it.GetPrompt()}");
                if (_interactAction.WasPressedThisFrame())
                    _current.Interact();
                return;
            }
        }

        _current = null;
        SetPrompt(null);
    }

    private void SetPrompt(string text)
    {
        if (promptText == null) return;
        promptText.text = text ?? string.Empty;
        promptText.enabled = !string.IsNullOrEmpty(text);
    }
}