>**记录平时工作和学习中遇到的技术问题**

开发问题和备忘

# 效果展示

![](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/691621486aeee5b335240d62565b5d64.Apr-07-2025%207-53-42%C3%A2%C2%80%C2%AFPM.gif)

:::info{title="使用方法"}
选中场景中需要批量重命名的对象，右键打开菜单，点击选项`Batch Rename GameObjects`，填写自定义名称和序号即可。
:::


# 完整代码
已上传到Github仓库，可直接下载 [BatchRenameTool](https://github.com/xuxuxuJS/BatchRenameTool)

![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/80fdc034e12c346c6acf8d8684ae89f7.image.webp)


```c#
#if UNITY_EDITOR
using System.IO;
using UnityEditor;
using UnityEngine;

public class BatchRenameGameObjects : EditorWindow
{
    #region members
    private Vector2 scrollPos;
    private int charSize;
    private string targetName = string.Empty;
    private string startNum_str = "0";
    private int startNum_int = 0;
    private bool isTwoDigitFormat = false; // 标记是否为两位数字格式
    #endregion

    #region get window
    [MenuItem("CustomEditorWindow/Batch Rename GameObjects")]
    private static void OpenWindow()
    {
        GetWindow<BatchRenameGameObjects>("Batch Rename GameObjects").Show();
    }

    // 添加右键菜单项，设置为优先显示在 GameObject 菜单的开头
    [MenuItem("GameObject/Batch Rename GameObjects", false, 0)]
    private static void OpenRenameToolFromContextMenu()
    {
        // 打开批量重命名工具
        GetWindow<BatchRenameGameObjects>("Batch Rename GameObjects").Show();
    }
    #endregion

    #region render the window
    private void OnGUI()
    {
        scrollPos = GUILayout.BeginScrollView(scrollPos);
        {
            #region tool title
            charSize = GUI.skin.label.fontSize;
            GUI.color = Color.yellow;
            GUILayout.Space(10);
            GUI.skin.label.fontSize = 24;
            GUI.skin.label.alignment = TextAnchor.MiddleCenter;
            GUILayout.Label("Batch Rename GameObjects");
            GUI.skin.label.fontSize = charSize;
            GUI.skin.label.alignment = TextAnchor.MiddleLeft;
            GUI.color = Color.white;
            GUILayout.Space(20);
            #endregion

            GUILayout.BeginVertical();
            {
                #region text input
                GUILayout.BeginHorizontal();
                {
                    GUILayout.Label("Name Style: ");
                    GUILayout.FlexibleSpace();
                    targetName = GUILayout.TextField(targetName, GUILayout.Width(140));
                }
                GUILayout.EndHorizontal();
                GUILayout.Space(10);

                GUILayout.BeginHorizontal();
                {
                    GUILayout.Label("Start Number: ");
                    GUILayout.FlexibleSpace();
                    startNum_str = GUILayout.TextField(startNum_str, GUILayout.Width(60));
                    try
                    {
                        startNum_int = int.Parse(startNum_str);
                        isTwoDigitFormat = startNum_str.Length == 2 && startNum_str.StartsWith("0"); // 判断是否需要两位数格式
                    }
                    catch
                    {

                    }
                }
                GUILayout.EndHorizontal();
                #endregion
                #region button
                GUILayout.Space(30);
                bool hasObject = (Selection.objects.Length > 0);
                GUI.enabled = hasObject;

                GUILayout.FlexibleSpace();
                if (!hasObject)
                {
                    GUI.color = Color.red;
                    GUILayout.Button("No Selected Objects!");
                    GUI.color = Color.white;

                }
                else
                {
                    if (GUILayout.Button("Rename"))
                    {
                        Rename(targetName, startNum_int);
                    }
                }
                GUILayout.Space(20);
                #endregion
            }
            GUILayout.EndVertical();
        }
        GUILayout.EndScrollView();
    }
    #endregion

    #region Rename Function
    private void Rename(string t_name, int t_index)
    {
        string name = t_name.Trim(); //去除头尾空白字符串
        int index = t_index;
        if ((name + index) != string.Empty) //若名字不为空
        {
            bool isAssetsObject = false; //flag, 是否是assets文件夹的资源

            foreach (Object o in Selection.objects)
            {
                string path_g = AssetDatabase.GetAssetPath(o); //获得选中物的路径
                //查看路径后缀
                if (Path.GetExtension(path_g) != "") //若后缀不为空, 则为assets文件夹物体
                {
                    if (name.Length >= 2 && name.Substring(0, 2) == "m_") // m_ 开头会被吞
                    {
                        //用 M_ 修正
                        string temp_name = name.Remove(0, 1);
                        name = temp_name.Insert(0, "M");
                    }

                    // 根据是否是两位数字格式来选择格式化方式
                    string formattedIndex = isTwoDigitFormat ? index.ToString().PadLeft(2, '0') : index.ToString();
                    AssetDatabase.RenameAsset(path_g, name + formattedIndex); //改名API
                    if (!isAssetsObject)
                    {
                        isAssetsObject = true; //修改flag
                    }
                }
                else //后缀为空, 是场景物体
                {
                    // 根据是否是两位数字格式来选择格式化方式
                    string formattedIndex = isTwoDigitFormat ? index.ToString().PadLeft(2, '0') : index.ToString();
                    o.name = name + formattedIndex;
                }
                index++;
            }
            if (isAssetsObject) //若是assets文件夹资源, 则刷新assets
            {
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
        }
    }
    #endregion
}
#endif
```

Unity批量重命名工具

![logo.webp](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/480d21958c72f232a5008fc68284d352.logo_%C3%A5%C2%89%C2%AF%C3%A6%C2%9C%C2%AC.webp)


# 1.创建API key
访问[DeepSeek开放平台](https://platform.deepseek.com/api_keys)，登录你的账号，创建一个API Key，随便命名，我这里命名为`Unity_API`

![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/165c49152261c505bcfeb1a077337809.image.webp)
复制并保存好提供的key，DeepSeek平台的规则只允许你在刚创建的时候查看一次key，之后就不能查看了，最好粘贴到记事本或文件传输助手当中

![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/21b29de5aa79920bd29bca20280d8bff.image.webp)
# 2.UI组件
在Unity中分别创建三个UI组件：
Input Field获取用户的输入，Text用于显示DeepSeek返回的回答，Button用于发送用户的请求
![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/f474a22fb5fe5d516d8834c8c2d0262c.image.webp)
# 3.编写脚本
创建空物体命名为`DeepSeekChat`，将我提供的代码复制粘贴，我们先获取到UI组件，我这里用public直接拖入，将刚刚获取到的API key填入到字段`apiKey`中，Json解析库依赖Newtonsoft.Json，如果没有需要下载并导入
![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/28e2b0e1f5fd4a3ccf137fa2f08bbb0d.image.webp)
```c#
using UnityEngine;
using UnityEngine.Networking;
using System.Collections;
using System.Text;
using UnityEngine.UI;
using TMPro;
using System;
using Newtonsoft.Json;

public class DeepSeekChat : MonoBehaviour
{
    //>这里填你你创建好的API key即可
    public string apiKey = "";
    public string apiUrl = "https://api.deepseek.com/v1/chat/completions";
    public TMP_InputField inputField;
    public TextMeshProUGUI chatText;
    public Button btnResquest;
    bool isFirst = true;
    private void Start()
    {
        btnResquest.onClick.AddListener(SendMessageToDeepSeek);
    }

    public void SendMessageToDeepSeek()
    {
        string userMessage = inputField.text;
        //清空文本框
        chatText.text = "";
        StartCoroutine(PostRequest(userMessage));
    }

    IEnumerator PostRequest(string userMessage)
    {
        // 创建请求体
        var requestBody = new
        {
            model = "deepseek-chat",
            messages = new[]
            {
                new { role = "user", content = userMessage }
            },
        };

        string jsonBody = JsonConvert.SerializeObject(requestBody);
        // 创建UnityWebRequest
        UnityWebRequest request = new UnityWebRequest(apiUrl, "POST");
        byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonBody);

        request.uploadHandler = new UploadHandlerRaw(bodyRaw);
        request.downloadHandler = new DownloadHandlerBuffer();
        request.SetRequestHeader("Content-Type", "application/json");
        request.SetRequestHeader("Authorization", "Bearer " + apiKey);

        // 发送请求
        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.ConnectionError || request.result == UnityWebRequest.Result.ProtocolError)
        {
            Debug.LogError("Error: " + request.error); //打印错误详情
        }
        else
        {
            // 解析响应
            string responseJson = request.downloadHandler.text;
            var response = JsonUtility.FromJson<DeepSeekResponse>(responseJson);
            Debug.Log("DeepSeek: " + response.choices[0].message.content);

            //用户的提问
            //chatText.text += "\nUser: " + userMessage;

            // 返回的回答
            if (isFirst)
                chatText.text += "DeepSeek: " + response.choices[0].message.content;
            else
                chatText.text += "\nDeepSeek: " + response.choices[0].message.content;

            isFirst = false;
        }
    }
}

[System.Serializable]
public class DeepSeekResponse
{
    public Choice[] choices;
}

[System.Serializable]
public class Choice
{
    public Message message;
}

[System.Serializable]
public class Message
{
    public string role;
    public string content;
}
```

# 4.启动Unity
启动引擎看看效果如何，等待的过程还是有点久的，可能要几十秒，这主要是因为最近DeepSeek热度太高，请求也大，官方做出了一定的限制

![434149c9-2f59-4fa7-9c46-5d2d79afb3ac.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/d66844f2cd952a007c0ffd0fc4a3efa6.434149c9-2f59-4fa7-9c46-5d2d79afb3ac.webp)

Unity接入DeepSeek API实现对话

# 前言

这一篇是流程的第二个部分，主要内容是通过拆解官方Demo-StarForce中的所有流程脚本来绘制流程图串联，并对每个流程的内容和作用进行解释。



# Procedure：
​![Procedure.drawio](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/Procedure.drawio-20240930173318-4a5ix83.png)​

# ProcedureLaunch

游戏启动流程，进行初始的构建和配置

```csharp
    /// <summary>
    /// 启动流程,配置游戏基础信息
    /// </summary>
    public class ProcedureLaunch : ProcedureBase
    {
        protected override void OnEnter(ProcedureOwner procedureOwner)
        {
            // 设置英文环境，否则有些国家地区读表错误
            System.Globalization.CultureInfo.DefaultThreadCurrentCulture = new System.Globalization.CultureInfo("en-US");
        
            AwaitableExtensions.SubscribeEvent();
            EntityExtension.SubscribeEvent();
            Debug.Log("------------注册完成---->>>>启动流程");

            base.OnEnter(procedureOwner);
         
            // 构建信息：发布版本时，把一些数据以 Json 的格式写入 Assets/GameMain/Configs/BuildInfo.txt，供游戏逻辑读取
            GameEntry.BuiltinData.InitBuildInfo();

            // 语言配置：设置当前使用的语言，如果不设置，则默认使用操作系统语言
            InitLanguageSettings();

            // 变体配置：根据使用的语言，通知底层加载对应的资源变体 
            InitCurrentVariant();

            // 声音配置：根据用户配置数据，设置即将使用的声音选项
            InitSoundSettings();

            // 默认字典：加载默认字典文件 Assets/GameMain/Configs/DefaultDictionary.xml
            // 此字典文件记录了资源更新前使用的各种语言的字符串，会随 App 一起发布，故不可更新
            GameEntry.BuiltinData.InitDefaultDictionary();
        }
```

# ProcedureSplash

闪屏流程，在开始时会先进行三种判断，根据当前模式的不同进行对应的资源初始化操作，并切换到所对应的流程：

```csharp
    /// <summary>
    /// 编辑器模式下，直接进入预加载流程；否则，检测一下版本是否需要热更新
    /// </summary>
    public class ProcedureSplash : ProcedureBase
    {
        protected override void OnUpdate(ProcedureOwner procedureOwner, float elapseSeconds, float realElapseSeconds)
        {
            base.OnUpdate(procedureOwner, elapseSeconds, realElapseSeconds);

            // TODO: 这里可以播放一个 Splash 动画
            // ...

            if (GameEntry.Base.EditorResourceMode)
            {
                // 编辑器模式
                Log.Info("Editor resource mode detected.");
                ChangeState<ProcedurePreload>(procedureOwner);
            }
            else if (GameEntry.Resource.ResourceMode == ResourceMode.Package)
            {
                // 单机模式
                Log.Info("Package resource mode detected.");
                ChangeState<ProcedureInitResources>(procedureOwner);
            }
            else
            {
                // 可更新模式
                Log.Info("Updatable resource mode detected.");
                ChangeState<ProcedureCheckVersion>(procedureOwner);
            }
        }
    }
```

# ProcedureInitResources

资源初始化流程，该流程逻辑较为简单，在刚进入时调用资源组件中的`InitResources`​函数，该函数的内部调用了`ResourceManager`​加载所有的资源进行解析并初始化，完成后提供一个回调函数（见第二段代码），`OnUpdate`​在不断的检查是否初始化完毕，完成后进入下一个流程`ProcedurePreload`​

* ```csharp
      public class ProcedureInitResources : ProcedureBase
      {
          protected override void OnEnter(ProcedureOwner procedureOwner)
          {
              base.OnEnter(procedureOwner);

              m_InitResourcesComplete = false;

              GameEntry.Resource.InitResources(OnInitResourcesComplete);
          }

          protected override void OnUpdate(ProcedureOwner procedureOwner, float elapseSeconds, float realElapseSeconds)
          {
              base.OnUpdate(procedureOwner, elapseSeconds, realElapseSeconds);

              if (!m_InitResourcesComplete)
              {
                  // 初始化资源未完成则继续等待
                  return;
              }

              ChangeState<ProcedurePreload>(procedureOwner);
          }

          private void OnInitResourcesComplete()
          {
              m_InitResourcesComplete = true;
              Log.Info("Init resources complete.");
          }
      }
  ```

* ```csharp
      public void InitResources(InitResourcesCompleteCallback initResourcesCompleteCallback)
      {
            m_ResourceManager.InitResources(initResourcesCompleteCallback);
      }
  ```

# ProcedurePreload

资源预加载流程，市面上的游戏基本上都有这样的一个逻辑，在游戏开始时一般有Loading页面来加载游戏进度，其中就包含资源预加载的流程，该流程主要是做的是`PreloadResources`​函数里的内容

```csharp
        private void PreloadResources()
        {
            //加载基础配置Config
            LoadConfig("DefaultConfig");

            //加载所有配置表DataTable
            foreach (string dataTableName in DataTableNames)
            {
                LoadDataTable(dataTableName);
            }

            //加载资源字典 Key对应的Asset
            LoadDictionary("Default");

            //加载字体
            LoadFont("MainFont");

            //TODO:
            //加载别的
        }
```

# ProcedureCheckVersion

版本检查流程，流程刚进入时注册两个了事件，Web请求成功和失败事件，注册后向服务器请求版本信息，传入两个参数，第一个本地版本的构建信息，第二个获取当前的平台（`Windows`​，`MacOS`​，`IOS`​，`Android`​）

```csharp
        protected override void OnEnter(ProcedureOwner procedureOwner)
        {
            base.OnEnter(procedureOwner);

            m_CheckVersionComplete = false;
            m_NeedUpdateVersion = false;
            m_VersionInfo = null;

            GameEntry.Event.Subscribe(WebRequestSuccessEventArgs.EventId, OnWebRequestSuccess);
            GameEntry.Event.Subscribe(WebRequestFailureEventArgs.EventId, OnWebRequestFailure);

            // 向服务器请求版本信息
            GameEntry.WebRequest.AddWebRequest(Utility.Text.Format(GameEntry.BuiltinData.BuildInfo.CheckVersionUrl, GetPlatformPath()), this);
        }
```

* ​`OnWebRequestSuccess`​ 请求成功

  1. 服务器响应，请求成功，将服务器返回的版本数据进行解析转换为字符串，如何字符串为空则判定为解析失败，逻辑直接返回，认定为版本需要更新；
  2. 字符串不为空，包含版本构建的信息，输出版本数据，然后判断应用是否需要强制更新，检查版本数据是否一致，检查完毕，根据`NeedUpdateVersion`​这个字段来判断是否需要版更新，如果需要，进入`ProcedureUpdateVersion`​流程，不需要则进入`ProcedureVerifyResources`​流程
  3. 在判断中如存在：文件读取失败，文件中版本号字段解析失败，版本号与服务器最新版本号不相等，都认为是需要更新版本，进入`ProcedureUpdateVersion`​流程。

* ​`OnWebRequestFailure`​请求失败

  1. 直接返回，输出版本错误信息

剩余三个流程，分别是`ProcedureUpdateVersion`​，`ProcedureVerifyResources`​，`ProcedureCheckResources`​，可以参考阅读[花桑的博客](https://www.drflower.top/posts/12f10ec9/)，他对这三个流程有更为详尽的解释

# Game

Game流程其实就是真正进入游戏开始后的逻辑了，我在流程图中提供了部分可能会存在的自定义流程，其实这里完全就是由框架的使用者自行决定添加来进行补充。

GameFramework03_2_Procedure流程剖析

# 定义

​`贯穿游戏运行时整个生命周期的有限状态机。通过流程，将不同的游戏状态进行解耦将是一个非常好的习惯。对于网络游戏，你可能需要如检查资源流程、更新资源流程、检查服务器列表流程、选择服务器流程、登录服务器流程、创建角色流程等流程，而对于单机游戏，你可能需要在游戏选择菜单流程和游戏实际玩法流程之间做切换。如果想增加流程，只要派生自 ProcedureBase 类并实现自己的流程类即可使用。`​



# 本质

* 单个流程本质上是一个状态，由状态机来进行管理的，我们可以将一个个的流程看作是状态机中的某个状态，切换流程即是切换状态，这样就很好理解了；
* 流程的执行是线性的，在游戏中的同一时刻只会处于一个流程中，不会同时进行多个流程。

# 作用

* 项目从开始到结束，都是由流程来贯穿的。
* 将业务逻辑划分为一个一个的流程，通过这样的方式，使得项目的逻辑划分更清晰。
* 如果想要改变整块业务的逻辑执行顺序，切换流程即可。

# ProcedureBase

* ​`ProcedureBase`​是所有流程的基类，进入`ProcudureBase`​查看代码结构，自身继承自`FsmState`​状态机类，它FsmState的代码几乎一致，拥有一个状态的所有生命周期，是一个状态的完整体现；

```csharp
 //流程基类。
 public abstract class ProcedureBase : FsmState<IProcedureManager>
 {
     protected internal override void OnInit(IFsm<IProcedureManager> procedureOwner)
     {
         base.OnInit(procedureOwner);
     }

     protected internal override void OnEnter(IFsm<IProcedureManager> procedureOwner)
     {
         base.OnEnter(procedureOwner);
     }

     protected internal override void OnUpdate(IFsm<IProcedureManager> procedureOwner, float elapseSeconds, float realElapseSeconds)
     {
         base.OnUpdate(procedureOwner, elapseSeconds, realElapseSeconds);
     }

     protected internal override void OnLeave(IFsm<IProcedureManager> procedureOwner, bool isShutdown)
     {
         base.OnLeave(procedureOwner, isShutdown);
     }

     protected internal override void OnDestroy(IFsm<IProcedureManager> procedureOwner)
     {
         base.OnDestroy(procedureOwner);
     }
 }
```

# ProcedureManager

* Manager会在Initialize时创建一个管理流程的状态机以及所有的继承了ProcedureBase的流程，`StartProcedure`​这个关键的函数决定了状态机从哪个流程开始启动

  ```csharp
          /// <summary>
          /// 初始化流程管理器。
          /// </summary>
          /// <param name="fsmManager">有限状态机管理器。</param>
          /// <param name="procedures">流程管理器包含的流程。</param>
          public void Initialize(IFsmManager fsmManager, params ProcedureBase[] procedures)
          {
              if (fsmManager == null)
              {
                  throw new GameFrameworkException("FSM manager is invalid.");
              }

              m_FsmManager = fsmManager;
              m_ProcedureFsm = m_FsmManager.CreateFsm(this, procedures);
          }

          /// <summary>
          /// 开始流程。
          /// </summary>
          /// <typeparam name="T">要开始的流程类型。</typeparam>
          public void StartProcedure<T>() where T : ProcedureBase
          {
              if (m_ProcedureFsm == null)
              {
                  throw new GameFrameworkException("You must initialize procedure first.");
              }

              m_ProcedureFsm.Start<T>();
          }
  ```
* 同时，Manager也提供了一些别的属性和方法，用于得到某个具体的流程以及它的属性信息：
  ​![image](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241024200343.png)
  ​![image](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241024200410.png)​

# 编写第一个启动流程

* 创建一个Procedure文件夹用于管理流程相关脚本，游戏中的所有流程脚本都存放此处：
  ​![QQ_1727719321201](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241001020204.png)​
* **ProcedureLaunch**
  同样的，继承自`ProcedureBase`​，此处列出一个流程的所有生命周期函数，它都交给了状态基类来调用，子类来重写，我们可以按需使用它；我们在进入流程的时候输出一段话“游戏流程启动”。

  ```csharp
    protected internal override void OnInit(IFsm<IProcedureManager> procedureOwner)
    {
        base.OnInit(procedureOwner);
    }

    protected internal override void OnEnter(IFsm<IProcedureManager> procedureOwner)
    {
        base.OnEnter(procedureOwner);
    }

    protected internal override void OnUpdate(IFsm<IProcedureManager> procedureOwner, float elapseSeconds, float realElapseSeconds)
    {
        base.OnUpdate(procedureOwner, elapseSeconds, realElapseSeconds);
    }

    protected internal override void OnLeave(IFsm<IProcedureManager> procedureOwner, bool isShutdown)
    {
        base.OnLeave(procedureOwner, isShutdown);
    }

    protected internal override void OnDestroy(IFsm<IProcedureManager> procedureOwner)
    {
        base.OnDestroy(procedureOwner);
    }
  ```
* 编译后，可以在Proceduer组件中看到启动流程脚本了，勾选它并启动Unity，输出log信息

  ​![QQ_1727720374871](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241001021936.png)

  ​![QQ_1727720534457](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241001022229.png)
* **注意：**

  **如果你编写了多个流程，请记住勾选你所需要的，项目中的所有流程都会在Procedure组件中显示出来，只有被勾选的脚本才会执行。** ![QQ_1727720840980](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241001022724.png)​

  **如果确认代码无误，但是仍没有输出信息，查看是否开启了GF的日志输出：**
  ​![QQ_1727722660649](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241001025926.png)​

# 流程切换

创建一个新的流程，命名为ProcedureMenu，实现从启动流程 => 菜单流程：

* ​![QQ_1727721295305](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241001023504.png)
* 在启动流程进入时，立刻切换到菜单流程：
  ​![QQ_1727721830616](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241001024352.png)​
* 还是不要忘了记得勾选！查看log信息，流程切换成功
  ​![QQ_1727721978453](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20241001024620.png)​
* **通过以上举例，我们已经可以理解流程执行的过程和原理了，当我们需要切换流程时，只需要调用提供的方法**​**​`ChangeState<T>`​** ​**即可，切换的过程是通过FSM内部执行的，开发者只需要关心流程的自身逻辑和切换的时机。**

# 流程组件相关属性和函数

```csharp
        //获取当前流程
        GameEntry.Procedure.CurrentProcedure;

        //获取当前流程的持续时间
        GameEntry.Procedure.CurrentProcedureTime;

        //是否存在流程
        GameEntry.Procedure.HasProcedure<T>;

        //获取某个流程
        GameEntry.Procedure.GetProcedure<T>;
```

# 扩展：游戏中的流程

**如下图，是游戏中可能会包含的流程（通过解读StarForce源码得出），我将会在文章的第二个部分会对各个流程进行详细的解释**

​![Procedure.drawio](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/Procedure.drawio-20240930173318-4a5ix83.png)​