Update TEngine.Runtime.asmdef

Update YooAsset

Books/0-介绍.md

@@ -0,0 +1,29 @@
+# 介绍- Introduce
+
+### TEngine
+  <a style="text-decoration:none">
+    <img src="https://img.shields.io/badge/Unity%20Ver-2021.3.20++-blue.svg?style=flat-square" alt="status" />
+  </a>
+  <a style="text-decoration:none">
+    <img src="https://img.shields.io/github/license/ALEXTANGXIAO/TEngine" alt="license" />
+  </a>
+  <a style="text-decoration:none">
+    <img src="https://img.shields.io/github/last-commit/ALEXTANGXIAO/TEngine" alt="last" />
+  </a>
+  <a style="text-decoration:none">
+    <img src="https://img.shields.io/github/issues/ALEXTANGXIAO/TEngine" alt="issue" />
+  </a>
+  <a style="text-decoration:none">
+    <img src="https://img.shields.io/github/languages/top/ALEXTANGXIAO/TEngine" alt="topLanguage" />
+  </a>
+
+TEngine是一套用于Unity框架解决方案，用于帮助研发团队快速进行开发。
+
+### 开箱即用
+开箱即用、用法简洁，即用即上手.高可读性和详细的文档说明帮助你更快更好的进行游戏开发。您不需要关心框架的底层，分离独自实现您的GamePlay。
+
+### 性能强大
+TEngine 底层使用基于UniTask的异步以及事件分发，可插件定制化，把复杂游戏简单化切以高性能、低耦合度实现。
+
+### 高内聚低耦合
+内嵌了The Best 次时代热更新解决方案<a href="https://github.com/focus-creative-games/hybridclr"><strong>HybridCLR</strong></a>、百万DAU验证的资源解决方案<a href="https://github.com/tuyoogame/YooAsset"><strong>YooAsset</strong></a>、你的游戏最佳配置解决方案<a href="https://github.com/focus-creative-games/luban"><strong>Luban</strong></a>

Books/1-快速开始.md

@@ -0,0 +1,63 @@
+# 快速开始- Quickly Start
+快速上手
+本教程引导从空项目开始体验TEngine。出于简化起见，只演示目标平台为Windows的情况。
+
+请在Standalone平台上正确跑通热更新流程后再自行尝试Android、iOS平台的热更新，它们的流程非常相似。
+
+### 1.使用Unity2021.3.20f1c1打开项目工程。
+
+### 2.默认选择顶部栏目EditorMode编辑器下的模拟模式并点击Launcher开始运行
+![image](src/1-1.png)
+
+### 3.Editor编辑器下运行成功！
+![image](src/1-2.png)
+
+### 4.打包运行
+ *   1.运行菜单 HybridCLR/Install... 安装HybridCLR，每次更新HybridCLR版本需要重新执行一次安装。
+ *   2.运行菜单 HybridCLR/Define Symbols/Enable HybridCLR 运行开启HybridCLR热更新。
+ *   3.运行菜单 HybridCLR/Generate/All 进行必要的生成操作。这一步不可遗漏!!!
+ *   4.运行菜单 HybridCLR/Build/BuildAssets And CopyTo AssemblyPath，生成热更新dll并copy到热更程序集中。
+ *   5.运行菜单 YooAsset/AssetBundle Builder 构建AB。
+ *   6.打开Build Settings对话框，点击Build And Run，打包并且运行热更新示例工程。
+    
+### 遇到问题请查看HybridlCLR的<a href="https://hybridclr.doc.code-philosophy.com/docs/help/commonerrors"><strong>常见错误(commonerrors)</strong></a>
+
+### 系统需求
+默认版本：Unity2021.3.20f1c1 
+
+支持版本: Unity2019.4 & Unity2020.3 & Unity2021.3 & Unity2022.3
+
+支持平台: Windows、OSX、Android、iOS、WebGL
+
+开发环境: .NET4.x
+
+### 目录结构
+```
+Assets
+├── AssetArt            // 美术资源目录
+│   └── Atlas           // 自动生成图集目录
+├── AssetRaw            // 热更资源目录
+│   ├── UIRaw           // UI图片目录
+│   │   ├── Atlas       // 需要自动生成图集的UI素材目录
+│   │   └── Raw         // 不需要自动生成图集的UI素材目录
+├── Editor              // 编辑器脚本目录
+├── HybridCLRData       // hybridclr相关目录
+├── Scenes              // 主场景目录
+├── GameScripts         // 程序集目录
+└── TEngine             // 框架核心目录              
+    ├── AssetSetting    // YooAsset资源设置  
+    ├── Editor          // TEngine-Editor程序集
+    └── Runtime         // TEngine-Runtime程序集
+```
+
+### 热更新程序集划分
+```
+Assets/GameScripts
+├── Main                // 主程序程序集(启动器与流程)
+└── HotFix              // 游戏热更程序集目录 [Folder]
+    ├── GameBase        // 游戏基础框架程序集 [Dll]
+    ├── GameProto       // 游戏配置协议程序集 [Dll]
+    └── GameLogic       // 游戏业务逻辑程序集 [Dll]
+            ├── GameApp.cs                  // 热更主入口
+            └── GameApp_RegisterSystem.cs   // 热更主入口注册系统
+```

Books/2-框架概览.md

@@ -0,0 +1,82 @@
+# TEngine
+
+## TEngine-Runtime
+### AOT内核基于Gameframework,优化、最简化以及商业化适配。
+![image](src/2-1.png)
+
+## AOT游戏框架模块基类。
+#### 框架思路为面向接口编程，如Resource资源模块，开发白皮书为先定义IResourceManager的接口规范，然后编写ResourceManager继承框架具体实现(ModuleImp)以及实现接口。最后实现调用层Module，调用层可以拓展编辑器供开发者自定义模块参数。
+``` csharp
+/// <summary>
+/// 游戏框架模块抽象类。ModuleImp为具体框架模块实现。
+/// </summary>
+internal abstract class ModuleImp
+{
+    /// <summary>
+    /// 获取游戏框架模块优先级。
+    /// </summary>
+    /// <remarks>优先级较高的模块会优先轮询，并且关闭操作会后进行。</remarks>
+    internal virtual int Priority => 0;
+
+    /// <summary>
+    /// 游戏框架模块轮询。
+    /// </summary>
+    /// <param name="elapseSeconds">逻辑流逝时间，以秒为单位。</param>
+    /// <param name="realElapseSeconds">真实流逝时间，以秒为单位。</param>
+    internal abstract void Update(float elapseSeconds, float realElapseSeconds);
+
+    /// <summary>
+    /// 关闭并清理游戏框架模块。
+    /// </summary>
+    internal abstract void Shutdown();
+}
+
+//=====================================================================//
+
+/// <summary>
+/// 游戏框架模块抽象类。Module 为Mono调用层。
+/// </summary>
+public abstract class Module : MonoBehaviour
+{
+    /// <summary>
+    /// 游戏框架模块初始化。
+    /// </summary>
+    protected virtual void Awake()
+    {
+        ModuleSystem.RegisterModule(this);
+    }
+}
+```
+
+## 热更域程序集设计与说明
+```
+Assets/GameScripts
+├── Main                // 主程序程序集(启动器与流程)
+└── HotFix              // 游戏热更程序集目录 [Folder]
+    ├── GameBase        // 游戏基础框架程序集 [Dll]
+    ├── GameProto       // 游戏配置协议程序集 [Dll]
+    └── GameLogic       // 游戏业务逻辑程序集 [Dll]
+            ├── GameApp.cs                  热更主入口
+            └── GameApp_RegisterSystem.cs   热更主入口注册系统
+```
+游戏内主要玩法逻辑包括UI会在GameLogic中编写，GameBase则存放一些通用性的逻辑，GameProto存放与服务区交互的协议以及配置表逻辑。若有项目需求完全可以进行自定义增删HotFix程序集。
+
+PS：注意增删程序集后需要同步到HybridClr的Setting面板以及TEngineSetting的面板。TEngineSettings面板有按钮可以从HybridClr中同步AOT与热更程序集。
+
+## 常用模块接口
+
+<strong>[3-1-资源模块](./3-1-资源模块.md)<strong>
+
+<strong>[3-2-事件模块](./3-2-事件模块.md)<strong>
+
+<strong>[3-3-内存池模块](./3-3-内存池模块.md)<strong>
+
+<strong>[3-4-对象池模块](./3-4-对象池模块.md)<strong>
+
+<strong>[3-5-UI模块](./3-5-UI模块.md)<strong>
+
+<strong>[3-6-配置表模块](./3-6-配置表模块.md)<strong>
+
+<strong>[3-7-流程模块](./3-7-流程模块.md)<strong>
+
+<strong>[3-8-网络模块](./3-8-网络模块.md)<strong>

Books/3-1-资源模块.md

@@ -0,0 +1,200 @@
+## 3-1.资源模块 - ResourceModule
+
+#### 资源模块默认使用Addressable可寻址定位。(!注意需要打包的资源不可以重名)
+
+资源模块运行模式有EditorSimulateMode、OfflinePlayMode以及HostPlayMode
+编辑器模式下以顶部导航栏的选项卡为优先选项，打包后以Scene场景中ResourceModule脚本的Enum选项卡为优先选项(打包后不会走EditorSimulateMode)
+
+Scene窗口Resource对象可以设置一些资源模块的常用设置，比如打包后的资源模式、资源校验等级以及自动卸载资源间隔等。
+![image](src/3-1-1.png)
+
+Menu窗口TEngineSetting可以设置一些资源模块的热更新设置，比如资源服务器地址以及在线参数等。备注在Luban目录下有一个基于Node的静态文件服务器，可以把在线参数以及AB放入用于做热更新测试。
+![image](src/3-1-2.png)
+
+## 重要拓展概念
+* AssetReference (资源引用标识) 通用加载资源的时候绑定一个引用标识使你无需关心手动Dispose资源句柄。
+
+* AssetGroup（资源组数据）进行资源分组绑定管理内存中的生命周期资源生命周期托管给资源组的根节点进行Dispose。
+
+* LruCacheTable (Least Recently Used Cache缓存表)
+
+* ArcCacheTable (Adaptive Replacement Cache缓存表)
+
+## 加载资源示范
+注意！资源模块默认使用Addressable可寻址定位。传入资源名字无需后缀即可！！
+``` csharp
+
+//同步加载。
+GameModule.Resource.LoadAsset<SkillDisplayData>(location);
+
+//异步加载。
+GameModule.Resource.LoadAssetAsync<SkillDisplayData>(location, OnLoadSuccess);
+private void OnLoadSuccess(AssetOperationHandle assetOperationHandle){}
+
+//使用UniTask异步加载。
+await GameModule.Resource.LoadAssetAsync<SkillDisplayData>(location,CancellationToken.None);
+```
+
+## 常用接口
+remark：资源模块初始化的生命周期已经在流程模块实现了，具体有需求可以自定义开发。
+``` csharp
+/// <summary>
+/// 获取当前资源包版本。
+/// </summary>
+/// <returns>资源包版本。</returns>
+public string GetPackageVersion();
+
+/// <summary>
+/// 异步更新最新包的版本。
+/// </summary>
+/// <param name="appendTimeTicks">请求URL是否需要带时间戳。</param>
+/// <param name="timeout">超时时间。</param>
+/// <returns>请求远端包裹的最新版本操作句柄。</returns>
+public UpdatePackageVersionOperation UpdatePackageVersionAsync(bool appendTimeTicks = false, int timeout = 60);
+
+/// <summary>
+/// 向网络端请求并更新清单
+/// </summary>
+/// <param name="packageVersion">更新的包裹版本</param>
+/// <param name="autoSaveVersion">更新成功后自动保存版本号，作为下次初始化的版本。</param>
+/// <param name="timeout">超时时间（默认值：60秒）</param>
+public UpdatePackageManifestOperation UpdatePackageManifestAsync(string packageVersion, bool autoSaveVersion = true, int timeout = 60);
+
+/// <summary>
+/// 创建资源下载器，用于下载当前资源版本所有的资源包文件。
+/// </summary>
+public ResourceDownloaderOperation CreateResourceDownloader();
+
+
+/// <summary>
+/// 清理包裹未使用的缓存文件。
+/// </summary>
+public ClearUnusedCacheFilesOperation ClearUnusedCacheFilesAsync();
+
+
+/// <summary>
+/// 清理沙盒路径。
+/// </summary>
+public void ClearSandbox();
+
+/// <summary>
+/// 强制执行释放未被使用的资源。
+/// </summary>
+/// <param name="performGCCollect">是否使用垃圾回收。</param>
+public void ForceUnloadUnusedAssets(bool performGCCollect);
+
+/// <summary>
+/// 检查资源是否存在。
+/// </summary>
+/// <param name="assetName">要检查资源的名称。</param>
+/// <returns>检查资源是否存在的结果。</returns>
+public HasAssetResult HasAsset(string assetName);
+
+/// 同步加载资源。
+/// </summary>
+/// <param name="assetName">要加载资源的名称。</param>
+/// <typeparam name="T">要加载资源的类型。</typeparam>
+/// <returns>资源实例。</returns>
+T LoadAsset<T>(string assetName) where T : Object;
+
+/// <summary>
+/// 同步加载资源。
+/// </summary>
+/// <param name="assetName">要加载资源的名称。</param>
+/// <param name="parent">父节点位置。</param>
+/// <typeparam name="T">要加载资源的类型。</typeparam>
+/// <returns>资源实例。</returns>
+T LoadAsset<T>(string assetName, Transform parent) where T :Object;
+
+/// <summary>
+/// 同步加载资源。
+/// </summary>
+/// <param name="handle">资源操作句柄。</param>
+/// <param name="assetName">要加载资源的名称。</param>
+/// <typeparam name="T">要加载资源的类型。</typeparam>
+/// <returns>资源实例。</returns>
+T LoadAsset<T>(string assetName,out AssetOperationHandle handle) where T : Object;
+
+/// <summary>
+/// 同步加载资源。
+/// </summary>
+/// <param name="assetName">要加载资源的名称。</param>
+/// <param name="handle">资源操作句柄。</param>
+/// <param name="parent">父节点位置。</param>
+/// <typeparam name="T">要加载资源的类型。</typeparam>
+/// <returns>资源实例。</returns>
+T LoadAsset<T>(string assetName, Transform parent,out AssetOperationHandle handle) where T :Object;
+
+/// <summary>
+/// 异步加载资源。
+/// </summary>
+/// <param name="assetName">要加载资源的名称。</param>
+/// <param name="cancellationToken">取消操作Token。</param>
+/// <typeparam name="T">要加载资源的类型。</typeparam>
+/// <returns>异步资源实例。</returns>
+UniTask<T> LoadAssetAsync<T>(string assetName,CancellationToken cancellationToken) where T : Object;
+
+/// <summary>
+/// 异步加载游戏物体。
+/// </summary>
+/// <param name="assetName">要加载的游戏物体名称。</param>
+/// <param name="cancellationToken">取消操作Token。</param>
+/// <returns>异步游戏物体实例。</returns>
+UniTask<UnityEngine.GameObject> LoadGameObjectAsync(string assetName,CancellationToken cancellationToken);
+
+/// <summary>
+/// 同步加载资源并获取句柄。
+/// </summary>
+/// <param name="assetName">要加载资源的名称。</param>
+/// <typeparam name="T">要加载资源的类型。</typeparam>
+/// <returns>同步加载资源句柄。</returns>
+AssetOperationHandle LoadAssetGetOperation<T>(string assetName) where T : Object;
+
+/// <summary>
+/// 异步加载资源并获取句柄。
+/// </summary>
+/// <param name="assetName">要加载资源的名称。</param>
+/// <typeparam name="T">要加载资源的类型。</typeparam>
+/// <returns>异步加载资源句柄。</returns>
+AssetOperationHandle LoadAssetAsyncHandle<T>(string assetName) where T : Object;
+
+/// <summary>
+/// 同步加载子资源对象
+/// </summary>
+/// <typeparam name="TObject">资源类型</typeparam>
+/// <param name="location">资源的定位地址</param>
+public SubAssetsOperationHandle LoadSubAssetsSync<TObject>(string location) where TObject : UnityEngine.Object;
+
+/// <summary>
+/// 异步加载子资源对象
+/// </summary>
+/// <typeparam name="TObject">资源类型</typeparam>
+/// <param name="location">资源的定位地址</param>
+public SubAssetsOperationHandle LoadSubAssetsAsync<TObject>(string location) where TObject : UnityEngine.Object;
+
+/// <summary>
+/// 同步加载子资源对象
+/// </summary>
+/// <param name="assetInfo">资源信息。</param>
+public SubAssetsOperationHandle LoadSubAssetsSync(AssetInfo assetInfo);
+
+/// <summary>
+/// 异步加载场景。
+/// </summary>
+/// <param name="location">场景的定位地址</param>
+/// <param name="sceneMode">场景加载模式</param>
+/// <param name="activateOnLoad">加载完毕时是否主动激活</param>
+/// <param name="priority">优先级</param>
+/// <returns>异步加载场景句柄。</returns>
+SceneOperationHandle LoadSceneAsync(string location, LoadSceneMode sceneMode = LoadSceneMode.Single, bool activateOnLoad = true, int priority = 100);
+
+/// <summary>
+/// 异步加载场景
+/// </summary>
+/// <param name="assetInfo">场景的资源信息</param>
+/// <param name="sceneMode">场景加载模式</param>
+/// <param name="activateOnLoad">加载完毕时是否主动激活</param>
+/// <param name="priority">优先级</param>
+/// <returns>异步加载场景句柄。</returns>
+SceneOperationHandle LoadSceneAsync(AssetInfo assetInfo, LoadSceneMode sceneMode = LoadSceneMode.Single, bool activateOnLoad = true, int priority = 100);
+```

Books/3-2-事件模块.md

@@ -0,0 +1,69 @@
+# 3-2.事件模块 - GameEvent
+高效且无GC的事件系统GameEvent，可以指定事件ID/事件String监听和分发事件。通过事件来驱动模块，如战斗的角色身上的事件流、UI和网络以及Model的数据流、开发中的绝大部分情况都可以通过事件来进行驱动。(配合UI模块或者拓展的战斗模块实现MVE[Model - View - Event]事件驱动架构)
+
+事件模块支持string和int作为事件Id，但推荐是使用int因为可以避免事件字典的哈希碰撞。这里实现了StringId.StringToHash的方法来定义事件ID达到事件系统的最佳性能。
+
+<strong>注：UI模块的事件和UI生命周期存在绑定，销毁UI时可以自动移除UI所监听的事件,开发过程中只需要关心添加事件，避免了关闭UI但没有移除事件监听的问题，角色模块也可以参考实现。(AddUIEvent)</strong>
+``` csharp
+public static readonly int Hellp = StringId.StringToHash("Hellp.Hellp");
+
+class A
+{
+   public A()
+   {
+     //添加事件监听string
+     GameEvent.AddEventListener("TEngine很好用",TodoSomeThings);
+     //添加事件监听int 事件ID
+     GameEvent.AddEventListener(Hellp,TodoSomeThings2);
+   }
+}
+
+class B
+{
+  private void SaySomeThings()
+  {
+      //发送事件流
+      GameEvent.Send("TEngine很好用");
+      GameEvent.Send(Hellp);
+  }
+}
+
+【举个例子：游戏中血量扣除的时候，服务器发来了一个减少Hp的消息包，
+我们可以在收到这个消息包的时候发送一个事件流，在玩家头顶的HP进度
+条组件/左上角Hp的UI血条组件添加一个监听事件，各个模块负责自己监听后的逻辑】
+Server -> SendMessage(ReduceHP)
+
+class ClientHandle
+{
+  private void HandleMessage(MainPack mainpack)
+  {
+    ...
+    HpPack hpPack = mainpack.hpPack;
+    int playerId = mainpack.playerId;
+    var player = PlayerMgr.Instance.GetPlayer(playerId);
+    if(player != null){
+      player.Event.Send("Hpchange",hpPack);       //局部的事件管理器
+      GameEvent.Send("Hpchange",hpPack);  //全局事件中心
+    }
+  }
+}
+
+class PlayerHp
+{
+  public ECSEventCmpt Event { get; set; }
+  PlayerHp(){
+    Event.AddEventListener<HpPack>(Hellp,HandleUpChange);
+  }
+}
+
+[Window(UILayer.UI)]
+class BattleMainUI: UIWindow
+{
+    public override void RegisterEvent()
+    {
+        AddUIEvent<HpPack>(Hellp,HandleUpChange);
+    }
+
+    public void HandleUpChange(HpPack pack){}
+}
+```

Books/3-3-内存池模块.md

@@ -0,0 +1,23 @@
+# 3-3.内存池模块 - MemoryPool
+内存池更为轻量化，相对于对象池更适合一些更抽象碎片化的内存对象。
+
+Scene窗口MemoryPool对象可以设置内存池检查，防止回收问题与内存泄漏问题。
+![image](src/3-3-1.png)
+
+使用案例
+``` csharp
+/// <summary>
+/// 资源组数据。
+/// <remarks>DisposeGroup。</remarks>
+/// </summary>
+public class AssetGroup : IMemory
+{
+    public void Clear(){}
+}
+
+//内存池中获取/生成内存对象。
+AssetGroup assetGroup = MemoryPool.Acquire<AssetGroup>();
+
+//释放内存对象还给内存池。
+MemoryPool.Release(assetGroup);
+```

Books/3-4-对象池模块.md

@@ -0,0 +1,64 @@
+# 3-4.对象池模块 - ObjectModule
+对象池较中量级，在客户端开发中是一个经常使用的技术，技术点我相信大家都懂，这里不过多讨论。
+
+使用案例
+``` csharp
+/// <summary>
+/// Actor对象。
+/// </summary>
+public class Actor : ObjectBase
+{
+    /// <summary>
+    /// 释放对象。
+    /// </summary>
+    /// <param name="isShutdown">是否是关闭对象池时触发。</param>
+    protected override void Release(bool isShutdown){}
+
+    /// <summary>
+    /// 创建Actor对象。
+    /// </summary>
+    /// <param name="actorName">对象名称。</param>
+    /// <param name="target">对象持有实例。</param>
+    /// <returns></returns>
+    public static Actor Create(string name, object target)
+    {
+        var actor = MemoryPool.Acquire<Actor>();
+        actor.Initialize(name, target);
+        return actor;
+    }
+}
+
+/// <summary>
+/// Actor对象池。
+/// </summary>
+private IObjectPool<Actor> _actorPool;
+    
+void Start()
+{
+    //创建允许单次获取的对象池。
+    _actorPool = GameModule.ObjectPool.CreateSingleSpawnObjectPool<Actor>(Utility.Text.Format("Actor Instance Pool ({0})", name));
+}
+
+/// <summary>
+/// 创建Actor对象。
+/// </summary>
+/// <param name="actorName">对象名称。</param>
+/// <param name="target">对象持有实例。</param>
+/// <returns>Actor对象实例</returns>
+public Actor CreateActor(string actorName, GameObject target)
+{
+    Actor ret = null;
+    if (_actorPool.CanSpawn())
+    {
+        ret = _actorPool.Spawn();
+    }
+    else
+    {
+        ret = Actor.Create(actorName, target);
+        _actorPool.Register(ret,true);
+    }
+
+    return ret;
+}
+
+```

Books/3-5-UI模块.md

@@ -0,0 +1,126 @@
+# 3-5.UI模块 - UIModule
+一个游戏70%都是UI，剩下30%才是GamePlay，所以有一套简洁强大的商业化UI模块以及UI开发工作流将是项目的一大利器，能够提高至少一倍的开发效率。(配合事件模块实现MVE[Model - View - Event]事件驱动架构)
+
+UI脚本为纯C#实现，脱离Mono的生命周期，由UIModule的帧更新驱动并管理UI的生命周期。
+
+IUIBehaviour为UI通用行为接口、UIBase为UI基类、UIWindow为UI窗口基类，UIWidget为UI组件基类。
+
+## 前期配置：
+注意！！！！m_item节点为特殊节点表示是UI下的UIWidget组件，不会继续往下遍历生成UI代码。若需要这个UIWidget组件m_item的代码则在m_item右键生成这个组件的UI脚本。
+
+Scene窗口下右键ScriptGenerator菜单下About目录有默认UI命名前缀规范。
+![image](src/3-5-1.png)
+
+有自定义需求可以在TEngineSetting下进行自定义。
+![image](src/3-5-2.png)
+### 开发工作流：
+1.遵守前期默认配置或者自定义配置进行UI编排
+![image](src/3-5-3.png)
+
+2.在UI的根节点右键ScriptGenerator生成UI代码到剪贴板上！！！（注-使用-UniTask的生成代码可以做异步事件流驱动的UI。）
+![image](src/3-5-4.png)
+
+3.自行创建UI脚本到需要的目录下并复制UI脚本。
+
+## 举例示范
+``` csharp
+// 同步打开面板
+GameModule.UI.ShowUI<GameMainUI>([nullable]userData);
+
+// 异步打开面板
+GameModule.UI.ShowUIAsync<GameMainUI>([nullable]userData);
+
+namespace GameLogic
+{
+    /// <summary>
+    /// BattleMainUI面板
+    /// <remarks>UIWindow需要以下特性，UILayer可以自行定义，fullScreen表示为全屏面板会停止和隐藏这个面板堆栈后面的面板。</remarks>
+    /// </summary>
+    [Window(UILayer.Bottom,fullScreen:true)]
+    class BattleMainUI : UIWindow
+    {
+        private TouchMove m_touchView;
+        
+        #region 脚本工具生成的代码
+        private RectTransform m_rectContainer;
+        private GameObject m_itemTouch;
+        private Button m_btnLeaveBattle;
+        private GameObject m_goTopInfo;
+        private Button m_btnPause;
+        public override void ScriptGenerator()
+        {
+            m_rectContainer = FindChildComponent<RectTransform>("m_rectContainer");
+            m_itemTouch = FindChild("m_rectContainer/m_itemTouch").gameObject;
+            m_btnLeaveBattle = FindChildComponent<Button>("m_btnLeaveBattle");
+            m_goTopInfo = FindChild("m_goTopInfo").gameObject;
+            m_btnPause = FindChildComponent<Button>("m_goTopInfo/m_btnPause");
+            m_btnLeaveBattle.onClick.AddListener(OnClickLeaveBattleBtn);
+            m_btnPause.onClick.AddListener(OnClickPauseBtn);
+        }
+        #endregion
+
+        #region 事件
+
+        private void OnClickPauseBtn()
+        {
+            BattleSys.Instance.Pause = !BattleSys.Instance.Pause;
+        }
+
+        private void OnClickLeaveBattleBtn()
+        {
+            BattleSys.Instance.StopBattle(isBattleEnd:false,isWin:false);
+        }
+        #endregion
+
+        //注册事件举例
+        public override void RegisterEvent()
+        {
+            //通过AddUIEvent这样注册事件会把事件的生命周期绑定给面板，面板销毁的时候自动移除监听。
+            AddUIEvent(ActorLogicEventDefined.OnMainPlayerBagDataChange, RefreshUI);
+        }
+
+        public override void BindMemberProperty()
+        {
+            //特殊的m_item节点的域不属于父级UIWindows，所以如注意所说需要同样创建这个UIWidget的脚本并生成代码过去。 可以如下创建或者走type、path创建。
+            m_touchView = CreateWidget<TouchMove>(m_itemTouch);
+        }
+
+        ......
+    }
+}
+
+namespace GameLogic
+{
+    /// <summary>
+    /// 移动操作UIWidget。
+    /// </summary>
+    class TouchMove : UIWidget, IUICtrlMove
+    {
+        public override void BindMemberProperty()
+        {
+        }
+
+        //注意Update只有在重写了此方法才会驱动这个Widget或者面板的Update。
+        public override void OnUpdate()
+        {
+            TProfiler.BeginSample("CheckMoveTouchFinger");
+            CheckMoveTouchFinger();
+            TProfiler.EndSample();
+
+            TProfiler.BeginSample("UpdateTouchMovePos");
+            UpdateTouchMovePos();
+            TProfiler.EndSample();
+
+            TProfiler.BeginSample("UpdateKeyMove");
+            UpdateKeyMove();
+            TProfiler.EndSample();
+        }
+        ......
+    }
+}
+```
+
+## UI进阶
+UI面板需要标记UIWindowAttribute，以标识层级(可以自行定义)和是否全屏。全屏面板则会把下层面板的Visible设置为false。
+![image](src/3-5-5.png)
+

Books/3-6-配置表模块.md

@@ -0,0 +1,63 @@
+# 3-6.配置表模块 - ConfigSystem
+接入最佳游戏配置解决方案 - <a href="https://github.com/focus-creative-games/luban"><strong>Luban</strong></a>
+
+<a href="https://luban.doc.code-philosophy.com/#/manual/traits"><strong>Luban文档 </strong></a>
+
+### 在TEngine中Luban配置表目录位于以下目录
+![image](src/3-6-1.png)
+
+### 安装luban配置表
+1.在TEngine根目录同级克隆下最新的luban-next仓库。
+![image](src/3-6-2.png)
+2.Tools目录执行build-luban完成
+![image](src/3-6-3.png)
+
+3.转表则去luban配置目录执行对应bat
+
+TEngine内置默认使用懒加载配置，也支持基于UniTask的异步加载，同步加载，包括服务器的Task异步加载，使用对应转表的bat即可。
+
+### 介绍
+luban是你的最佳游戏配置解决方案。
+
+luban高效地处理游戏开发中常见的excel、json、xml之类的数据，检查数据错误，生成c#等各种语言的代码，导出成bytes或json等多种格式。
+
+luban统一了游戏配置开发工作流，极大提升了策划和程序的工作效率。
+
+核心特性
+强大的数据解析和转换能力 {excel(csv,xls,xlsx)、json、bson、xml、yaml、lua、unity ScriptableObject} => {binary、json、bson、xml、lua、yaml、erlang、 custom format}
+增强的excel格式，可以简洁地配置出像简单列表、子结构、结构列表，以及任意复杂的深层次的嵌套结构。
+完备的类型系统，支持OOP类型继承，搭配excel、json、lua、xml等格式数据灵活优雅表达行为树、技能、剧情、副本之类复杂GamePlay数据
+支持生成c#、java、go、c++、lua、python、javascript、typescript、erlang、rust、gdscript 代码
+支持生成 protobuf(schema + binary + json)、flatbuffers(schema + json)、msgpack(binary)
+强大的数据校验能力。ref引用检查、path资源路径、range范围检查等等
+完善的本地化支持。静态文本值本地化、动态文本值本地化、时间本地化、main-patch多地区版本
+强大灵活的自定义能力，支持自定义代码模板和数据模板
+通用型生成和缓存工具。也可以用于生成协议、数据库之类的代码，甚至可以用作对象缓存服务。
+
+
+---
+
+使用案例
+``` csharp
+/// <summary>
+/// 道具配置表管理器。
+/// </summary>
+public class ItemConfigMgr: Singleton<ItemConfigMgr>
+{
+    /// <summary>
+    /// 道具Table。
+    /// </summary>
+    private TbItem TbItem => ConfigLoader.Instance.Tables.TbItem;
+
+    /// <summary>
+    /// 获取道具配置表。
+    /// </summary>
+    /// <param name="itemId">道具Id。</param>
+    /// <returns>道具配置表。</returns>
+    public ItemConfig GetItemConfig(int itemId)
+    {
+        TbItem.DataMap.TryGetValue(itemId, out var config);
+        return config;
+    }
+}
+```

Books/3-7-流程模块.md

@@ -0,0 +1,27 @@
+# 7.流程模块 - ProcedureModule
+
+### ProcedureLaunch - 流程启动
+
+### ProcedureSplash - 流程闪屏
+
+### ProcedureInitPackage - 流程初始化Package
+
+### ProcedurePreload - 流程预加载
+
+### ProcedureInitResources - 流程初始化Resources
+
+### ProcedureUpdateVersion - 流程更新版本Version
+
+### ProcedureUpdateManifest - 流程更新Mainfest清单
+
+### ProcedureCreateDownloader - 流程创建下载器
+
+### ProcedureDownloadFile - 流程下载文件
+
+### ProcedureDownloadOver - 流程下载文件结束
+
+### ProcedureClearCache - 流程清理缓存
+
+### ProcedureLoadAssembly - 流程加载进入热更新程序集
+
+### ProcedureStartGame - 流程开始游戏

Books/3-8-网络模块.md

@@ -0,0 +1,2 @@
+# 8.网络模块 - Network
+待补充

Books/99-各平台运行RunAble.md

@@ -0,0 +1,26 @@
+# TEngine各平台下运行
+
+### 日志记录编辑器下运行
+![image](src/Editor-RunSuccessed.png)
+
+---
+### Win64位包运行
+
+![image](src/Win64-RunSuccessed.png)
+
+---
+### 安卓真机运行
+![image](src/Android-RunSuccessed.png)
+
+### IOS真机运行
+![image](src/Iphone-RunSuccessed.png)
+
+### WebGL真机运行
+![image](src/WebGL-RunSuccessed.png)
+
+### 索尼 PS5 真机运行
+
+![image](src/Console%20Viewer.png)
+
+
+![image](src/Console%20Output.png)

Books/Donate.md

@@ -0,0 +1,16 @@
+## <strong>Buy me a coffee.
+
+您的赞助会让我们做得更快更好，如果觉得TEngine对您有帮助，不妨赞助我买杯咖啡吧~
+
+
+<p align="center">
+
+<img src="src/Donate-微信.jpg" alt="logo" width="384" height="562">
+
+</p>
+
+<p align="center">
+
+<img src="src/Donate-支付宝.jpg" alt="logo" width="384" height="562">
+
+</p>

BuildCLI/build_android.bat

@@ -0,0 +1,9 @@
+cd /d %~dp0
+
+call path_define.bat
+
+%UNITYEDITOR_PATH%/Unity.exe %WORKSPACE% -logFile %BUILD_LOGFILE% -executeMethod TEngine.ReleaseTools.AutomationBuildAndroid -quit -batchmode -CustomArgs:Language=en_US; %WORKSPACE%
+
+@REM for /f "delims=[" %%i in (%BUILD_LOGFILE%) do echo %%i
+
+pause

BuildCLI/build_android.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+cd "$(dirname "$0")"
+
+source ./path_define.sh
+
+"${UNITYEDITOR_PATH}/Unity" "${WORKSPACE}" \
+  -logFile "${BUILD_LOGFILE}" \
+  -executeMethod TEngine.ReleaseTools.AutomationBuildAndroid \
+  -quit -batchmode \
+  -CustomArgs:Language=en_US "${WORKSPACE}"
+
+while IFS= read -r line; do
+  echo "$line"
+done < "${BUILD_LOGFILE}"
+
+echo "按任意键继续..."
+read -k1

BuildCLI/path_define.bat

@@ -0,0 +1,6 @@
+cd /d %~dp0
+
+set WORKSPACE=G:/github/TEngine/UnityProject
+set UNITYEDITOR_PATH=G:/UnityEditor/2021.3.20f1c1/Editor
+set BUILD_DLL_LOGFILE=./build_dll.log
+set BUILD_LOGFILE=./build.log

BuildCLI/path_define.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+cd "$(dirname "$0")"
+
+export WORKSPACE="/Users/your_user/github/TEngine/UnityProject"  # 请替换为 macOS 上的实际路径
+export UNITYEDITOR_PATH="/Applications/Unity/Hub/Editor/2021.3.20f1c1/Unity.app/Contents/MacOS"  # 请替换为 macOS 上的 Unity 路径
+export BUILD_DLL_LOGFILE="./build_dll.log"
+export BUILD_LOGFILE="./build.log"
+
+echo "环境变量已设置："
+echo "WORKSPACE=${WORKSPACE}"
+echo "UNITYEDITOR_PATH=${UNITYEDITOR_PATH}"
+echo "BUILD_DLL_LOGFILE=${BUILD_DLL_LOGFILE}"
+echo "BUILD_LOGFILE=${BUILD_LOGFILE}"

Configs/GameConfig/CustomTemplate/ConfigSystem.cs

@@ -0,0 +1,58 @@
+using Luban;
+using GameConfig;
+using TEngine;
+using UnityEngine;
+
+/// <summary>
+/// 配置加载器。
+/// </summary>
+public class ConfigSystem
+{
+    private static ConfigSystem _instance;
+
+    public static ConfigSystem Instance => _instance ??= new ConfigSystem();
+
+    private bool _init = false;
+
+    private Tables _tables;
+
+    public Tables Tables
+    {
+        get
+        {
+            if (!_init)
+            {
+                Load();
+            }
+
+            return _tables;
+        }
+    }
+    
+    private IResourceModule _resourceModule;
+
+    /// <summary>
+    /// 加载配置。
+    /// </summary>
+    public void Load()
+    {
+        _tables = new Tables(LoadByteBuf);
+        _init = true;
+    }
+
+    /// <summary>
+    /// 加载二进制配置。
+    /// </summary>
+    /// <param name="file">FileName</param>
+    /// <returns>ByteBuf</returns>
+    private ByteBuf LoadByteBuf(string file)
+    {
+        if (_resourceModule == null)
+        {
+            _resourceModule = ModuleSystem.GetModule<IResourceModule>();
+        }
+        TextAsset textAsset = _resourceModule.LoadAsset<TextAsset>(file);
+        byte[] bytes = textAsset.bytes;
+        return new ByteBuf(bytes);
+    }
+}

Configs/GameConfig/CustomTemplate/CustomTemplate_Client_LazyLoad/cs-bin/tables.sbn

@@ -0,0 +1,55 @@
+using Luban;
+
+{{namespace_with_grace_begin __namespace}}
+public partial class {{__name}}
+{
+    #region The Tables
+
+    {{~for table in __tables ~}}
+{{~if table.comment != '' ~}}
+    /// <summary>
+    /// {{escape_comment table.comment}}
+    /// </summary>
+{{~end~}}
+    private {{table.full_name}} m_{{table.name}};
+    public {{table.full_name}} {{format_property_name __code_style table.name}} 
+    {
+        get
+        {
+            if (m_{{table.name}} == null)
+            {
+                m_{{table.name}} = new {{table.full_name}}(defaultLoader("{{table.output_data_file}}"));
+                m_{{table.name}}.ResolveRef(this);
+            }
+            return m_{{table.name}};
+        }
+        set
+        {
+            m_{{table.name}} = value;
+            m_{{table.name}}.ResolveRef(this);
+        }
+    }
+    {{~end~}}
+
+    #endregion
+
+    System.Func<string, ByteBuf> defaultLoader;
+
+    public {{__name}}(System.Func<string, ByteBuf> loader)
+    {
+        SetDefaultLoader(loader);
+        Init();
+    }
+    
+    public void SetDefaultLoader(System.Func<string, ByteBuf> loader)
+    {
+        defaultLoader = null;
+        defaultLoader = loader;
+    }
+
+    //public partial void Init();
+
+    public void Init(){}
+}
+
+{{namespace_with_grace_end __namespace}}

Configs/GameConfig/CustomTemplate/ExternalTypeUtil.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+
+public static class ExternalTypeUtil
+{
+    public static Vector2 NewVector2(GameConfig.vector2 v)
+    {
+        return new Vector2(v.X, v.Y);
+    }
+
+    public static Vector3 NewVector3(GameConfig.vector3 v)
+    {
+        return new Vector3(v.X, v.Y, v.Z);
+    }
+
+    public static Vector4 NewVector4(GameConfig.vector4 v)
+    {
+        return new Vector4(v.X, v.Y, v.Z, v.W);
+    }
+
+    public static Vector2Int NewVector2Int(GameConfig.vector2int v)
+    {
+        return new Vector2Int(v.X, v.Y);
+    }
+
+    public static Vector3Int NewVector3Int(GameConfig.vector3int v)
+    {
+        return new Vector3Int(v.X, v.Y, v.Z);
+    }
+}

Configs/GameConfig/Defines/builtin.xml

@@ -0,0 +1,46 @@
+<module name="">
+    <bean name="vector2" valueType="1" sep=",">
+        <var name="x" type="float" />
+        <var name="y" type="float" />
+        <mapper target="client" codeTarget="cs-bin,cs-simple-json,cs-newtonsoft-json">
+            <option name="type" value="UnityEngine.Vector2" />
+            <option name="constructor" value="ExternalTypeUtil.NewVector2" />
+        </mapper>
+    </bean>
+    <bean name="vector3" valueType="1" sep=",">
+        <var name="x" type="float" />
+        <var name="y" type="float" />
+        <var name="z" type="float" />
+        <mapper target="client" codeTarget="cs-bin,cs-simple-json,cs-newtonsoft-json">
+            <option name="type" value="UnityEngine.Vector3" />
+            <option name="constructor" value="ExternalTypeUtil.NewVector3" />
+        </mapper>
+    </bean>
+    <bean name="vector4" valueType="1" sep=",">
+        <var name="x" type="float" />
+        <var name="y" type="float" />
+        <var name="z" type="float" />
+        <var name="w" type="float" />
+        <mapper target="client" codeTarget="cs-bin,cs-simple-json,cs-newtonsoft-json">
+            <option name="type" value="UnityEngine.Vector4" />
+            <option name="constructor" value="ExternalTypeUtil.NewVector4" />
+        </mapper>
+    </bean>
+    <bean name="vector2int" valueType="1" sep=",">
+        <var name="x" type="int" />
+        <var name="y" type="int" />
+        <mapper target="client" codeTarget="cs-bin,cs-simple-json,cs-newtonsoft-json">
+            <option name="type" value="UnityEngine.Vector2Int" />
+            <option name="constructor" value="ExternalTypeUtil.NewVector2Int" />
+        </mapper>
+    </bean>
+    <bean name="vector3int" valueType="1" sep=",">
+        <var name="x" type="int" />
+        <var name="y" type="int" />
+        <var name="z" type="int" />
+        <mapper target="client" codeTarget="cs-bin,cs-simple-json,cs-newtonsoft-json">
+            <option name="type" value="UnityEngine.Vector3" />
+            <option name="constructor" value="ExternalTypeUtil.NewVector3" />
+        </mapper>
+    </bean>
+</module>

Configs/GameConfig/gen_code_bin_to_project.bat

@@ -0,0 +1,22 @@
+Cd /d %~dp0
+echo %CD%
+
+set WORKSPACE=../..
+set LUBAN_DLL=%WORKSPACE%\Tools\Luban\Luban.dll
+set CONF_ROOT=.
+set DATA_OUTPATH=%WORKSPACE%/UnityProject/Assets/AssetRaw/Configs/bytes/
+set CODE_OUTPATH=%WORKSPACE%/UnityProject/Assets/GameScripts/HotFix/GameProto/GameConfig/
+
+xcopy /s /e /i /y "%CONF_ROOT%\CustomTemplate\ConfigSystem.cs" "%WORKSPACE%\UnityProject\Assets\GameScripts\HotFix\GameProto\ConfigSystem.cs"
+xcopy /s /e /i /y "%CONF_ROOT%\CustomTemplate\ExternalTypeUtil.cs" "%WORKSPACE%\UnityProject\Assets\GameScripts\HotFix\GameProto\ExternalTypeUtil.cs"
+
+dotnet %LUBAN_DLL% ^
+    -t client ^
+    -c cs-bin ^
+    -d bin^
+    --conf %CONF_ROOT%\luban.conf ^
+    -x code.lineEnding=crlf ^
+    -x outputCodeDir=%CODE_OUTPATH% ^
+    -x outputDataDir=%DATA_OUTPATH% 
+pause
+

Configs/GameConfig/gen_code_bin_to_project.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+cd "$(dirname "$0")"
+echo "当前目录: $(pwd)"
+
+export WORKSPACE="$(realpath ../../)"
+export LUBAN_DLL="${WORKSPACE}/Tools/Luban/Luban.dll"
+export CONF_ROOT="$(pwd)"
+export DATA_OUTPATH="${WORKSPACE}/UnityProject/Assets/AssetRaw/Configs/bytes/"
+export CODE_OUTPATH="${WORKSPACE}/UnityProject/Assets/GameScripts/HotFix/GameProto/GameConfig/"
+
+cp -R "${CONF_ROOT}/CustomTemplate/ConfigSystem.cs" \
+   "${WORKSPACE}/UnityProject/Assets/GameScripts/HotFix/GameProto/ConfigSystem.cs"
+cp -R "${CONF_ROOT}/CustomTemplate/ExternalTypeUtil.cs" \
+    "${WORKSPACE}/UnityProject/Assets/GameScripts/HotFix/GameProto/ExternalTypeUtil.cs"
+
+dotnet "${LUBAN_DLL}" \
+    -t client \
+    -c cs-bin \
+    -d bin \
+    --conf "${CONF_ROOT}/luban.conf" \
+    -x code.lineEnding=crlf \
+    -x outputCodeDir="${CODE_OUTPATH}" \
+    -x outputDataDir="${DATA_OUTPATH}"
+
+echo "操作完成，按任意键退出..."
+read -k1

Configs/GameConfig/gen_code_bin_to_project_lazyload.bat

@@ -0,0 +1,23 @@
+Cd /d %~dp0
+echo %CD%
+
+set WORKSPACE=../..
+set LUBAN_DLL=%WORKSPACE%\Tools\Luban\Luban.dll
+set CONF_ROOT=.
+set DATA_OUTPATH=%WORKSPACE%/UnityProject/Assets/AssetRaw/Configs/bytes/
+set CODE_OUTPATH=%WORKSPACE%/UnityProject/Assets/GameScripts/HotFix/GameProto/GameConfig/
+
+xcopy /s /e /i /y "%CONF_ROOT%\CustomTemplate\ConfigSystem.cs" "%WORKSPACE%\UnityProject\Assets\GameScripts\HotFix\GameProto\ConfigSystem.cs"
+xcopy /s /e /i /y "%CONF_ROOT%\CustomTemplate\ExternalTypeUtil.cs" "%WORKSPACE%\UnityProject\Assets\GameScripts\HotFix\GameProto\ExternalTypeUtil.cs"
+
+dotnet %LUBAN_DLL% ^
+    -t client ^
+    -c cs-bin ^
+    -d bin^
+    --conf %CONF_ROOT%\luban.conf ^
+    --customTemplateDir %CONF_ROOT%\CustomTemplate\CustomTemplate_Client_LazyLoad ^
+    -x code.lineEnding=crlf ^
+    -x outputCodeDir=%CODE_OUTPATH% ^
+    -x outputDataDir=%DATA_OUTPATH% 
+pause
+

Configs/GameConfig/gen_code_bin_to_project_lazyload.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+cd "$(dirname "$0")"
+echo "当前目录: $(pwd)"
+
+export WORKSPACE="$(realpath ../../)"
+export LUBAN_DLL="${WORKSPACE}/Tools/Luban/Luban.dll"
+export CONF_ROOT="$(pwd)"
+export DATA_OUTPATH="${WORKSPACE}/UnityProject/Assets/AssetRaw/Configs/bytes/"
+export CODE_OUTPATH="${WORKSPACE}/UnityProject/Assets/GameScripts/HotFix/GameProto/GameConfig/"
+
+cp -R "${CONF_ROOT}/CustomTemplate/ConfigSystem.cs" \
+   "${WORKSPACE}/UnityProject/Assets/GameScripts/HotFix/GameProto/ConfigSystem.cs"
+cp -R "${CONF_ROOT}/CustomTemplate/ExternalTypeUtil.cs" \
+    "${WORKSPACE}/UnityProject/Assets/GameScripts/HotFix/GameProto/ExternalTypeUtil.cs"
+
+dotnet "${LUBAN_DLL}" \
+    -t client \
+    -c cs-bin \
+    -d bin \
+    --conf "${CONF_ROOT}/luban.conf" \
+    --customTemplateDir "${CONF_ROOT}/CustomTemplate/CustomTemplate_Client_LazyLoad" \
+    -x code.lineEnding=crlf \
+    -x outputCodeDir="${CODE_OUTPATH}" \
+    -x outputDataDir="${DATA_OUTPATH}"
+
+echo "操作完成，按任意键退出..."
+read -k1

Configs/GameConfig/gen_code_bin_to_server.bat

@@ -0,0 +1,19 @@
+Cd /d %~dp0
+echo %CD%
+
+set WORKSPACE=../../
+set LUBAN_DLL=%WORKSPACE%/Tools/Luban/Luban.dll
+set CONF_ROOT=.
+set DATA_OUTPATH=%WORKSPACE%/Server/GameConfig 
+set CODE_OUTPATH=%WORKSPACE%/Server/Hotfix/Config/GameConfig
+
+dotnet %LUBAN_DLL% ^
+    -t server^
+    -c cs-bin ^
+    -d bin^
+    --conf %CONF_ROOT%\luban.conf ^
+    -x code.lineEnding=crlf ^
+    -x outputCodeDir=%CODE_OUTPATH% ^
+    -x outputDataDir=%DATA_OUTPATH% 
+pause
+

Configs/GameConfig/gen_code_bin_to_server.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+cd "$(dirname "$0")"
+echo "当前目录: $(pwd)"
+
+export WORKSPACE="$(realpath ../../)"
+export LUBAN_DLL="${WORKSPACE}/Tools/Luban/Luban.dll"
+export CONF_ROOT="$(pwd)"
+export DATA_OUTPATH="${WORKSPACE}/Server/GameConfig"
+export CODE_OUTPATH="${WORKSPACE}/Server/Hotfix/Config/GameConfig"
+
+dotnet "${LUBAN_DLL}" \
+    -t server \
+    -c cs-bin \
+    -d bin \
+    --conf "${CONF_ROOT}/luban.conf" \
+    -x code.lineEnding=crlf \
+    -x outputCodeDir="${CODE_OUTPATH}" \
+    -x outputDataDir="${DATA_OUTPATH}"
+
+echo "操作完成，按任意键退出..."
+read -k1

Configs/GameConfig/luban.conf

@@ -0,0 +1,22 @@
+{
+	"groups":
+	[
+		{"names":["c"], "default":true},
+		{"names":["s"], "default":true},
+		{"names":["e"], "default":true}
+	],
+	"schemaFiles":
+	[
+		{"fileName":"Defines", "type":""},
+		{"fileName":"Datas/__tables__.xlsx", "type":"table"},
+		{"fileName":"Datas/__beans__.xlsx", "type":"bean"},
+		{"fileName":"Datas/__enums__.xlsx", "type":"enum"}
+	],
+	"dataDir": "Datas",
+	"targets":
+	[
+		{"name":"server", "manager":"Tables", "groups":["s"], "topModule":"GameConfig"},
+		{"name":"client", "manager":"Tables", "groups":["c"], "topModule":"GameConfig"},
+		{"name":"all", "manager":"Tables", "groups":["c,s,e"], "topModule":"GameConfig"}
+	]
+}

README.md

@@ -33,9 +33,6 @@
 
 #### TEngine是一个简单(新手友好开箱即用)且强大的Unity框架全平台解决方案,对于需要一套上手快、文档清晰、高性能且可拓展性极强的商业级解决方案的开发者或者团队来说是一个很好的选择。
 
-
-## <a href="http://1.12.241.46:5000/"><strong>文档快速入门 »</strong></a>
-
 ## 文档快速预览 - 5分钟
 * [全平台跑通示意](Books/99-各平台运行RunAble.md): 全平台跑通示意。
 * [01_介绍](Books/0-介绍.md): 简单介绍。
@@ -46,49 +43,49 @@
 * [06_对象池模块](Books/3-4-%E5%AF%B9%E8%B1%A1%E6%B1%A0%E6%A8%A1%E5%9D%97.md): 展示对象池模块概览。
 * [07_配置表模块](Books/3-6-%E9%85%8D%E7%BD%AE%E8%A1%A8%E6%A8%A1%E5%9D%97.md): 展示配置表模块概览。
 * [08_流程模块](Books/3-7-%E6%B5%81%E7%A8%8B%E6%A8%A1%E5%9D%97.md): 展示商业化流程模块。
+* [09_UI模块](Books/3-5-UI模块.md): 展示商业化UI模块。
 
 
 ## <strong>为什么要使用TEngine
 0. 开箱即用5分钟即可上手整套开发流程，代码整洁，思路清晰，功能强大。高内聚低耦合。您可以很轻易的把您不需要的模块进行移除替换。
 1. 严格按照商业要求使用次世代的HybridClr进行热更新、最佳的Luban配置表(TEngine支持懒加载、异步加载、同步加载配置。)、百万DAU游戏验证过的YooAsset资源框架（框架管理资源引用与释放。），全平台热更新流程已跑通。
 2. 严格按照商业化流程执行的热更新、商业化的UI开发流程、以及资源管理等等，设计并实现了YooAsset资源自动释放、支持LRU、ARC严格管理资源内存。
-3. C#双端解决方案，服务器使用Fantasy，是一套源于ETServer，但极为简洁，性能更强，更好上手的一套商业级服务器框架。
-4. 支持全平台，已有项目使用TEngine上架Steam、Wechat-minigame、AppStore。
+3. 支持全平台，已有项目使用TEngine上架Steam、Wechat-minigame、AppStore。
 
-## <strong>资源重要拓展概念
-* AssetReference (资源引用标识) 通用加载资源的时候绑定一个引用标识使你无需关心手动Dispose资源句柄。
+## <strong>最新的Demo飞机大战位于demo分支
 
-* AssetGroup（资源组数据）进行资源分组绑定管理内存中的生命周期资源生命周期托管给资源组的根节点进行Dispose。
+## <strong>服务器相关
+TEngine本身为纯净的客户端。不强绑定任何服务器。但是个人开发以及中小型公司开发双端则推荐C#服务器。
 
-* LruCacheTable (Least Recently Used Cache缓存表)
-
-* ArcCacheTable (Adaptive Replacement Cache缓存表)
-
-## <strong>为什么服务器使用C#
 Net Core现在已经更新到了8.0的版本，在性能和设计上其实是远超JAVA和GO。在JAVAER还在为JVM更新和添加更多功能时，其实他们已经被国内大环境所包围了，看不到.Net Core的性能之强，组件化的结构。国内大环境是JAVA和GO的天下这个不可否认，但是国外C#也确实很多。其实.Net Core最大的问题是大多数自己人都不知道他的优点(AOT、JIT混合编译、热重载等等)，甚至很多守旧派抵制core。GO喜欢吹性能，但其实目前来看，除了协程的轻量级，大多数性能测试其实不如JAVA和.Net。简单可以说出了C++的性能以外，Net Core其实都打得过。
-<strong>当然作为商业级解决方案服务器的耦合度也极低，如果不喜欢您也可以很轻松直接移除替换成你的服务器。</strong>
+
+需要服务器可以合并<a href="https://github.com/ALEXTANGXIAO/GameNetty"><strong>GameNetty</strong></a>过来，或者分支Fantasy为接好的带有Fantasy服务器的双端分支。
 
 ## <strong>项目结构概览
 ```
 Assets
+├── AssetArt            // 美术资源目录
+│   └── Atlas           // 自动生成图集目录
 ├── AssetRaw            // 热更资源目录
-├── Atlas               // 自动生成图集目录
+│   ├── UIRaw           // UI图片目录
+│   │   ├── Atlas       // 需要自动生成图集的UI素材目录
+│   │   └── Raw         // 不需要自动生成图集的UI素材目录
+├── Editor              // 编辑器脚本目录
 ├── HybridCLRData       // hybridclr相关目录
+├── Scenes              // 主场景目录
 ├── TEngine             // 框架核心目录
 └── GameScripts         // 程序集目录
-    ├── Editor          // 编辑器程序集
-    ├── Main            // 主程序程序集(启动器与流程)
+    ├── Procedure       // 启动器与流程
     └── HotFix          // 游戏热更程序集目录 [Folder]
-        ├── GameBase    // 游戏基础框架程序集 [Dll]
-        ├── GameProto   // 游戏配置协议程序集 [Dll]  
-        ├── BattleCore  // 游戏核心战斗程序集 [Dll] 
+        ├── GameProto   // 游戏配置协议程序集 [Dll]
         └── GameLogic   // 游戏业务逻辑程序集 [Dll]
-            ├── GameApp.cs                  // 热更主入口
-            └── GameApp_RegisterSystem.cs   // 热更主入口注册系统   
-```
+            └── GameApp.cs                  // 热更主入口
 
- - 必要：项目使用了以下第三方插件，请自行购买导入：
-   - /Unity/Assets/Plugins/Sirenix
+
+TEngine
+├── Editor              // TEngine编辑器核心代码
+└── Runtime             // TEngine运行时核心代码
+```
 
 ---
 ## <strong>优质开源项目推荐
@@ -99,4 +96,11 @@ Assets
 
 #### <a href="https://github.com/focus-creative-games/hybridclr"><strong>HybridCLR</strong></a> - 特性完整、零成本、高性能、低内存的近乎完美的Unity全平台原生c#热更方案
 
-#### <a href="https://github.com/qq362946/Fantasy"><strong>Fantasy</strong></a> - Fantasy是一套源于ETServer但极为简洁，性能更强，更好上手的一套商业级服务器框架。
+#### <a href="https://github.com/qq362946/Fantasy"><strong>Fantasy</strong></a> - Fantasy是一套源于ETServer但极为简洁，更好上手的一套商业级服务器框架。
+
+#### <a href="https://github.com/ALEXTANGXIAO/GameNetty"><strong>GameNetty</strong></a> - GameNetty是一套源于ETServer，首次拆分最新的ET8.1的前后端解决方案（包），客户端最精简大约750k，完美做成包的形式，几乎零成本 无侵入的嵌入进你的框架。
+
+
+## <strong>Buy me a 奶茶.
+
+[您的赞助会让我们做得更快更好，如果觉得TEngine对您有帮助，不妨请我可爱的女儿买杯奶茶吧~](Books/Donate.md)

Tools/FileServer/.gitignore

@@ -0,0 +1,8 @@
+node_modules
+*.swap
+.idea
+.DS_Store
+*.log
+.vscode
+*-lock.json
+AssetsRoot

Tools/FileServer/README.md

@@ -0,0 +1,42 @@
+## 使用node搭建静态资源服务器
+
+### 安装
+
+```bash
+npm install yumu-static-server -g
+```
+
+### 使用
+
+```bash
+server  # 会在当前目录下启动一个静态资源服务器，默认端口为8080
+
+server -p[port] 3000  # 会在当前目录下启动一个静态资源服务器，端口为3000
+
+server -i[index] index.html  # 设置文件夹在默认加载的文件
+
+server -c[charset] UTF-8  # 设置文件默认加载的字符编码
+
+server -cors  # 开启文件跨域
+
+server -h[https]  # 开启https服务
+
+server --openindex  # 是否打开默认页面
+
+server --no-openbrowser  # 关闭自动打开浏览器
+```
+
+### 基本功能
+
+1. 启动静态资源服务器
+2. 端口可配置
+3. 字符编码可配置
+4. 文件夹下默认加载文件可配置
+5. 是否跨域可配置
+6. 开启https服务
+
+### TODO
+
+- [x] 引入handlerbars编译模板
+- [x] 支持文件是否跨域
+- [x] 支持https服务

Tools/FileServer/bin/app.js

@@ -0,0 +1,26 @@
+const StaticServer = require('../src/static-server');
+
+const options = require('yargs')
+    .option('p', { alias: 'port',  describe: '设置服务启动的端口号', type: 'number' })
+    .option('i', { alias: 'index', describe: '设置默认打开的主页', type: 'string' })
+    .option('c', { alias: 'charset', describe: '设置文件的默认字符集', type: 'string' })
+    .option('o', { alias: 'openindex', describe: '是否打开默认页面', type: 'boolean' })
+    .option('h', { alias: 'https', describe: '是否启用https服务', type: 'boolean' })
+    .option('cors', { describe: '是否开启文件跨域', type: 'boolean' })
+    .option('openbrowser', { describe: '是否默认打开浏览器', type: 'boolean' })
+
+    // 默认参数
+    .default('openbrowser', true)
+    // .default('https', true)
+    .default('port', 8080)
+    .default('index', 'index.html')
+    .default('openindex', 'index.html')
+    .default('charset', 'UTF-8')
+  
+    .help()
+    .alias('?', 'help')
+
+    .argv;
+
+const server = new StaticServer(options);
+server.start();

Tools/FileServer/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+module.exports = require('./bin/app.js');

Tools/FileServer/instal.bat

@@ -0,0 +1 @@
+npm install yumu-static-server -g

Tools/FileServer/instal.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+npm install yumu-static-server -g

Tools/FileServer/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "static-server",
+  "version": "0.0.1",
+  "description": "使用node搭建静态资源服务器",
+  "main": "index.js",
+  "scripts": {
+    "dev": "supervisor bin/app.js",
+    "start": "npm run dev"
+  },
+  "bin": {
+    "server": "index.js"
+  },
+  "author": "Alex",
+  "license": "ISC",
+  "keywords": [
+    "static-server",
+    "server"
+  ],
+  "dependencies": {
+    "chalk": "^2.3.2",
+    "handlebars": "^4.0.11",
+    "mime": "^2.2.0",
+    "open": "^7.1.0",
+    "pem": "^1.12.5",
+    "yargs": "^6.6.0"
+  },
+  "devDependencies": {
+    "supervisor": "^0.12.0"
+  }
+}

Tools/FileServer/src/mime.js

@@ -0,0 +1,12 @@
+const path = require('path');
+const mime = require('mime');
+
+const lookup = (pathName) => {
+    let ext = path.extname(pathName);
+    ext = ext.split('.').pop();
+    return mime.getType(ext) || mime.getType('txt');
+}
+
+module.exports = {
+    lookup
+};

Tools/FileServer/src/static-server.js

@@ -0,0 +1,334 @@
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const fs = require('fs');
+const url = require('url');
+const zlib = require('zlib');
+const chalk = require('chalk');
+const os = require('os');
+const open = require("open");
+const Handlebars = require('handlebars');
+const pem = require('pem');
+const mime = require('./mime');
+const Template = require('./templates');
+
+const _defaultTemplate = Handlebars.compile(Template.page_dafault);
+const _404TempLate = Handlebars.compile(Template.page_404);
+
+const hasTrailingSlash = url => url[url.length - 1] === '/';
+
+const ifaces = os.networkInterfaces();
+
+class StaticServer {
+    constructor(options) {
+        this.port = options.port;
+        this.indexPage = options.index;
+        this.openIndexPage = options.openindex;
+        this.openBrowser = options.openbrowser;
+        this.charset = options.charset;
+        this.cors = options.cors;
+        this.protocal = options.https ? 'https' : 'http';
+        this.zipMatch = '^\\.(css|js|html)$';
+    }
+
+    /**
+     * 响应错误
+     *
+     * @param {*} err
+     * @param {*} res
+     * @returns
+     * @memberof StaticServer
+     */
+    respondError(err, res) {
+        res.writeHead(500);
+        return res.end(err);        
+    }
+
+    /**
+     * 响应404
+     *
+     * @param {*} req
+     * @param {*} res
+     * @memberof StaticServer
+     */
+    respondNotFound(req, res) {
+        res.writeHead(404, {
+            'Content-Type': 'text/html'
+        });
+        const html = _404TempLate();
+        res.end(html);
+    }
+
+    respond(pathName, req, res) {
+        fs.stat(pathName, (err, stat) => {
+            if (err) return respondError(err, res);
+            this.responseFile(stat, pathName, req, res);
+        });
+    }
+
+    /**
+     * 判断是否需要解压
+     *
+     * @param {*} pathName
+     * @returns
+     * @memberof StaticServer
+     */
+    shouldCompress(pathName) {
+        return path.extname(pathName).match(this.zipMatch);
+    }
+
+    /**
+     * 解压文件
+     *
+     * @param {*} readStream
+     * @param {*} req
+     * @param {*} res
+     * @returns
+     * @memberof StaticServer
+     */
+    compressHandler(readStream, req, res) {
+        const acceptEncoding = req.headers['accept-encoding'];
+        if (!acceptEncoding || !acceptEncoding.match(/\b(gzip|deflate)\b/)) {
+            return readStream;
+        } else if (acceptEncoding.match(/\bgzip\b/)) {
+            res.setHeader('Content-Encoding', 'gzip');
+            return readStream.pipe(zlib.createGzip());
+        }
+    }
+
+    /**
+     * 响应文件路径
+     *
+     * @param {*} stat
+     * @param {*} pathName
+     * @param {*} req
+     * @param {*} res
+     * @memberof StaticServer
+     */
+    responseFile(stat, pathName, req, res) {
+        // 设置响应头
+        res.setHeader('Content-Type', `${mime.lookup(pathName)}; charset=${this.charset}`);
+        res.setHeader('Accept-Ranges', 'bytes');
+
+        // 添加跨域
+        if (this.cors) res.setHeader('Access-Control-Allow-Origin', '*');
+
+        let readStream;
+        readStream = fs.createReadStream(pathName);
+        if (this.shouldCompress(pathName)) { // 判断是否需要解压
+            readStream = this.compressHandler(readStream, req, res);
+        }
+        readStream.pipe(res);
+    }
+  
+    /**
+     * 响应重定向
+     *
+     * @param {*} req
+     * @param {*} res
+     * @memberof StaticServer
+     */
+    respondRedirect(req, res) {
+        const location = req.url + '/';
+        res.writeHead(301, {
+            'Location': location,
+            'Content-Type': 'text/html'
+        });
+        const html = _defaultTemplate({
+            htmlStr: `Redirecting to <a href='${location}'>${location}</a>`,
+            showFileList: false
+        })
+        res.end(html);
+    }
+
+    /**
+     * 响应文件夹路径
+     *
+     * @param {*} pathName
+     * @param {*} req
+     * @param {*} res
+     * @memberof StaticServer
+     */
+    respondDirectory(pathName, req, res) {
+        const indexPagePath = path.join(pathName, this.indexPage);
+        // 如果文件夹下存在index.html，则默认打开
+        if (this.openIndexPage && fs.existsSync(indexPagePath)) {
+            this.respond(indexPagePath, req, res);
+        } else {
+            fs.readdir(pathName, (err, files) => {
+                if (err) {
+                    respondError(err, res);
+                }
+                const requestPath = url.parse(req.url).pathname;
+                const fileList = [];
+                files.forEach(fileName => {
+                    let itemLink = path.join(requestPath, fileName);
+                    let isDirectory = false;
+                    const stat = fs.statSync(path.join(pathName, fileName));
+                    if (stat && stat.isDirectory()) {
+                        itemLink = path.join(itemLink, '/');
+                        isDirectory = true;
+                    }     
+                    fileList.push({
+                        link: itemLink,
+                        name: fileName,
+                        isDirectory
+                    });            
+                });
+                // 排序，目录在前，文件在后
+                fileList.sort((prev, next) => {
+                    if (prev.isDirectory && !next.isDirectory) {
+                        return -1;
+                    }
+                    return 1;
+                });
+                res.writeHead(200, {
+                    'Content-Type': 'text/html'
+                });
+                const html = _defaultTemplate({
+                    requestPath,
+                    fileList,
+                    showFileList: true
+                })
+                res.end(html);
+            });
+        }
+    }
+
+    /**
+     * 路由处理
+     *
+     * @param {*} pathName
+     * @param {*} req
+     * @param {*} res
+     * @memberof StaticServer
+     */
+    routeHandler(pathName, req, res) {
+        const realPathName = pathName.split('?')[0];
+        fs.stat(realPathName, (err, stat) => {
+            this.logGetInfo(err, pathName);
+            if (!err) {
+                const requestedPath = url.parse(req.url).pathname;
+                // 检查url
+                // 如果末尾有'/'，且是文件夹，则读取文件夹
+                // 如果是文件夹，但末尾没'/'，则重定向至'xxx/'
+                // 如果是文件，则判断是否是压缩文件，是则解压，不是则读取文件
+                if (hasTrailingSlash(requestedPath) && stat.isDirectory()) {
+                    this.respondDirectory(realPathName, req, res);
+                } else if (stat.isDirectory()) {
+                    this.respondRedirect(req, res);
+                } else {
+                    this.respond(realPathName, req, res);
+                }
+            } else {
+                this.respondNotFound(req, res);
+            }
+        });
+    }
+
+    /**
+     * 打印ip地址
+     *
+     * @memberof StaticServer
+     */
+    logUsingPort() {
+        const me = this;
+        console.log(`${chalk.yellow(`Starting up your server\nAvailable on:`)}`);
+        Object.keys(ifaces).forEach(function (dev) {
+            ifaces[dev].forEach(function (details) {
+                if (details.family === 'IPv4') {
+                    console.log(`   ${me.protocal}://${details.address}:${chalk.green(me.port)}`);
+                }
+            });
+        });
+        console.log(`${chalk.cyan(Array(50).fill('-').join(''))}`);
+    }
+
+    /**
+     * 打印占用端口
+     *
+     * @param {*} oldPort
+     * @param {*} port
+     * @memberof StaticServer
+     */
+    logUsedPort(oldPort, port) {
+        const me = this;
+        console.log(`${chalk.red(`The port ${oldPort} is being used, change to port `)}${chalk.green(me.port)} `);
+    }
+
+    /**
+     * 打印https证书友好提示
+     *
+     * @memberof StaticServer
+     */
+    logHttpsTrusted() {
+        console.log(chalk.green('Currently is using HTTPS certificate (Manually trust it if necessary)'));
+    }
+
+
+    /**
+     * 打印路由路径输出
+     *
+     * @param {*} isError
+     * @param {*} pathName
+     * @memberof StaticServer
+     */
+    logGetInfo(isError, pathName) {
+        if (isError) {
+            console.log(chalk.red(`404  ${pathName}`));
+        } else {
+            console.log(chalk.cyan(`200  ${pathName}`));
+        }
+    }
+
+    startServer(keys) {
+        const me = this;
+        let isPostBeUsed = false;
+        const oldPort = me.port;
+        const protocal = me.protocal === 'https' ? https : http;
+        const options = me.protocal === 'https' ? { key: keys.serviceKey, cert: keys.certificate } : null;
+        const callback = (req, res) => {
+            const pathName = path.join(process.cwd(), path.normalize(decodeURI(req.url)));
+            me.routeHandler(pathName, req, res);
+        };
+        const params = [callback];
+        if (me.protocal === 'https') params.unshift(options);
+        const server = protocal.createServer(...params).listen(me.port);
+        server.on('listening', function () { // 执行这块代码说明端口未被占用
+            if (isPostBeUsed) {
+                me.logUsedPort(oldPort, me.port);
+            }
+            me.logUsingPort();
+            if (me.openBrowser) {
+                open(`${me.protocal}://127.0.0.1:${me.port}`);
+            }
+        });
+        
+        server.on('error', function (err) {
+            if (err.code === 'EADDRINUSE') { // 端口已经被使用
+                isPostBeUsed = true;
+                me.port = parseInt(me.port) + 1;
+                server.listen(me.port);
+            } else {
+                console.log(err);
+            }
+        })
+    }
+
+    start() {
+        const me = this;
+        if (this.protocal === 'https') {
+            pem.createCertificate({ days: 1, selfSigned: true }, function (err, keys) {
+                if (err) {
+                  throw err
+                }
+                me.logHttpsTrusted();
+                me.startServer(keys);
+            })
+        } else {
+            me.startServer();
+        }
+    }
+}
+
+module.exports = StaticServer;

Tools/FileServer/src/templates/404.js

@@ -0,0 +1,44 @@
+module.exports =  `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <meta http-equiv="X-UA-Compatible" content="ie=edge"/>
+  <title>node静态服务器</title>
+  <style>
+    .not-found-content {
+      display: flex;
+      justify-content: center;
+      min-height: 500px;
+      align-items: center;
+    }
+    .not-found-content .img-notfound {
+      margin-right: 50px;
+    }
+    .not-found-content h3 {
+      color: #333;
+      font-size: 24px;
+      margin: 20px 0;
+      font-weight: 400;
+      line-height: 24px;
+    }
+    .not-found-content p {
+      color: #666;
+      font-size: 16px;
+      line-height: 20px;
+      margin-bottom: 7px;
+    }
+  </style>
+</head>
+<body>
+  <div class="not-found-content">
+    <img src="https://img.alicdn.com/tfs/TB1txw7bNrI8KJjy0FpXXb5hVXa-260-260.png" class="img-notfound" alt="not found">
+    <div class="prompt">
+      <h3>抱歉，你访问的路径不存在</h3>
+      <p>您要找的页面没有找到，请返回<a class="link-font" href="/">首页</a>继续浏览</p>
+    </div>
+  </div>
+</body>
+</html>
+`

Tools/FileServer/src/templates/default.js

@@ -0,0 +1,93 @@
+module.exports = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <title>node静态服务器</title>
+  <style>
+    html, body, ul, li, p{
+      padding: 0;
+      margin: 0;
+    }
+    html, body {
+      padding: 0;
+      margin: 0;
+      width: 100%;
+      height: 100%;
+    }
+    .app {
+      padding: 20px 50px 0;
+      min-height: calc(100% - 70px);
+      overflow: hidden;
+      color: #333;
+    }
+    .directory li {
+      list-style: circle;
+      margin-left: 20px;
+    }
+    .directory li p {
+      line-height: 1.7;
+      margin: 14px 0;
+    }
+    .directory li p a{
+      color: #333;
+      font-weight: 400;
+      text-decoration: none;
+    }
+    .directory li p span{
+      color: #3dcccc;
+    }
+    .directory li p a:hover {
+      color: red;
+    }
+    .footer {
+      text-align: center;
+      height: 50px;
+      font-size: 12px;
+    }
+    .footer span {
+      display: block;
+      line-height: 24px;
+    }
+    .footer .bold {
+      font-weight: 600;
+    }
+    .footer a {
+      color: #333;
+    }
+    .footer a:hover {
+      color: red;
+    }
+  </style>
+</head>
+<body>
+  <div class="app">
+      <h3>当前目录：<span>{{requestPath}}</span></h3>
+      {{#if showFileList}}
+        <ul class="directory">
+          {{#each fileList}}
+            <li>
+              <p>
+                {{#if isDirectory }}
+                <span>「目录」</span>
+                {{else}}
+                <span>「文件」</span>
+                {{/if}}
+                <a href='{{link}}'>{{name}}</a>
+              </p>
+            </li>
+          {{/each}}
+        </ul>
+      {{else}}
+        {{htmlStr}}
+      {{/if}}
+  </div>
+  <div class="footer">
+      <span>Github地址: <a target="_blank" href="https://github.com/WisestCoder/static-server">https://github.com/WisestCoder/static-server</a></span>
+      <span class="bold">By <a target="_blank" href="https://github.com/WisestCoder">WisestCoder</a></span>
+  </div>
+</body>
+</html>
+`;

Tools/FileServer/src/templates/index.js

@@ -0,0 +1,7 @@
+const page_dafault = require('./default');
+const page_404 = require('./404');
+
+module.exports = {
+  page_dafault,
+  page_404
+};

Tools/FileServer/start.bat

@@ -0,0 +1 @@
+server -p 8081 -cors 

Tools/FileServer/start.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+server -p 8081 -cors 

Tools/GameEventSourceGenerator/.idea/.idea.SourceGenerator/.idea/.gitignore

@@ -0,0 +1,13 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Rider ignored files
+/modules.xml
+/projectSettingsUpdater.xml
+/.idea.SourceGenerator.iml
+/contentModel.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

Tools/GameEventSourceGenerator/.idea/.idea.SourceGenerator/.idea/.name

@@ -0,0 +1 @@
+SourceGenerator

Tools/GameEventSourceGenerator/.idea/.idea.SourceGenerator/.idea/encodings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding" addBOMForNewFiles="with BOM under Windows, with no BOM otherwise" />
+</project>

Tools/GameEventSourceGenerator/.idea/.idea.SourceGenerator/.idea/indexLayout.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="UserContentModel">
+    <attachedFolders />
+    <explicitIncludes />
+    <explicitExcludes />
+  </component>
+</project>

Tools/GameEventSourceGenerator/.idea/.idea.SourceGenerator/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>

Tools/GameEventSourceGenerator/Analyzer/Extension/AnalyzerHelper.cs

@@ -0,0 +1,568 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.FlowAnalysis;
+using Exception = System.Exception;
+
+namespace Analyzer
+{
+    public static class AnalyzerHelper
+    {
+        /// <summary>
+        ///     获取语法树节点的子节点中第一个指定类型节点
+        /// </summary>
+        /// <param name="syntaxNode">语法树节点</param>
+        /// <typeparam name="T">指定语法节点类型</typeparam>
+        /// <returns>第一个指定类型节点</returns>
+        public static T? GetFirstChild<T>(this SyntaxNode syntaxNode) where T : SyntaxNode
+        {
+            foreach (SyntaxNode? childNode in syntaxNode.ChildNodes())
+            {
+                if (childNode.GetType() == typeof(T))
+                {
+                    return childNode as T;
+                }
+            }
+
+            return null;
+        }
+
+        public static SyntaxNode? GetFirstChild(this SyntaxNode syntaxNode)
+        {
+            var childNodes = syntaxNode.ChildNodes();
+            if (childNodes.Count() > 0)
+            {
+                return childNodes.First();
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///     获取语法树节点的子节点中最后一个指定类型节点
+        /// </summary>
+        /// <param name="syntaxNode">语法树节点</param>
+        /// <typeparam name="T">指定语法节点类型</typeparam>
+        /// <returns>最后一个指定类型节点</returns>
+        public static T? GetLastChild<T>(this SyntaxNode syntaxNode) where T : SyntaxNode
+        {
+            foreach (SyntaxNode? childNode in syntaxNode.ChildNodes().Reverse())
+            {
+                if (childNode.GetType() == typeof(T))
+                {
+                    return childNode as T;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///     获取语法节点所属的ClassDeclarationSyntax
+        /// </summary>
+        public static ClassDeclarationSyntax? GetParentClassDeclaration(this SyntaxNode syntaxNode)
+        {
+            SyntaxNode? parentNode = syntaxNode.Parent;
+            while (parentNode != null)
+            {
+                if (parentNode is ClassDeclarationSyntax classDeclarationSyntax)
+                {
+                    return classDeclarationSyntax;
+                }
+
+                parentNode = parentNode.Parent;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///     INamedTypeSymbol 是否有指定的Attribute
+        /// </summary>
+        public static bool HasAttribute(this ITypeSymbol typeSymbol, string AttributeName)
+        {
+            foreach (AttributeData? attributeData in typeSymbol.GetAttributes())
+            {
+                if (attributeData.AttributeClass?.ToString() == AttributeName)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static bool HasAttributeInTypeAndBaseTyes(this ITypeSymbol typeSymbol, string AttributeName)
+        {
+            if (typeSymbol.HasAttribute(AttributeName))
+            {
+                return true;
+            }
+
+            foreach (var baseType in typeSymbol.BaseTypes())
+            {
+                if (baseType.HasAttribute(AttributeName))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static IEnumerable<ITypeSymbol> BaseTypes(this ITypeSymbol typeSymbol)
+        {
+            ITypeSymbol? baseType = typeSymbol.BaseType;
+            while (baseType != null)
+            {
+                yield return baseType;
+                baseType = baseType.BaseType;
+            }
+        }
+
+        /// <summary>
+        ///     INamedTypeSymbol 是否有指定的基类Attribute
+        /// </summary>
+        public static bool HasBaseAttribute(this INamedTypeSymbol namedTypeSymbol, string AttributeName)
+        {
+            foreach (AttributeData? attributeData in namedTypeSymbol.GetAttributes())
+            {
+                INamedTypeSymbol? attributeType = attributeData.AttributeClass?.BaseType;
+                while (attributeType != null)
+                {
+                    if (attributeType.ToString() == AttributeName)
+                    {
+                        return true;
+                    }
+
+                    attributeType = attributeType.BaseType;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        ///     INamedTypeSymbol 获取指定类型的第一个Attribute
+        /// </summary>
+        public static AttributeData? GetFirstAttribute(this INamedTypeSymbol namedTypeSymbol, string AttributeName)
+        {
+            foreach (AttributeData? attributeData in namedTypeSymbol.GetAttributes())
+            {
+                if (attributeData.AttributeClass?.ToString() == AttributeName)
+                {
+                    return attributeData;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///     INamedTypeSymbol 是否含有指定接口
+        /// </summary>
+        public static bool HasInterface(this INamedTypeSymbol namedTypeSymbol, string InterfaceName)
+        {
+            foreach (INamedTypeSymbol? iInterface in namedTypeSymbol.AllInterfaces)
+            {
+                if (iInterface.IsInterface(InterfaceName))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 某个接口symbol 是否是指定的接口
+        /// </summary>
+        public static bool IsInterface(this INamedTypeSymbol namedTypeSymbol, string InterfaceName)
+        {
+            return $"{namedTypeSymbol.GetNameSpace()}.{namedTypeSymbol.Name}" == InterfaceName;
+        }
+
+        /// <summary>
+        ///     判断指定的程序集是否需要分析
+        /// </summary>
+        public static bool IsAssemblyNeedAnalyze(string? assemblyName, params string[] analyzeAssemblyNames)
+        {
+            if (assemblyName == null)
+            {
+                return false;
+            }
+
+            foreach (string analyzeAssemblyName in analyzeAssemblyNames)
+            {
+                if (assemblyName == analyzeAssemblyName)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 获取 成员访问语法节点的父级类型
+        /// </summary>
+        public static ITypeSymbol? GetMemberAccessSyntaxParentType(this MemberAccessExpressionSyntax memberAccessExpressionSyntax,
+            SemanticModel semanticModel)
+        {
+            SyntaxNode? firstChildSyntaxNode = memberAccessExpressionSyntax.GetFirstChild();
+            if (firstChildSyntaxNode == null)
+            {
+                return null;
+            }
+
+            ISymbol? firstChildSymbol = semanticModel.GetSymbolInfo(firstChildSyntaxNode).Symbol;
+            if (firstChildSymbol == null)
+            {
+                return null;
+            }
+
+            if (firstChildSymbol is ILocalSymbol localSymbol)
+            {
+                return localSymbol.Type;
+            }
+
+            if (firstChildSymbol is IParameterSymbol parameterSymbol)
+            {
+                return parameterSymbol.Type;
+            }
+
+            if (firstChildSymbol is IPropertySymbol propertySymbol)
+            {
+                return propertySymbol.Type;
+            }
+
+            if (firstChildSymbol is IMethodSymbol methodSymbol)
+            {
+                return methodSymbol.ReturnType;
+            }
+
+            if (firstChildSymbol is IFieldSymbol fieldSymbol)
+            {
+                return fieldSymbol.Type;
+            }
+
+            if (firstChildSymbol is IEventSymbol eventSymbol)
+            {
+                return eventSymbol.Type;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 获取最近的指定类型祖先节点
+        /// </summary>
+        public static T? GetNeareastAncestor<T>(this SyntaxNode syntaxNode) where T : SyntaxNode
+        {
+            foreach (var ancestorNode in syntaxNode.Ancestors())
+            {
+                if (ancestorNode is T Tancestor)
+                {
+                    return Tancestor;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 判断函数是否是否含有指定类型的参数
+        /// </summary>
+        public static bool HasParameterType(this IMethodSymbol methodSymbol, string parameterType, out IParameterSymbol? cencelTokenSymbol)
+        {
+            foreach (var parameterSymbol in methodSymbol.Parameters)
+            {
+                if (parameterSymbol.Type.ToString() == parameterType)
+                {
+                    cencelTokenSymbol = parameterSymbol;
+                    return true;
+                }
+            }
+
+            cencelTokenSymbol = null;
+            return false;
+        }
+
+        /// <summary>
+        /// 获取所有指定类型的子节点
+        /// </summary>
+        public static IEnumerable<T> DescendantNodes<T>(this SyntaxNode syntaxNode) where T : SyntaxNode
+        {
+            foreach (var descendantNode in syntaxNode.DescendantNodes())
+            {
+                if (descendantNode is T node)
+                {
+                    yield return node;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获取与该语法节点同层级的上一个节点
+        /// </summary>
+        public static SyntaxNode? PreviousNode(this SyntaxNode syntaxNode)
+        {
+            if (syntaxNode.Parent == null)
+            {
+                return null;
+            }
+
+            int index = 0;
+            foreach (var childNode in syntaxNode.Parent.ChildNodes())
+            {
+                if (childNode == syntaxNode)
+                {
+                    break;
+                }
+
+                index++;
+            }
+
+            if (index == 0)
+            {
+                return null;
+            }
+
+            return syntaxNode.Parent.ChildNodes().ElementAt(index - 1);
+        }
+
+        /// <summary>
+        /// 获取与该语法节点同层级的下一个节点
+        /// </summary>
+        public static SyntaxNode? NextNode(this SyntaxNode syntaxNode)
+        {
+            if (syntaxNode.Parent == null)
+            {
+                return null;
+            }
+
+            int index = 0;
+
+            foreach (var childNode in syntaxNode.Parent.ChildNodes())
+            {
+                if (childNode == syntaxNode)
+                {
+                    break;
+                }
+
+                index++;
+            }
+
+            if (index == syntaxNode.Parent.ChildNodes().Count() - 1)
+            {
+                return null;
+            }
+
+            return syntaxNode.Parent.ChildNodes().ElementAt(index + 1);
+        }
+
+        /// <summary>
+        /// 获取await表达式所在的控制流block
+        /// </summary>
+        public static BasicBlock? GetAwaitStatementControlFlowBlock(StatementSyntax statementSyntax, AwaitExpressionSyntax awaitExpressionSyntax, SemanticModel semanticModel)
+        {
+            // 跳过 return 表达式
+            if (statementSyntax.IsKind(SyntaxKind.ReturnStatement))
+            {
+                return null;
+            }
+
+            var methodSyntax = statementSyntax.GetNeareastAncestor<MethodDeclarationSyntax>();
+            if (methodSyntax == null)
+            {
+                return null;
+            }
+
+            // 构建表达式所在函数的控制流图
+            var controlFlowGraph = ControlFlowGraph.Create(methodSyntax, semanticModel);
+
+            if (controlFlowGraph == null)
+            {
+                return null;
+            }
+
+            if (statementSyntax is LocalDeclarationStatementSyntax)
+            {
+                return null;
+            }
+
+            BasicBlock? block = controlFlowGraph.Blocks.FirstOrDefault(x => x.Operations.Any(y => y.Syntax.Contains(statementSyntax)));
+            return block;
+        }
+
+        /// <summary>
+        /// 判断类是否为partial类
+        /// </summary>
+        public static bool IsPartial(this ClassDeclarationSyntax classDeclaration)
+        {
+            foreach (var modifier in classDeclaration.Modifiers)
+            {
+                if (modifier.IsKind(SyntaxKind.PartialKeyword))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static string? GetNameSpace(this INamedTypeSymbol namedTypeSymbol)
+        {
+            INamespaceSymbol? namespaceSymbol = namedTypeSymbol.ContainingNamespace;
+            string? namespaceName = namespaceSymbol?.Name;
+            while (namespaceSymbol?.ContainingNamespace != null)
+            {
+                namespaceSymbol = namespaceSymbol.ContainingNamespace;
+                if (string.IsNullOrEmpty(namespaceSymbol.Name))
+                {
+                    break;
+                }
+
+                namespaceName = $"{namespaceSymbol.Name}.{namespaceName}";
+            }
+
+            if (string.IsNullOrEmpty(namespaceName))
+            {
+                return null;
+            }
+
+            return namespaceName;
+        }
+
+        /// <summary>
+        /// 根据语义模型的文件路径 判断是否需要分析
+        /// </summary>
+        public static bool IsSemanticModelNeedAnalyze(SemanticModel semanticModel, params string[] filePaths)
+        {
+            foreach (var filePath in filePaths)
+            {
+                if (semanticModel.SyntaxTree.FilePath.Contains(filePath))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 类型symbol是否有指定名字 指定参数的方法
+        /// </summary>
+        public static bool HasMethodWithParams(this INamedTypeSymbol namedTypeSymbol, string methodName, params ITypeSymbol[] typeSymbols)
+        {
+            foreach (var member in namedTypeSymbol.GetMembers())
+            {
+                if (member is not IMethodSymbol methodSymbol)
+                {
+                    continue;
+                }
+
+                if (methodSymbol.Name != methodName)
+                {
+                    continue;
+                }
+
+                if (typeSymbols.Length != methodSymbol.Parameters.Length)
+                {
+                    continue;
+                }
+
+                if (typeSymbols.Length == 0)
+                {
+                    return true;
+                }
+
+                bool isEqual = true;
+
+                for (int i = 0; i < typeSymbols.Length; i++)
+                {
+                    if (typeSymbols[i].ToString() != methodSymbol.Parameters[i].Type.ToString())
+                    {
+                        isEqual = false;
+                        break;
+                    }
+                }
+
+                if (isEqual)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 类型symbol是否有指定名字 指定参数的方法
+        /// </summary>
+        public static bool HasMethodWithParams(this INamedTypeSymbol namedTypeSymbol, string methodName, params string[] typeSymbols)
+        {
+            foreach (var member in namedTypeSymbol.GetMembers())
+            {
+                if (member is not IMethodSymbol methodSymbol)
+                {
+                    continue;
+                }
+
+                if (methodSymbol.Name != methodName)
+                {
+                    continue;
+                }
+
+                if (typeSymbols.Length != methodSymbol.Parameters.Length)
+                {
+                    continue;
+                }
+
+                if (typeSymbols.Length == 0)
+                {
+                    return true;
+                }
+
+                bool isEqual = true;
+
+                for (int i = 0; i < typeSymbols.Length; i++)
+                {
+                    if (typeSymbols[i] != methodSymbol.Parameters[i].Type.ToString())
+                    {
+                        isEqual = false;
+                        break;
+                    }
+                }
+
+                if (isEqual)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+
+        /// <summary>
+        /// 方法symbol 是否有指定的attribute
+        /// </summary>
+        public static bool HasAttribute(this IMethodSymbol methodSymbol, string AttributeName)
+        {
+            foreach (AttributeData? attributeData in methodSymbol.GetAttributes())
+            {
+                if (attributeData?.AttributeClass?.ToString() == AttributeName)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

Tools/GameEventSourceGenerator/SourceGenerator.sln

@@ -0,0 +1,41 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.002.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SourceGenerator", "SourceGenerator\SourceGenerator.csproj", "{26B3F75F-AB7F-48F8-B234-F5A26E8CA319}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{57F17CC8-F26D-496E-B8E9-2601F9FF3CE5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{57F17CC8-F26D-496E-B8E9-2601F9FF3CE5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{57F17CC8-F26D-496E-B8E9-2601F9FF3CE5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{57F17CC8-F26D-496E-B8E9-2601F9FF3CE5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{26B3F75F-AB7F-48F8-B234-F5A26E8CA319}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{26B3F75F-AB7F-48F8-B234-F5A26E8CA319}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{26B3F75F-AB7F-48F8-B234-F5A26E8CA319}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{26B3F75F-AB7F-48F8-B234-F5A26E8CA319}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F02E4A8C-07E7-4C7F-B30A-3D5BE1C7CB98}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F02E4A8C-07E7-4C7F-B30A-3D5BE1C7CB98}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F02E4A8C-07E7-4C7F-B30A-3D5BE1C7CB98}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F02E4A8C-07E7-4C7F-B30A-3D5BE1C7CB98}.Release|Any CPU.Build.0 = Release|Any CPU
+		{23425ADC-1091-46A0-94BF-8EA6A7F5EFD7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{23425ADC-1091-46A0-94BF-8EA6A7F5EFD7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{23425ADC-1091-46A0-94BF-8EA6A7F5EFD7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{23425ADC-1091-46A0-94BF-8EA6A7F5EFD7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CA734AB9-F825-4DDA-BCB1-AD5FC464CAB0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CA734AB9-F825-4DDA-BCB1-AD5FC464CAB0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CA734AB9-F825-4DDA-BCB1-AD5FC464CAB0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CA734AB9-F825-4DDA-BCB1-AD5FC464CAB0}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {FCBB04E4-2793-4CF8-9278-E932D3B254AC}
+	EndGlobalSection
+EndGlobal

Tools/GameEventSourceGenerator/SourceGenerator/Definition.cs

@@ -0,0 +1,7 @@
+public class Definition
+{
+    public const string FrameworkNameSpace = "TEngine";
+    public const string NameSpace = "GameLogic";
+    public const string EventInterface = "EventInterface";
+    public const string StringToHash = "RuntimeId.ToRuntimeId";
+}

Tools/GameEventSourceGenerator/SourceGenerator/Generator/EventInterfaceGenerator.cs

@@ -0,0 +1,192 @@
+using Microsoft.CodeAnalysis;  
+using Microsoft.CodeAnalysis.CSharp;  
+using Microsoft.CodeAnalysis.CSharp.Syntax;  
+using System.Collections.Generic;  
+using System.Linq;  
+using System.Text;
+using Analyzer;
+
+[Generator]  
+public class EventInterfaceGenerator : ISourceGenerator  
+{  
+    public void Initialize(GeneratorInitializationContext context)  
+    {  
+        // 可以在这里进行初始化  
+    }  
+
+    public void Execute(GeneratorExecutionContext context)  
+    {  
+        // 获取当前语法树  
+        var syntaxTrees = context.Compilation.SyntaxTrees;  
+        
+        List<string> classNameList = new List<string>();
+
+        foreach (var tree in syntaxTrees)  
+        {  
+            var root = tree.GetRoot();  
+            var interfaces = root.DescendantNodes()  
+                .OfType<InterfaceDeclarationSyntax>()  
+                .Where(i => i.AttributeLists.Count > 0 &&   
+                            i.AttributeLists  
+                             .Any(a => a.Attributes  
+                             .Any(attr => attr.Name.ToString() == $"{Definition.EventInterface}")));  
+           
+            foreach (var interfaceNode in interfaces)  
+            {  
+                var interfaceName = interfaceNode.Identifier.ToString();  
+                var fullName = interfaceNode.SyntaxTree.GetRoot()
+                    .DescendantNodes()
+                    .OfType<NamespaceDeclarationSyntax>()
+                    .Select(ns => ns.Name.ToString())
+                    .Concat(new[] { interfaceName })
+                    .Aggregate((a, b) => a + "." + b);
+                var eventClassName = $"{interfaceName}_Event";  
+                var eventClassCode = GenerateEventClass(interfaceName, eventClassName, interfaceNode);  
+
+                context.AddSource($"{eventClassName}.g.cs", eventClassCode);  
+
+                // 生成实现类  
+                var implementationClassCode = GenerateImplementationClass(fullName, interfaceName, interfaceNode,context);  
+                context.AddSource($"{interfaceName}_Gen.g.cs", implementationClassCode);  
+                
+                
+                classNameList.Add($"{interfaceName}_Gen");
+            }  
+        }  
+        
+        string uniqueFileName = $"GameEventHelper.g.cs";
+        context.AddSource(uniqueFileName, GenerateGameEventHelper(classNameList));
+    }  
+    
+    private string GenerateGameEventHelper(List<string> classNameList)
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine($"//------------------------------------------------------------------------------");
+        sb.AppendLine($"//  <auto-generated>");
+        sb.AppendLine($"//     This code was generated by autoBindTool.");
+        sb.AppendLine($"//     Changes to this file may cause incorrect behavior and will be lost if");
+        sb.AppendLine($"//     the code is regenerated.");
+        sb.AppendLine($"//  </auto-generated>");
+        sb.AppendLine($"//------------------------------------------------------------------------------");
+        sb.AppendLine();
+        sb.AppendLine($"using UnityEngine;");
+        sb.AppendLine($"using UnityEngine.UI;");
+        sb.AppendLine($"using {Definition.FrameworkNameSpace};");
+        sb.AppendLine();
+        sb.AppendLine($"namespace {Definition.NameSpace}");
+        sb.AppendLine($"{{");
+        sb.AppendLine($"    public static class GameEventHelper");
+        sb.AppendLine("    {");
+        sb.AppendLine($"        public static void Init()");
+        sb.AppendLine("        {");
+
+        foreach (var className in classNameList)
+        {
+            sb.AppendLine($"            var m_{className} = new {className}(GameEvent.EventMgr.GetDispatcher());");
+        }
+
+        sb.AppendLine("        }");
+
+
+        sb.AppendLine("    }");
+        sb.AppendLine("}");
+        return sb.ToString();
+    }
+
+    private string GenerateEventClass(string interfaceName, string className, InterfaceDeclarationSyntax interfaceNode)  
+    {  
+        var methods = interfaceNode.Members.OfType<MethodDeclarationSyntax>();  
+        var sb = new StringBuilder();  
+
+        sb.AppendLine($"//------------------------------------------------------------------------------");  
+        sb.AppendLine($"//	<auto-generated>");  
+        sb.AppendLine($"//		This code was generated by autoBindTool.");  
+        sb.AppendLine($"//		Changes to this file may cause incorrect behavior and will be lost if");  
+        sb.AppendLine($"//		the code is regenerated.");  
+        sb.AppendLine($"//	</auto-generated>");  
+        sb.AppendLine($"//------------------------------------------------------------------------------");  
+        sb.AppendLine();  
+        sb.AppendLine($"using UnityEngine;");  
+        sb.AppendLine($"using UnityEngine.UI;");  
+        sb.AppendLine($"using {Definition.FrameworkNameSpace};");  
+        sb.AppendLine();  
+        sb.AppendLine($"namespace {Definition.NameSpace}");  
+        sb.AppendLine("{");  
+        sb.AppendLine($"    public partial class {className}");  
+        sb.AppendLine("    {");  
+
+        foreach (var method in methods)  
+        {  
+            var methodName = method.Identifier.ToString();  
+            var parameters = string.Join(", ", method.ParameterList.Parameters.Select(p => $"{p.Type} {p.Identifier}"));  
+            sb.AppendLine($"        public static readonly int {methodName} = {Definition.StringToHash}(\"{className}.{methodName}\");");  
+        }  
+
+        sb.AppendLine("    }");  
+        sb.AppendLine("}");  
+        return sb.ToString();  
+    }  
+
+    private string GenerateImplementationClass(string interfaceFullName, string interfaceName, InterfaceDeclarationSyntax interfaceNode,GeneratorExecutionContext context)  
+    {  
+        var semanticModel = context.Compilation.GetSemanticModel(interfaceNode.SyntaxTree);
+        var sb = new StringBuilder();  
+
+        sb.AppendLine($"//------------------------------------------------------------------------------");  
+        sb.AppendLine($"//	<auto-generated>");  
+        sb.AppendLine($"//		This code was generated by autoBindTool.");  
+        sb.AppendLine($"//		Changes to this file may cause incorrect behavior and will be lost if");  
+        sb.AppendLine($"//		the code is regenerated.");  
+        sb.AppendLine($"//	</auto-generated>");  
+        sb.AppendLine($"//------------------------------------------------------------------------------");  
+        sb.AppendLine();  
+        sb.AppendLine($"using UnityEngine;");  
+        sb.AppendLine($"using UnityEngine.UI;");  
+        sb.AppendLine($"using {Definition.FrameworkNameSpace};");  
+        sb.AppendLine();  
+        sb.AppendLine($"namespace {Definition.NameSpace}");  
+        sb.AppendLine($"{{");  
+        sb.AppendLine($"    public partial class {interfaceName}_Gen : {interfaceName}");  
+        sb.AppendLine("    {");  
+        sb.AppendLine("        private EventDispatcher _dispatcher;");  
+        sb.AppendLine($"        public {interfaceName}_Gen(EventDispatcher dispatcher)");  
+        sb.AppendLine("        {");  
+        sb.AppendLine("            _dispatcher = dispatcher;");  
+        sb.AppendLine($"             GameEvent.EventMgr.RegWrapInterface(\"{interfaceFullName}\", this);");
+        sb.AppendLine("        }");  
+
+        foreach (var method in interfaceNode.Members.OfType<MethodDeclarationSyntax>())  
+        {  
+            var methodName = method.Identifier.ToString();  
+            var parameters = GenerateParameters(method, semanticModel);
+
+            sb.AppendLine($"        public void {methodName}({parameters})");  
+            sb.AppendLine("        {");  
+            if (method.ParameterList.Parameters.Count > 0)  
+            {  
+                var paramNames = string.Join(", ", method.ParameterList.Parameters.Select(p => p.Identifier.ToString()));  
+                sb.AppendLine($"            _dispatcher.Send({interfaceName}_Event.{methodName}, {paramNames});");  
+            }  
+            else  
+            {  
+                sb.AppendLine($"            _dispatcher.Send({interfaceName}_Event.{methodName});");  
+            }  
+            sb.AppendLine("        }");  
+        }  
+
+        sb.AppendLine("    }");  
+        sb.AppendLine("}");  
+        return sb.ToString();  
+    }  
+
+    private string GenerateParameters(MethodDeclarationSyntax method, SemanticModel semanticModel)
+    {
+        return string.Join(", ", method.ParameterList.Parameters.Select(p => 
+        {
+            var typeSymbol = semanticModel.GetTypeInfo(p.Type).Type;
+            return typeSymbol != null 
+                ? $"{typeSymbol.ToDisplayString()} {p.Identifier}"
+                : $"{p.Type} {p.Identifier}";
+        }));
+    }
+}

Tools/GameEventSourceGenerator/SourceGenerator/SourceGenerator.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <IncludeBuildOutput>false</IncludeBuildOutput>
+        <Nullable>enable</Nullable>
+        <LangVersion>12</LangVersion>
+        <IncludeBuildOutput>false</IncludeBuildOutput>
+        <DevelopmentDependency>true</DevelopmentDependency>
+        <IncludeSymbols>false</IncludeSymbols>
+        <NoWarn>1701;1702;RS2008</NoWarn>
+        <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+        <SatelliteResourceLanguages>en</SatelliteResourceLanguages>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Compile Include="../Analyzer/Extension/*.cs">
+            <Link>Extension\%(RecursiveDir)%(FileName)%(Extension)</Link>
+        </Compile>
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.9.0" PrivateAssets="all" />
+        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+
+<!--    <Target Name="PostBuild" AfterTargets="PostBuildEvent">-->
+<!--        <Copy SourceFiles="$(TargetDir)/$(TargetName).dll" DestinationFolder="$(ProjectDir)/../../Unity/Assets/Plugins/" ContinueOnError="false" />-->
+<!--    </Target>-->
+
+</Project>

Tools/GameEventSourceGenerator/SourceGenerator/bin/Debug/SourceGenerator.deps.json

@@ -0,0 +1,236 @@
+{
+  "runtimeTarget": {
+    "name": ".NETStandard,Version=v2.0/",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETStandard,Version=v2.0": {},
+    ".NETStandard,Version=v2.0/": {
+      "SourceGenerator/1.0.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.3.3",
+          "Microsoft.CodeAnalysis.CSharp": "3.9.0",
+          "NETStandard.Library": "2.0.3"
+        },
+        "runtime": {
+          "SourceGenerator.dll": {}
+        }
+      },
+      "Microsoft.CodeAnalysis.Analyzers/3.3.3": {},
+      "Microsoft.CodeAnalysis.Common/3.9.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.3.3",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Memory": "4.5.4",
+          "System.Reflection.Metadata": "5.0.0",
+          "System.Runtime.CompilerServices.Unsafe": "5.0.0",
+          "System.Text.Encoding.CodePages": "4.5.1",
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.CodeAnalysis.dll": {
+            "assemblyVersion": "3.9.0.0",
+            "fileVersion": "3.900.21.12420"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.CSharp/3.9.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Common": "3.9.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.CodeAnalysis.CSharp.dll": {
+            "assemblyVersion": "3.9.0.0",
+            "fileVersion": "3.900.21.12420"
+          }
+        }
+      },
+      "Microsoft.NETCore.Platforms/1.1.0": {},
+      "NETStandard.Library/2.0.3": {
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "1.1.0"
+        }
+      },
+      "System.Buffers/4.5.1": {
+        "runtime": {
+          "lib/netstandard2.0/System.Buffers.dll": {
+            "assemblyVersion": "4.0.3.0",
+            "fileVersion": "4.6.28619.1"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {
+        "dependencies": {
+          "System.Memory": "4.5.4"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Collections.Immutable.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "System.Memory/4.5.4": {
+        "dependencies": {
+          "System.Buffers": "4.5.1",
+          "System.Numerics.Vectors": "4.4.0",
+          "System.Runtime.CompilerServices.Unsafe": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Memory.dll": {
+            "assemblyVersion": "4.0.1.1",
+            "fileVersion": "4.6.28619.1"
+          }
+        }
+      },
+      "System.Numerics.Vectors/4.4.0": {
+        "runtime": {
+          "lib/netstandard2.0/System.Numerics.Vectors.dll": {
+            "assemblyVersion": "4.1.3.0",
+            "fileVersion": "4.6.25519.3"
+          }
+        }
+      },
+      "System.Reflection.Metadata/5.0.0": {
+        "dependencies": {
+          "System.Collections.Immutable": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Reflection.Metadata.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "System.Runtime.CompilerServices.Unsafe/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "System.Text.Encoding.CodePages/4.5.1": {
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Text.Encoding.CodePages.dll": {
+            "assemblyVersion": "4.1.1.0",
+            "fileVersion": "4.6.27129.4"
+          }
+        }
+      },
+      "System.Threading.Tasks.Extensions/4.5.4": {
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Threading.Tasks.Extensions.dll": {
+            "assemblyVersion": "4.2.0.1",
+            "fileVersion": "4.6.28619.1"
+          }
+        }
+      }
+    }
+  },
+  "libraries": {
+    "SourceGenerator/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Microsoft.CodeAnalysis.Analyzers/3.3.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-j/rOZtLMVJjrfLRlAMckJLPW/1rze9MT1yfWqSIbUPGRu1m1P0fuo9PmqapwsmePfGB5PJrudQLvmUOAMF0DqQ==",
+      "path": "microsoft.codeanalysis.analyzers/3.3.3",
+      "hashPath": "microsoft.codeanalysis.analyzers.3.3.3.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.Common/3.9.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-HiWjF7PNIEngmFg2Xk8cZ/83lRIRkk9v+5ibbY5B7VvjNGdClGAMuWtZER9F5rGRR41VbJLco9ah73jFTh4vPw==",
+      "path": "microsoft.codeanalysis.common/3.9.0",
+      "hashPath": "microsoft.codeanalysis.common.3.9.0.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.CSharp/3.9.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-NTsiK3fnoZGemy4dBHrILwg9rL+jDnOJ7aixFu4EOWM1r6MZMrNCIhT2tO4AmIMdfICLPwj910uZRRLpbMnqHg==",
+      "path": "microsoft.codeanalysis.csharp/3.9.0",
+      "hashPath": "microsoft.codeanalysis.csharp.3.9.0.nupkg.sha512"
+    },
+    "Microsoft.NETCore.Platforms/1.1.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==",
+      "path": "microsoft.netcore.platforms/1.1.0",
+      "hashPath": "microsoft.netcore.platforms.1.1.0.nupkg.sha512"
+    },
+    "NETStandard.Library/2.0.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
+      "path": "netstandard.library/2.0.3",
+      "hashPath": "netstandard.library.2.0.3.nupkg.sha512"
+    },
+    "System.Buffers/4.5.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg==",
+      "path": "system.buffers/4.5.1",
+      "hashPath": "system.buffers.4.5.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.Memory/4.5.4": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-1MbJTHS1lZ4bS4FmsJjnuGJOu88ZzTT2rLvrhW7Ygic+pC0NWA+3hgAen0HRdsocuQXCkUTdFn9yHJJhsijDXw==",
+      "path": "system.memory/4.5.4",
+      "hashPath": "system.memory.4.5.4.nupkg.sha512"
+    },
+    "System.Numerics.Vectors/4.4.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-UiLzLW+Lw6HLed1Hcg+8jSRttrbuXv7DANVj0DkL9g6EnnzbL75EB7EWsw5uRbhxd/4YdG8li5XizGWepmG3PQ==",
+      "path": "system.numerics.vectors/4.4.0",
+      "hashPath": "system.numerics.vectors.4.4.0.nupkg.sha512"
+    },
+    "System.Reflection.Metadata/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-5NecZgXktdGg34rh1OenY1rFNDCI8xSjFr+Z4OU4cU06AQHUdRnIIEeWENu3Wl4YowbzkymAIMvi3WyK9U53pQ==",
+      "path": "system.reflection.metadata/5.0.0",
+      "hashPath": "system.reflection.metadata.5.0.0.nupkg.sha512"
+    },
+    "System.Runtime.CompilerServices.Unsafe/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ZD9TMpsmYJLrxbbmdvhwt9YEgG5WntEnZ/d1eH8JBX9LBp+Ju8BSBhUGbZMNVHHomWo2KVImJhTDl2hIgw/6MA==",
+      "path": "system.runtime.compilerservices.unsafe/5.0.0",
+      "hashPath": "system.runtime.compilerservices.unsafe.5.0.0.nupkg.sha512"
+    },
+    "System.Text.Encoding.CodePages/4.5.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-4J2JQXbftjPMppIHJ7IC+VXQ9XfEagN92vZZNoG12i+zReYlim5dMoXFC1Zzg7tsnKDM7JPo5bYfFK4Jheq44w==",
+      "path": "system.text.encoding.codepages/4.5.1",
+      "hashPath": "system.text.encoding.codepages.4.5.1.nupkg.sha512"
+    },
+    "System.Threading.Tasks.Extensions/4.5.4": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==",
+      "path": "system.threading.tasks.extensions/4.5.4",
+      "hashPath": "system.threading.tasks.extensions.4.5.4.nupkg.sha512"
+    }
+  }
+}

Tools/GameEventSourceGenerator/SourceGenerator/obj/Debug/.NETStandard,Version=v2.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]

Tools/GameEventSourceGenerator/SourceGenerator/obj/Debug/SourceGenerator.AssemblyInfo.cs

@@ -0,0 +1,22 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("SourceGenerator")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+b7d75c0f6f518a5f2ca0ed9304411302709f8dbe")]
+[assembly: System.Reflection.AssemblyProductAttribute("SourceGenerator")]
+[assembly: System.Reflection.AssemblyTitleAttribute("SourceGenerator")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// 由 MSBuild WriteCodeFragment 类生成。
+

Tools/GameEventSourceGenerator/SourceGenerator/obj/Debug/SourceGenerator.AssemblyInfoInputs.cache

@@ -0,0 +1 @@
+1f4b8d9919850399efa15c732e9aadbc83f7ae6889745a83831d20da225de402

Tools/GameEventSourceGenerator/SourceGenerator/obj/Debug/SourceGenerator.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,12 @@
+is_global = true
+build_property.TargetFramework = netstandard2.0
+build_property.TargetPlatformMinVersion = 7.0
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = SourceGenerator
+build_property.ProjectDir = E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 

Tools/GameEventSourceGenerator/SourceGenerator/obj/Debug/SourceGenerator.csproj.CoreCompileInputs.cache

@@ -0,0 +1 @@
+ff752c9a870df6aafb4669266bbcfd2f80f90bfd76a1bae882d02d67457c3ec4

Tools/GameEventSourceGenerator/SourceGenerator/obj/Debug/SourceGenerator.csproj.FileListAbsolute.txt

@@ -0,0 +1,32 @@
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.deps.json
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.dll
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.pdb
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.csproj.AssemblyReference.cache
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.GeneratedMSBuildEditorConfig.editorconfig
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.AssemblyInfoInputs.cache
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.AssemblyInfo.cs
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.csproj.CoreCompileInputs.cache
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.sourcelink.json
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.dll
+G:\github\TEngine\Tools\SourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.pdb
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.csproj.AssemblyReference.cache
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.GeneratedMSBuildEditorConfig.editorconfig
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.AssemblyInfoInputs.cache
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.AssemblyInfo.cs
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.csproj.CoreCompileInputs.cache
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.dll
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.pdb
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.deps.json
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.dll
+C:\Users\Admin\Downloads\GameEventSourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.pdb
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.deps.json
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.dll
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\bin\Debug\SourceGenerator.pdb
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.csproj.AssemblyReference.cache
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.GeneratedMSBuildEditorConfig.editorconfig
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.AssemblyInfoInputs.cache
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.AssemblyInfo.cs
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.csproj.CoreCompileInputs.cache
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.sourcelink.json
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.dll
+E:\WorkSpace\ZGame\Tools\GameEventSourceGenerator\SourceGenerator\obj\Debug\SourceGenerator.pdb

Tools/GameEventSourceGenerator/SourceGenerator/obj/Debug/SourceGenerator.sourcelink.json

@@ -0,0 +1 @@
+{"documents":{"E:\\WorkSpace\\ZGame\\*":"https://raw.githubusercontent.com/Alex-Rachel/ZGame/b7d75c0f6f518a5f2ca0ed9304411302709f8dbe/*"}}

Tools/GameEventSourceGenerator/SourceGenerator/obj/SourceGenerator.csproj.nuget.dgspec.json

@@ -0,0 +1,82 @@
+{
+  "format": 1,
+  "restore": {
+    "E:\\WorkSpace\\ZGame\\Tools\\GameEventSourceGenerator\\SourceGenerator\\SourceGenerator.csproj": {}
+  },
+  "projects": {
+    "E:\\WorkSpace\\ZGame\\Tools\\GameEventSourceGenerator\\SourceGenerator\\SourceGenerator.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "E:\\WorkSpace\\ZGame\\Tools\\GameEventSourceGenerator\\SourceGenerator\\SourceGenerator.csproj",
+        "projectName": "SourceGenerator",
+        "projectPath": "E:\\WorkSpace\\ZGame\\Tools\\GameEventSourceGenerator\\SourceGenerator\\SourceGenerator.csproj",
+        "packagesPath": "C:\\Users\\Admin\\.nuget\\packages\\",
+        "outputPath": "E:\\WorkSpace\\ZGame\\Tools\\GameEventSourceGenerator\\SourceGenerator\\obj\\",
+        "projectStyle": "PackageReference",
+        "configFilePaths": [
+          "C:\\Users\\Admin\\AppData\\Roaming\\NuGet\\NuGet.Config",
+          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+        ],
+        "originalTargetFrameworks": [
+          "netstandard2.0"
+        ],
+        "sources": {
+          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "netstandard2.0": {
+            "targetAlias": "netstandard2.0",
+            "projectReferences": {}
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        },
+        "restoreAuditProperties": {
+          "enableAudit": "true",
+          "auditLevel": "low",
+          "auditMode": "direct"
+        }
+      },
+      "frameworks": {
+        "netstandard2.0": {
+          "targetAlias": "netstandard2.0",
+          "dependencies": {
+            "Microsoft.CodeAnalysis.Analyzers": {
+              "include": "Runtime, Build, Native, ContentFiles, Analyzers, BuildTransitive",
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[3.3.3, )"
+            },
+            "Microsoft.CodeAnalysis.CSharp": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[3.9.0, )"
+            },
+            "NETStandard.Library": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[2.0.3, )",
+              "autoReferenced": true
+            }
+          },
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48",
+            "net481"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\8.0.300\\RuntimeIdentifierGraph.json"
+        }
+      }
+    }
+  }
+}

Tools/GameEventSourceGenerator/SourceGenerator/obj/SourceGenerator.csproj.nuget.g.props

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
+    <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
+    <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
+    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
+    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">C:\Users\Admin\.nuget\packages\</NuGetPackageFolders>
+    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
+    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">6.12.2</NuGetToolVersion>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <SourceRoot Include="C:\Users\Admin\.nuget\packages\" />
+  </ItemGroup>
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)microsoft.codeanalysis.analyzers\3.3.3\build\Microsoft.CodeAnalysis.Analyzers.props" Condition="Exists('$(NuGetPackageRoot)microsoft.codeanalysis.analyzers\3.3.3\build\Microsoft.CodeAnalysis.Analyzers.props')" />
+  </ImportGroup>
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <PkgMicrosoft_CodeAnalysis_Analyzers Condition=" '$(PkgMicrosoft_CodeAnalysis_Analyzers)' == '' ">C:\Users\Admin\.nuget\packages\microsoft.codeanalysis.analyzers\3.3.3</PkgMicrosoft_CodeAnalysis_Analyzers>
+  </PropertyGroup>
+</Project>

Tools/GameEventSourceGenerator/SourceGenerator/obj/SourceGenerator.csproj.nuget.g.targets

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)netstandard.library\2.0.3\build\netstandard2.0\NETStandard.Library.targets" Condition="Exists('$(NuGetPackageRoot)netstandard.library\2.0.3\build\netstandard2.0\NETStandard.Library.targets')" />
+    <Import Project="$(NuGetPackageRoot)microsoft.codeanalysis.analyzers\3.3.3\build\Microsoft.CodeAnalysis.Analyzers.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.codeanalysis.analyzers\3.3.3\build\Microsoft.CodeAnalysis.Analyzers.targets')" />
+  </ImportGroup>
+</Project>