SimpleLLMControllableNPC.cs

using UnityEngine;
using UnityEngine.AI; // Äëÿ NavMeshAgent
using System.Collections; // Äëÿ êîðóòèí
using System.IO; // Äëÿ ðàáîòû ñ ôàéëàìè
using LitJson; // Äëÿ JSON-ñåðèàëèçàöèè/äåñåðèàëèçàöèè
using UnityEngine.UI;

// Êëàññ äëÿ ñîõðàíåíèÿ äàííûõ NPC
[System.Serializable]
public class SimpleNPCSaveData
{
    public string id; // Óíèêàëüíûé ID äëÿ ýòîãî NPC

    // --- ÊËÞ×ÅÂÎÅ ÈÇÌÅÍÅÍÈÅ ÇÄÅÑÜ ---
    // Ñîõðàíÿåì Vector3 êàê îòäåëüíûå float êîìïîíåíòû
    public float posX, posY, posZ;
    // Ñîõðàíÿåì Quaternion êàê îòäåëüíûå float êîìïîíåíòû
    public float rotX, rotY, rotZ, rotW;
    // --- ÊÎÍÅÖ ÊËÞ×ÅÂÛÕ ÈÇÌÅÍÅÍÈÉ ÇÄÅÑÜ ---

    public string currentStateName; // Ñîõðàíÿåì òåêóùåå ñîñòîÿíèå äëÿ âîññòàíîâëåíèÿ

    // Ìåòîä-ïîìîùíèê äëÿ ïðåîáðàçîâàíèÿ Vector3 â êîìïîíåíòû
    public void SetPosition(Vector3 position)
    {
        posX = position.x;
        posY = position.y;
        posZ = position.z;
    }
    // Ìåòîä-ïîìîùíèê äëÿ ïîëó÷åíèÿ Vector3 èç êîìïîíåíòîâ
    public Vector3 GetPosition()
    {
        return new Vector3(posX, posY, posZ);
    }

    // Ìåòîä-ïîìîùíèê äëÿ ïðåîáðàçîâàíèÿ Quaternion â êîìïîíåíòû
    public void SetRotation(Quaternion rotation)
    {
        rotX = rotation.x;
        rotY = rotation.y;
        rotZ = rotation.z;
        rotW = rotation.w;
    }
    // Ìåòîä-ïîìîùíèê äëÿ ïîëó÷åíèÿ Quaternion èç êîìïîíåíòîâ
    public Quaternion GetRotation()
    {
        return new Quaternion(rotX, rotY, rotZ, rotW);
    }
}

// Èíòåðôåéñ, êîòîðûé NPC äîëæåí ðåàëèçîâàòü, ÷òîáû ïðèíèìàòü êîìàíäû îò LLM
/*public interface ILLMControllableNPC
{
    void MoveToPosition(Vector3 position);
    void MoveToObject(GameObject targetObject);
    void SetBehavior(string behaviorType); // Íàïðèìåð, "Patrol", "Idle"
    void SayDialogue(string text);
}*/

// === ÎÑÍÎÂÍÎÉ ÑÊÐÈÏÒ ÓÏÐÀÂËßÅÌÎÃÎ NPC ===
[RequireComponent(typeof(NavMeshAgent))]
[RequireComponent(typeof(Animator))]
public class SimpleLLMControllableNPC : MonoBehaviour, ILLMControllableNPC
{
    [Header("Íàñòðîéêè NPC")]
    [Tooltip("Óíèêàëüíûé ID äëÿ ñîõðàíåíèÿ ýòîãî NPC (íàïðèìåð, 'Robot_001').")]
    public string npcID = "NPC_Default";
    [Tooltip("Ñêîðîñòü ïåðåìåùåíèÿ NPC.")]
    public float movementSpeed = 3.5f;

    public enum NPCState
    {
        Idle,
        Moving,
        Patrolling,
        Dialoguing
    }

    public NPCState currentState = NPCState.Idle;

    [Header("Íàñòðîéêè Ïàòðóëèðîâàíèÿ (îïöèîíàëüíî)")]
    [Tooltip("Òî÷êè, ïî êîòîðûì NPC áóäåò ïàòðóëèðîâàòü â ñîñòîÿíèè Patrol.")]
    public Transform[] patrolPoints;
    private int currentPatrolPointIndex = 0;
    [Tooltip("Ðàññòîÿíèå äî òî÷êè, êîãäà NPC ñ÷èòàåò, ÷òî äîñòèã åå è ïåðåõîäèò ê ñëåäóþùåé.")]
    public float waypointThreshold = 0.5f;

    [Header("Íàñòðîéêè Àíèìàòîðà")]
    [Tooltip("Èìÿ Float-ïàðàìåòðà ñêîðîñòè â Animator Controller (íàïðèìåð, 'Speed').")]
    public string speedAnimatorParam = "Speed";
    [Tooltip("Èìÿ Bool-ïàðàìåòðà äëÿ äâèæåíèÿ â Animator Controller (íàïðèìåð, 'IsMoving').")]
    public string isMovingAnimatorParam = "IsMoving";
    [Tooltip("Èìÿ Trigger-ïàðàìåòðà äëÿ íà÷àëà äèàëîãà â Animator Controller (íàïðèìåð, 'StartDialogue').")]
    public string startDialogueAnimatorParam = "StartDialogue";
    [Tooltip("Èìÿ Trigger-ïàðàìåòðà äëÿ îñòàíîâêè äèàëîãà (îïöèîíàëüíî, åñëè åñòü).")]
    public string stopDialogueAnimatorParam = "StopDialogue";
    [Tooltip("Èìÿ Trigger-ïàðàìåòðà äëÿ ïåðåõîäà â ñîñòîÿíèå ïàòðóëèðîâàíèÿ (îïöèîíàëüíî, åñëè åñòü).")]
    public string startPatrolAnimatorParam = "StartPatrol";
    [Tooltip("Èìÿ Trigger-ïàðàìåòðà äëÿ ïåðåõîäà â ñîñòîÿíèå áåçäåéñòâèÿ (îïöèîíàëüíî, åñëè åñòü).")]
    public string startIdleAnimatorParam = "StartIdle";

    public Text npcText;
    // --- Ïðèâàòíûå ïåðåìåííûå ---
    private NavMeshAgent navMeshAgent;
    private Animator animator;
    private Coroutine currentActionCoroutine;

    private const string SAVE_FOLDER_NAME = "GameSaves";
    private string saveFilePath;

    void Awake()
    {
        navMeshAgent = GetComponent<NavMeshAgent>();
        animator = GetComponent<Animator>();

        if (navMeshAgent == null)
        {
            Debug.LogError($"SimpleLLMControllableNPC: NavMeshAgent íå íàéäåí íà {gameObject.name}. Îòêëþ÷àåì ñêðèïò.", this);
            enabled = false;
            return;
        }
        navMeshAgent.speed = movementSpeed;

        if (animator == null)
        {
            Debug.LogError($"SimpleLLMControllableNPC: Animator íå íàéäåí íà {gameObject.name}. Àíèìàöèè ðàáîòàòü íå áóäóò.", this);
        }

        string saveFolder = Path.Combine(Application.persistentDataPath, SAVE_FOLDER_NAME); // Óáåäèòåñü, ÷òî Application.persistentDataPath èñïîëüçóåòñÿ
        if (!Directory.Exists(saveFolder))
        {
            Directory.CreateDirectory(saveFolder);
        }
        saveFilePath = Path.Combine(saveFolder, $"{npcID}_SimpleNPC.json");
    }

    void Start()
    {
        LoadState();
        ChangeState(currentState);
    }

    void Update()
    {
        if (currentState == NPCState.Patrolling)
        {
            if (patrolPoints == null || patrolPoints.Length == 0)
            {
                Debug.LogWarning($"{gameObject.name}: Íåò ïàòðóëüíûõ òî÷åê. Ïåðåõîä â Idle.");
                ChangeState(NPCState.Idle);
                return;
            }

            if (!navMeshAgent.pathPending && navMeshAgent.remainingDistance < waypointThreshold)
            {
                GoToNextPatrolPoint();
            }
        }

      /*  if (animator != null && navMeshAgent.enabled)
        {
            animator.SetFloat(speedAnimatorParam, navMeshAgent.velocity.magnitude);
            animator.SetBool(isMovingAnimatorParam, navMeshAgent.velocity.magnitude > 0.1f);
        } */
    }

    void OnApplicationQuit()
    {
        SaveState();
    }

    private void ChangeState(NPCState newState)
    {
        if (currentState == newState) return;

        Debug.Log($"{gameObject.name}: Changing state from {currentState} to {newState}");
        currentState = newState;

        if (currentActionCoroutine != null)
        {
            StopCoroutine(currentActionCoroutine);
            currentActionCoroutine = null;
        }

        if (animator != null)
        {
            foreach (var param in animator.parameters)
            {
                if (param.type == AnimatorControllerParameterType.Trigger)
                {
                    animator.ResetTrigger(param.name);
                }
            }
        }

        switch (currentState)
        {
            case NPCState.Idle:
                navMeshAgent.isStopped = true;
                if (animator != null && !string.IsNullOrEmpty(startIdleAnimatorParam)) animator.SetTrigger(startIdleAnimatorParam);
                break;
            case NPCState.Moving:
                navMeshAgent.isStopped = false;
                break;
            case NPCState.Patrolling:
                navMeshAgent.isStopped = false;
                if (animator != null && !string.IsNullOrEmpty(startPatrolAnimatorParam)) animator.SetTrigger(startPatrolAnimatorParam);
                GoToNextPatrolPoint();
                break;
            case NPCState.Dialoguing:
                navMeshAgent.isStopped = true;
                if (animator != null && !string.IsNullOrEmpty(startDialogueAnimatorParam)) animator.SetTrigger(startDialogueAnimatorParam);
                break;
        }
    }

    public void MoveToPosition(Vector3 position)
    {
        if (navMeshAgent != null && navMeshAgent.enabled)
        {
            ChangeState(NPCState.Moving);
            navMeshAgent.SetDestination(position);
            currentActionCoroutine = StartCoroutine(WaitForDestination(position));
            Debug.Log($"{gameObject.name} ïîëó÷èë êîìàíäó: MoveToPosition ê {position}.");
        }
        else
        {
            Debug.LogWarning($"{gameObject.name}: NavMeshAgent íåàêòèâåí èëè îòñóòñòâóåò äëÿ MoveToPosition.");
            SayDialogue("ß íå ìîãó äâèãàòüñÿ, ìîé íàâèãàöèîííûé ìîäóëü îòêëþ÷åí.");
        }
    }

    public void MoveToObject(GameObject targetObject)
    {
        if (navMeshAgent != null && navMeshAgent.enabled)
        {
            if (targetObject != null)
            {
                ChangeState(NPCState.Moving);
                navMeshAgent.SetDestination(targetObject.transform.position);
                currentActionCoroutine = StartCoroutine(WaitForDestination(targetObject.transform.position));
                Debug.Log($"{gameObject.name} ïîëó÷èë êîìàíäó: MoveToObject ê {targetObject.name}.");
            }
            else
            {
                Debug.LogWarning($"{gameObject.name}: Öåëåâîé îáúåêò äëÿ MoveToObject ðàâåí null.");
                SayDialogue("ß íå ìîãó íàéòè öåëü, êîòîðóþ âû óêàçàëè.");
            }
        }
        else
        {
            Debug.LogWarning($"{gameObject.name}: NavMeshAgent íåàêòèâåí èëè îòñóòñòâóåò äëÿ MoveToObject.");
            SayDialogue("ß íå ìîãó äâèãàòüñÿ, ìîé íàâèãàöèîííûé ìîäóëü îòêëþ÷åí.");
        }
    }

    public void SetBehavior(string behaviorType)
    {
        try
        {
            NPCState newNPCState = (NPCState)System.Enum.Parse(typeof(NPCState), behaviorType, true);
            ChangeState(newNPCState);
            Debug.Log($"{gameObject.name} ïîëó÷èë êîìàíäó: SetBehavior ê {behaviorType}.");
            SayDialogue($"Òåïåðü ÿ â ðåæèìå {behaviorType}.");
        }
        catch (System.ArgumentException)
        {
            Debug.LogError($"Íåèçâåñòíûé òèï ïîâåäåíèÿ äëÿ NPC: {behaviorType}");
            SayDialogue($"Èçâèíèòå, ÿ íå ïîíÿë êîìàíäó '{behaviorType}'.");
        }
    }

    public void SayDialogue(string text)
    {
        ChangeState(NPCState.Dialoguing);

        Debug.Log($"NPC {gameObject.name} (ãîâîðèò): \"{text}\"");
        npcText.text = "- " + text;
        currentActionCoroutine = StartCoroutine(EndDialogueAfterDelay(3f));
    }

    private IEnumerator WaitForDestination(Vector3 targetPos)
    {
        yield return new WaitUntil(() => !navMeshAgent.pathPending && navMeshAgent.remainingDistance <= navMeshAgent.stoppingDistance + 0.1f);

        if (currentState == NPCState.Moving)
        {
            ChangeState(NPCState.Idle);
            Debug.Log($"{gameObject.name} äîñòèã öåëè. Âîçâðàùàþñü â Idle.");
        }
    }

    private IEnumerator EndDialogueAfterDelay(float delay)
    {
        yield return new WaitForSeconds(delay);
        if (currentState == NPCState.Dialoguing)
        {
            if (animator != null && !string.IsNullOrEmpty(stopDialogueAnimatorParam)) animator.SetTrigger(stopDialogueAnimatorParam);
            ChangeState(NPCState.Idle);
            Debug.Log($"{gameObject.name}: Äèàëîã çàâåðøåí. Âîçâðàùàþñü â Idle.");
        }
    }

    private void GoToNextPatrolPoint()
    {
        if (patrolPoints == null || patrolPoints.Length == 0)
        {
            Debug.LogWarning($"{gameObject.name}: Íåò ïàòðóëüíûõ òî÷åê. Ïåðåõîä â Idle.");
            ChangeState(NPCState.Idle);
            return;
        }

        navMeshAgent.SetDestination(patrolPoints[currentPatrolPointIndex].position);
        currentPatrolPointIndex = (currentPatrolPointIndex + 1) % patrolPoints.Length;
        Debug.Log($"{gameObject.name} äâèæåòñÿ ê ïàòðóëüíîé òî÷êå {patrolPoints[currentPatrolPointIndex].name}.");
    }

    // ====================================================================
    // Ìåòîäû ÑÎÕÐÀÍÅÍÈß è ÇÀÃÐÓÇÊÈ ñîñòîÿíèÿ
    // ====================================================================

    /// <summary>
    /// Ñîõðàíÿåò òåêóùåå ñîñòîÿíèå NPC â JSON ôàéë.
    /// </summary>
    public void SaveState()
    {
        try
        {
            SimpleNPCSaveData saveData = new SimpleNPCSaveData(); // Ñîçäàåì ýêçåìïëÿð
            saveData.id = this.npcID;

            // --- Èñïîëüçóåì ìåòîäû-ïîìîùíèêè äëÿ ïðåîáðàçîâàíèÿ ---
            saveData.SetPosition(transform.position);
            saveData.SetRotation(transform.rotation);
            // --- Êîíåö èñïîëüçîâàíèÿ ìåòîäîâ-ïîìîùíèêîâ ---

            saveData.currentStateName = currentState.ToString();
            string json = JsonMapper.ToJson(saveData);
            File.WriteAllText(saveFilePath, json);
            Debug.Log($"NPC '{npcID}' state saved. State: {currentState}.");
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error saving NPC '{npcID}' state: {e.Message}");
        }
    }

    /// <summary>
    /// Çàãðóæàåò ñîñòîÿíèå NPC èç JSON ôàéëà.
    /// </summary>
    public void LoadState()
    {
        try
        {
            if (File.Exists(saveFilePath))
            {
                string json = File.ReadAllText(saveFilePath);
                SimpleNPCSaveData loadedData = JsonMapper.ToObject<SimpleNPCSaveData>(json);

                this.npcID = loadedData.id;

                navMeshAgent.enabled = false; // Âðåìåííî îòêëþ÷àåì àãåíò
                // --- Èñïîëüçóåì ìåòîäû-ïîìîùíèêè äëÿ ïîëó÷åíèÿ ---
                transform.position = loadedData.GetPosition();
                transform.rotation = loadedData.GetRotation();
                // --- Êîíåö èñïîëüçîâàíèÿ ìåòîäîâ-ïîìîùíèêîâ ---
                navMeshAgent.enabled = true;

                currentState = (NPCState)System.Enum.Parse(typeof(NPCState), loadedData.currentStateName);

                Debug.Log($"NPC '{npcID}' state loaded. State: {currentState}.");
            }
            else
            {
                Debug.Log($"NPC '{npcID}' save file not found. Starting at default State {currentState}.");
                SaveState();
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error loading NPC '{npcID}' state: {e.Message}");
            currentState = NPCState.Idle;
            SaveState();
        }
    }

    // === Îòëàäêà â ðåäàêòîðå ===
#if UNITY_EDITOR
    void OnDrawGizmosSelected()
    {
        UnityEditor.Handles.Label(transform.position + Vector3.up * 2f,
                                 $"NPC: {npcID}\nState: {currentState}");

        if (navMeshAgent != null && navMeshAgent.hasPath)
        {
            Gizmos.color = Color.blue;
            Vector3[] pathCorners = navMeshAgent.path.corners;
            for (int i = 0; i < pathCorners.Length - 1; i++)
            {
                Gizmos.DrawLine(pathCorners[i], pathCorners[i + 1]);
            }
        }

        if (patrolPoints != null && patrolPoints.Length > 0)
        {
            Gizmos.color = Color.green;
            for (int i = 0; i < patrolPoints.Length; i++)
            {
                if (patrolPoints[i] != null)
                {
                    Gizmos.DrawSphere(patrolPoints[i].position, 0.3f);
                    if (i < patrolPoints.Length - 1 && patrolPoints[i + 1] != null)
                    {
                        Gizmos.DrawLine(patrolPoints[i].position, patrolPoints[i + 1].position);
                    }
                    else if (i == patrolPoints.Length - 1 && patrolPoints.Length > 1 && patrolPoints[0] != null)
                    {
                        Gizmos.DrawLine(patrolPoints[i].position, patrolPoints[0].position);
                    }
                }
            }
        }
    }
#endif
}