devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Unity】AI实战应用——Unity接入GPT和对游戏开发实际应用的展望_unity接入chatgpt

作者：Cpp五条 | 2024-02-15 19:20:04

赞

踩

unity接入chatgpt

GPT for unity插件地址: GitHub - sunsvip/ChatGPTForUnity: ChatGPT for unity

用法:

  1. 打开Unity PackageManager界面.
  2. Add package from git URL
  3. 粘贴插件地址添加 https://github.com/sunsvip/ChatGPTForUnity.git

————————————————————————————————————

几个资本大佬花钱让一群程序员研发出了AI，砸了程序员的大锅。尤其是ChatGPT 4.0发布后，认识的同事朋友们都在恐慌AI的发展，甚至有不少人开始抗拒。我的观点是：人工智能是大势所趋，势不可挡，那就驾驭它吧！

我司已经在商业项目中实际使用了AI, 包括Stable Diffusion及其扩展插件，当然也有爆火的GPT。

Midjourney + Stable Diffusion + ControlNET + Lora以及Photoshop Stable Diffusion 等插件的结合使用已经强大到基本取代初中级原画师；

GPT 4.0势头已经咄咄逼人，据说下一代会进化到运行时处理功能，比如对磁盘的读写等。用户让“创建一个cs代码”，它就能在电脑硬盘里创建一个代码文件。个人觉得任重道远，功能越强责任越大，如果没有有效解决安全问题之前，这一步很难到来。

GPT已经能全面应用到游戏开发的各个环节了，策划的剧情设定、技术的代码编写优化、测试的测试用例等。我从去年12月开始使用，完全把它当成了一个搜索引擎，自从有了它几乎没使用多少次谷歌百度。4.0的到来彻底激发了我对ChatGPT实际应用的思考。

首先第一步肯定是先把GPT接入Unity，先建立起通讯，以此为基础各种应用功能才能百花齐放。

工具效果预览：

将回答里的代码保存成文件

 GPT接口实现：

用UnityWebRequest实现一个与ChatGPT通讯的类，之后的各种功能基于此类。

一，获取API Key

GPT提供了开放接口，仅需一个个人版的API Key即可, API Key获取入口:https://platform.openai.com/account/api-keys

 二，使用UnityWebRequest发送Post请求和接收GPT返回信息

GPT URL:  https://api.openai.com/v1/chat/completions

上行数据结构如下：

  1. {
  2.   "messages": [
  3.     {
  4.       "role": "user",
  5.       "content": "你是机器人吗"//要发送的问题
  6.     }
  7.   ],
  8.   "model": "gpt-3.5-turbo",//AI数据模型
  9.   "temperature": 0.7 //默认是1, 数值越大结果随机性越高
  10. }

 需要注意的是，messages是个数组，如果想连续对话就需要把发送历史塞到这个messages数组，gpt根据你的发送历史分析上下文给出处理结果。gpt消耗token不是根据发送请求次数计算，聊天历史越多单次发送请求消耗的token越多，所以及时清除历史(新建话题)可以节省token消耗。

下行数据结构如下：

  1. {
  2.   "id": "chatcmpl-xxxxxxxxxxxxxxxxxx",
  3.   "object": "chat.completion",
  4.   "created": 1678987654,
  5.   "model": "gpt-3.5-turbo-0301",
  6.   "usage": {
  7.     "prompt_tokens": 14,
  8.     "completion_tokens": 23,
  9.     "total_tokens": 37
  10.   },
  11.   "choices": [
  12.     {
  13.       "message": {
  14.         "role": "assistant",
  15.         "content": "\n\n是的，我是一个AI语言模型，也可以被称为机器人。" //得到的回复
  16.       },
  17.       "finish_reason": "stop",
  18.       "index": 0
  19.     }
  20.   ]
  21. }

使用UnityWebRequest发送Post请求：

  1. private IEnumerator Request(string input, Action<bool, string> onComplete, Action<float> onProgressUpdate)
  2.         {
  3.             var msg = new Message()
  4.             {
  5.                 role = UserId,
  6.                 content = input,
  7.             };
  8.             requestData.AppendChat(msg);
  9.             messageHistory.Add(msg);
  10.  
  11.             using (webRequest = new UnityWebRequest(ChatgptUrl, "POST"))
  12.             {
  13.                 var jsonDt = UtilityBuiltin.Json.ToJson(requestData);
  14.                 Debug.Log(jsonDt);
  15.                 byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonDt);
  16.                 webRequest.uploadHandler = new UploadHandlerRaw(bodyRaw);
  17.                 webRequest.downloadHandler = new DownloadHandlerBuffer();
  18.                 webRequest.SetRequestHeader("Content-Type", "application/json");
  19.                 webRequest.SetRequestHeader("Authorization", $"Bearer {this.ApiKey}");
  20.                 //webRequest.certificateHandler = new ChatGPTWebRequestCert();
  21.                 var req = webRequest.SendWebRequest();
  22.                 while (!webRequest.isDone)
  23.                 {
  24.                     onProgressUpdate?.Invoke((webRequest.downloadProgress + webRequest.uploadProgress) / 2f);
  25.                     yield return null;
  26.                 }
  27.  
  28.                 if (webRequest.result != UnityWebRequest.Result.Success)
  29.                 {
  30.                     Debug.LogError($"---------ChatGPT请求失败:{webRequest.error}---------");
  31.                     onComplete?.Invoke(false, string.Empty);
  32.                 }
  33.                 else
  34.                 {
  35.                     var json = webRequest.downloadHandler.text;
  36.                     Debug.Log(json);
  37.                     try
  38.                     {
  39.                         ChatCompletion result = UtilityBuiltin.Json.ToObject<ChatCompletion>(json);
  40.                         int lastChoiceIdx = result.choices.Count - 1;
  41.                         var replyMsg = result.choices[lastChoiceIdx].message;
  42.                         replyMsg.content = replyMsg.content.Trim();
  43.                         messageHistory.Add(replyMsg);
  44.                         onComplete?.Invoke(true, replyMsg.content);
  45.                     }
  46.                     catch (System.Exception e)
  47.                     {
  48.                         Debug.LogError($"---------ChatGPT返回数据解析失败:{e.Message}---------");
  49.                         onComplete?.Invoke(false, e.Message);
  50.                     }
  51.                 }
  52.                 webRequest.Dispose();
  53.                 webRequest = null;
  54.             }
  55.         }

 以上就是向ChatGPT发送请求并接受回复的核心代码，非常简单。然而不出意外的话会出现请求报错：Cert verify failed: UNITYTLS_X509VERIFY_FLAG_CN_MISMATCH， https证书验证失败。

所以还需要自定义验证类，直接跳过验证返回true：

  1. class ChatGPTWebRequestCert : UnityEngine.Networking.CertificateHandler
  2.     {
  3.         protected override bool ValidateCertificate(byte[] certificateData)
  4.         {
  5.             //return base.ValidateCertificate(certificateData);
  6.             return true;
  7.         }
  8.     }

然后为UnityWebRequest势力指定验证Handler：

webRequest.certificateHandler = new ChatGPTWebRequestCert();

再次运行就能正常接收数据了。

完整代码：

  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using Unity.EditorCoroutines.Editor;
  7. using UnityEditor;
  8. using UnityEngine;
  9. using UnityEngine.Networking;
  10.  
  11. namespace UnityGameFramework.Editor.AIAssistant
  12. {
  13.     public class ChatGPT
  14.     {
  15.         const string ChatgptUrl = "https://api.openai.com/v1/chat/completions";
  16.         const string DefaultAPIKey = "替换自己的ChatGPT API Key";
  17.         const string DefaultModel = "gpt-3.5-turbo";
  18.         const float DefaultTemperature = 0;
  19.         const string DefaultUserId = "user";
  20.         string ApiKey;
  21.         string UserId;
  22.         List<Message> messageHistory;
  23.         public List<Message> MessageHistory => messageHistory;
  24.         ChatGPTRequestData requestData;
  25.         UnityWebRequest webRequest;
  26.         public float ChatGPTRandomness { get => requestData.temperature; set { requestData.temperature = Mathf.Clamp(value, 0, 2); } }
  27.         public bool IsRequesting => webRequest != null && !webRequest.isDone;
  28.         public float RequestProgress => IsRequesting ? (webRequest.uploadProgress + webRequest.downloadProgress) / 2f : 0f;
  29.         public ChatGPT(string apiKey = DefaultAPIKey, string userId = DefaultUserId, string model = DefaultModel, float temperature = DefaultTemperature)
  30.         {
  31.             this.ApiKey = apiKey;
  32.             this.UserId = string.IsNullOrWhiteSpace(userId) ? DefaultUserId : userId;
  33.             messageHistory = new List<Message>();
  34.             requestData = new ChatGPTRequestData(model, temperature);
  35.         }
  36.         /// <summary>
  37.         /// 接着上次的话题
  38.         /// </summary>
  39.         public void RestoreChatHistory()
  40.         {
  41.             var chatHistoryJson = EditorPrefs.GetString("ChatGPT.Settings.ChatHistory", string.Empty);
  42.             var requestDataJson = EditorPrefs.GetString("ChatGPT.Settings.RequestData", string.Empty);
  43.             if (!string.IsNullOrEmpty(chatHistoryJson))
  44.             {
  45.                 var jsonObj = UtilityBuiltin.Json.ToObject<ChatGPTRequestData>(requestDataJson);
  46.                 if (jsonObj != null)
  47.                 {
  48.                     requestData.messages = jsonObj.messages;
  49.                 }
  50.             }
  51.             if (!string.IsNullOrEmpty(requestDataJson))
  52.             {
  53.                 var jsonObj = UtilityBuiltin.Json.ToObject<List<Message>>(chatHistoryJson);
  54.                 if (jsonObj != null)
  55.                 {
  56.                     messageHistory = jsonObj;
  57.                 }
  58.             }
  59.         }
  60.         public void SaveChatHistory()
  61.         {
  62.             var chatHistoryJson = UtilityBuiltin.Json.ToJson(messageHistory);
  63.             var requestDataJson = UtilityBuiltin.Json.ToJson(requestData);
  64.             EditorPrefs.SetString("ChatGPT.Settings.ChatHistory", chatHistoryJson);
  65.             EditorPrefs.SetString("ChatGPT.Settings.RequestData", requestDataJson);
  66.         }
  67.         public void Send(string message, Action<bool, string> onComplete = null, Action<float> onProgressUpdate = null)
  68.         {
  69.             EditorCoroutineUtility.StartCoroutine(Request(message, onComplete, onProgressUpdate), this);
  70.         }
  71.  
  72.         public async Task<string> SendAsync(string message)
  73.         {
  74.             bool isCompleted = false;
  75.             string result = string.Empty;
  76.             Action<bool, string> onComplete = (success, str) =>
  77.             {
  78.                 isCompleted = true;
  79.                 if (success) result = str;
  80.             };
  81.  
  82.             EditorCoroutineUtility.StartCoroutine(Request(message, onComplete, null), this);
  83.             while (!isCompleted)
  84.             {
  85.                 await Task.Delay(10);
  86.             }
  87.             return result;
  88.         }
  89.         private IEnumerator Request(string input, Action<bool, string> onComplete, Action<float> onProgressUpdate)
  90.         {
  91.             var msg = new Message()
  92.             {
  93.                 role = UserId,
  94.                 content = input,
  95.             };
  96.             requestData.AppendChat(msg);
  97.             messageHistory.Add(msg);
  98.  
  99.             using (webRequest = new UnityWebRequest(ChatgptUrl, "POST"))
  100.             {
  101.                 var jsonDt = UtilityBuiltin.Json.ToJson(requestData);
  102.                 Debug.Log(jsonDt);
  103.                 byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonDt);
  104.                 webRequest.uploadHandler = new UploadHandlerRaw(bodyRaw);
  105.                 webRequest.downloadHandler = new DownloadHandlerBuffer();
  106.                 webRequest.SetRequestHeader("Content-Type", "application/json");
  107.                 webRequest.SetRequestHeader("Authorization", $"Bearer {this.ApiKey}");
  108.                 webRequest.certificateHandler = new ChatGPTWebRequestCert();
  109.                 var req = webRequest.SendWebRequest();
  110.                 while (!webRequest.isDone)
  111.                 {
  112.                     onProgressUpdate?.Invoke((webRequest.downloadProgress + webRequest.uploadProgress) / 2f);
  113.                     yield return null;
  114.                 }
  115.  
  116.                 if (webRequest.result != UnityWebRequest.Result.Success)
  117.                 {
  118.                     Debug.LogError($"---------ChatGPT请求失败:{webRequest.error}---------");
  119.                     onComplete?.Invoke(false, string.Empty);
  120.                 }
  121.                 else
  122.                 {
  123.                     var json = webRequest.downloadHandler.text;
  124.                     Debug.Log(json);
  125.                     try
  126.                     {
  127.                         ChatCompletion result = UtilityBuiltin.Json.ToObject<ChatCompletion>(json);
  128.                         int lastChoiceIdx = result.choices.Count - 1;
  129.                         var replyMsg = result.choices[lastChoiceIdx].message;
  130.                         replyMsg.content = replyMsg.content.Trim();
  131.                         messageHistory.Add(replyMsg);
  132.                         onComplete?.Invoke(true, replyMsg.content);
  133.                     }
  134.                     catch (System.Exception e)
  135.                     {
  136.                         Debug.LogError($"---------ChatGPT返回数据解析失败:{e.Message}---------");
  137.                         onComplete?.Invoke(false, e.Message);
  138.                     }
  139.                 }
  140.                 webRequest.Dispose();
  141.                 webRequest = null;
  142.             }
  143.         }
  144.         public void NewChat()
  145.         {
  146.             requestData.ClearChat();
  147.             messageHistory.Clear();
  148.         }
  149.         public bool IsSelfMessage(Message msg)
  150.         {
  151.             return this.UserId.CompareTo(msg.role) == 0;
  152.         }
  153.     }
  154.  
  155.     class ChatGPTRequestData
  156.     {
  157.         public List<Message> messages;
  158.         public string model;
  159.         public float temperature;
  160.  
  161.         public ChatGPTRequestData(string model, float temper)
  162.         {
  163.             this.model = model;
  164.             this.temperature = temper;
  165.             this.messages = new List<Message>();
  166.         }
  167.  
  168.         /// <summary>
  169.         /// 同一话题追加会话内容
  170.         /// </summary>
  171.         /// <param name="chatMsg"></param>
  172.         /// <returns></returns>
  173.         public ChatGPTRequestData AppendChat(Message msg)
  174.         {
  175.             this.messages.Add(msg);
  176.             return this;
  177.         }
  178.         /// <summary>
  179.         /// 清除聊天历史(结束一个话题), 相当于新建一个聊天话题
  180.         /// </summary>
  181.         public void ClearChat()
  182.         {
  183.             this.messages.Clear();
  184.         }
  185.     }
  186.  
  187.     class ChatGPTWebRequestCert : UnityEngine.Networking.CertificateHandler
  188.     {
  189.         protected override bool ValidateCertificate(byte[] certificateData)
  190.         {
  191.             //return base.ValidateCertificate(certificateData);
  192.             return true;
  193.         }
  194.     }
  195.     class Usage
  196.     {
  197.         public int prompt_tokens;
  198.         public int completion_tokens;
  199.         public int total_tokens;
  200.     }
  201.  
  202.     public class Message
  203.     {
  204.         public string role;
  205.         public string content;
  206.     }
  207.  
  208.     class Choice
  209.     {
  210.         public Message message;
  211.         public string finish_reason;
  212.         public int index;
  213.     }
  214.  
  215.     class ChatCompletion
  216.     {
  217.         public string id;
  218.         public string @object;
  219.         public int created;
  220.         public string model;
  221.         public Usage usage;
  222.         public List<Choice> choices;
  223.     }
  224. }
  225.

使用方法一, 同步获取结果：

  1. var ai = new ChatGPT();
  2. var str = await ai.SendAsync("你好");
  3. Debug.Log(str);

 使用方法二, 异步获取结果:

new ChatGPT().Send("你好", (success, message) => { if (success) Debug.Log(message); }, requestProgress => { Debug.Log($"Request progress:{requestProgress}"); });

三，基于上面的类实现一个AI聊天窗口

为什么要写个聊天窗口：

1. https://chat.openai.com/chat 网页版登陆锁IP，并且会验证时区，如果用美国的节点时区时间对不上拒绝登录。

2. 虽然登录成功后不科学也能用，但是同一话题很快就会超时无法应答，刷新界面或新建话题才能正常使用，总之非常鸡肋。

而通过开放接口就没有这些问题，API请求会更加爽快。

聊天窗口功能设计：

1. 需要一个滚动列表展示双方对话记录，对话文本内容支持选择复制。

2. 问题输入框和发送按钮、新建话题(清除话题对话)

3. 对话历史存档。

代码实现，比较简单就不解释了，直接上源码：

  1. using System;
  2. using UnityEditor;
  3. using UnityEngine;
  4.  
  5. namespace UnityGameFramework.Editor.AIAssistant
  6. {
  7.     [EditorToolMenu("AI助手/ChatGPT", 5)]
  8.     public class ChatGPTWindow : EditorToolBase
  9.     {
  10.         public override string ToolName => "ChatGPT";
  11.  
  12.         Vector2 scrollPos = Vector2.zero;
  13.  
  14.         ChatGPT ai;
  15.         private bool settingFoldout = false;
  16.         string message;
  17.         const string aiRoleName = "AI";
  18.         private float chatBoxWidthRatio = 0.85f;
  19.         private float iconSizeRatio = 0.6f;
  20.         private float chatBoxPadding = 20;
  21.         private float chatBoxEdgePadding = 10;
  22.  
  23.         GUIStyle myChatStyle;
  24.         GUIStyle aiChatStyle;
  25.  
  26.         GUIStyle aiIconStyle;
  27.         GUIStyle myIconStyle;
  28.         GUIStyle txtAreaStyle;
  29.  
  30.         GUIContent chatContent;
  31.  
  32.         bool isEditorInitialized = false;
  33.         private float scrollViewHeight;
  34.  
  35.         private void OnEnable()
  36.         {
  37.             EditorApplication.update += OnEditorUpdate;
  38.             ai = new ChatGPT(AppBuildSettings.Instance.ChatGPTKey);
  39.             ai.ChatGPTRandomness = AppBuildSettings.Instance.ChatGPTRandomness;
  40.             chatContent = new GUIContent();
  41.             ai.RestoreChatHistory();
  42.         }
  43.  
  44.         private void OnEditorUpdate()
  45.         {
  46.             if (EditorApplication.isCompiling || EditorApplication.isUpdating)
  47.             {
  48.                 return;
  49.             }
  50.             try
  51.             {
  52.                 InitGUIStyles();
  53.                 isEditorInitialized = true;
  54.                 EditorApplication.update -= OnEditorUpdate;
  55.             }
  56.             catch (Exception)
  57.             {
  58.  
  59.             }
  60.         }
  61.  
  62.         private void InitGUIStyles()
  63.         {
  64.             aiChatStyle = new GUIStyle(EditorStyles.selectionRect);
  65.             aiChatStyle.wordWrap = true;
  66.             aiChatStyle.normal.textColor = Color.white;
  67.             aiChatStyle.fontSize = 18;
  68.             aiChatStyle.alignment = TextAnchor.MiddleLeft;
  69.  
  70.             myChatStyle = new GUIStyle(EditorStyles.helpBox);
  71.             myChatStyle.wordWrap = true;
  72.             myChatStyle.normal.textColor = Color.white;
  73.             myChatStyle.fontSize = 18;
  74.             myChatStyle.alignment = TextAnchor.MiddleLeft;
  75.  
  76.  
  77.             txtAreaStyle = new GUIStyle(EditorStyles.textArea);
  78.             txtAreaStyle.fontSize = 18;
  79.  
  80.             aiIconStyle = new GUIStyle();
  81.             aiIconStyle.wordWrap = true;
  82.             aiIconStyle.alignment = TextAnchor.MiddleCenter;
  83.             aiIconStyle.fontSize = 18;
  84.             aiIconStyle.fontStyle = FontStyle.Bold;
  85.             aiIconStyle.normal.textColor = Color.black;
  86.             aiIconStyle.normal.background = EditorGUIUtility.FindTexture("sv_icon_dot5_pix16_gizmo");
  87.  
  88.             myIconStyle = new GUIStyle(aiIconStyle);
  89.             myIconStyle.normal.background = EditorGUIUtility.FindTexture("sv_icon_dot2_pix16_gizmo");
  90.         }
  91.  
  92.         private void OnDisable()
  93.         {
  94.             ai.SaveChatHistory();
  95.         }
  96.         private void OnGUI()
  97.         {
  98.             if (!isEditorInitialized) return;
  99.             EditorGUILayout.BeginVertical();
  100.             {
  101.                 scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
  102.                 {
  103.                     scrollViewHeight = 0;
  104.                     foreach (var msg in ai.MessageHistory)
  105.                     {
  106.                         var msgRect = EditorGUILayout.BeginVertical();
  107.                         {
  108.                             EditorGUILayout.BeginHorizontal();
  109.                             {
  110.                                 bool isMyMsg = ai.IsSelfMessage(msg);
  111.                                 var labelStyle = isMyMsg ? myChatStyle : aiChatStyle;
  112.                                 chatContent.text = msg.content;
  113.                                 float chatBoxWidth = this.position.width * chatBoxWidthRatio;
  114.                                 float iconSize = (this.position.width - chatBoxWidth) * iconSizeRatio;
  115.                                 float chatBoxHeight = Mathf.Max(iconSize, chatBoxEdgePadding + labelStyle.CalcHeight(chatContent, chatBoxWidth - chatBoxEdgePadding));
  116.                                 if (isMyMsg) { GUILayout.FlexibleSpace(); }
  117.                                 else
  118.                                 {
  119.                                     EditorGUILayout.LabelField(aiRoleName, aiIconStyle, GUILayout.Width(iconSize), GUILayout.Height(iconSize));
  120.                                 }
  121.                                 EditorGUILayout.SelectableLabel(msg.content, labelStyle, GUILayout.Width(chatBoxWidth), GUILayout.Height(chatBoxHeight));
  122.                                 if (!isMyMsg) { GUILayout.FlexibleSpace(); }
  123.                                 else
  124.                                 {
  125.                                     EditorGUILayout.LabelField(msg.role, myIconStyle, GUILayout.Width(iconSize), GUILayout.Height(iconSize));
  126.                                 }
  127.                                 EditorGUILayout.EndHorizontal();
  128.                             }
  129.                             EditorGUILayout.EndVertical();
  130.                         }
  131.                         EditorGUILayout.Space(chatBoxPadding);
  132.                         scrollViewHeight += msgRect.height;
  133.                     }
  134.                     EditorGUILayout.EndScrollView();
  135.                 }
  136.  
  137.                 if (ai.IsRequesting)
  138.                 {
  139.                     var barWidth = position.width * 0.8f;
  140.                     var pBarRect = new Rect((position.width - barWidth) * 0.5f, (position.height - 30f) * 0.5f, barWidth, 30f);
  141.                     EditorGUI.ProgressBar(pBarRect, ai.RequestProgress, $"请求进度:{ai.RequestProgress:P2}");
  142.                 }
  143.                 GUILayout.FlexibleSpace();
  144.                 if (settingFoldout = EditorGUILayout.Foldout(settingFoldout, "展开设置项:"))
  145.                 {
  146.                     EditorGUILayout.BeginVertical("box");
  147.                     {
  148.                         EditorGUILayout.BeginHorizontal();
  149.                         {
  150.                             EditorGUILayout.LabelField("ChatGPT API Key:", GUILayout.Width(170));
  151.                             AppBuildSettings.Instance.ChatGPTKey = EditorGUILayout.TextField(AppBuildSettings.Instance.ChatGPTKey);
  152.                             EditorGUILayout.EndHorizontal();
  153.                         }
  154.  
  155.                         EditorGUILayout.BeginHorizontal();
  156.                         {
  157.                             EditorGUILayout.LabelField("结果随机性:", GUILayout.Width(170));
  158.                             ai.ChatGPTRandomness = AppBuildSettings.Instance.ChatGPTRandomness = EditorGUILayout.Slider(AppBuildSettings.Instance.ChatGPTRandomness, 0, 2);
  159.                             EditorGUILayout.EndHorizontal();
  160.                         }
  161.                         EditorGUILayout.EndVertical();
  162.                     }
  163.  
  164.                 }
  165.                 //EditorGUILayout.LabelField(scrollPos.ToString());
  166.                 EditorGUILayout.BeginHorizontal();
  167.                 {
  168.                     message = EditorGUILayout.TextArea(message, txtAreaStyle, GUILayout.MinHeight(80));
  169.  
  170.                     EditorGUI.BeginDisabledGroup(ai.IsRequesting);
  171.                     {
  172.                         if (GUILayout.Button("发送消息", GUILayout.MaxWidth(120), GUILayout.Height(80)))
  173.                         {
  174.                             if (!string.IsNullOrWhiteSpace(message))
  175.                             {
  176.                                 ai.Send(message, OnChatGPTMessage);
  177.                             }
  178.                         }
  179.                         if (GUILayout.Button("新话题", GUILayout.MaxWidth(80), GUILayout.Height(80)))
  180.                         {
  181.                             ai.NewChat();
  182.                         }
  183.                         EditorGUI.EndDisabledGroup();
  184.                     }
  185.  
  186.                     EditorGUILayout.EndHorizontal();
  187.                 }
  188.                 EditorGUILayout.EndVertical();
  189.             }
  190.         }
  191.  
  192.         private void OnChatGPTMessage(bool arg1, string arg2)
  193.         {
  194.             scrollPos.y = scrollViewHeight;
  195.             if (arg1)
  196.             {
  197.                 message = string.Empty;
  198.             }
  199.             Repaint();
  200.         }
  201.     }
  202. }

添加代码后，Toolbar的Tools工具栏会自动识别这个工具菜单，点击即可打开AI对话窗口：

 AI的应用展望：

下一步就是为GPT赋予双手，添加各种指令Handler。比如生成json文件、生成语言国际化Excel文件、修改优化代码、生成代码文件、生成Shader、一键拼UI等等。

分为三个模块：

1. 描述文本(发送给GPT)

2. 动态追加描述内容：有时需要追加一些文本数据，比如让GPT优化一段代码，需要动态追加把代码补充到描述文本。

3. 结果解析。得到目标结果，使用Handler解析GPT返回结果，达成某种功能。GPT返回的代码或json等数据都会用标签包住，通过解析标签就可以生成各种类型的文件。

最终就可以不用写程序，只写问题的描述文本，确保能从GPT得到满意答案就可以实现某项功能。想要新增新的工具，扩展新的功能只需要在文件中添加修改问题描述文本即可。

比如语言国际化，我通过问题描述让GPT从工程代码中扫描所有语言本地化函数GF.Localization.GetText()传入的国际化文本，并且把文本翻译成中文，把结果以key，value键值对保存输出json文件。最后我得到了GPT返回的诸如{"Hello":”你好“}的所有国际化文本和翻译结果。

然后我只需要解析GPT返回结果，生成语言国际化文件到工程中就完成了AI自动处理语言国际化的问题。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/86209
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号