![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)​

GameFramework03_1_Procedure流程解读

# GameEntry Class

在 GF 中，调用框架中组件有两种写法，比如在这里我们获取 UI 组件：

1. 通过 Runtime 获取

```csharp
UIComponent uiComponent = UnityGameFramework.Runtime.GameEntry.GetComponent<UIComponent>();
uiComponent.OpenUIForm("",this);
```

2. 封装为静态类，全局调用

```csharp
GameEntry.UI.OpenUIForm("",this);
```



两种方式都可以得到，但明显后者更快捷，GameEntry 的主要作用就是为了更方便的全局调用。

# 初始化

1. 分别创建三个脚本，命名为 `GameEntry`​，`GameEntry.Builtin`​，`GameEntry.Custom`​
   ​![QQ_1727026306505](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240923013157.png)​

	三个脚本分别代表 GameEntry 类的三个部分，下面来依次讲解他们的作用：

* **GameEntry**

  在这里调用组件初始化方法，将内置组件和自定义组件初始化，使用 `partial` ​关键字将 GameEntry 类进行拆分为三个部分

  ```c#
  using UnityEngine;
  using UnityGameFramework.Runtime;

  /// <summary>
  /// 游戏入口。
  /// </summary>
  public partial class GameEntry : MonoBehaviour
  {
      private void Start()
      {
          //初始化内置组件
          InitBuiltinComponents();
          //初始化自定义组件
          InitCustomComponents();
      }
  }
  ```

* **GameEntry.Builtin**

  用于初始化内部组件，将各个组件封装为静态的属性供外部调用，并提供一个初始化方法用于 GameEntry

  ```csharp
  using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;
  using UnityGameFramework.Runtime;

  public partial class GameEntry : MonoBehaviour
  {
      /// <summary>
      /// 获取游戏基础组件。
      /// </summary>
      public static BaseComponent Base
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取配置组件。
      /// </summary>
      public static ConfigComponent Config
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取数据结点组件。
      /// </summary>
      public static DataNodeComponent DataNode
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取数据表组件。
      /// </summary>
      public static DataTableComponent DataTable
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取调试组件。
      /// </summary>
      public static DebuggerComponent Debugger
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取下载组件。
      /// </summary>
      public static DownloadComponent Download
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取实体组件。
      /// </summary>
      public static EntityComponent Entity
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取事件组件。
      /// </summary>
      public static EventComponent Event
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取文件系统组件。
      /// </summary>
      public static FileSystemComponent FileSystem
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取有限状态机组件。
      /// </summary>
      public static FsmComponent Fsm
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取本地化组件。
      /// </summary>
      public static LocalizationComponent Localization
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取网络组件。
      /// </summary>
      public static NetworkComponent Network
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取对象池组件。
      /// </summary>
      public static ObjectPoolComponent ObjectPool
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取流程组件。
      /// </summary>
      public static ProcedureComponent Procedure
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取资源组件。
      /// </summary>
      public static ResourceComponent Resource
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取场景组件。
      /// </summary>
      public static SceneComponent Scene
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取配置组件。
      /// </summary>
      public static SettingComponent Setting
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取声音组件。
      /// </summary>
      public static SoundComponent Sound
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取界面组件。
      /// </summary>
      public static UIComponent UI
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取网络组件。
      /// </summary>
      public static WebRequestComponent WebRequest
      {
          get;
          private set;
      }

      private static void InitBuiltinComponents()
      {
          Base = UnityGameFramework.Runtime.GameEntry.GetComponent<BaseComponent>();
          Config = UnityGameFramework.Runtime.GameEntry.GetComponent<ConfigComponent>();
          DataNode = UnityGameFramework.Runtime.GameEntry.GetComponent<DataNodeComponent>();
          DataTable = UnityGameFramework.Runtime.GameEntry.GetComponent<DataTableComponent>();
          Debugger = UnityGameFramework.Runtime.GameEntry.GetComponent<DebuggerComponent>();
          Download = UnityGameFramework.Runtime.GameEntry.GetComponent<DownloadComponent>();
          Entity = UnityGameFramework.Runtime.GameEntry.GetComponent<EntityComponent>();
          Event = UnityGameFramework.Runtime.GameEntry.GetComponent<EventComponent>();
          FileSystem = UnityGameFramework.Runtime.GameEntry.GetComponent<FileSystemComponent>();
          Fsm = UnityGameFramework.Runtime.GameEntry.GetComponent<FsmComponent>();
          Localization = UnityGameFramework.Runtime.GameEntry.GetComponent<LocalizationComponent>();
          Network = UnityGameFramework.Runtime.GameEntry.GetComponent<NetworkComponent>();
          ObjectPool = UnityGameFramework.Runtime.GameEntry.GetComponent<ObjectPoolComponent>();
          Procedure = UnityGameFramework.Runtime.GameEntry.GetComponent<ProcedureComponent>();
          Resource = UnityGameFramework.Runtime.GameEntry.GetComponent<ResourceComponent>();
          Scene = UnityGameFramework.Runtime.GameEntry.GetComponent<SceneComponent>();
          Setting = UnityGameFramework.Runtime.GameEntry.GetComponent<SettingComponent>();
          Sound = UnityGameFramework.Runtime.GameEntry.GetComponent<SoundComponent>();
          UI = UnityGameFramework.Runtime.GameEntry.GetComponent<UIComponent>();
          WebRequest = UnityGameFramework.Runtime.GameEntry.GetComponent<WebRequestComponent>();
          Debug.Log(">>>>>>初始化内置组件成功");
      }
  }
  ```

* **GameEntry.Custom**
  我们可以在这里扩展实现自己的组件并初始化

  ```csharp
  using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;

  public partial class GameEntry : MonoBehaviour
  {
      //自定义组件
      //>>>

      //初始化自定义组件
      private void InitCustomComponents()
      {
          Debug.Log(">>>>>>初始化自定义组件成功");
      }
  }
  ```

# 启动

完成脚本的准备后，为 GameFramework 创建一个父物体 `GF`​，并将 `GameEntry` ​挂载在物体上，启动 Unity
​![QQ_1727108774350](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240924002616.png)​

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

Consolo 窗口输出 log，所有组件初始化成功，至此准备工作完毕，进入游戏流程

GameFramework02_GameEntry游戏入口

# 前言

**GameFramework**一个基于Unity引擎的开源框架，封装了游戏开发中常用的模块，制定了一系列的游戏业务的代码规范，适合中大型的游戏开发。在此之前，如果你想要开发项目不知从何入手，没有一个循序渐进且规范的流程，学习并使用GF将大大提高开发效率，提高我们的一个代码思维；使用框架尤其对于新手而言，是一种约束和提升，比如在接入GF后，打开一个UI必须继承和实现接口，使用规定的方法打开，不能随心所欲的写代码，这正是框架发挥的作用的体现，面向接口编程，与引擎和各类方案进行解耦。

# **框架组成**

![20240403145812](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240403145812.png)
![20240405005049](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240405005049.png)



框架由两个部分组成，`GameFramework`和`Unity GameFramework`（一下简称`GF`和`UGF`）

> 1. GF是一个VS工程(.sln),它建立在UGF上层,框架中的基础逻辑的实现在这里，占据源码的大部分，以`.dll`形式存在，这个部分是与游戏引擎无关的，不依赖Unity
   ![20240405010134](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240405010134.png)
   
> 2. UGF是一个Unity项目(.meta，.prefab)，基于GF并对其扩展，为了能够直接使用Unity当中的类和组件；UGF中包含的`.Runtime`​和`.Editor`​是为了实现引擎版本的兼容性和工具面板，我们也可以在UGF中自定义实现一些组件。  
   ​![20240405010242](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240405010242.png)​

# 模块概述

&rArr; [GF官方介绍](https://gameframework.cn/document/)

# 源码替换

## 注意事项

**如果要替换源码，那么一定要在Github上下载UGF和GF两个部分，而不能去单独去官网下载v2020.05.31的** **​`.unitypackage`​**​ **的包，因为官网的是老版本，这会导致UGF的** **​`.dll`​**​ **和GF代码的版本不一致，导入后引发API不存在的问题，会产出以下报错，请一定去Github主页下载!**  
​![bea8ff376ba9475e1646ec1433e1eb27](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/bea8ff376ba9475e1646ec1433e1eb27.png)​

## 替换步骤

1. 在E大的Github主页下载GF和UGF，无论什么形式`gitclone`或`.zip`，下载好后，先将`UnityGameFramework`导入进Unity中
   ![QQ_1726196125885](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726196125885.png)
2. 删除`GameFramework`的`.dll`文件，删除后会出现报错，先不用管
   ![QQ_1726196285367](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726196285367.png)
   ![QQ_1726196382271](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726196382271.png)
3. 将`GameFramework`文件夹拖入`UnityGameFramework/Libraries`路径下
   ![QQ_1726196679129](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726196679129.png)
4. 在`GameFramework`​目录下新建一个同名的`AssemblyDefinition`​文件，并勾选`Allow unsafe code`​，Apply应用一下  
   ​![903ccd0aa9782747ddebd6dab363c462](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/903ccd0aa9782747ddebd6dab363c462.png)  
   ​![QQ_1726197987965](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726197987965.png)​
5. 将`Scripts/Editor`文件夹下的`UnityGameFramework.Editor`依赖于刚刚创建的asdf，点击Apply
   ![QQ_1726198649709](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726198649709.png)
6. 将`Scripts/Runtime`文件夹下`UnityGameFramework.Runtime`同时依赖，Apply后重新编译，报错消失，源码替换完毕！
   ![QQ_1726198718559](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726198718559.png)
   ![QQ_1726198802436](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726198802436.png)

# 完毕

* **完成以上,源码版本的GF框架就应用在你的项目中了**
* 在GF的官方教程前三章的教程中已经提供了如何入门的基本介绍,建议在学习之前之前先阅读完前三章的内容，然后再开始对后续框架各个模块的了解和学习 ⇒ [传送门](https://gameframework.cn/category/tutorial/)  
  ​![20240403173750](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240403173750.png)​

‍