【游戏开发高阶】从零到一教你Unity使用ToLua实现热更新（含Demo工程 | LuaFramework | 增量 | HotUpdate）

川长思鸟来 2022-09-03 13:15 34阅读 0赞

### 文章目录 ###

*   *   *  零、前言
         *  一、我做的热更新Demo
         *   *  1、效果演示
             *  2、流程图
             *  3、工程源码
         *  二、为什么要有热更新
         *  三、Unity如何支持热更新
         *   *  1、热更C\#代码
             *  2、热更lua代码与资源
         *  四、Unity中集成tolua框架: LuaFramewrk
         *   *  1、下载tolua框架: LuaFramewrk
             *  2、打开tolua框架项目：LuaFramework\_UGUI
             *  3、生成注册文件：生成Wrap类
             *  4、Generate All菜单
             *  5、解决报错问题
             *   *  5.1、GetElementType()为空报错
                 *  5.2、UnityEngine\_ParticleSystemWrap报错
                 *  5.3、特定的Wrap移动到BaseType中
                 *  5.4、LightWrap和MeshRendererWrap报错
         *  五、tolua框架的工作流程
         *   *  1、Main.cs：入口脚本
             *  2、StartUp：启动游戏框架
             *  3、LuaManager：Lua管理器
             *   *  3.1、LuaState：lua虚拟机
                 *  3.2、LuaLoader：lua文件加载器
                 *  3.3、LuaLooper：lua生命周期控制
             *  4、GameManager：游戏管理器
             *   *  4.1、释放资源
                 *  4.2、更新资源
                 *  4.3、执行lua代码
                 *  4.4、lua业务代码的结构
         *  六、我的热更Demo的一些介绍说明
         *   *  1、Web服务器
             *  2、代码结构：Scripts目录
             *  3、资源目录结构：RawAssets目录、GameRes目录
             *  4、资源配置：resources.bytes、ResourcesCfg.cs
             *  5、资源管理器：ResourceMgr.cs
             *  6、界面管理器：PanelMgr.cs、BasePanel.cs
             *  7、热更新逻辑：HotUpdater.cs
             *  8、下载器：Downloader.cs
             *  9、文件解压和压缩
             *  10、AES对称加密解密
             *  11、打整包
             *  12、打热更包
         *  七、完毕

### 零、前言 ###

嗨，大家好，我是新发。  
有同学私信我，问我能不能写一篇关于`ToLua`热更新的教程。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70]  
今天，我就来好好讲讲，内容会比较长，建议大家收藏后慢慢看。

### 一、我做的热更新Demo ###

我花了一些时间做了一个`Demo`，采用的是`Unity + tolua`，实现完整的热更流程，包括版本管理、资源打包、资源加载、`lua`代码加密解密、热更包下载、断点续传等功能。

#### 1、效果演示 ####

效果如下，下载多个增量包：  
![请添加图片描述][432dc12d06e043a3afee960827629643.gif]  
跳过大版本更新：  
![请添加图片描述][f1fce415ed91437bbf87c5eb2e1a99ea.gif]  
断点续传：  
![请添加图片描述][f52f0de5fa8f4415b975f477e6b54083.gif]

#### 2、流程图 ####

对应的流程图如下（图片可放大）：  
![请添加图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 1]  
首先是版本管理器，记录当前的最新版本；  
启动时显示更新界面，这里就涉及到界面资源的加载，我封装了资源管理器和界面管理器，资源管理器优先从热更目录（`persistentDataPath`的`update`）中查找资源，如果找不到才去包内的`StreamingAssets`目录找资源；  
接着执行热更逻辑，先去`Web`服务器请求更新列表，判断版本号，是整包更新还是增量更新，是否是强制更新；  
根据更新列表执行下载，这里我使用独立线程下载，这样不会卡住`UI`主线程的进度更新显示；  
下载过程支持断点续传，这样可以避免下载过程中网络断开或强杀进程后需要从头开始下载；  
下载完增量包后校验`MD5`是否正确，如果`MD5`不正确则重新下载；  
校验`MD5`正确后解压到`persistentDataPath`的`update`目录中；  
启动`lua`框架前，先预加载`lua`的`bundle`：`lua.bundle`和`lua_update.bundle`；  
最后启动`lua`框架，显示登录界面。

另外，我单独写一套简单的打包工具，方便打`AssetBundle`、`APP`整包和增量包，  
打`APP`整包之前会先生成一份原始的`lua`文件的`MD5`列表，打`lua`、配置、资源等的`AssetBundle`，最终才生成`APP`整包；  
另外，打包`lua`时我先对`lua`做了加密，这样可以防止被别人直接拿到`lua`明文文件。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 2]

#### 3、工程源码 ####

我的热更新`Demo`工程以上传到`CODE CHINA`，地址：[https://codechina.csdn.net/linxinfa/UnityHotUpdateFramework][https_codechina.csdn.net_linxinfa_UnityHotUpdateFramework]  
感兴趣的同学可自行下载下来学习，另外，我使用的`Unity`版本为`2021.1.7f1c1`，如果你使用的版本与我的不同，可能打开工程会报错。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 3]

关于我这个`Demo`的一些介绍说明，可以跳到文章第六节，接下来，我先花一点篇幅讲讲热更新和`tolua`框架。

### 二、为什么要有热更新 ###

关于为什么要有热更新，我简单啰嗦几句。  
假设你开发了一个游戏，上架到应用市场，之后用户反馈了一个严重`BUG`，你紧急修复后，需要重新打包`APP`，重新提审应用市场，经过焦急地等待，终于过审了，接着玩家需要重新下载`APP`，重新安装。整个流程可想而知，无法做到快速高效，而且一旦需要重新下载和安装，用户很可能就流失了。  
所以我们需要有一种可以不重新安装`APP`就可以修复`BUG`的方式，那就是热更新，我们一般也叫增量更新。  
事实上，热更新不仅仅应用于修复`BUG`，也经常用于线上的小版本迭代。实际的游戏项目开发节奏是很快的，一般分为大版本迭代和小版本迭代。大版本会设计比较多的开发内容，周期长，一般在两周到一个月左右；然而在同类游戏竞品的激烈竞争下，你不得不小步快跑地迭代新内容，持续给玩家新的游戏内容，拉高留存，提升活跃度。所以在大版本周期中，就会设计一些小版本迭代，以热更的方式把内容更新到线上版本，这样既不需要重新提审`APP`到应用商店，又不需要玩家重新下载`APP`和安装，一举多得。

### 三、Unity如何支持热更新 ###

热更新的内容包括代码和资源，代码有`C#`代码、`lua`代码，资源包括配置表、预设、音乐音效、动画、字体、图片、材质等等，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 4]

#### 1、热更C\#代码 ####

`Unity`默认的开发语言是`C#`，我们写的`C#`代码最终会被编译成`dll`由`Unity`引擎来加载。所以可以把部分`C#`代码编译成一个独立的`dll`，上传到`Web`服务器，启动游戏时从服务器下载`dll`文件，在运行时重新加载`dll`，通过这种方式来达到热更新的目的，不过这种方式被视为是危险操作，因为鬼知道你重新加载的`dll`的代码里是不是病毒，如果你的项目上架了应用市场，使用这种`dll`的热更操作，大概率会被应用市场视为违规操作而下架。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 5]

> 注：顺便说一下，如果你使用`IL2CPP`方式打包，则你的`C#`代码会被转成`C++`代码。

#### 2、热更lua代码与资源 ####

说到游戏的热更新，就不得不提`lua`，`lua`这门语言是运行时动态解释的，它没运行时就是一个普通的文本文件，我们可以把它看成是资源文件。所以`lua`代码热更和资源热更本质是一样的，一般都是打成`AssetBundle`放在`Web`服务器，客户端从`Web`服务器下载最新的`AssetBundle`到本地。

市面上的`lua`框架有很多，比如`tolua`、`xlua`、`ulua`、`slua`等等，本质都是在`Unity`环境里内嵌一个`lua`虚拟机（使用`c`语言实现的虚拟机），游戏运行时动态解析`lua`脚本并执行，所以我们就可以把一些逻辑用`lua`来实现，然后再通过`Web`服务器下载`lua`脚本（一般是`lua`源码做加密后再打成`AssetBundle`文件，或者是使用`luac`将`lua`源码编译成字节码然后再打成`AssetBundle`文件），从而实现热更的目的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 6]

### 四、Unity中集成tolua框架: LuaFramewrk ###

#### 1、下载tolua框架: LuaFramewrk ####

`tolua`的`GitHub`地址：[https://github.com/topameng/tolua][https_github.com_topameng_tolua]  
如果有同学无法访问`GitHub`，也可以通过`Code China`的镜像源来下载，  
地址：[https://codechina.csdn.net/mirrors/topameng/tolua][https_codechina.csdn.net_mirrors_topameng_tolua]  
我们可以看到它提供了两个版本的框架：`LuaFramework_NGUI`和`LuaFramework_UGUI`。  
我们下载`UGUI`版本的：[https://codechina.csdn.net/mirrors/jarjin/LuaFramework\_UGUI][https_codechina.csdn.net_mirrors_jarjin_LuaFramework_UGUI]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 7]

#### 2、打开tolua框架项目：LuaFramework\_UGUI ####

下载下来后，我们在`Unity Hub`中添加它，可以看到它是使用`Unity5`版本做的，我使用`Unity2021.1.7f1c1`版本打开它，  
![在这里插入图片描述][d32f0b4a2e9742d6a0de9194c0dc984f.png]  
可想而知，肯定会有一些兼容问题的报错，不要怕，我都帮你一一解决了，`Unity2021.1.7f1c1`版本的`LuaFramework_UGUI`我已上传到`CODE CHINA`，如果你也是使用`2021`版本的`Unity`，可以直接使用我的版本，地址：[https://codechina.csdn.net/linxinfa/LuaFramework\_UGUI\_2021][https_codechina.csdn.net_linxinfa_LuaFramework_UGUI_2021]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 8]  
不过，为了然你了解一些细节，我还是把我的解决过程写出来吧，  
我建议大家往下看我是如何解决这些报错问题的，这对于你理解LuaFramework的工作原理是有帮助的，授人以鱼不如授人以渔，你是要鱼还是渔呢？

潇洒地点击`确定`按钮，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 9]

#### 3、生成注册文件：生成Wrap类 ####

经过几分钟的载入等待，弹出了下面这个框，点击`确定`，它会将`Unity`常用的`C#`类生成`Wrap`类并注册到`lua`虚拟机中，这样我们就可以在`lua`中使用这些`c#`类了，  
![在这里插入图片描述][049dd14fe2b14f2da9363b242bb1407c.png]  
上面点击`确定`按钮，等效于点击菜单`Lua / Gen Lua Wrap Files`，所以如果你不小心点击了`取消`按钮，可以在菜单这里执行，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 10]  
生成`Wrap`成功后，我们可以在`Assets/LuaFramework/ToLua/Source/Generate`目录中看到很多`Wrap`类，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 11]  
自问：它是怎么知道要生成哪些类的`Wrap`类的呢？  
答案就在`CustomSettings.cs`脚本中，如果你打开`CustomSettings.cs`脚本，你可以看到很多`_GT(typeof(XXXXX))`，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 12]  
它就是根据这里来生成对应的`Wrap`类的，如果你想在`lua`中使用你自己写的类，则需要在这里加上`_GT`的调用，例：

_GT(typeof(MyClass)),

> 注：`GT`就是`Genrate Table`的意思，在`lua`中，类其实就是`table`

#### 4、Generate All菜单 ####

上面我们只是生成了`Wrap`类，事实上，还要生成`Lua Delegates`和`LuaBinder`，你可以在菜单中看到，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 13]  
生成的`Wrap`类需要在`LuaBinder`中注册到`lua`虚拟机中，生成的`lua`委托需要在`DelegateFactory`中注册到`lua`虚拟机中，当然，这些都是自动生成的，我们只需执行菜单即可。  
一般我们都是直接点击菜单`Lua / Generate All`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 14]  
它会做三件事情：  
1 根据`CustomSettings`中的`customDelegateList`，生成`lua`委托并在`DelegateFactory`中注册到`lua`虚拟机中；  
2 根据`CustomSettings`中的`customTypeList`，生成`Wrap`类；  
3 在`LuaBinder`中生成`Wrap`类的注册逻辑。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 15]

#### 5、解决报错问题 ####

##### 5.1、GetElementType()为空报错 #####

我们点击`Generate All`菜单后，报了如下错：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 16]  
定位到代码处：`ToLuaExport.cs`第`295`行，`GetElementType()`可能返回空，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 17]  
我们加上判空，这是`ToLuaExport.cs`工具的问题，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 18]

##### 5.2、UnityEngine\_ParticleSystemWrap报错 #####

重新点击`Generate All`菜单，报了新的错，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 19]  
定位到代码处：`UnityEngine_ParticleSystemWrap.cs`脚本，可以看到是生成的`Wrap`类的`ParticleSystem`的`SetParticles`的异参重载函数的生成有问题，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 20]  
事实上，这个`SetParticles`这个方法我们基本不用在`lua`代码中使用到，所以简单粗暴把它注释掉就可以了，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 21]  
同理，解决掉`UnityEngine_ParticleSystemWrap`类的同类报错。

##### 5.3、特定的Wrap移动到BaseType中 #####

问题来了，因为`Wrap`是工具生成的，上面我们这样修改`Wrap`类，下次重新生成的时候会被覆盖回去，就又会报错了。  
解决办法是把它移到`Assets / LuaFramework / ToLua / BaseType`目录中，如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 22]  
记得在`CustomSettings.cs`中把对应的类的`_GT`调用注释掉，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 23]  
我们重新点击`Generate All`菜单，可以看到不会帮我们重新生成`UnityEngine_ParticleSystemWrap`类了，不过新的问题来了，在`LuaBinder`中会自动帮我们注册生成的`Wrap`类，现在我们没有指定生成`UnityEngine_ParticleSystemWrap`，自然在`LuaBinder`中就不会帮我们生成注册的逻辑了，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 24]  
没关系，`BaseType`中的也有一些`Wrap`类，它们肯定也是要注册到`lua`虚拟机中的，我们只需要随便找一个看看它是在哪里引用的就可以啦，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 25]  
通过引用查找，我们跳到了`LuaState.cs`脚本中，可以看到那些`BasetType`中的`Wrap`类是在`LuaState`的`OpenBaseLibs`函数中执行注册的，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 26]  
我们只需要在这里添加上`Register`调用就可以了，不过需要注意命名空间，它是以`BeginModule`和`EndModule`来包裹的，多层命名空间可以嵌套，例：

BeginModule("System");
    BeginModule("Generic");
    System_Collections_Generic_ListWrap.Register(this);
    System_Collections_Generic_DictionaryWrap.Register(this);
    System_Collections_Generic_KeyValuePairWrap.Register(this);
    EndModule();//Generic
    EndModule();//end System

我们的`ParticleSystem`是在`UnityEngine`命名空间下的，所以放在`BeginModule("UnityEngine");`和`EndModule();`之间，如下：  
![在这里插入图片描述][02b9d261a100451c8d7e55c1fdaab5d4.png]

##### 5.4、LightWrap和MeshRendererWrap报错 #####

我们看到它没有报错了，打开`main`场景，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 27]  
运行，闪一下，报了一个`Error`，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 28]  
我是`Windows`平台，所以我点击 `Build Windows Resource`菜单，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 29]  
报了下面新的错误：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 30]  
一个是`UnityEngine_LightWrap`类，一个是`UnityEngine_MeshRendererWrap`类，我们使用上面类似`UnityEngine_ParticleSystemWrap`的方法来处理即可。  
我们重新执行菜单`Generate All`和 `Build Windows Resource`，  
可以在`Assets / StreamingAssets`目录中生成了很多`AssetBundle`文件，说明资源打包成功了，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 31]  
此时我们重新运行，即可看到可以正常运行了，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 32]

### 五、tolua框架的工作流程 ###

上面我们看到运行后出现了一个`UI`界面，这个`UI`界面是在`lua`代码中创建的，那么，`Unity`是如何加载并执行`lua`代码的呢？下面我来一步步讲，希望你耐心看完。

#### 1、Main.cs：入口脚本 ####

我们看回`main`场景的`Hierarchy`视图，有个`GameManager`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 33]  
它身上挂着一个`Main`脚本，明显，这就是入口脚本，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 34]

#### 2、StartUp：启动游戏框架 ####

我们打开`Main.cs`脚本，如下，那句`StartUp`就是最关键的调用，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 35]  
里面会发送一个`START_UP`消息，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 36]  
触发`StartUpCommand`类执行`Execute`，我们可以看到在这里添加了很多管理器，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 37]  
这些管理器会挂到`GameManager`物体上，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 38]  
当然，我们可以根据自己的需求添加新的管理器，也可以把不需要的管理器删掉，特别是你是项目中途继承`tolua`框架的话，很多管理器可能你本身项目中就已经有了，比如界面管理器、资源管理器、声音管理器、网络管理器、线程管理器等等，如果你想成为一位架构师，我建议你自己尝试去写这些管理器。  
上面那些管理器中，最核心最关键的就是`LuaManager`，我这里要重点讲一下`LuaManager`。

#### 3、LuaManager：Lua管理器 ####

`LuaManager`是整个`tolua`框架的核心，它的三个核心成员如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 39]

// lua虚拟机
    private LuaState lua;
    // lua文件加载器
    private LuaLoader loader;
    // lua生命周期控制
    private LuaLooper loop;

下面我挨个讲解他们各自做的事情。

##### 3.1、LuaState：lua虚拟机 #####

我们的`lua`代码需要经过`lua`解释器进行解释才能执行，`lua`解释器是使用`c`语言写的，它在各个平台下有对应的库文件，我之前写过一篇文章：[《【游戏开发进阶篇】教你在Windows平台编译tolua runtime的各个平台库（Unity | 热更新 | tolua | 交叉编译）》][Windows_tolua runtime_Unity _ _ _ tolua _]，里面我详细讲解了各个平台的`tolua`库文件的编译，感兴趣的同学可以去看看。  
库函数的声明在`LuaDLL.cs`中，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 40]  
`LuaState`中封装了很多对`LuaDLL`的调度，比如调用某个`lua`的方法，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 41]  
`LuaState`又是由`LuaManager`来调度的，所以调度关系为`LuaManager -> LuaState -> LuaDLL`，  
启动框架时，主要是调度`LuaState`做了下面这些事情：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 42]

##### 3.2、LuaLoader：lua文件加载器 #####

`LuaLoader`是文件加载器，它继承`LuaFileUtils`，主要提供`lua`文件的读取、查找功能。  
核心成员变量：

public bool beZip = false;
    protected List<string> searchPaths = new List<string>();
    protected Dictionary<string, AssetBundle> zipMap = new Dictionary<string, AssetBundle>();

当`beZip`为`false`时，在`searchPaths`中查找读取`lua文`件；否则从外部设置过来`bundel`文件中读取`lua`文件，我们可以重写`ReadFile`方法，根据自己的设计去加载`lua`文件，比如你对`lua`文件做了加密，则需要在加载这里先做解密。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 43]

##### 3.3、LuaLooper：lua生命周期控制 #####

在`Unity`中，`MonoBehaviour`是有生命周期的，  
可以参见Unity官方文档的说明：[https://docs.unity3d.com/Manual/ExecutionOrder.html][https_docs.unity3d.com_Manual_ExecutionOrder.html]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 44]  
我们的`tolua`为了实现类似的生命周期的功能，封装了一些`API`，

// LuaDLL.cs
    
    [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)]
    public static extern int tolua_update(IntPtr L, float deltaTime, float unscaledDelta);
    
    [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)]
    public static extern int tolua_lateupdate(IntPtr L);
    
    [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)]
    public static extern int tolua_fixedupdate(IntPtr L, float fixedTime);

这些`API`就是由`LuaLooper`来调度的，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 45]

> 注：如果没有`LuaLooper`，则`lua`的协程会无法正常执行。

#### 4、GameManager：游戏管理器 ####

框架中帮我们提供了`GameManager`：游戏管理器，这个我们可以自己写一个，不是用框架中的`GameManager`，不过我这里讲一下框架中的`GameManager`做了什么事情。

##### 4.1、释放资源 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 46]

`GameManager`启动时，会先检测资源路径（`Util.DataPath`）中是否有`lua`文件，如果没有，则将`StreamingAssets`目录中的`files.txt`文件拷贝到资源路径（`Util.DataPath`）中，其中`files.txt`记录了`StreamingAssets`目录中所有`lua`文件和资源文件的`md5`。  
遍历`files.txt`文件，把`StreamingAssets`目录中的`lua`文件和资源文件拷贝到资源路径（`Util.DataPath`）中，这个过程叫做释放资源。

##### 4.2、更新资源 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 47]

根据`AppConst.UpdateMode`决定要不要执行更新资源。  
如果需要更新，则访问`Web`服务器地址`AppConst.WebUrl`，下载最新的`files.txt`。  
然后遍历最新的`files.txt`，检查本地文件是否缺少或者`MD5`是否不相等，然后去`Web`服务器下载`lua`代码或资源，下载使用了线程管理器启动独立线程进行下载。

##### 4.3、执行lua代码 #####

更新完`lua`代码和资源后会调用`GameManager`的`OnInitialize`，到这里就可以启动`lua`虚拟机执行`lua`代码了。  
启动`lua`虚拟机：

LuaManager.InitStart();

执行`lua`代码：

-- 加载Game.lua脚本
    LuaManager.DoFile("Logic/Game");  
    -- 执行lua的Game.OnInitOK方法
    Util.CallMethod("Game", "OnInitOK");

我们在场景中看到的界面，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 32]  
就是在`Game.OnInitOK`里面创建出来的，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 48]

##### 4.4、lua业务代码的结构 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 49]

`lua`业务代码的结构是这样的，以`Demo`中的界面为了例，`Prompt`是提示界面，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 50]  
对应一个`PromptCtrl.lua`脚本（界面交互逻辑，类似`Android`的`Activity`脚本）和`PromptPanel.lua`脚本（界面`UI`对象绑定，类似于`Android`的`layout`布局文件）。`CtrlManager.lua`就是管理和调度`Ctrl`脚本的，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 51]  
先在`define.lua`中定义`Ctrl`和`Panel`的名字，

-- define.lua
    
    CtrlNames = {
        
    	Prompt = "PromptCtrl",
    	Message = "MessageCtrl"
    }
    
    PanelNames = {
        
    	"PromptPanel",	
    	"MessagePanel",
    }

然后所有的`Ctrl`在`CtrlManager`中注册，

-- CtrlManager.lua
    
    function CtrlManager.Init()
    	logWarn("CtrlManager.Init----->>>");
    	ctrlList[CtrlNames.Prompt] = PromptCtrl.New();
    	ctrlList[CtrlNames.Message] = MessageCtrl.New();
    	return this;
    end

通过`CtrlManager`获取对应的`Ctrl`对象，调用`Awake()`方法，

-- CtrlManager.lua
    local ctrl = CtrlManager.GetCtrl(CtrlNames.Prompt);
    if ctrl ~= nil then
        ctrl:Awake();
    end

`Ctrl`中，`Awake()`方法中调用`C#`的`PanelManager`的`CreatePanel`方法，

-- PromptCtrl.lua
    function PromptCtrl.Awake()
    	logWarn("PromptCtrl.Awake--->>");
    	panelMgr:CreatePanel('Prompt', this.OnCreate);
    end

`C#`的`PanelManager`的`CreatePanel`方法去加载界面预设，并挂上`LuaBehaviour`脚本，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 52]  
这个`LuaBehaviour`脚本，主要是管理`Panel`的生命周期，调用`lua`中`Panel`的`Awake`，获取`UI`元素对象，

-- PromptPanel.lua
    
    local transform;
    local gameObject;
    
    PromptPanel = {
        };
    local this = PromptPanel;
    
    --启动事件--
    function PromptPanel.Awake(obj)
    	gameObject = obj;
    	transform = obj.transform;
    
    	this.InitPanel();
    	logWarn("Awake lua--->>"..gameObject.name);
    end
    
    --初始化面板--
    function PromptPanel.InitPanel()
    	this.btnOpen = transform:Find("Open").gameObject;
    	this.gridParent = transform:Find('ScrollView/Grid');
    end
    
    --单击事件--
    function PromptPanel.OnDestroy()
    	logWarn("OnDestroy---->>>");
    end

界面创建后会回调`Ctrl`的`OnCreate()`，在`Ctrl`中对`UI`元素对象添加一些事件和控制，

-- PromptCtrl.lua
    --启动事件--
    function PromptCtrl.OnCreate(obj)
    	gameObject = obj;
    	transform = obj.transform;
    
    	panel = transform:GetComponent('UIPanel');
    	prompt = transform:GetComponent('LuaBehaviour');
    	logWarn("Start lua--->>"..gameObject.name);
    
    	prompt:AddClick(PromptPanel.btnOpen, this.OnClick);
    	resMgr:LoadPrefab('prompt', {
         'PromptItem' }, this.InitPanel);
    end

### 六、我的热更Demo的一些介绍说明 ###

#### 1、Web服务器 ####

`Web`服务器我是使用小皮客户端，直接启动一个`Apache`的`Web`服务器。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 53]  
实际项目会使用阿里云、腾讯云这些云服作为`Web`服务器。  
增量包放在`Web`服务器跟目录中，![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 54]  
`update_list.json`是更新列表文件，里面记录每个增量包的版本号、`md5`、大小和`url`，例：

[
        {
        
            "appVersion": "1.0.0.0",
            "appUrl": "https://blog.csdn.net/linxinfa",
            "updateList":
            [
    			{
        
                    "resVersion": "1.0.0.2",
                    "md5": "206933991b0fd0275695e302b9fa0839",
                    "size": 916897,
                    "url": "http://localhost:7890/res_1.0.0.2.zip"
                },
                {
        
                    "resVersion": "1.0.0.1",
                    "md5": "6d71d1648247546b43197d1ddd832ad6",
                    "size": 4737,
                    "url": "http://localhost:7890/script_1.0.0.1.zip"
                }
            ]
        }
    ]

#### 2、代码结构：Scripts目录 ####

我的代码结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 55]

#### 3、资源目录结构：RawAssets目录、GameRes目录 ####

生肉资源放在`RawAssets`目录中，比如动画、字体、图片等，这些资源会被预设依赖，预设是熟肉资源，相对的，这些就是生肉资源。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 56]  
熟肉资源放在`GameRes`目录中，其中`BaseRes`放热更之前就要使用的资源，其他目录的资源都是热更后才加载的，  
![在这里插入图片描述][5b311d1294be4faca67ee75c940d5261.png]

#### 4、资源配置：resources.bytes、ResourcesCfg.cs ####

我把资源路径配置在`resources.bytes`中，如下：

[
        {
         "id":1, "editor_path":"UIPrefabs/LoginPanel.prefab", "desc":"登录界面" },
        {
         "id":2, "editor_path":"UIPrefabs/PlazaPanel.prefab", "desc":"大厅界面" },
        {
         "id":3, "editor_path":"UIPrefabs/TipsFly.prefab", "desc":"提示语" }
    ]

`editor_path`是相对`GameRes`的路径，它的第一级目录将会作为`AssetBundle`的名字，比如上面三个资源的一级目录都是`UIPrefab`，所以他们会一起打在一个叫`uiprefab.bundle`的`AssetBundle`文件中。  
我封装了`ResourcesCfg`脚本来读取`resources.bytes`，你可以通过`GetResCfg`方法来获取配置，

// ResourcesCfg.cs
    
    public ResourcesCfgItem GetResCfg(int resId)

例：

var resCfg = ResourcesCfg.instance.GetResCfg(1);

#### 5、资源管理器：ResourceMgr.cs ####

配置了资源后，可以通过资源管理器来加载资源，我封装了两个接口：

// ResourceMgr.cs
    
    public T LoadAsset<T>(int resId) where T : UObject
    public T LoadAsset<T>(string resPath) where T : UObject

你可以通过资源`id`来加载资源，  
例：

var loginPanelObj = ResourceMgr.instance.LoadAsset<GameObject>(1);

也可以通过相对路径来加载资源，  
例：

var loginPanelObj = ResourceMgr.instance.LoadAsset<GameObject>("UIPrefabs/LoginPanel.prefab");

不过如果要显示界面，建议使用`PanelMgr`来调度和统一管理。

#### 6、界面管理器：PanelMgr.cs、BasePanel.cs ####

为了方便管理界面，我封装了界面基类`BasePanel`，由它来调度界面的生命周期，它有一个`panelName`成员，初始化时会去查找与`panelName`同名的`lua`脚本，调度生命周期相关的函数，界面的创建和销毁由`PanelMgr`来统一调用。  
画个图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 57]

#### 7、热更新逻辑：HotUpdater.cs ####

热更新逻辑我封装在`HotUpdater`中，它做的事情如下：  
1 请求更新列表；  
2 根据版本号计算真正需要下载的文件，最终决定是否需要更新，是强制更新还是可选更新；  
3 执行下载，调度`Downloader`类完成下载任务；  
4 在`Update`中监听下载事件，并根据事件调用界面更新的委托函数，实现界面状态更新；  
5 下载完成后执行`MD5`校验，如果校验不通过，重新执行下载；  
6 `MD5`校验通过后，执行文件解压，解压到`persistentDataPath/update`目录中；  
7 解压完毕后删除`zip`文件；  
8 下载下一个增量包，直到全部下载完毕；  
9 下载完毕后，回调`actionAllDownloadDone`委托函数。

#### 8、下载器：Downloader.cs ####

`Downloader`主要就是执行下载任务，使用的是`HttpWebRequest`来请求`Web`服务器，

var httpReq = HttpWebRequest.Create(url) as HttpWebRequest;

要支持断点续传，需要判断`HttpWebResponse`的`StatusCode`是否为`HttpStatusCode.PartialContent`，如果是才支持断点续传，否则要重新从头下载，

var response = (HttpWebResponse)httpReq.GetResponse();
    if (response.StatusCode != HttpStatusCode.PartialContent)
    {
        
    	// 不能断点续传，要重新下载
    }

断点续传的核心就是本地文件`Seek`到文件末尾，`HttpWebRequest.AddRange`到要续传的位置，如下：

m_fs = new FileStream(savePath, FileMode.OpenOrCreate, FileAccess.Write);
    var lastDownloadSize = fs.Length;
    
    m_fs.Seek(lastDownloadSize, SeekOrigin.Current);
    httpReq.AddRange(lastDownloadSize);

下载文件的写文件比较耗时，使用独立的线程来执写文件，

// 开启一个独立的写文件线程
    if (null == m_thread)
    {
        
    	m_stopThread = false;
    	m_thread = new Thread(WriteThread);
    	m_thread.Start();
    }

写文件的逻辑就是从`HttpWebResponse`的`Stream`流中读取数据然后写到本地的文件中，

var readSize = m_ns.Read(m_buff, 0, m_buff.Length);
    if (readSize > 0)
    {
        
        m_fs.Write(m_buff, 0, readSize);
        curDownloadSize += readSize;
        Thread.Sleep(0);
    }
    else
    {
        
        // 完毕
        m_stopThread = true;
        state = DownloadState.End;
        Dispose();
    }

#### 9、文件解压和压缩 ####

增量包我是在打包工具中执行了压缩，压成`.zip`文件，客户端热更新时下载后会执行解压。  
压缩和解压我使用的库是`Ionic.Zip.Unity.dll`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 58]  
压缩文件：

// using Ionic.Zip;
    
    using (ZipFile zip = new ZipFile())
    {
        
    	// 设置压缩密码
    	// zip.Password = "123456";
        zip.AddDirectory(Application.dataPath + "/TestDir", "./TestDir");
        zip.AddFile(Application.dataPath + "/Test1.txt", "./");
        zip.Save(Application.dataPath + "/result.zip");
    }

解压文件：

using (ZipFile zip = new ZipFile(Application.dataPath + "/result.zip"))
    {
        
    	// 设置解压密码
    	// zip.Password = "123456";
    	// 直接解压所有文件
        // zip.ExtractAll(Application.dataPath + "/UnZip");
        foreach (var entity in zip)
        {
        	
        	// 挨个文件解压
    		entity.Extract(Application.dataPath + "/UnZip");
    	}
    }

#### 10、AES对称加密解密 ####

`lua`代码打包成`AssetBundle`时，我先把`lua`代码拷贝到一个临时目录中并做加密，然后才执行`AssetBundle`打包。  
我使用的加密算法是`AES`，对应的脚本是`AESEncrypt.cs`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 59]  
解密接口：

public static byte[] Encrypt(byte[] toEncryptArray)

解密接口：

public static byte[] Decrypt(byte[] toDecryptArray)

我们可以使用`AssetStudio`对打出来的`lua`的`AssetBundle`进行逆向，可以看到逆向出来的是乱码，说明我们的加密生效了，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 60]

> 注：`AssetStudio`下载地址：[https://codechina.csdn.net/mirrors/perfare/assetstudio][https_codechina.csdn.net_mirrors_perfare_assetstudio]

#### 11、打整包 ####

点击菜单`Build / 打包APP`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 61]  
设置你要打的整包的版本号，点击`Save`，然后点击`Build APP`即可，生成的`APP`会放在`Assets`同级目录的`Bin`目录中，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 62]  
以`Windows`平台为例，如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 63]  
会自动生成一个`LuaFrameworkFiles_版本号.json`文件，里面记录了打包时的`LuaFramework`的文件的`md5`，方便后续打增量包是进行`MD5`对比。

#### 12、打热更包 ####

点击菜单`Build / 打热更包`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 64]  
设置增量包的版本号，设置要读取的`LuaFrameworkFiles_xxxx.json`文件的版本号，根据需要添加要打进增量包的资源文件，最后点击打热更包按钮即可，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 65]  
生成的热更包会存放在`Bin`目录中，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 66]  
我们只需将其拷贝到`Web`服务器，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 67]  
并配置到`update_list.json`即可，如下：

[
        {
        
            "appVersion": "1.0.0.0",
            "appUrl": "https://blog.csdn.net/linxinfa",
            "updateList":
            [
                {
        
                    "resVersion": "1.0.0.1",
                    "md5": "50d550486de1a72bd0caaa560128a9ad",
                    "size": 908405,
                    "url": "http://localhost:7890/res_1.0.0.1.zip"
                }
            ]
        }
    ]

`md5`和`size`可以使用`Hash.exe`查看，它非常的小巧，只有`28KB`，  
![在这里插入图片描述][3d5576f7edc141e3bc6c2350720b9d10.png]  
我也把他放在`CODE CHINA`上了，下载地址：  
[https://codechina.csdn.net/linxinfa/UnityHotUpdateFramework/-/raw/master/HexTool/Hash.exe][https_codechina.csdn.net_linxinfa_UnityHotUpdateFramework_-_raw_master_HexTool_Hash.exe]  
直接把文件拖到窗口中即可查看`size`和`md5`了，注意它生成的是大写的`md5`，我们配置的时候转成小写（因为我程序里计算`md5`用的是小写，或者改下加个`ToLower`调用，这个自由发挥~）

### 七、完毕 ###

好了，就先写这么多吧~  
希望可以帮助到对热更新有困惑的同学。  
我是林新发：[https://blog.csdn.net/linxinfa][https_blog.csdn.net_linxinfa]  
原创不易，若转载请注明出处，感谢大家~  
喜欢我的可以点赞、关注、收藏，如果有什么技术上的疑问，欢迎留言或私信~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70]: /images/20220829/b3d93fc2b4304912868f30d53d8c5d10.png
[432dc12d06e043a3afee960827629643.gif]: /images/20220829/91dfb86b6f014060a79bed5a791d5402.png
[f1fce415ed91437bbf87c5eb2e1a99ea.gif]: /images/20220829/88a209f205564e1786f8e2cb7090e8a1.png
[f52f0de5fa8f4415b975f477e6b54083.gif]: /images/20220829/979b2e2479ea404e93d373d7a5d53d2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 1]: /images/20220829/1b8f76ea604f40729bca547c3ed3c952.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 2]: /images/20220829/240eb9617dce4d3a8ef5ff0442a6f62a.png
[https_codechina.csdn.net_linxinfa_UnityHotUpdateFramework]: https://codechina.csdn.net/linxinfa/UnityHotUpdateFramework
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 3]: /images/20220829/052adaed0b5d413f9293d58e490ba5e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 4]: /images/20220829/bbc969c1bbeb4a32b78906bec79af9ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 5]: /images/20220829/d670bc2b7abf462eb5070282de0605bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 6]: /images/20220829/4d915d3decd6493ebb0d210a42837fb3.png
[https_github.com_topameng_tolua]: https://github.com/topameng/tolua
[https_codechina.csdn.net_mirrors_topameng_tolua]: https://codechina.csdn.net/mirrors/topameng/tolua
[https_codechina.csdn.net_mirrors_jarjin_LuaFramework_UGUI]: https://codechina.csdn.net/mirrors/jarjin/LuaFramework_UGUI
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 7]: /images/20220829/f7a2f0037c484aa59a778a215f8eac18.png
[d32f0b4a2e9742d6a0de9194c0dc984f.png]: /images/20220829/2348f0acca924ad69cf47f5df3e7f8e3.png
[https_codechina.csdn.net_linxinfa_LuaFramework_UGUI_2021]: https://codechina.csdn.net/linxinfa/LuaFramework_UGUI_2021
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 8]: /images/20220829/3554944fe5004b53a5a37c899112a768.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 9]: /images/20220829/5174f816c03143ae99543b652a1bd8d8.png
[049dd14fe2b14f2da9363b242bb1407c.png]: /images/20220829/2e7e8957e8be4e398951cbf11453168c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 10]: /images/20220829/f3e18d7a59054dbca0829740c289b42e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 11]: /images/20220829/6f668cf06b31472ab36c1460520ecc3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 12]: /images/20220829/77055a2ae96e4b9b84c679c52b2897ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 13]: /images/20220829/a0bb5242aaba40bab29a70869f87f24d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 14]: /images/20220829/dd6b0233d28c4416b8f4d0cac02f34b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 15]: /images/20220829/c4debb0d0aed4758b92c4fb47993c47b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 16]: /images/20220829/1f99edc53c914df98d1dec0dd369d89e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 17]: /images/20220829/a1e30ba3d8e84c9294a1a502b892a3cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 18]: /images/20220829/e2cadb6c59ef47da9520cf1a4fddd621.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 19]: /images/20220829/0913e3c902834b3da81bd6667d4c09f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 20]: /images/20220829/e7c79e3dc7064635a869596afee1329e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 21]: /images/20220829/9995f9b2f4b5401192dd71f708bd770a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 22]: /images/20220829/d9c6c4767ce247158a6af32d201df794.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 23]: /images/20220829/2329fb86be7b4bc58fac80b2b35b1c88.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 24]: /images/20220829/5a3385a647eb402eac9d5a81ec4d8315.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 25]: /images/20220829/c5dcfcf8081d4bb8a35dcb6fdba1f197.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 26]: /images/20220829/ce34e7d7259c43d7b303dfb522cf759b.png
[02b9d261a100451c8d7e55c1fdaab5d4.png]: /images/20220829/05ba40b1aac344fe8634e730ec9dcb95.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 27]: /images/20220829/4fda2c3482594288858ddfbee9b8bd10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 28]: /images/20220829/6e4376886db24ff18a480bbee386c94f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 29]: /images/20220829/d56f0baf217e4a2a874788a7b93deaa0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 30]: /images/20220829/89b097db696047a88e70f4039986e3dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 31]: /images/20220829/de90888bb385473da8694dc3b9945ffe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 32]: /images/20220829/7b8e8a47fb454554a3e18a732c6e3037.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 33]: /images/20220829/39863b71edb94304a234a3cdee9adee8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 34]: /images/20220829/9dff5e285d964ec1940d0ee69ec31061.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 35]: /images/20220829/8812af960307483cb102e03f3cb265df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 36]: /images/20220829/618cfc4538814c6eba4d3324102aa891.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 37]: /images/20220829/497b609e4b11488190847bc83aa3c080.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 38]: /images/20220829/73fd0163091c47649fabfffc06e01532.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 39]: /images/20220829/cc452a319b544d0f886ba468f8cc9db7.png
[Windows_tolua runtime_Unity _ _ _ tolua _]: https://linxinfa.blog.csdn.net/article/details/118353526
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 40]: /images/20220829/cad40783479648baba391c8eec671c35.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 41]: /images/20220829/e4777649175148de83ee1e922f35c817.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 42]: /images/20220829/964ef98af9864d19902427aede25f449.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 43]: /images/20220829/72e4a50afde948218dd7eac373d294d9.png
[https_docs.unity3d.com_Manual_ExecutionOrder.html]: https://docs.unity3d.com/Manual/ExecutionOrder.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 44]: /images/20220829/169e6c9f00744ab2b8a02e22e7d8f86c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 45]: /images/20220829/8ee8dae3507c48ef80a9e3ab9d1c74b5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 46]: /images/20220829/18f136e214dd475cb04fd9788e29fb19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 47]: /images/20220829/4acb3308dd9c4a588693cfc0b3ce27e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 48]: /images/20220829/ce19d29aae5b4699bb910370664b5893.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 49]: /images/20220829/8f6ee44d3393436eba044fa034390045.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 50]: /images/20220829/4059caf270114a2dbf26fca16ec94f72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 51]: /images/20220829/3e02b26594844b35bc68c34277e1605c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 52]: /images/20220829/a1e996eb76634b8baf75c46fd61860e9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 53]: /images/20220829/eb09e1c239df4e02921148fb00c4ea59.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 54]: /images/20220829/20d14d54dbe2499c87202666c35a6fed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 55]: /images/20220829/76418d17fc6c4911b34a5ee93cda78cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 56]: /images/20220829/ee7c22b39ade4ca1a8fd476f2116ab83.png
[5b311d1294be4faca67ee75c940d5261.png]: /images/20220829/93032dbfec174683bc849347feb79b41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 57]: /images/20220829/bd9611a63083413d93b98e7583023218.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 58]: /images/20220829/b49f82d0998c456098f139d7e9391f8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 59]: /images/20220829/65dc51d4dd344ac79c50a7d0a3b9c4fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 60]: /images/20220829/5a3f85187af842998b2723c04a42674a.png
[https_codechina.csdn.net_mirrors_perfare_assetstudio]: https://codechina.csdn.net/mirrors/perfare/assetstudio
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 61]: /images/20220829/83635f7f893e4168b1d439cb89b75768.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 62]: /images/20220829/60382e8f6cfb4669bbd79b602deee0ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 63]: /images/20220829/185861634e1045d486405e31fb2ab0e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 64]: /images/20220829/ab2643552a404f859c223e1fa404886c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 65]: /images/20220829/4db16677c8294f9294080613ee121685.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 66]: /images/20220829/9263278f7a4e4c6695fed67f21fbc70d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 67]: /images/20220829/7aa63e3e40db46eca8606979304dd7c2.png
[3d5576f7edc141e3bc6c2350720b9d10.png]: /images/20220829/c734e4947db8400dadaf9197eae1c8b0.png
[https_codechina.csdn.net_linxinfa_UnityHotUpdateFramework_-_raw_master_HexTool_Hash.exe]: https://codechina.csdn.net/linxinfa/UnityHotUpdateFramework/-/raw/master/HexTool/Hash.exe
[https_blog.csdn.net_linxinfa]: https://blog.csdn.net/linxinfa