精华内容
下载资源
问答
  • GF框架
    千次阅读
    2018-10-24 15:22:52

    GF(Go Frame)是一款模块化、松耦合、轻量级、高性能的Go语言Web开发框架。支持热重启、热更新、多域名、多端口、多服务、HTTP/HTTPS、动态路由等特性 ,并提供了Web服务开发的系列核心组件,如:Router、Cookie、Session、服务注册、配置管理、模板引擎、数据校验、分页管理、数据库ORM等等等等, 并且提供了数十个实用开发模块集,如:缓存、日志、时间、命令行、二进制、文件锁、对象池、连接池、数据编码、进程管理、进程通信、TCP/UDP组件、 并发安全容器、Goroutine池等等等等等等。

    开源项目地址(仓库保持实时同步): GiteeGithub。 使用中有任何问题/建议,欢迎加入技术QQ群交流:116707870。 如有优秀的框架使用案例,欢迎联系作者将地址展示到项目库中,您的牛逼将被世人所瞻仰。

    安装

    go get -u gitee.com/johng/gf

    限制

    golang版本 >= 1.9.2

    特点

    1. 轻量级、高性能,模块化、松耦合设计,丰富的开发模块;
    2. 热重启、热更新特性,并支持Web界面及命令行管理接口;
    3. 专业的技术交流群,完善的开发文档及示例代码,良好的中文化支持;
    4. 支持多种形式的服务注册特性,灵活高效的路由控制管理;
    5. 支持服务事件回调注册功能,可供选择的pprof性能分析模块;
    6. 支持配置文件及模板文件的自动检测更新机制,即修改即生效;
    7. 支持自定义日期时间格式的时间模块,类似PHP日期时间格式化;
    8. 强大的数据/表单校验模块,支持常用的40种及自定义校验规则;
    9. 强大的网络通信TCP/UDP组件,并提供TCP连接池特性,简便高效;
    10. 提供了对基本数据类型的并发安全封装,提供了常用的数据结构容器;
    11. 支持Go变量/Json/Xml/Yml/Toml任意数据格式之间的相互转换及创建;
    12. 强大的数据库ORM,支持应用层级的集群管理、读写分离、负载均衡,查询缓存、方法及链式ORM操作;
    13. 更多特点请查阅框架手册源码

    文档

    GoFrame开发文档:http://gf.johng.cn

    使用

    Hello World

    package main
    
    import (
        "gitee.com/johng/gf/g"
        "gitee.com/johng/gf/g/net/ghttp"
    )
    
    func main() {
        s := g.Server()
        s.BindHandler("/", func(r *ghttp.Request) {
            r.Response.Write("Hello World")
        })
        s.Run()
    }

    多域名支持

    package main
    
    import (
        "gitee.com/johng/gf/g"
        "gitee.com/johng/gf/g/net/ghttp"
    )
    
    func main() {
        s := g.Server()
        s.Domain("localhost1,localhost2").BindHandler("/", func(r *ghttp.Request) {
            r.Response.Write("localhostx")
        })
        s.Run()
    }

    多端口支持

    package main
    
    import (
        "gitee.com/johng/gf/g"
        "gitee.com/johng/gf/g/net/ghttp"
    )
    
    func main() {
        s := g.Server()
        s.BindHandler("/", func(r *ghttp.Request){
            r.Response.Writeln("go frame!")
        })
        s.SetPort(8080, 8081, 8082)
        s.Run()
    }

    路由控制

    package main
    
    import (
        "gitee.com/johng/gf/g"
        "gitee.com/johng/gf/g/net/ghttp"
    )
    
    func main() {
        s := g.Server()
        s.BindHandler("/order/:action/{page}.html", func(r *ghttp.Request){
            r.Response.Writef("action:%s, page:%s", r.Get("action"), r.Get("page"))
        })
        s.SetPort(8199)
        s.Run()
    }

    数据库ORM

    ORM创建/关闭

    // 获取默认配置的单例数据库对象(配置名称为"default")
    db, err := gdb.DB()
    // 获取配置分组名称为"user-center"的单例数据库对象
    db, err := gdb.DB("user-center")
    // 无须显示Close,数据库引擎底层采用了链接池设计,当链接不再使用时会自动关闭

    单表/联表查询

    // 查询多条记录并使用Limit分页
    r, err := db.Table("user").Where("u.uid > ?", 1).Limit(0, 10).Select()
    // 查询符合条件的单条记录(第一条)
    r, err := db.Table("user u").LeftJoin("user_detail ud", "u.uid=ud.uid").Fields("u.*,ud.site").Where("u.uid=?", 1).One()
    // 查询指定字段值
    r, err := db.Table("user u").RightJoin("user_detail ud", "u.uid=ud.uid").Fields("ud.site").Where("u.uid=?", 1).Value()
    // 分组及排序
    r, err := db.Table("user u").InnerJoin("user_detail ud", "u.uid=ud.uid").Fields("u.*,ud.city").GroupBy("city").OrderBy("register_time asc").Select()
    // 不使用john的联表查询
    r, err := db.Table("user u,user_detail ud").Where("u.uid=ud.uid").Fields("u.*,ud.city").All()
    // 不使用Fields方法指定查询字段时,默认查询为"*"
    r, err := db.Table("user").Where("u.uid=1",).One()

    更新/删除

    // 更新
    r, err := db.Table("user").Data(gdb.Map{"name" : "john2"}).Where("name=?", "john").Update()
    r, err := db.Table("user").Data("name='john3'").Where("name=?", "john2").Update()
    // 删除
    r, err := db.Table("user").Where("uid=?", 10).Delete()
    // Data数值方法的参数形式比较灵活
    r, err := db.Table("user").Data(`name="john"`).Update()
    r, err := db.Table("user").Data("name", "john").Update()
    r, err := db.Table("user").Data(g.Map{"name" : "john"}).Update()

    写入/保存

    r, err := db.Table("user").Data(gdb.Map{"name": "john"}).Insert()
    r, err := db.Table("user").Data(gdb.Map{"uid": 10000, "name": "john"}).Replace()
    r, err := db.Table("user").Data(gdb.Map{"uid": 10001, "name": "john"}).Save()

    事务操作

    if tx, err := db.Begin(); err == nil {
        if r, err := tx.Table("user").Data(gdb.Map{"uid":1, "name": "john"}).Save(); err == nil {
            tx.Commit()
        } else {
            tx.Rollback()
        }
    
        fmt.Println(r, err)
    }
    更多相关内容
  • GF框架+XIL 项目整合

    2021-11-25 11:24:17
    客户端打包exe的GF加载框架需要添加以byte[]加载适配。 byte[] dll { get; set; } public EditorResLoadRuntime(byte[] dll) { this.dll = dll; } public Stream GetStream() { return new MemoryStream(dll); } ...

    项目unity版本:2020.3.18f1
    XIL版本:Commits on Oct 26, 2021
    GameFramework版本:Commits on Sep 28, 2021
    UnityGameFramework版本:Commits on Oct 28, 2021
    StarForce版本:Commits on Aug 9, 2021
    HFS版本:2.3


    项目克隆:

    StarForce克隆仓库:https://github.com/EllanJiang/StarForce
    UnityGameFramework克隆仓库:https://github.com/EllanJiang/UnityGameFramework
    GameFramework克隆仓库:https://github.com/EllanJiang/GameFramework
    GameFramework使用手册看源码

    StartForce源码配置

    1.在StarForce\Assets\GameFramework放入UnityGameFramework
    2.在StarForce\Assets\GameFramework\UnityGameFramework\Libraries,把dll换成GameFramework内容。此时会报错,缺少命名空间引用。右键Libraries目录Assembly Definition生成名为GameFramework的程序集,找到UnityGameFramework.Editor和UnityGameFramework.Runtime添加GameFramework程序集的引用,报错即可消失。
    3.检查不安全代码的勾是否勾上。

    模拟远程AB热更配置

    HFS 虚拟文件服务器

    HFS下载地址:HFS

    AB配置

    在这里插入图片描述

    在这里插入图片描述

    打包出来目录结构是这样子的

    在这里插入图片描述

    在AB目录创建一个名为version.txt的文件,以json协议检查AB配置,配置此文件最好打开VersiongInfo.cs脚本配合食用,毕竟不知道代码变更,如果只是抄我的字段,那此坑得填。

    namespace StarForce
    {
        public class VersionInfo
        {
            // 是否需要强制更新游戏应用
            public bool ForceUpdateGame
            {
                get;
                set;
            }
    
            // 最新的游戏版本号
            public string LatestGameVersion
            {
                get;
                set;
            }
    
            // 最新的游戏内部版本号
            public int InternalGameVersion
            {
                get;
                set;
            }
    
            // 最新的资源内部版本号
            public int InternalResourceVersion
            {
                get;
                set;
            }
    
            // 资源更新下载地址
            public string UpdatePrefixUri
            {
                get;
                set;
            }
    
            // 资源版本列表长度
            public int VersionListLength
            {
                get;
                set;
            }
    
            // 资源版本列表哈希值
            public int VersionListHashCode
            {
                get;
                set;
            }
    
            // 资源版本列表压缩后长度
            public int VersionListCompressedLength
            {
                get;
                set;
            }
    
            // 资源版本列表压缩后哈希值
            public int VersionListCompressedHashCode
            {
                get;
                set;
            }
        }
    }
    

    在这里插入图片描述

    这里的VersionList数据根据StarForce\AB\BuildReport\0_1_0_XX\BuildLog.txt找到

    {
        "ForceGameUpdate":false,//是否强制更新
        "LatestGameVersion":"0.1.0",//最新的游戏版本号
        "InternalGameVersion":1,//最新的游戏内部版本号
        "InternalResourceVersion":3,//最新的资源内部版本号
        "UpdatePrefixUri":"http://10.23.48.21/Windows64", //服务器资源更新地址
        "VersionListLength":7104,//特指GameFrameworkVersion.xxxxx.dat文件的大小
        "VersionListHashCode":2063015162,//GameFrameworkVersion.xxxxx.dat文件hash
        "VersionListCompressedLength":2559,//特指GameFrameworkVersion.xxxxx.dat文件压缩后的大小
        "VersionListCompressedHashCode":-131527863,//GameFrameworkVersion.xxxxx.dat文件压缩后的hash
        "END_OF_JSON":""//结束符
    }
    

    打开文件StarForce\Assets\GameMain\Configs\BuildInfo.txt

    {
      "GameVersion": "0.1.0",//最新的游戏版本号
      "InternalGameVersion": 0,//最新的游戏内部版本号
      "CheckVersionUrl": "http://10.23.48.21/Version.txt",//服务器文件version.txt地址
      "WindowsAppUrl": "http://10.23.48.21/Windows64",//win资源服务器
      "MacOSAppUrl": "https://starforce.gameframework.cn",//macOS资源服务器
      "IOSAppUrl": "https://starforce.gameframework.cn",//ios资源服务器
      "AndroidAppUrl": "https://starforce.gameframework.cn",//android资源服务器
      "END_OF_JSON": ""
    }
    
    

    打开HFS.exe,往里面存放full目录下的Window64和version.txt文件
    在这里插入图片描述

    检查Procedure是否都勾上
    在这里插入图片描述
    去掉Editor Resource Mode勾
    在这里插入图片描述
    打包运行。

    代码热更

    XIL仓库地址:XIL
    XIL使用手册看官方文档和源码

    给StartForce配置XIL

    1.把Demo、hotScripts、XIL三个目录放到StartForce/Assets目录下在这里插入图片描述

    2.在StartForce目录下新建HotProject~放入XIL目录下的Hot目录、DyncDll.csproj文件、Hot.sln解决方案在这里插入图片描述

    在这里插入图片描述

    修复编译报错

    1.Hot.sln解决方案,在解决方案看dll引用,如果报黄色警告都是需要修复,
    在这里插入图片描述
    2.打开DyncDLL.csproj文件,修改依赖路径。
    在这里插入图片描述
    3.如何修呢,怎么知道哪些需要哪些不需要呢,我秉承一贯原则,有需要才加,像Analytics(Services玩家数据埋点接口)、Newtonsoft.Json(json工具)、Purchasing.Common、UntiyEngine.Purchasing(IAP内购支付接口)等我都直接删除.剩下些必要的就修改本机对应路径就行。

    4.编辑器跑一下demo,修复奇奇怪怪的报错

    5.测试热更前,做一下准备。

    1.该在GF哪个流程加载dll?

    ProcedurePreload.PreloadResource进行资源加载。

            private void PreloadResources()
            {
                // Preload configs
                LoadConfig("DefaultConfig");
    
                // Preload data tables
                foreach (string dataTableName in DataTableNames)
                {
                    LoadDataTable(dataTableName);
                }
    
                // Preload dictionaries
                LoadDictionary("Default");
    
                // Preload fonts
                LoadFont("MainFont");
    
                LoadDLL("DyncDll");
                //GameEntry.Procedure.gameObject.AddComponent<HelloWorld>();
            }
            private void LoadDLL(string dllName)
            {
                string dllAssetName = AssetUtility.GetDLLAsset(dllName, false);
                //Debug.Log(dllAssetName);
    
                GameFrameworkLog.Debug("dll:{0}",dllAssetName);
    
                m_LoadedFlag.Add(dllAssetName, false);
    
    
    
                GameEntry.Resource.LoadBinary(dllAssetName, new LoadBinaryCallbacks(
                    (assetName, asset, duration, userData) =>
                    {
                        m_LoadedFlag[dllAssetName] = true;
    
                        GameFrameworkLog.Debug(asset);
                        GameFrameworkLog.Debug(userData);
                        GameFrameworkLog.Debug(duration);
                        GameFrameworkLog.Debug(assetName);
    #if USE_HOT
                        wxb.hotMgr.DLL = asset;
                        wxb.hotMgr.isGF = true;
    #endif
                        HelloWorld hellowrod = GameEntry.WebRequest.gameObject.AddComponent<HelloWorld>();
    
                        Debug.Log(asset);
    
                    },
    
                    (assetName, status, errorMessage, userData) =>
                    {
                        Log.Error("Can not load font '{0}' from '{1}' with error message '{2}'.", dllAssetName, assetName, errorMessage);
                    }));
            }
    

    2.dll以什么形式打AB包?

    把DyncDll.dll改成DyncDll.dll.bytes
    以Load From Binary形式进行打包和加载。
    在这里插入图片描述

    3.XIL现在能支持什么形式加载域?

    demo里例子是支持文件加载。客户端打包exe的GF加载框架需要添加以byte[]加载适配。

    		byte[] dll { get; set; }
            public EditorResLoadRuntime(byte[] dll)
            {
                this.dll = dll;
            }
    
            public Stream GetStream()
            {
                return new MemoryStream(dll);
            }
    

    完整代码会上传到github仓库
    仓库地址:GF-XIL
    1.安装hfs,把打包的资源和version.txt放上去。
    2.更改version.txt的UpdatePrefixUri为你自己的ip地址
    3.更改BuildInfo文件里的ip为你自己的ip地址
    4.把StarForce Launcher、Main、Menu场景放入BuildSettings里,打包出一个可以运行exe.运行即可.
    5.如果想要在编辑器运行demo,点击Hotfix inject in Editor即可。
    在这里插入图片描述

    StarFroce+XIL整合总结

    跑起来。中间因为文档的缺少,不得不去啃源码。
    还好加了群,大家回答都很热情。因为问和答有个时间差,还闹了低级错误,妄想直接给dll打AB包,
    为此还改了配置和源码(unity不能给识别不出来的资产打包(也许改底层打包源码可以)),MD是我不配,哈哈哈。

    总的来说,网上的文档详细的有可能有些细节就过时了,还是需要自己多多打断点跑源码。

    展开全文
  • 早在我没有发现启动场景的时候,我先发现了gameframework的那个预制,我想...这是流程组件节点Procedure 进入代码看看就知道确实是继承gf的组件类的 很明显这里勾选的是整个游戏启用的所有流程,entrance proc...

    早在我没有发现启动场景的时候,我先发现了gameframework的那个预制,我想启动游戏的时候首先遇到的一个问题就是流程,我已经在前文提到过。

     

    StarForce的启动场景中也有gameframwork这个预制只不过是已经经过作者加工组装之后的这点还是很好辨认出来的。builtin部分就是gameframework预制体了

     

    这是流程组件节点Procedure   进入代码看看就知道确实是继承gf的组件类的

     

    很明显这里勾选的是整个游戏启用的所有流程,entrance procedure 顾名思义是启动的第一个流程,这在前文中也提到过了。在前文中我也发现了游戏的在启动之前是要获取场景上的所有组件的。从前文的在ProcedureLaunch流程中组件报空就可得知。而获得所有组件的脚本是GameEntry脚本。

     

     

    先获取游戏的GF里的标准组件,再获取使用者自定义的组件StarFore就有两个自定义的组件(BuiltinData组件和HPBar组件)

     

    作者这里用partial class 把同属于GameEntry类的各个功能的方法写在了不同的脚本里。作者这种方法可以对代码进行不同功能呢的整理让一个文件里的代码不会太长。整体也挺有条理的。

     

    现在先看那个ProcedureLaunch流程吧首先是继承流程的基类。

     

    流程基类

     

     

    这里还不是UGF里面内容哦 是游戏逻辑需要用户自己实现的。(作者也写了命名空间可以看出来还是在StarFore内的)

     

    接着再往基类里面走,这次直接使用了GF里面的代码(不是UGF)哦。

     

    在这里发现gf中的流程基类是继承有限状态机类的 并且类型是IProcedureManager流程管理接口。

    往基类走可以知道这就是流程类的最终基类了是一个有限状态机泛型类并且有泛型约束

     

    这里的泛型约束的我也不太熟悉在网上看了相关的内容

     

    这很好解释了作者的代码就是一个预防措施(目前我是这么想的,接口是引用类型是合理的)

     

    流程管理接口。

     

    在这里原来using不仅只是用来引用命名空间的啊

    拓展C#中using的三种使用方法:https://www.cnblogs.com/mslalan/p/7452021.html

    作者在这里使用的是

    2.using别名。

    using 别名 = 包括详细命名空间信息的具体的类型。

    例如:

    using aClass = NameSpace1.MyClass; 

     

    这种做法有个好处就是当同一个cs引用了两个不同的命名空间,但两个命名空间都包括了一个相同名字的类型的时候。当需要用到这个类型的时候,就每个地方都要用详细命名空间的办法来区分这些相同名字的类型。而用别名的方法会更简洁,用到哪个类就给哪个类做别名声明就可以了。注意:并不是说两个名字重复,给其中一个用了别名,另外一个就不需要用别名了,如果两个都要使用,则两个都需要用using来定义别名的。

     

    进入代码查看

    IFsm = 有限状态机接口(接口)

    FsmState = 有限状态机状态基类 (抽象类)

    IProcedureManager = 流程管理接口(接口)

    其实最主要的就是FsmState<T>(泛型类)GameFramework.Procedure.ProcedureBase类里面的方法比较多

    FsmState里有除了上图中的方法还有两个改变状态的方法功能应该是差不多的

      

    在这两个方法中还引用了其他类就是Fsm<T> 从名字来看着就是有限状态机的类了 FsmState<T>是有限状态机状态基类    一个是状态机本身一个是状态机的状态基类。

    再进入这个Fsm<T>类中查看

    状态机类继承状态机基类,引用接口,状态机接口。

    附上最终的图解 有点乱哈哈

    上面我只是针对我自己这个流程的梳理 网上烟雨博客做了个全局的梳理我觉得很好如下:

     

     

    fsm主要是在fsmstate 和 fsmmanager 之前做一个桥梁的作用

    总结一下就是在fsm主要是在fsmstate 和流程控制就是状态的切换,fsm更新最新的流程,在每个流程内切换其他流程的时候也和fsm里进行数据交互。用烟雨的话说就是:

    由基层的Fsm更新来驱动状态机状态的更新,状态机状态的切换也会传递到底层的Fsm上,即一切状态都被Fsm持有与维护

     

    到这里为止已经把流程这个类梳理了一遍了

    图上有很多函数我没有写出来就写了一些重要的。

    现在回到最上层看下StarForce的启动流程做了些什么事情。在这里作者的注释已经写得很清楚了。

     

    启动流程的功能就是初始化一些游戏的基本配置,然后在运行的一帧后就切换到splash流程。

    starForce的总体流程如下:

     

    想要添加自定义的流程

    只要自定义的类继承自procedureBase并实现流程基类里相应的方法就行了。

    每个流程就是一个游戏状态,作者也是这个这么设计的。相当于把运行时的游戏逻辑分类了,

    展开全文
  • GF开发框架-其他

    2021-06-11 21:26:24
    GF(Go Frame)是一款模块化、高性能、生产级的Go基础开发框架。 实现了比较完善的基础设施建设以及开发工具链,提供了常用的基础开发模块, 如:缓存、日志、队列、数组、集合、容器、定时器、命令行、内存锁、对象池...
  • GF开发框架 v1.14.5

    2020-12-08 01:41:00
    为您提供GF开发框架下载,GF(Go Frame)是一款模块化、高性能、生产级的Go基础开发框架。 实现了比较完善的基础设施建设以及开发工具链,提供了常用的基础开发模块, 如:缓存、日志、队列、数组、集合、容器、定时器...
  • GF资源管理实属牛批,但要使用它,并不是全自动的,还是要配置一下 创建一个静态类,类名随意,注意里面至少要包含以下三个属性,后面的地址所指就是打AB包所必须的三个配置文件(这个地址可以自己更改,注意改变...

    1.AB包相关配置

    GF资源管理实属牛批,但要使用它,并不是全自动的,还是要配置一下

    创建一个静态类,类名随意,注意里面至少要包含以下三个属性,后面的地址所指就是打AB包所必须的三个配置文件(这个地址可以自己更改,注意改变路径就行)

            [AssetBundleBuilderConfigPath] public static string AssetBundleBuilderConfig =
                Utility.Path.GetCombinePath(Application.dataPath, "GameMain/Configs/AssetBundleBuilder.xml");
    
            [AssetBundleEditorConfigPath] public static string AssetBundleEditorConfig =
                Utility.Path.GetCombinePath(Application.dataPath, "GameMain/Configs/AssetBundleEditor.xml");
    
            [AssetBundleCollectionConfigPath] public static string AssetBundleCollectionConfig =
                Utility.Path.GetCombinePath(Application.dataPath, "GameMain/Configs/AssetBundleCollection.xml");

    其中除了AssetBundleEditor.xml,其余两个都可以在打包的时候自动升成。所以我们要指定目录创建AssetBundleEditor.xml文件,并在里面填入以下信息

    其中SourceAssetRootPath是指定资源根目录位置的,自己注意视情况更改

    <?xml version="1.0" encoding="UTF-8"?>
    <UnityGameFramework>
        <AssetBundleEditor>
            <Settings>
                <SourceAssetRootPath>Assets/GameMain</SourceAssetRootPath>
                <SourceAssetSearchPaths>
                    <SourceAssetSearchPath RelativePath=""/>
                </SourceAssetSearchPaths>
                <SourceAssetUnionTypeFilter>t:Scene t:Prefab t:Shader t:Model t:Material t:Texture t:AudioClip
                    t:AnimationClip t:AnimatorController t:Font t:TextAsset t:ScriptableObject
                </SourceAssetUnionTypeFilter>
                <SourceAssetUnionLabelFilter>l:AssetBundleInclusive</SourceAssetUnionLabelFilter>
                <SourceAssetExceptTypeFilter>t:Script</SourceAssetExceptTypeFilter>
                <SourceAssetExceptLabelFilter>l:AssetBundleExclusive</SourceAssetExceptLabelFilter>
                <AssetSorter>Name</AssetSorter>
            </Settings>
        </AssetBundleEditor>
    </UnityGameFramework>

    2.UI模块相关

    说实话我没想到使用UI模块会出那么多变故。。。我花了半天时间才找到问题所在。。。

    首先要创建并设置一个默认Canvas,因为没有Canvas的支撑,UGUI无法正确显示

    再搞一个UGuiGroupHelper

    //------------------------------------------------------------
    // Author: 烟雨迷离半世殇
    // Mail: 1778139321@qq.com
    // Data: 2019年1月11日 23:35:22
    //------------------------------------------------------------
    
    using UnityEngine;
    using UnityEngine.UI;
    using UnityGameFramework.Runtime;
    
    namespace GameMain.Scripts.UI
    {
        public class UGuiGroupHelper : UIGroupHelperBase
        {
            public const int DepthFactor = 1000;
    
            private int m_Depth = 0;
            private Canvas m_CachedCanvas = null;
    
            /// <summary>
            /// 设置界面组深度。
            /// </summary>
            /// <param name="depth">界面组深度。</param>
            public override void SetDepth(int depth)
            {
                m_Depth = depth;
                m_CachedCanvas.overrideSorting = true;
                m_CachedCanvas.sortingOrder = DepthFactor * depth;
            }
    
            private void Awake()
            {
                m_CachedCanvas = gameObject.GetOrAddComponent<Canvas>();
                gameObject.GetOrAddComponent<GraphicRaycaster>();
            }
    
            private void Start()
            {
                m_CachedCanvas.overrideSorting = true;
                m_CachedCanvas.sortingOrder = DepthFactor * m_Depth;
    
                RectTransform transform = GetComponent<RectTransform>();
                transform.anchorMin = Vector2.zero;
                transform.anchorMax = Vector2.one;
                transform.anchoredPosition = Vector2.zero;
                transform.sizeDelta = Vector2.zero;
            }
        }
    }

    按下图所示替换默认的辅助器

    然后是UGuiForm

    //------------------------------------------------------------
    // Author: 烟雨迷离半世殇
    // Mail: 1778139321@qq.com
    // Data: 2019年1月11日 23:42:05
    //------------------------------------------------------------
    
    using UnityEngine;
    using UnityEngine.UI;
    using UnityGameFramework.Runtime;
    
    namespace GameMain.Scripts.UI
    {
       public class UGuiForm : UIFormLogic
        {
            private Canvas m_CachedCanvas = null;
    
            public const int DepthFactor = 100;
            public int OriginalDepth
            {
                get;
                private set;
            }
    
            public int Depth
            {
                get
                {
                    return m_CachedCanvas.sortingOrder;
                }
            }
    
            protected override void OnInit(object userData)
            {
                base.OnInit(userData);
    
                m_CachedCanvas = gameObject.GetOrAddComponent<Canvas>();
                m_CachedCanvas.overrideSorting = true;
                OriginalDepth = m_CachedCanvas.sortingOrder;
    
                RectTransform transform = GetComponent<RectTransform>();
                transform.anchorMin = Vector2.zero;
                transform.anchorMax = Vector2.one;
                transform.anchoredPosition = Vector2.zero;
                transform.sizeDelta = Vector2.zero;
    
                gameObject.GetOrAddComponent<GraphicRaycaster>();
            }
    
            protected override void OnDepthChanged(int uiGroupDepth, int depthInUIGroup)
            {
                int oldDepth = Depth;
                base.OnDepthChanged(uiGroupDepth, depthInUIGroup);
                int deltaDepth = UGuiGroupHelper.DepthFactor * uiGroupDepth + DepthFactor * depthInUIGroup - oldDepth +
                                 OriginalDepth;
                Canvas[] canvases = GetComponentsInChildren<Canvas>(true);
                for (int i = 0; i < canvases.Length; i++)
                {
                    canvases[i].sortingOrder += deltaDepth;
                }
            }
        }
    }

    每个UIForm都要继承这个类

    至此,你做的UI效果,才是你想要的效果。。。

    最后,配置表里面的被其他UI遮挡是否会暂停,只会在同一UI Group下面生效

    3.配表相关

    保存的时候选择-文本文件(制表符分隔)

    在Unity中应当能识别其数据

    没有的话,就用文本文档打开,另存为UTF-8

    4:使用类自动生成工具

    先在Scripts下面新建如下

    (重要部分E大和我已经打上注释,请注意查看,PS:代码全部为E大所开发,本人只是将自己的理解传达给大家,文件头的Author请自动忽略)

    他们依次为

    DataTableCodeTemplate.txt

    //------------------------------------------------------------
    // Game Framework
    // Copyright © 2013-2019 Jiang Yin. All rights reserved.
    // Homepage: http://gameframework.cn/
    // Feedback: mailto:jiangyin@gameframework.cn
    //------------------------------------------------------------
    // 此文件由工具自动生成,请勿直接修改。
    // 生成时间:__DATA_TABLE_CREATE_TIME__
    //------------------------------------------------------------
    
    using GameFramework;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Text;
    using UnityEngine;
    using UnityGameFramework.Runtime;
    
    namespace __DATA_TABLE_NAME_SPACE__
    {
        /// <summary>
        /// __DATA_TABLE_COMMENT__
        /// </summary>
        public class __DATA_TABLE_CLASS_NAME__ : DataRowBase
        {
            private int m_Id = 0;
    
            /// <summary>
            /// __DATA_TABLE_ID_COMMENT__
            /// </summary>
            public override int Id
            {
                get
                {
                    return m_Id;
                }
            }
    
    __DATA_TABLE_PROPERTIES__
    
    __DATA_TABLE_STRING_PARSER__
    
    __DATA_TABLE_BYTES_PARSER__
    
    __DATA_TABLE_STREAM_PARSER__
    
    __DATA_TABLE_PROPERTY_ARRAY__
        }
    }
    //------------------------------------------------------------
    // Author: 烟雨迷离半世殇
    // Mail: 1778139321@qq.com
    // Data: 2019年2月10日
    //------------------------------------------------------------
    
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Text;
    using System.Text.RegularExpressions;
    using GameFramework;
    using UnityEngine;
    using UnityGameFramework.Editor.DataTableTools;
    
    namespace Assets.GameMain.Scripts.DataTable.DataTableGenerator
    {
        public class DataTableGenerator
        {
            //数据表(.txt文件所在位置)
            private const string DataTablePath = "Assets/GameMain/DataTables";
            //生成的CSharp类所在位置
            private const string CSharpCodePath = "Assets/GameMain/Scripts/DataTable";
            //用于临时存读CSharp代码的txt文件所在位置(如果没有,请创建)
            private const string CSharpCodeTemplateFileName = "Assets/GameMain/Configs/DataTableCodeTemplate.txt";
            private static readonly Regex EndWithNumberRegex = new Regex(@"\d+$");
            private static readonly Regex NameRegex = new Regex(@"^[A-Z][A-Za-z0-9_]+$");
    
            public static DataTableProcessor CreateDataTableProcessor(string dataTableName)
            {
                return new DataTableProcessor(Utility.Path.GetCombinePath(DataTablePath, dataTableName + ".txt"), Encoding.Default, 1, 2, null, 3, 4, 1);
            }
    
            public static bool CheckRawData(DataTableProcessor dataTableProcessor, string dataTableName)
            {
                for (int i = 0; i < dataTableProcessor.RawColumnCount; i++)
                {
                    string name = dataTableProcessor.GetName(i);
                    if (string.IsNullOrEmpty(name) || name == "#")
                    {
                        continue;
                    }
    
                    if (!NameRegex.IsMatch(name))
                    {
                        Debug.LogWarning(Utility.Text.Format("Check raw data failure. DataTableName='{0}' Name='{1}'", dataTableName, name));
                        return false;
                    }
                }
    
                return true;
            }
    
            public static void GenerateDataFile(DataTableProcessor dataTableProcessor, string dataTableName)
            {
                string binaryDataFileName = Utility.Path.GetCombinePath(DataTablePath, dataTableName + ".bytes");
                if (!dataTableProcessor.GenerateDataFile(binaryDataFileName, Encoding.UTF8) && File.Exists(binaryDataFileName))
                {
                    File.Delete(binaryDataFileName);
                }
            }
    
            public static void GenerateCodeFile(DataTableProcessor dataTableProcessor, string dataTableName)
            {
                dataTableProcessor.SetCodeTemplate(CSharpCodeTemplateFileName, Encoding.UTF8);
                dataTableProcessor.SetCodeGenerator(DataTableCodeGenerator);
    
                string csharpCodeFileName = Utility.Path.GetCombinePath(CSharpCodePath, "DR" + dataTableName + ".cs");
                if (!dataTableProcessor.GenerateCodeFile(csharpCodeFileName, Encoding.UTF8, dataTableName) && File.Exists(csharpCodeFileName))
                {
                    File.Delete(csharpCodeFileName);
                }
            }
    
            private static void DataTableCodeGenerator(DataTableProcessor dataTableProcessor, StringBuilder codeContent, object userData)
            {
                string dataTableName = (string)userData;
    
                codeContent.Replace("__DATA_TABLE_CREATE_TIME__", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
                //所生成的CSharp类的命名空间,请保证它与BinaryReaderExtension.cs和DataTableExtension.cs的命名空间一致,否则将不能正确解析
                codeContent.Replace("__DATA_TABLE_NAME_SPACE__", "Assets.GameMain.Scripts.DataTable");
                codeContent.Replace("__DATA_TABLE_CLASS_NAME__", "DR" + dataTableName);
                codeContent.Replace("__DATA_TABLE_COMMENT__", dataTableProcessor.GetValue(0, 1) + "。");
                codeContent.Replace("__DATA_TABLE_ID_COMMENT__", "获取" + dataTableProcessor.GetComment(dataTableProcessor.IdColumn) + "。");
                codeContent.Replace("__DATA_TABLE_PROPERTIES__", GenerateDataTableProperties(dataTableProcessor));
                codeContent.Replace("__DATA_TABLE_STRING_PARSER__", GenerateDataTableStringParser(dataTableProcessor));
                codeContent.Replace("__DATA_TABLE_BYTES_PARSER__", GenerateDataTableBytesParser(dataTableProcessor));
                codeContent.Replace("__DATA_TABLE_STREAM_PARSER__", GenerateDataTableStreamParser(dataTableProcessor));
                codeContent.Replace("__DATA_TABLE_PROPERTY_ARRAY__", GenerateDataTablePropertyArray(dataTableProcessor));
            }
    
            private static string GenerateDataTableProperties(DataTableProcessor dataTableProcessor)
            {
                StringBuilder stringBuilder = new StringBuilder();
                bool firstProperty = true;
                for (int i = 0; i < dataTableProcessor.RawColumnCount; i++)
                {
                    if (dataTableProcessor.IsCommentColumn(i))
                    {
                        // 注释列
                        continue;
                    }
    
                    if (dataTableProcessor.IsIdColumn(i))
                    {
                        // 编号列
                        continue;
                    }
    
                    if (firstProperty)
                    {
                        firstProperty = false;
                    }
                    else
                    {
                        stringBuilder.AppendLine().AppendLine();
                    }
    
                    stringBuilder
                        .AppendLine("        /// <summary>")
                        .AppendFormat("        /// 获取{0}。", dataTableProcessor.GetComment(i)).AppendLine()
                        .AppendLine("        /// </summary>")
                        .AppendFormat("        public {0} {1}", dataTableProcessor.GetLanguageKeyword(i), dataTableProcessor.GetName(i)).AppendLine()
                        .AppendLine("        {")
                        .AppendLine("            get;")
                        .AppendLine("            private set;")
                        .Append("        }");
                }
    
                return stringBuilder.ToString();
            }
    
            private static string GenerateDataTableStringParser(DataTableProcessor dataTableProcessor)
            {
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder
                    .AppendLine("        public override bool ParseDataRow(GameFrameworkSegment<string> dataRowSegment)")
                    .AppendLine("        {")
                    .AppendLine("            // Star Force 示例代码,正式项目使用时请调整此处的生成代码,以处理 GCAlloc 问题!")
                    .AppendLine("            string[] columnTexts = dataRowSegment.Source.Substring(dataRowSegment.Offset, dataRowSegment.Length).Split(DataTableExtension.DataSplitSeparator);")
                    .AppendLine("            for (int i = 0; i < columnTexts.Length; i++)")
                    .AppendLine("            {")
                    .AppendLine("                columnTexts[i] = columnTexts[i].Trim(DataTableExtension.DataTrimSeparator);")
                    .AppendLine("            }")
                    .AppendLine()
                    .AppendLine("            int index = 0;");
    
                for (int i = 0; i < dataTableProcessor.RawColumnCount; i++)
                {
                    if (dataTableProcessor.IsCommentColumn(i))
                    {
                        // 注释列
                        stringBuilder.AppendLine("            index++;");
                        continue;
                    }
    
                    if (dataTableProcessor.IsIdColumn(i))
                    {
                        // 编号列
                        stringBuilder.AppendLine("            m_Id = int.Parse(columnTexts[index++]);");
                        continue;
                    }
    
                    if (dataTableProcessor.IsSystem(i))
                    {
                        string languageKeyword = dataTableProcessor.GetLanguageKeyword(i);
                        if (languageKeyword == "string")
                        {
                            stringBuilder.AppendFormat("            {0} = columnTexts[index++];", dataTableProcessor.GetName(i)).AppendLine();
                        }
                        else
                        {
                            stringBuilder.AppendFormat("            {0} = {1}.Parse(columnTexts[index++]);", dataTableProcessor.GetName(i), languageKeyword).AppendLine();
                        }
                    }
                    else
                    {
                        stringBuilder.AppendFormat("            {0} = DataTableExtension.Parse{1}(columnTexts[index++]);", dataTableProcessor.GetName(i), dataTableProcessor.GetType(i).Name).AppendLine();
                    }
                }
    
                stringBuilder
                    .AppendLine()
                    .AppendLine("            GeneratePropertyArray();")
                    .AppendLine("            return true;")
                    .Append("        }");
    
                return stringBuilder.ToString();
            }
    
            private static string GenerateDataTableBytesParser(DataTableProcessor dataTableProcessor)
            {
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder
                    .AppendLine("        public override bool ParseDataRow(GameFrameworkSegment<byte[]> dataRowSegment)")
                    .AppendLine("        {")
                    .AppendLine("            // Star Force 示例代码,正式项目使用时请调整此处的生成代码,以处理 GCAlloc 问题!")
                    .AppendLine("            string[] columnTexts = dataRowSegment.Source.Substring(dataRowSegment.Offset, dataRowSegment.Length).Split(DataTableExtension.DataSplitSeparator);")
                    .AppendLine("            for (int i = 0; i < columnTexts.Length; i++)")
                    .AppendLine("            {")
                    .AppendLine("                columnTexts[i] = columnTexts[i].Trim(DataTableExtension.DataTrimSeparator);")
                    .AppendLine("            }")
                    .AppendLine()
                    .AppendLine("            int index = 0;");
    
                for (int i = 0; i < dataTableProcessor.RawColumnCount; i++)
                {
                    if (dataTableProcessor.IsCommentColumn(i))
                    {
                        // 注释列
                        continue;
                    }
    
                    if (dataTableProcessor.IsIdColumn(i))
                    {
                        // 编号列
                        stringBuilder.AppendLine("                    m_Id = binaryReader.ReadInt32();");
                        continue;
                    }
    
                    stringBuilder.AppendFormat("                    {0} = binaryReader.Read{1}();", dataTableProcessor.GetName(i), dataTableProcessor.GetType(i).Name).AppendLine();
                }
    
                stringBuilder
                    .AppendLine("                }")
                    .AppendLine("            }")
                    .AppendLine()
                    .AppendLine("            GeneratePropertyArray();")
                    .AppendLine("            return true;")
                    .Append("        }");
    
                return stringBuilder.ToString();
            }
    
            private static string GenerateDataTableStreamParser(DataTableProcessor dataTableProcessor)
            {
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder
                    .AppendLine("        public override bool ParseDataRow(GameFrameworkSegment<Stream> dataRowSegment)")
                    .AppendLine("        {")
                    .AppendLine("            Log.Warning(\"Not implemented ParseDataRow(GameFrameworkSegment<Stream>)\");")
                    .AppendLine("            return false;")
                    .Append("        }");
    
                return stringBuilder.ToString();
            }
    
            private static string GenerateDataTablePropertyArray(DataTableProcessor dataTableProcessor)
            {
                List<PropertyCollection> propertyCollections = new List<PropertyCollection>();
                for (int i = 0; i < dataTableProcessor.RawColumnCount; i++)
                {
                    if (dataTableProcessor.IsCommentColumn(i))
                    {
                        // 注释列
                        continue;
                    }
    
                    if (dataTableProcessor.IsIdColumn(i))
                    {
                        // 编号列
                        continue;
                    }
    
                    string name = dataTableProcessor.GetName(i);
                    if (!EndWithNumberRegex.IsMatch(name))
                    {
                        continue;
                    }
    
                    string propertyCollectionName = EndWithNumberRegex.Replace(name, string.Empty);
                    int id = int.Parse(EndWithNumberRegex.Match(name).Value);
    
                    PropertyCollection propertyCollection = null;
                    foreach (PropertyCollection pc in propertyCollections)
                    {
                        if (pc.Name == propertyCollectionName)
                        {
                            propertyCollection = pc;
                            break;
                        }
                    }
    
                    if (propertyCollection == null)
                    {
                        propertyCollection = new PropertyCollection(propertyCollectionName, dataTableProcessor.GetLanguageKeyword(i));
                        propertyCollections.Add(propertyCollection);
                    }
    
                    propertyCollection.AddItem(id, name);
                }
    
                StringBuilder stringBuilder = new StringBuilder();
                bool firstProperty = true;
                foreach (PropertyCollection propertyCollection in propertyCollections)
                {
                    if (firstProperty)
                    {
                        firstProperty = false;
                    }
                    else
                    {
                        stringBuilder.AppendLine().AppendLine();
                    }
    
                    stringBuilder
                        .AppendFormat("        private KeyValuePair<int, {1}>[] m_{0} = null;", propertyCollection.Name, propertyCollection.LanguageKeyword).AppendLine()
                        .AppendLine()
                        .AppendFormat("        public int Get{0}(int id)", propertyCollection.Name).AppendLine()
                        .AppendLine("        {")
                        .AppendFormat("            foreach (KeyValuePair<int, {1}> i in m_{0})", propertyCollection.Name, propertyCollection.LanguageKeyword).AppendLine()
                        .AppendLine("            {")
                        .AppendLine("                if (i.Key == id)")
                        .AppendLine("                {")
                        .AppendLine("                    return i.Value;")
                        .AppendLine("                }")
                        .AppendLine("            }")
                        .AppendLine()
                        .AppendFormat("            throw new GameFrameworkException(Utility.Text.Format(\"Get{0} with invalid id '{{0}}'.\", id.ToString()));", propertyCollection.Name).AppendLine()
                        .AppendLine("        }")
                        .AppendLine()
                        .AppendFormat("        public int Get{0}At(int index)", propertyCollection.Name).AppendLine()
                        .AppendLine("        {")
                        .AppendFormat("            if (index < 0 || index >= m_{0}.Length)", propertyCollection.Name).AppendLine()
                        .AppendLine("            {")
                        .AppendFormat("                throw new GameFrameworkException(Utility.Text.Format(\"Get{0}At with invalid index '{{0}}'.\", index.ToString()));", propertyCollection.Name).AppendLine()
                        .AppendLine("            }")
                        .AppendLine()
                        .AppendFormat("            return m_{0}[index].Value;", propertyCollection.Name).AppendLine()
                        .Append("        }");
                }
    
                if (propertyCollections.Count > 0)
                {
                    stringBuilder.AppendLine().AppendLine();
                }
    
                stringBuilder
                    .AppendLine("        private void GeneratePropertyArray()")
                    .AppendLine("        {");
    
                firstProperty = true;
                foreach (PropertyCollection propertyCollection in propertyCollections)
                {
                    if (firstProperty)
                    {
                        firstProperty = false;
                    }
                    else
                    {
                        stringBuilder.AppendLine().AppendLine();
                    }
    
                    stringBuilder
                        .AppendFormat("            m_{0} = new KeyValuePair<int, {1}>[]", propertyCollection.Name, propertyCollection.LanguageKeyword).AppendLine()
                        .AppendLine("            {");
    
                    int itemCount = propertyCollection.ItemCount;
                    for (int i = 0; i < itemCount; i++)
                    {
                        KeyValuePair<int, string> item = propertyCollection.GetItem(i);
                        stringBuilder.AppendFormat("                new KeyValuePair<int, {0}>({1}, {2}),", propertyCollection.LanguageKeyword, item.Key.ToString(), item.Value).AppendLine();
                    }
    
                    stringBuilder.Append("            };");
                }
    
                stringBuilder
                    .AppendLine()
                    .Append("        }");
    
                return stringBuilder.ToString();
            }
    
            private sealed class PropertyCollection
            {
                private readonly string m_Name;
                private readonly string m_LanguageKeyword;
                private readonly List<KeyValuePair<int, string>> m_Items;
    
                public PropertyCollection(string name, string languageKeyword)
                {
                    m_Name = name;
                    m_LanguageKeyword = languageKeyword;
                    m_Items = new List<KeyValuePair<int, string>>();
                }
    
                public string Name
                {
                    get
                    {
                        return m_Name;
                    }
                }
    
                public string LanguageKeyword
                {
                    get
                    {
                        return m_LanguageKeyword;
                    }
                }
    
                public int ItemCount
                {
                    get
                    {
                        return m_Items.Count;
                    }
                }
    
                public KeyValuePair<int, string> GetItem(int index)
                {
                    if (index < 0 || index >= m_Items.Count)
                    {
                        throw new GameFrameworkException(Utility.Text.Format("GetItem with invalid index '{0}'.", index.ToString()));
                    }
    
                    return m_Items[index];
                }
    
                public void AddItem(int id, string propertyName)
                {
                    m_Items.Add(new KeyValuePair<int, string>(id, propertyName));
                }
            }
        }
    }
    //------------------------------------------------------------
    // Author: 烟雨迷离半世殇
    // Mail: 1778139321@qq.com
    // Data: 2019年2月10日
    //------------------------------------------------------------
    
    using Assets.GameMain.Scripts.Procedure;
    using GameFramework;
    using UnityEditor;
    using UnityEngine;
    using UnityGameFramework.Editor.DataTableTools;
    
    namespace Assets.GameMain.Scripts.DataTable.DataTableGenerator
    {
        public class DataTableGeneratorMenu
        {
            [MenuItem("DataTableTools/Generate DataTables")]
            private static void GenerateDataTables()
            {
                //所要生成的CSharp类取决于ProcedurePreload.DataTableNames(自己视情况改变)
                foreach (string dataTableName in ProcedurePreload.DataTableNames)
                {
                    DataTableProcessor dataTableProcessor = DataTableGenerator.CreateDataTableProcessor(dataTableName);
                    if (!DataTableGenerator.CheckRawData(dataTableProcessor, dataTableName))
                    {
                        Debug.LogError(Utility.Text.Format("Check raw data failure. DataTableName='{0}'", dataTableName));
                        return;
                    }
    
                    DataTableGenerator.GenerateDataFile(dataTableProcessor, dataTableName);
                    DataTableGenerator.GenerateCodeFile(dataTableProcessor, dataTableName);
                }
    
                AssetDatabase.Refresh();
            }
        }
    }
    //------------------------------------------------------------
    // Author: 烟雨迷离半世殇
    // Mail: 1778139321@qq.com
    // Data: 2019年2月10日
    //------------------------------------------------------------
    
    using System;
    using UnityEngine;
    using System.IO;
    namespace Assets.GameMain.Scripts.DataTable
    {
        public static class BinaryReaderExtension
        {
            public static Color32 ReadColor32(this BinaryReader binaryReader)
            {
                return new Color32(binaryReader.ReadByte(), binaryReader.ReadByte(), binaryReader.ReadByte(), binaryReader.ReadByte());
            }
    
            public static Color ReadColor(this BinaryReader binaryReader)
            {
                return new Color(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
            }
    
            public static DateTime ReadDateTime(this BinaryReader binaryReader)
            {
                return new DateTime(binaryReader.ReadInt64());
            }
    
            public static Quaternion ReadQuaternion(this BinaryReader binaryReader)
            {
                return new Quaternion(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
            }
    
            public static Rect ReadRect(this BinaryReader binaryReader)
            {
                return new Rect(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
            }
    
            public static Vector2 ReadVector2(this BinaryReader binaryReader)
            {
                return new Vector2(binaryReader.ReadSingle(), binaryReader.ReadSingle());
            }
    
            public static Vector3 ReadVector3(this BinaryReader binaryReader)
            {
                return new Vector3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
            }
    
            public static Vector4 ReadVector4(this BinaryReader binaryReader)
            {
                return new Vector4(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
            }
        }
    }

     

     

    //------------------------------------------------------------
    // Author: 烟雨迷离半世殇
    // Mail: 1778139321@qq.com
    // Data: 2019年1月12日 20:56:31
    //------------------------------------------------------------
    
    using GameFramework;
    using System;
    using Assets.GameMain.Scripts.Definition.Constant;
    using GameMain;
    using UnityEngine;
    using UnityGameFramework.Runtime;
    
    namespace Assets.GameMain.Scripts.DataTable
    {
        public static class DataTableExtension
        {
            //CSharp类的前置命名空间
            private const string DataRowClassPrefixName = "Assets.GameMain.Scripts.DataTable.DR";
            internal const char DataSplitSeparator = '\t';
            internal const char DataTrimSeparator = '\"';
    
            public static void LoadDataTable(this DataTableComponent dataTableComponent, string dataTableName,
                LoadType loadType, object userData = null)
            {
                if (string.IsNullOrEmpty(dataTableName))
                {
                    Log.Warning("Data table name is invalid.");
                    return;
                }
    
                string[] splitNames = dataTableName.Split('_');
                if (splitNames.Length > 2)
                {
                    Log.Warning("Data table name is invalid.");
                    return;
                }
    
                string dataRowClassName = DataRowClassPrefixName + splitNames[0];
    
                Type dataRowType = Type.GetType(dataRowClassName);
                if (dataRowType == null)
                {
                    Log.Warning("Can not get data row type with class name '{0}'.", dataRowClassName);
                    return;
                }
    
                string dataTableNameInType = splitNames.Length > 1 ? splitNames[1] : null;
                dataTableComponent.LoadDataTable(dataRowType, dataTableName, dataTableNameInType,
                    AssetUtility.GetDataTableAsset(dataTableName, loadType), loadType,
                    Constant.AssetPriority.DataTableAsset, userData);
            }
    
            public static Color32 ParseColor32(string value)
            {
                string[] splitValue = value.Split(',');
                return new Color32(byte.Parse(splitValue[0]), byte.Parse(splitValue[1]), byte.Parse(splitValue[2]),
                    byte.Parse(splitValue[3]));
            }
    
            public static Color ParseColor(string value)
            {
                string[] splitValue = value.Split(',');
                return new Color(float.Parse(splitValue[0]), float.Parse(splitValue[1]), float.Parse(splitValue[2]),
                    float.Parse(splitValue[3]));
            }
    
            public static Quaternion ParseQuaternion(string value)
            {
                string[] splitValue = value.Split(',');
                return new Quaternion(float.Parse(splitValue[0]), float.Parse(splitValue[1]), float.Parse(splitValue[2]),
                    float.Parse(splitValue[3]));
            }
    
            public static Rect ParseRect(string value)
            {
                string[] splitValue = value.Split(',');
                return new Rect(float.Parse(splitValue[0]), float.Parse(splitValue[1]), float.Parse(splitValue[2]),
                    float.Parse(splitValue[3]));
            }
    
            public static Vector2 ParseVector2(string value)
            {
                string[] splitValue = value.Split(',');
                return new Vector2(float.Parse(splitValue[0]), float.Parse(splitValue[1]));
            }
    
            public static Vector3 ParseVector3(string value)
            {
                string[] splitValue = value.Split(',');
                return new Vector3(float.Parse(splitValue[0]), float.Parse(splitValue[1]), float.Parse(splitValue[2]));
            }
    
            public static Vector4 ParseVector4(string value)
            {
                string[] splitValue = value.Split(',');
                return new Vector4(float.Parse(splitValue[0]), float.Parse(splitValue[1]), float.Parse(splitValue[2]),
                    float.Parse(splitValue[3]));
            }
        }
    }

     

    展开全文
  • 基于gf框架的管理平台,支持登录、认证、组织机构、用户、角色、菜单、日志
  • gf框架之gdb - 优雅强大的数据库ORM

    千次阅读 2018-03-12 02:55:25
    gf框架的数据库ORM操作由gdb包提供支持,gdb包经过非常精心优雅的设计,提供了非常强大的配置管理、方法操作、链式操作、事务操作等功能。gdb包具体API说明文档详见:godoc 。本章节对gdb包的使用进行基本的介绍,...
  • 文章来源:http://gf.johng.cn/494368 当用户访问某个URI时,Web Server能够精确的调用特定的服务接口提供服务,这些都是通过“服务注册”来实现的。Web Server提供服务需要回调函数/方法/对象/控制器的支持,ghttp...
  • gf框架使用sqlite3数据库后交叉编译cgo适配arm64-linux 文章目录gf框架使用sqlite3数据库后交叉编译cgo适配arm64-linux1. 前言2. 解决方案3. wsl+Windows交叉编译cgo工程3.1 简述cgo程序交叉编译3.2 安装交叉编译...
  • gf框架针对常用的数据格式编码解析,提供了异常强大灵活的功能,由gparser包提供,支持Go变量(interface{})、Struct、JSON、XML、YAML/YML、TOML数据格式之间的相互转换,支持按照层级进行数据检索访问、支持运行时...
  • gf框架JWT的使用方式

    2021-10-29 15:51:02
    goframe框架的JWT需要继承并实现里面的对应方法,在auth_jwt包中有相应的调用,以下为调用流程 1 正常来说,登陆时需要生成token并返回,gf的jwt包里有相应方法(loginHandler),并且写的很清楚,登陆的request...
  • GF_JustOneLevel(只有一关)基于框架的小游戏——《只有一关》没错,内容只有一关,游戏名字也叫做只有一关。其实这是我学习Unity3D后做的第一个游戏,现在用GameFramework重制一次。不过,由于时间关系,元素少了...
  • GF开发框架 v1.14.6

    2020-12-28 16:15:51
    为您提供GF开发框架下载,GF(Go Frame)是一款模块化、高性能、生产级的Go基础开发框架。 实现了比较完善的基础设施建设以及开发工具链,提供了常用的基础开发模块, 如:缓存、日志、队列、数组、集合、容器、定时器...
  • gf框架提供了几个非常实用的并发安全容器,其中gmap就是项目开发中最常用的一个。 gmap具体的方法请参考godoc:https://godoc.org/github.com/... gmap内部有多个类型结构体定义,包括:IntBoolMap、IntIntMap、...
  • GF(Go Frame)是一款模块化、高性能、生产级的Go基础开发框架。实现了比较完善的基础设施建设,包括常用的核心开发组件, 如:缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、...
  • postman测试gf框架登录及相关token接口 文章目录postman测试gf框架登录及相关token接口 登录时一般会通过token方式进行登录验证,各个子页面也通过token来进行超时判断,因此postman测试接口时可能需要设置用户验证...
  • 文章来源:http://gf.johng.cn/625833 基本介绍 平滑重启(热重启)是指Web Server在重启的时候不会中断已有请求的执行。该特性在不同的项目版本发布的时候特别有用,例如,当需要先后发布两个版本:A、B,那么在A执行...
  • Timeline运行时状态机无法切换下一个状态
  • gf框架提供了独立的二进制数据操作包gbinary,主要用于各种数据类型与[ ]byte二进制类型之间的相互转换;以及针对于整型数据进行精准按位处理的功能。常用于网络通信时数据编码/解码,以及数据文件操作时的编码/解码...
  • GF开发框架 v1.14.2

    2020-11-25 00:22:44
    为您提供GF开发框架下载,GF(Go Frame)是一款模块化、高性能、生产级的Go基础开发框架。 实现了比较完善的基础设施建设以及开发工具链,提供了常用的基础开发模块, 如:缓存、日志、队列、数组、集合、容器、定时器...
  • gf为控制器提供了良好的模板引擎支持,由gmvc.View视图对象进行管理,提供了良好的数据隔离性。控制器视图是并发安全设计的,允许在多线程中异步操作。 func (view *View) Assign(key string, value interface{}) .....
  • golang gf框架代码:package mainimport ("github.com/gogf/gf/net/ghttp""github.com/gogf/gf/os/glog")const (usernameIN = "admin"passwdIN = "admin"sessionKey = "adminLogin")func AuthMiddleware(re *ghttp....
  • gf框架提供了非常强大的Web Server模块,由ghttp包支持,API文档地址: godoc.org/github.com/johng-cn/gf/g/net/ghttp。 哈喽世界! 老规矩,我们先来一个Hello World: package main import...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,909
精华内容 1,563
关键字:

GF框架

友情链接: coreutils-7.1.tar.gz