:::info{title="框架概述"}
思考如何搭建一个UI框架，以过往的工作经验来说，尽可能将框架设计在Lua开发业务逻辑时进行规范化和便捷化，对于Unity来说用C#来设计框架当然是非常合适。然而，由于手游开发得考虑热更新的缘故，UI相关的业务对于游戏性能来说没有很大的影响，所以在设计上部分框架内容由C#来搭建，涉及到业务相关的内容由Lua来搭建。
框架分为以下几部分组成：
1. 基础UI组件
2. 定制UI组件
3. 支撑功能组件
4. 界面管理核心内容
:::

### 一 基础UI组件
- 基础UI组件概述
### 二 定制UI组件
- 定制UI组件
### 三 支撑功能组件
- 支撑功能组件
### 四 界面管理核心内容
- 界面管理核心内容总篇
1. [UI层级管理](https://www.xiaojuziya.com/post/17)

游戏开发UI框架总篇

:::info{title="概述"}
在游戏开发中，运营需要根据不同的地区来开启不同的活动，由于每个地区的时间都不相同，我们通常将时间统一成UTC时间，再根据需要转化成本地时间或者UTC时间。
:::
## 游戏中如何统一不同时区的时间
:::tip{title="以服务器的时间(戳)为准"}
服务端始终保持一个UTC时间，客户端用date本地化进行时间显示或者UTC时间显示。
:::

1. 客户端本地化显示时间或者UTC时间显示  
- 本地化显示
    ```lua
    local local_date = os.date("*t", time)  --本地时间
    totimestring(local_date) -- 输出成具体的时间格式
    ```
- UTC时间显示
     ```lua
    local utc_date = os.date("!*t", time)  --UTC
    totimestring(local_date) -- 输出成具体的时间格式
    ```
3. 客户端如何检查是否是同一天问题
- UTC时间检查
    >  这种来自于服务端的时间检查是否同一天，常用于今天是否领奖之类的。
    ```lua
    -- time1, time2都为UTC时间戳，来自于服务端
    function TimerManager:IsSameDayByUTC(time1, time2)
        local dateA = os.date("!*t", fixTime1)
        local dateB = os.date("!*t", fixTime2)
        return dateA.year == dateB.year and dateA.yday == dateB.yday
    end
    ```
- 客户端本地时间怎么取 
    :::warning{title="注意"}
    通常在游戏开发中服务端统一了UTC时间后，还需要根据本地时间来检查是否同一天，**需要特别注意**。不然很容易和UTC时间检查搅浑。  
    由于os.time()取到的客户端时间是一个离线的时间，不能直接拿来进行比较，所以我们需要借助服务端的**时间来推出准确的客户端时间**。
    :::
    ```lua
    -- 计算当前主机本地时间与格林尼治时间本地时间差值
    function TimerManager:self:GetFixTime()
        local now = os.time()
        return os.difftime(now, os.time(os.date("!*t", now)))
    end
    -- 本地时间
     function TimerManager:GetLocalTime(time)
        return time - self:GetFixTime()
    end
    ```
 - 本地时间检查是否是同一天
 同上UTC时间检查，注意不带“!”就好
## Lua函数os.time(table)
> 按table的内容返回一个时间值(数字)，若不带参数则使用当前时间(本时区此刻时间)作为table内容

:::warning{title="注意"}
time函数中所谓的本地时间，并不是是所在的时区的联网时间，而是离线时间
:::
- **无参调用 os.time()**  
    直接返回本地时间戳，即格林尼治时间1970.01.01-00：00：00到**现在这个点**（也就是本机时间）格林尼治时间经过的秒数。
- **含参调用 os.time**({year=, month=, day=, hour=, ..})  
    返回格林尼治时间为1970.01.01-00：00：00时本时区的时间到本时区table时刻，经过的秒数。
## Lua函数os.date(format, time)
> 返回一个按format格式化日期、时间的字串或表

:::tip{title="对于format是否带“!”的简单理解"}
**参考系**：**有**“!”时候以格林尼治时间0点(**时间戳0**)为参考系，**没有**“!”时候以本地时间0点(北京东八区,则起始**时间戳为8*3600=28800**)
- 当**有**“!”  
    表示格林尼治时间0点加上time(时间戳)的时间，代表的是格林尼治时间。
- 当**没有**“!”  
    表示格林尼治时间0点时候的**本地时间**(就是你所在的时区的时间)，time(时间戳)的时间，代表的是本地时间。
- 代码测试发现时间戳0时,本地(东八区)比格林尼治早八小时
```Lua
    os.date("!*t", 0) -- 格林尼治0时日期
    -- 主要输出 {year=1970, month=1, day=1, hour=0, min=0}
    os.date("*t", 0)  -- 本地0时日期
    -- 主要输出 {year=1970, month=1, day=1, hour=8, min=0}
```
:::
- **format字符是“\*t”**  
    返回一个带year （四位数字），month （1–12），day （1–31）， hour （0–23），min （0–59），sec （0–61）， wday （星期几，星期天为 1 ）， yday （当年的第几天）， 以及 isdst （夏令时标记，一个布尔量）。 对于最后一个域，如果该信息不提供的话就不存在。
- **format字符是非“\*t”**,以字符串形式返回，格式化方法法遵循 ISO C 函数 strftime 的规则  
    | 说明符 | 替换为 | 实例 |
    | --- | --- | --- |
    | %a | 缩写的星期几名称	| Sun |
    | %A | 完整的星期几名称	| Sunday |
    | %b | 缩写的月份名称	| Mar |
    | %B | 完整的月份名称	| March |
    | %c | 日期和时间表示法	Sun Aug 19 02:56:02 | 2012 |
    | %d | 一月中的第几天（01-31）	| 19 |
    | %H | 24 小时格式的小时（00-23）	| 14 |
    | %I | 12 小时格式的小时（01-12）	| 05 |
    | %j | 一年中的第几天（001-366）	| 231 |
    | %m | 十进制数表示的月份（01-12）	| 08 |
    | %M | 分（00-59）	| 55 |
    | %p | AM 或 PM 名称	| PM |
    | %S | 秒（00-61）	| 02 |
    | %U | 一年中的第几周，以第一个星期日作为第一周的第一天（00-53）	| 33 |
    | %w | 十进制数表示的星期几，星期日表示为 0（0-6）	| 4 |
    | %W | 一年中的第几周，以第一个星期一作为第一周的第一天（00-53）	| 34 |
    | %x | 日期表示法	08/19/| 12 |
    | %X | 时间表示法	02:50:| 06 |
    | %y | 年份，最后两个数字（00-99）	| 01 |
    | %Y | 年份	| 2012 |
    | %Z | 时区的名称或缩写	| CDT |
    | %% | 一个 % 符号	| % |
 ## Lua函数os.difftime (t2, t1)
  > 返回以秒计算的时刻t1到 t2 的差值。 在Windows，和其它一些系统中，这个值就等于 t2-t1

基于Lua在游戏中统一UTC时间与时区问题

:::info{title="源码"}
[github源码](https://github.com/SmallOrangeGame/UIFrame/releases/tag/%E6%B8%B8%E6%88%8F%E5%BC%80%E5%8F%91UI%E6%A1%86%E6%9E%B6-%E7%95%8C%E9%9D%A2%E7%AE%A1%E7%90%86%E6%A0%B8%E5%BF%83%E5%86%85%E5%AE%B9%E4%B9%8BUI%E5%B1%82%E7%BA%A7%E7%AE%A1%E7%90%861.0)
:::
:::tip{title="理解Unity渲染层级"}
[对于不清楚Unity渲染层级的可以看这篇文章](https://www.jianshu.com/p/0341f0ab9020)  
[也可直接看这篇介绍RenderQueue、SortingLayer、SortingOrder关系](https://www.jianshu.com/p/7a033810706f)  
在接下来的内容中，我们只讨论SortingLayer、SortingOrder对于层级的影响，其他的认为是相同的条件。
:::

### 一 设置SortingLayer
> SortingLayer在Inspector面板中点击Tag -> AddTag -> SortingLayer，可以添加自定义的sortingLayer，默认的sortingLayer为Default。
> 简单的设计三个层级，实际开发时候，注意要将所有层级都考虑到。
![image.png](https://pic.xiaojuziya.com/picgo/46848edc32eb3b84828c1c35b0a54401.image.png)
### 二 设计挂载的父节点
> 设计一个UI根节点组件，记录父节点，根据需要挂载的父节点进行挂载
![image.png](https://pic.xiaojuziya.com/picgo/65acbcfcc93a5f537a1e22afca171f35.image.png)

UIRoot.cs文件主要代码
```csharp
//主界面层
[SerializeField]
public Transform layerMainMenu = null;
//功能层
[SerializeField]
public Transform layerHome = null;
//功能弹窗层
[SerializeField]
public Transform layerPop = null;
```
### 三 Lua代码中指定加载父节点上
```lua
-- 简单介绍主要代码，后面介绍Lua的UI管理时候会详细介绍
local parent = UIRootCache[mPriority]  --FormPriority属性获得对应的父节点
handler = LoadUI(mAASKey,parent) -- mAASKey为UI的AAS值(路径） 资源加载
```
### 四 AAS加载资源
> Lua调用C#代码进入资源加载的逻辑，这里简单提一下，资源加载不详细介绍，后面专门介绍这个

### 五 UI资源加载完毕后，设置UI的层级SortingLayer与层数OrderLayer
1. 添加UIFormMono的组件
本身UI界面除了挂着Canvas外，也需要额外挂载一个UIFormMono的组件，除了用于重置坐标外，也需要设置层级层数
![image.png](https://pic.xiaojuziya.com/picgo/6a2fde74cf4984be507a20fab240b93d.image.png)
2. UIFormMono的组件重置坐标
    ```csharp
    void Awake()
    {
        transform.localScale = Vector3.zero;
        m_rectTransform = GetComponent<RectTransform>();
        m_canvas = GetComponent<Canvas>();
        //重置坐标相关
        m_rectTransform.anchorMin = Vector2.zero;
        m_rectTransform.anchorMax = Vector2.one;
        m_rectTransform.anchoredPosition3D = Vector3.zero;
        m_rectTransform.offsetMin = Vector2.zero;
        m_rectTransform.offsetMax = Vector2.zero;
        m_rectTransform.pivot = Vector3.one * 0.5f;
        m_rectTransform.localScale = Vector3.one;
        //设置层级 m_layerName为默认是空的
        SetLayer(m_layerName);
    }
    ```
3. UIFormMono的组件设置层级与层数
    ```csharp
    //设置显示层级
    public void SetLayer(string layerName)
    {
        m_layerName = layerName;
        if (m_canvas != null)
            m_canvas.sortingLayerName = layerName;
    }
    //设置显示层层数
    public void SetSortOrder(int sortOrder)
    {
        if (m_canvas == null)
            return;
        if (!m_canvas.overrideSorting)
            m_canvas.overrideSorting = true;
        m_canvas.sortingOrder = sortOrder;
    }
    ```
4. 资源加载完毕后设置层级
    ```lua
    function UIFormBase:OnUILoaded(...)
        ...
        self.m_Form = self.m_GameObject:GetComponent(typeof(UIFormMono))
        --层级调整 self.mPriority 为层级标识
        self.m_Form:SetLayer(self.mPriority)
    end
    ```
5. 资源加载完毕后设置层级
    ```lua
    -- UI加载完成后，UI管理器会对所有UI进行一次层数更新
    function UIManager:PostProcess()
        -- self.forms是按照UI先后打开维护的列表
        for index, uiForm in ipairs(self.forms) do
            uiForm:RefreshSortOrder(index)
        end
    end
    --刷新层数
    function UIFormBase:RefreshSortOrder(nOpenOrder)
        self.m_Form:SetSortOrder(nOpenOrder * 10)
    end
    ```
### 六 界面上UI或者特效层级管理
1. 添加UILayer组件
![image.png](https://pic.xiaojuziya.com/picgo/7b97d7199a7bc5d692f7cf94e50a7326.image.png)
     ```csharp
    //层次，默认就是父Canvas的层级
    [SerializeField]
    internal string layer;
    //层数，UI的层数=父Canvas的层数+order
    [SerializeField]
    internal int order = 1;
    
    void Start()
    {
        //递归找到界面挂载的UIFormMono，将自身UILayer添加到自动调整层级的列表中
        m_formMonoParent = GetParentComponent<UIFormMono>(transform);
        if (m_formMonoParent != null)
            m_formMonoParent.AddAutoLayer(this);
    }
     ```
 
2. UIFormMono组件添加自动调整层级的列表
    ```csharp
    public void AddAutoLayer(UILayer autoLayer)
    {
        if (!m_autoLayers.Contains(autoLayer))
            m_autoLayers.Add(autoLayer);
        autoLayer.Refresh();
        ...
    }
    ```
3. UILayer刷新层级
     ```csharp
    internal void Refresh()
    {
        Canvas parentCanvas = GetParentCanvas(transform);
        //UI的层数=父Canvas的层数+order
        canvas.sortingOrder = order + parentCanvas.sortingOrder;
        //如果设置了层级，择按照层级设置
        if (!string.IsNullOrEmpty(layer))
            canvas.sortingLayerID = SortingLayer.NameToID(layer);
        else
            canvas.sortingLayerID = parentCanvas.sortingLayerID;
    }
    //特效其实是设置Renderer的层级了，后面再补充这个
    ```
4. UIFormMono组件对多UILayer管理
     ```csharp
    //设置显示层级
    public void SetLayer(string layerName)
    {
         ...
        foreach (var p in m_autoLayers)
            p.Refresh();
    }
    //设置显示层层数
    public void SetSortOrder(int sortOrder)
    {
       ...
        foreach (var p in m_autoLayers)
            p.Refresh();
    }
    //添加到自动调整层级的列表
    public void AddAutoLayer(UILayer autoLayer)
    {
        if (!m_autoLayers.Contains(autoLayer))
            m_autoLayers.Add(autoLayer);

        autoLayer.Refresh();
        if (!IsShow())
            autoLayer.Hide();
        else
            autoLayer.Show();
    }
    //从自动调整层级的列表中移除
    public void RemoveAutoLayer(UILayer autoLayer)
    {
        if (m_autoLayers.Contains(autoLayer))
            m_autoLayers.Remove(autoLayer);
    }
    //UILayer依赖将本身添加到界面UIFormMono组件中进行管理
    void Start()
    {
        //递归找到界面挂载的UIFormMono，将自身UILayer添加到自动调整层级的列表中
        m_formMonoParent = GetParentComponent<UIFormMono>(transform);
        if (m_formMonoParent != null)
            m_formMonoParent.AddAutoLayer(this);
        ...
    }
    ```
5. UILayer多次关系，按照父节点刷新子节点来处理
     ```csharp
     void Start()
    {
        //递归找到上一层UILayer，将本身作为子层交给父UILayer管理
        m_parentLayer = GetParentComponent<UILayer>(transform);
        if (m_parentLayer != null)
            m_parentLayer.RegistSubLayer(this);
    }
    internal void Refresh()
    {
        //刷新子节点
        for (int i = 0; i < m_subLayers.Count; ++i)
            m_subLayers[i].Refresh();
    }
    //注册子节点
    protected void RegistSubLayer(UILayer layer)
    {
        if (!m_subLayers.Contains(layer))
            m_subLayers.Add(layer);
    }
    //清除子节点注册
    protected void UnRegistSubLayer(UILayer layer)
    {
        if (m_subLayers.Contains(layer))
            m_subLayers.Remove(layer);
    }
    ```

游戏开发UI框架-界面管理核心内容之UI层级管理

:::info{title="红点树概要"}
组成部分概要：红点在设计上分为结构层、驱动层、表现层。  
类型概要：红点分为静态和动态两种类型。   
- 静态红点树：顾名思义就是红点的结构是固定的，一旦定死，后面就不会在变化，例如活动页签上的红点。  
- 动态红点树：在事先定义了红点的结构，后面会根据情景去改变红点的结构，这里改变仅仅指树的同一层叶子节点的结构变化，并不会改变整个红点树结构。  
:::

## 第一部分 结构层

###  数据结构部分
:::info{title="概要"}
红点使用树形结构，用形如A.B.C方式来表示
::: 
1. 红点类型枚举定义
```lua
local GRedDotType = {
    Normal = 1, -- 一般红点
    Number = 2, -- 带数字红点
}
```
2. 红点配置方式
> 使用字符串方式配置， ["A.B.C"] = {type = GRedDotType.Number} 
A,B,C分别为红点的数据节点，A是B的父级，B是C的父级，当修改C红点数量时B,C依次会被刷新。	
```lua
local RedDotConf = {
    ["Guild"] = { type = GRedDotType.Normal },
    ["Task"] = { type = GRedDotType.Normal },
    ["Mail"] = { type = GRedDotType.Normal },
    ["Mail.Guild"] = { type = GRedDotType.Normal },
    ["Mail.Team"] = { type = GRedDotType.Normal },
    ["Mail.System"] = { type = GRedDotType.Normal },
}
```
3. 红点节点的数据结构
```lua
function RedDotNode:initialize(key,type)
    self.key = key	-- 节点本身的key
    self.type = type	-- 节点类型
    self.fullKey = false	-- 所有父节点的key和本身key，例如本身key为C，此处的fullKey为 A.B.C
    self.parent = false		-- 上一级父节点
    self.children = false	-- 子节点集合
    self.number = 0			-- 红点计数
    self.template = false --动态模板配置 索引 [XX.YY.0]={type=ZZZ}
end
```
    
### 构建红点树结构

:::info{title="概要"}
按照配置来创建并初始化红点树结构
:::

1. 通过配置创建树与节点
```lua
---创建红点树
function RedDotManager:CreateTree()
    local tree = {}
    for fullKey, conf in pairs(RedDotConf) do
        local keys = string.split(fullKey, ".")
        if keys == nil or #keys <= 0 then
            print("切割失败", keys)
            break
            end
            self:CreateNode(keys, conf, tree)
    end
    self:InitTree(tree)
end
---创建树的节点
---@param keys table 分割的keys
---@param parent table 父节点
---@return nil
function RedDotManager:CreateNode(keys, conf, parent)
    local node = {}
    for _, key in ipairs(keys) do
        -- 尝试从已经建好的树中找该节点，若没有找到则创建新节点
        node = parent[key]
        if not node then
            node = {}
            parent[key] = node
        end
        -- 若节点没有子节点，则创建子节点
        if not node.children then
            node.children = {}
        end
        -- 从子节点继续找接下来的节点
        parent = node.children
    end
    node.type = conf.type
end
```
2. 初始化树与节点
```lua
---初始化树
---@param tree table 树数据
---@param parnet table 父
---@return nil 注释
function RedDotManager:InitTree(tree, parent)
    if not tree or not next(tree) then
        return
    end
    -- 将该树上节点进行初始化(子节点交给递归方式完成)
    for k, v in pairs(tree) do
        self:InitNode(k, v, parent)
    end
end
---初始化节点
---@param key string 节点key
---@param value table 节点数据
---@param parent table
---@return nil
function RedDotManager:InitNode(key, value, parent)
    -- 处理动态红点
    -- 若改节点key为"0"且有父节点，则为事先定义的动态红点模板
    if key == "0" and parent then
        parent.template = value
        return parent
    end
    -- 为每一个节点都生成一个对象来管理
    local node = RedDotNode:new(key, value.type)
    -- 如果有父节点，则将节点绑定到父节点上
    if parent then
        parent:AddChild(node)
    end
    -- 按照全key来存储节点
    local fullKey = node:GetFullKey()
    self.m_RedDotMap[fullKey] = node
    -- 递归遍历子节点
    self:InitTree(node.children, node)
    return node
end
---添加孩子节点
---@param node table 节点
---@return nil
function RedDotNode:AddChild(node)
    if not self.children then
        self.children = {} 
    end
    -- 这里可以理解为链表的链接的方式形如方式A.B
    -- 每个节点父节点只有一个，子节点有多个
    -- B的父引用指向A
    -- A的子引用指向B
    node.parent = self
    self.children[node.key] = node
end
```

## 第二部分 驱动层

:::info{title="概要"}
驱动层主要干的是将红点的状态变化时候传递给表现层，我们通常对将红点进行计数，当计数大于0时候，该节点以及父节点都会显示红点。
:::

### 注册红点  
1. 用管理器统一注册红点
```lua
---注册红点
---@param fullKey string 全key
---@param go 对象
---@return nil
function RedDotManager:Register(fullKey, go)
   if not go then return end
   -- 对gameObject用this拓展一个自动添加组件的方法，将红点C#组件UIRedDot添加上去
   local com = go.gameObject:ExtAddComponent(typeof(UIRedDot), true)
   local node = self:GetNode(fullKey)
   if not node then
       self:RefreshGo(false, go, com)
       -- 调用红点组件的C#方法，将计数设为0来隐藏红点
       com:SetNumber(0)
   else
       self:RefreshGo(node, go, com)
       -- 对红点节点注册操作
       node:Register(com)
   end
end
---刷新对象
---@param node RedDotNode 节点对象
---@param go 对象
---@param com C# 组件
---@return nil
function RedDotManager:RefreshGo(node, go, com)
   local newKey = node and node:GetFullKey() or ""
   -- m_ComMap弱表引用
   local oldKey = self.m_ComMap[go]
   -- 这里其实是当红点节点Node上绑定的key不一致时候，将旧的key对应的对象注销掉再进行下一步注册
   if oldKey and oldKey ~= newKey then
       local oldNode = self:GetNode(oldKey)
       -- 注销红点
       if oldNode and oldNode.comDirty and oldNode.comDirty.com == com then
           oldNode:UnRegister()
       end
   end
   self.m_ComMap[go] = newKey
end
---获得节点
---@param fullKey string 全key
---@return RedDotNode
function RedDotManager:GetNode(fullKey)
    if not fullKey then return end
    if not self.m_RedDotMap[fullKey] then return end
    return self.m_RedDotMap[fullKey]
end
```
2. 节点传入组件进行刷新
```lua
---节点注册红点
---@param com C# 组件
---@return nil
function RedDotNode:Register(com)
    self.comDirty = {com = com}
    self:RefreshCom()
end
---刷新组件
---@return nil
function RedDotNode:RefreshCom()
    if not self.comDirty then return end
    local comDirty = self.comDirty
    local com = comDirty.com
    if not com or com:IsNull() then
        self.comDirty = false
        return
    end
    if com then
        local type = self:GetRedType()
        if comDirty.type ~= type then
            comDirty.type = type
            com:SetType(type)
        end
        local number = self:GetRedNumber()
        if comDirty.number ~= number then
            comDirty.number = number
            com:SetNumber(number)
        end
        com:SetEnable(comDirty.number > 0)
    end
end
```

### 注销红点
1. 用管理器统一注册红点
```lua
---注销红点
---@param fullKey string 全key
    ---@return nil
    function RedDotManager:UnRegister(fullKey)
        local node = self:GetNode(fullKey)
        if not node then return end
        node:UnRegister()
    end
```
2. 节点上清除组件
```lua
---节点注销红点
---@return nil
function RedDotNode:UnRegister()
    self.comDirty = false
end
```
 
### 修改红点（数据驱动）

:::info{title="驱动概要"}
用全key来找到对应的节点，通过修改节点中红点计数来刷新红点来驱动
:::

1. 管理器来修改红点
```lua
---设置红点计数
---@param fullKey number 全key
---@param number number 计数
---@return nil
function RedDotManager:SetRedNumber(fullKey, number)
    local node = self:GetNode(fullKey)
    if not node then return end
    node:SetRedNumber(number)
end
```
2. 节点来驱动红点修改
```lua
---设置红点计数
---@param number number 计数
---@return nil
function RedDotNode:SetRedNumber(number)
if self.type == GRedDotType.Normal then     -- 一般红点只要计数大于0就显示红点
       number = Mathf.Min(number, 1)
   end
   if self.number == number then
    return
        end
        self.number = number
        self:RefreshCom()
        -- 如果有父节点，则驱动父节点刷新计数
        if self.parent then
            self.parent:Action()
        end
    end
---父节点计数驱动 递归
---@return nil
function RedDotNode:Action()
    local number = 0
    if self.children then
        for _, node in pairs(self.children) do
            local nodeNumber = node:GetRedNumber()
            number = number + nodeNumber
        end
    end
    -- 将所有孩子节点的计数累加作为节点的计数
    self:SetRedSubNumber(number)
end
```
    
## 第三部分 表现层

:::info{title="概要"}
表现层只做红点的显示，将红点的数据与表现完全区分开。驱动层用数据来驱动表现层来展示红点(计数方式)。同时，考虑到避免手动挂载红点的麻烦，与驱动层的红点注册结合起来使用，这里使用C#组件的方式，通过AAS加载预设资源，计数来控制显隐。
:::
1. 预设制作  
    主要内容是一张红点图片，也可以带文本，挂特效  
2. C#脚本功能  
    提供AAS加载路径，在Awake时候加载资源  
    资源加载回调 刷新红点状态    
    
## 第四部分 动态红点
:::info{title="概要"}
动态的节点在声明时候将节点声明为0,例如["A.B.C.0"] = {type = GRedDotType.Number},表明C节点下面为动态红点，这种多出现于排行榜，邮箱红点。
:::
- 红点状态变化驱动数据
```lua
---初始化动态红点
---@param fullKey number 全key
---@param map table<number,0> 树匹配
---@param dontClear boolean 是否清理
---@return nil
function RedDotManager:InitDynamic(fullKey, map, dontClear)
    local parent = self:GetNode(fullKey)
    if not parent then return end
    -- 删除旧的 对于map中不包含的key进行删除操作
    local change = false
    if parent.children and not dontClear then
        for key, node in pairs(parent.children) do
            if not map[key] then
                parent.children[key] = nil
                change = true
                node.parent = nil
                node:SetRedNumber(0)
            end
        end
    end
    -- 遍历map进行动态红点初始化
    for key, number in pairs(map) do
        local node = parent:GetChild(key)
        if not node then
            node = self:InitNode(key, parent.template, parent)
        end
        node:SetRedNumber(number)
    end
    -- 如果有红点变化，则需要更新父节点
    if change then
        parent:Action()
    end
end
```

基于Lua实现红点系统

### 一 动效组件
1. 设计原理
    - 考虑移动、缩放、旋转、渐变这几个动效
    - 动画效果和动画使用分离
    - 动画逻辑与动画UI界面分离
2. 动画逻辑层
    - 引入DoTween动效 
    - 针对移动、缩放、旋转、渐变动效对DoTween封装成对应的方法
    - 设置显隐、启动、手动调用动效的机制
    - 开启Sequence，注册播放事件委托
3. 动画UI层
    - 根据功能显示隐藏详细
    - 实时播放功能
	


###  二多语言文本
1. 设计原理
    - 生成预设去掉文本内容
    - 支持预设上手动设置文本和代码中设置文本
    - 进入游戏时根据系统语言来获取对应的文本语言
2. 登录游戏获取文本语言
    - 登录时将系统语言记录下来
    - 根据记录的语言类型来加载对应的多语言表，按照键值对的方式储存到字典中
    - 根据文本key来获取文本的内容
3. 预设上设置文本的组件
    - 记录文本key到面板上
    - mono在Awake或者Start时候加载文本
    - 提供通过文本key预览文本内容的功能
4. 代码中手动设置文本的内容
    - 通过统一的接口来用文本key获取文本内容
    - 提供C#和Lua的接口
### 三 图片组件封装
1. 设计原理
    - 对原生的Image进一步封装组件
    - 生成预设时候去掉图片
    - 根据图片key从AAS中获得图片资源进行赋值图片
2. 图片组件
    - 通过接口传入图片key和回调函数
    - 只有图片显示时候才进行刷新图片
    - 如果当前有在加载中的hander先释放
    - 通过图片key从AAS中取资源，取到后进行资源回调

游戏中如何统一不同时区的时间

一 动效组件

一动效组件