LLM_NPC_Controller.cs

using UnityEngine;
using UnityEngine.UI;
using System.Collections; // Äëÿ êîðóòèí
using UnityEngine.Networking; // Äëÿ UnityWebRequest (HTTP çàïðîñû)
using LitJson; // Äëÿ ïàðñèíãà JSON îòâåòîâ îò LLM (òðåáóåòñÿ LitJson.dll â Assets/Plugins)
using System.Text; // Äëÿ ðàáîòû ñ êîäèðîâêàìè ñòðîê

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

public class LLM_NPC_Controller : MonoBehaviour
{
    [Header("UI ññûëêè")]
    [Tooltip("Ïîëå ââîäà òåêñòà äëÿ êîìàíä NPC.")]
    public InputField commandInputField;
    [Tooltip("Êíîïêà äëÿ îòïðàâêè êîìàíäû NPC.")]
    public Button sendCommandButton;
    [Tooltip("Ïîëå äëÿ îòîáðàæåíèÿ îòâåòîâ îò LLM/ñòàòóñà.")]
    public Text responseText;

    [Header("Íàñòðîéêè LLM API")]
    [Tooltip("URL âàøåãî LLM API (íàïðèìåð, Gemini API).")]
    public string llmApiUrl = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=";
    [Tooltip("Âàø API-êëþ÷ äëÿ LLM (íå õðàíèòå â îòêðûòîì âèäå â ïðîäàêøåíå!).")]
    public string apiKey = ""; // Çäåñü äîëæåí áûòü âàø API-êëþ÷

    [Header("Ññûëêè íà NPC")]
    [Tooltip("Ññûëêà íà NPC, êîòîðûì áóäåò óïðàâëÿòü LLM. Ó íåãî äîëæåí áûòü êîìïîíåíò, ðåàëèçóþùèé ILLMControllableNPC.")]
    public GameObject targetNPCGameObject;
    private ILLMControllableNPC targetNPC;

    void Start()
    {
       /* if (commandInputField == null || sendCommandButton == null || responseText == null)
        {
            Debug.LogError("LLM_NPC_Controller: UI ýëåìåíòû íå íàçíà÷åíû!");
            enabled = false;
            return;
        }

        if (targetNPCGameObject == null)
        {
            Debug.LogError("LLM_NPC_Controller: Target NPC GameObject íå íàçíà÷åí!");
            enabled = false;
            return;
        }

        targetNPC = targetNPCGameObject.GetComponent<ILLMControllableNPC>();
        if (targetNPC == null)
        {
            Debug.LogError($"LLM_NPC_Controller: Target NPC GameObject '{targetNPCGameObject.name}' íå ðåàëèçóåò èíòåðôåéñ ILLMControllableNPC!");
            enabled = false;
            return;
        } */

        sendCommandButton.onClick.AddListener(OnSendCommand);
        responseText.text = "Ãîòîâ ê êîìàíäàì...";
    }

    /// <summary>
    /// Âûçûâàåòñÿ ïðè íàæàòèè êíîïêè îòïðàâêè êîìàíäû.
    /// </summary>
    public void OnSendCommand()
    {
        string commandText = commandInputField.text;
        if (string.IsNullOrWhiteSpace(commandText))
        {
            responseText.text = "Ââåäèòå êîìàíäó!";
            return;
        }

        responseText.text = "Îòïðàâêà êîìàíäû LLM...";
        StartCoroutine(SendToLLM(commandText)); // Çàïóñêàåì êîðóòèíó äëÿ îòïðàâêè çàïðîñà
        commandInputField.text = ""; // Î÷èùàåì ïîëå ââîäà
    }

    /// <summary>
    /// Îòïðàâëÿåò çàïðîñ LLM API è îáðàáàòûâàåò îòâåò.
    /// </summary>
    /// <param name="userPrompt">Òåêñòîâàÿ êîìàíäà ïîëüçîâàòåëÿ.</param>
    IEnumerator SendToLLM(string userPrompt)
    {
        // === Øàã 1: Ôîðìèðîâàíèå çàïðîñà äëÿ LLM ===
        // Çäåñü ìû ïðîñèì LLM îòâåòèòü â ñòðóêòóðèðîâàííîì JSON-ôîðìàòå
        // Ýòî Î×ÅÍÜ ÂÀÆÍÎ, ÷òîáû LLM ãåíåðèðîâàëà ïàðñèðóåìûé îòâåò.
        string llmPrompt = $"You are an AI assistant controlling a game NPC. The user will give you a command for the NPC. " +
                           $"Your task is to convert this command into a JSON object with a 'command' field and relevant 'parameters'. " +
                           $"Possible commands: 'moveToObject' (parameters: objectName:string), 'moveToPosition' (parameters: x:float, y:float, z:float), " +
                           $"'setBehavior' (parameters: behaviorType:string - e.g., 'Patrol', 'Idle', 'ChasePlayer'), " +
                           $"'say' (parameters: text:string). " +
                           $"If the command is unclear, use 'say' and ask for clarification. " +
                           $"Strictly respond ONLY with the JSON object. Do not include any other text.\n" +
                           $"User command: \"{userPrompt}\"";

        // Åñëè âû èñïîëüçóåòå ìîäåëü, êîòîðàÿ ïîääåðæèâàåò responseSchema, èñïîëüçóéòå ýòî âìåñòî òåêñòîâîãî ïðîìïòà:
        /*
        const string payload = JsonMapper.ToJson(new {
            contents = new[] {
                new {
                    role = "user",
                    parts = new[] {
                        new { text = userPrompt }
                    }
                }
            },
            generationConfig = new {
                responseMimeType = "application/json",
                responseSchema = new {
                    type = "OBJECT",
                    properties = new {
                        command = new { type = "STRING" },
                        parameters = new {
                            type = "OBJECT",
                            additionalProperties = true
                        }
                    },
                    required = new[] { "command" }
                }
            }
        });
        */

        // Äëÿ gemini-2.0-flash, êîòîðûé ìû èñïîëüçóåì, ëó÷øå âñåãî ñðàáîòàåò ïðîìïò â òåêñòå
        string requestBody = JsonMapper.ToJson(new
        {
            contents = new[] {
                new {
                    role = "user",
                    parts = new[] {
                        new { text = llmPrompt }
                    }
                }
            }
        });

        // Debug.Log($"Sending to LLM: {requestBody}");

        UnityWebRequest request = new UnityWebRequest(llmApiUrl + apiKey, "POST");
        byte[] bodyRaw = Encoding.UTF8.GetBytes(requestBody);
        request.uploadHandler = new UploadHandlerRaw(bodyRaw);
        request.downloadHandler = new DownloadHandlerBuffer();
        request.SetRequestHeader("Content-Type", "application/json");

        yield return request.SendWebRequest(); // Îòïðàâëÿåì çàïðîñ è æäåì îòâåòà

        if (request.result != UnityWebRequest.Result.Success)
        {
            Debug.LogError($"Error sending to LLM: {request.error}");
            responseText.text = $"Îøèáêà LLM: {request.error}";
        }
        else
        {
            string jsonResponse = request.downloadHandler.text;
            Debug.Log($"Received from LLM: {jsonResponse}");
            ProcessLLMResponse(jsonResponse); // Îáðàáàòûâàåì îòâåò
        }
    }

    /// <summary>
    /// Ðàçáèðàåò JSON-îòâåò îò LLM è âûçûâàåò ñîîòâåòñòâóþùèå êîìàíäû íà NPC.
    /// </summary>
    /// <param name="jsonResponse">JSON-ñòðîêà îòâåòà îò LLM.</param>
    void ProcessLLMResponse(string jsonResponse)
    {
        try
        {
            // JsonMapper îæèäàåò, ÷òî êîðåíü JSON áóäåò îáúåêòîì èëè ìàññèâîì.
            // Îòâåò îò Gemini API ÷àñòî îáåðíóò â ñòðóêòóðó: { candidates: [ { content: { parts: [ { text: "..." } ] } } ] }
            JsonData rootData = JsonMapper.ToObject(jsonResponse);

            if (rootData == null || !rootData.ContainsKey("candidates") || rootData["candidates"].Count == 0 ||
                !rootData["candidates"][0].ContainsKey("content") || !rootData["candidates"][0]["content"].ContainsKey("parts") ||
                rootData["candidates"][0]["content"]["parts"].Count == 0)
            {
                responseText.text = "Îøèáêà: Íåêîððåêòíûé îòâåò îò LLM.";
                Debug.LogError("LLM response structure invalid: " + jsonResponse);
                return;
            }

            // Èçâëåêàåì òåêñò JSON-êîìàíäû èç îòâåòà LLM
            string commandJsonText = rootData["candidates"][0]["content"]["parts"][0]["text"].ToString();
            Debug.Log("Parsed command JSON text: " + commandJsonText);

            // Òåïåðü ïàðñèì ñàì JSON-îáúåêò êîìàíäû
            JsonData commandData = JsonMapper.ToObject(commandJsonText);

            string command = commandData["command"].ToString();
            JsonData parameters = commandData.ContainsKey("parameters") ? commandData["parameters"] : null;

            switch (command)
            {
                case "moveToObject":
                    if (parameters != null && parameters.ContainsKey("objectName"))
                    {
                        string objectName = parameters["objectName"].ToString();
                        GameObject targetObject = GameObject.Find(objectName); // Èùåì îáúåêò ïî èìåíè
                        if (targetObject != null)
                        {
                            targetNPC.MoveToObject(targetObject);
                            responseText.text = $"NPC äâèæåòñÿ ê {objectName}.";
                        }
                        else
                        {
                            responseText.text = $"Íå ìîãó íàéòè îáúåêò: {objectName}.";
                        }
                    }
                    else
                    {
                        responseText.text = "Îøèáêà: Äëÿ moveToObject òðåáóåòñÿ 'objectName'.";
                    }
                    break;

                case "moveToPosition":
                    if (parameters != null && parameters.ContainsKey("x") && parameters.ContainsKey("y") && parameters.ContainsKey("z"))
                    {
                        float x = (float)parameters["x"];
                        float y = (float)parameters["y"];
                        float z = (float)parameters["z"];
                        targetNPC.MoveToPosition(new Vector3(x, y, z));
                        responseText.text = $"NPC äâèæåòñÿ ê ïîçèöèè ({x}, {y}, {z}).";
                    }
                    else
                    {
                        responseText.text = "Îøèáêà: Äëÿ moveToPosition òðåáóþòñÿ 'x', 'y', 'z'.";
                    }
                    break;

                case "setBehavior":
                    if (parameters != null && parameters.ContainsKey("behaviorType"))
                    {
                        string behaviorType = parameters["behaviorType"].ToString();
                        targetNPC.SetBehavior(behaviorType);
                        responseText.text = $"NPC ïåðåõîäèò â ðåæèì: {behaviorType}.";
                    }
                    else
                    {
                        responseText.text = "Îøèáêà: Äëÿ setBehavior òðåáóåòñÿ 'behaviorType'.";
                    }
                    break;

                case "say":
                    if (parameters != null && parameters.ContainsKey("text"))
                    {
                        string text = parameters["text"].ToString();
                        targetNPC.SayDialogue(text);
                        responseText.text = $"NPC ãîâîðèò: \"{text}\"";
                    }
                    else
                    {
                        responseText.text = "Îøèáêà: Äëÿ say òðåáóåòñÿ 'text'.";
                    }
                    break;

                default:
                    responseText.text = $"Íåèçâåñòíàÿ êîìàíäà LLM: {command}.";
                    break;
            }
        }
        catch (System.Exception e)
        {
            responseText.text = "Îøèáêà ïàðñèíãà îòâåòà LLM.";
            Debug.LogError($"Error processing LLM response: {e.Message}\nResponse: {jsonResponse}");
        }
    }
}