Unity--C# 调用LUA文件

已于 2024-08-17 19:20:43 修改
阅读量428 收藏 7
点赞数 4
分类专栏： Unity 个人笔记 文章标签： unity c# lua
于 2024-08-17 19:18:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40669895/article/details/141285182
版权

C# 调用LUA文件

1.初始化Lua环境

XLua是一个为Unity设计的Lua编程语言解决方案，允许开发者在Unity项目中运行Lua脚本。

  1. 初始化Lua环境：在Start方法中，创建了一个LuaEnv对象，这是XLua库中用于表示Lua执行环境的类。
  2. 执行Lua代码：使用DoString方法执行一段Lua代码，这里是一个简单的打印语句print('hello xLua')。
  3. 加载Lua脚本：通过DoString方法使用require关键字加载了一个名为Main的Lua脚本。这个脚本应该位于Unity项目的Resources文件夹中，并且文件名需要以.txt结尾。
  4. 垃圾回收：luaEnv.Tick()方法用于执行Lua环境的垃圾回收，帮助清理Lua中未手动释放的对象。这可以在帧更新中定时调用，或者在切换场景时调用。
  5. 销毁Lua环境：luaEnv.Dispose()方法用于销毁Lua环境。在一般情况下，开发者可能不会销毁Lua环境，除非有特定的需求。
  6. 注意事项：在使用XLua时，需要注意资源的管理和加载路径，确保Lua脚本能够正确加载和执行。

具体代码如下

LuaEnv.cs

using System.Collections;
using System.Collections.Generic;
using XLua;
using UnityEngine;

public class LuaEnv : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        // Lua 环境, 就是一个类
        LuaEnv luaEnv = new LuaEnv();
        // 执行Lua语言
        luaEnv.DoString("print('hello xLua')");
        // 输出: LUA: hello xLua

        // 执行lua脚本--使用require关键字, 同时, 默认实在Resources文件下的并且需要加上.txt后缀才能执行
        luaEnv.DoString("require('Main')");

        //帮助我们清楚Lua中我们没有手动释放的对象 垃圾回收
        //帧更新中定时执行 或者 切场景时执行
        luaEnv.Tick();

        // 销毁lua环境/解析器  一般不销毁
        luaEnv.Dispose();
    }
}

2.使用xluaLoader调用lua文件

通过AddLoader方法, 添加我们中定义的加载函数, 如果自定函数能后找到我们的lua文件, 他就不会去目录中找lua文件了.

  1. 自定义Lua脚本加载器：通过AddLoader方法，将自定义的加载函数MyCustomLoader添加到Lua环境中。这个函数会在Lua执行require语句时被调用。
  2. 自定义加载逻辑：MyCustomLoader函数接收一个文件路径参数。函数首先输出文件路径，然后构造一个完整的Lua文件路径。如果文件存在，使用File.ReadAllBytes读取文件内容并返回；如果文件不存在，输出错误信息。
  3. 加载Lua脚本：通过DoString方法执行require('Main')，这会触发MyCustomLoader函数，根据自定义的路径加载名为Main的Lua脚本。

以下是LuaLoader.cs代码

using System.Collections;
using System.Collections.Generic;
using XLua;
using UnityEngine;
using System.IO;

public class LuaLoader : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        LuaEnv luaEnv = new LuaEnv();

        luaEnv.DoString("print('Hello World')");

        //xlua提供的一个路径重定向 的方法
        //允许我们自定义 加载 Lua文件的规则
        //当我们执行Lua语言 require 时 相当于执行一个1ua脚本
        //它就会 执行 我们自定义传入的这个函数

        luaEnv.AddLoader(MyCustomLoader);
        // 将MyCustomLoader的函数添加到了lua内部的一个委托中, 一旦找到了MyCustomLoader中的文件, 就不会执行其他的函数了
        // 最终是在AB中进行加载
        luaEnv.DoString("require('Main')");

    }

    public byte[] MyCustomLoader(ref string filepath)
    {
        // 文件名称
        Debug.Log(filepath);
        // 路径
        string luaFilePath = Application.dataPath + "/Lua/" + filepath + ".lua";
        Debug.Log("当前lua文件路径" + luaFilePath);

        // 判断文件是否存在
        if(File.Exists(luaFilePath))
        {
            return File.ReadAllBytes(luaFilePath);
        }
        else
        {
            Debug.Log("重定向文件错误, 错误文件名称: " + luaFilePath);
        }

        return null;
    }
}

3.LuaManager

在项目中, 我们是将lua脚本打包到ab包中, 然后进行加兹安lua脚本, 为了方便加载lua脚本,以及初始化lua环境, 因此, 可以使用管理器,以下是LuaManager.cs代码

using System.Collections;
using System.Collections.Generic;
using XLua;
using UnityEngine;
using System.IO;

// lua 解析器的管理器
public class LuaManager : BaseManager<LuaManager>
{
    // 执行lua语言的函数
    // 释放垃圾
    // 销毁lua解析器
    // lua脚本重定向

    private LuaEnv luaEnv;

    #region 初始化lua解析器和重定向lua文件
    /// <summary>
    /// 初始化lua解析器
    /// </summary>
    public void Init()
    {
        if (luaEnv != null)
        {
            return;
        }
        luaEnv = new LuaEnv();

        // 加载lua脚本重定向
        luaEnv.AddLoader(MyCustomLoader);
        // 手动加载ab包读取lua文件
        // luaEnv.AddLoader(MyCustomABLoader);
        // 使用AB包管理器加载lua文件
        //luaEnv.AddLoader(MyCustomABPLoader);
    }

    /// <summary>
    /// 传入lua文名, 即可执行lua文件
    /// </summary>
    /// <param name="fileName"></param>
    public void DoLuaFile(string fileName)
    {
        string str = string.Format("require('{0}')", fileName);
        DoString(str);
    }

    /// <summary>
    /// 返回luaEnv中的_G表
    /// </summary>
    public LuaTable Global 
    {
        get 
        {
            return luaEnv.Global;
        }
    }

    /// <summary>
    /// 重定向lua脚本
    /// </summary>
    /// <param name="filepath"></param>
    /// <returns></returns>
    public byte[] MyCustomLoader(ref string filepath)
    {
        
        // 路径
        string luaFilePath = Application.dataPath + "/Lua/" + filepath + ".lua";
        Debug.Log("当前lua文件路径" + luaFilePath);

        // 判断文件是否存在
        if (File.Exists(luaFilePath))
        {
            return File.ReadAllBytes(luaFilePath);
        }
        else
        {
            Debug.Log("重定向文件错误, 错误文件名称: " + luaFilePath);
        }

        return null;
    }

    #endregion

    #region lua加载AB包文件

    // Lua脚本都会放在AB里
    // 最终通过加载AB包, 然后加载AB包中的lua脚本, 最后才是执行lua脚本
    // 重定向加载AB包中的lua脚本
    public byte[] MyCustomABLoader(ref string filepath)
    {
        // 1. 加载AB包 -lua包里面(这里有没有依赖包和依赖关系)
        string abPath = Application.streamingAssetsPath + "/PC" + "/lua.ab";
        // 因为lua的loader是需要理科返回资源, 因此加载lua的时候后就不要使用异步加载了, 使用同步加载
        AssetBundle ab = AssetBundle.LoadFromFile(abPath);
        Debug.Log("ab包加载lua脚本");

        // 2. 加载AB包中的lua文件
        TextAsset tx = ab.LoadAsset<TextAsset>(filepath + ".lua");
        // 3. 执行lua脚本
        return tx.bytes;
    }

    public byte[] MyCustomABPLoader(ref string filepath)
    {
        // 1. 加载AB包 -lua包里面(这里有没有依赖包和依赖关系)
        // 这里的报名需要和ABManager中的定义的路径相关-注意修改
        string abPath = "/lua.ab";
        // 因为lua的loader是需要理科返回资源, 因此加载lua的时候后就不要使用异步加载了, 使用同步加载
        Debug.Log("ab包管理器加载lua脚本");
        Debug.Log(filepath + ".lua");

        // 2. 加载AB包中的lua文件
        TextAsset tx = ABManager.GetInstance().LoadResources<TextAsset>(abPath, filepath + ".lua");

        // 3. 执行lua脚本
        return tx.bytes;
    }


    #endregion

    #region lua自带函数: 执行lua, 垃圾回收, 销毁lua解析器

    /// <summary>
    ///  执行lua语言
    /// </summary>
    /// <param name="str"></param>
    public void DoString(string str)
    {
        if(luaEnv == null)
        {
            Debug.Log("Lua解析器为空, 需要先初始化lua解析器");
            return;
        }
        luaEnv.DoString(str);
    }

    /// <summary>
    /// 释放垃圾, 每一帧都执行
    /// </summary>
    public void Tick()
    {
        if (luaEnv == null)
        {
            Debug.Log("Lua解析器为空, 无法进行垃圾回收");
            return;
        }
        luaEnv.Tick();
    }

    /// <summary>
    /// 销毁lua解析器
    /// </summary>
    public void Dispose()
    {
        if (luaEnv == null)
        {
            Debug.Log("Lua解析器为空, 无法销毁lua解析器");
            return;
        }
        luaEnv.Dispose();
        luaEnv = null;
    }
    #endregion
}

测试代码如下

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class TestLuaManager : MonoBehaviour
{
    LuaManager luaManager;
    void Start()
    {
        luaManager = LuaManager.GetInstance();
        luaManager.Init();
        //luaManager.DoString("require('Main')");
        luaManager.DoLuaFile("Main");
    }
}

4.C#调用Lua中的全局变量

在C#中调用lua中的变量只能是全局变量, 且C#中的变量的名称需要和Lua中的一致, 且修饰符为public, 因为protected和private的权限导致无法完成C#和lua的映射.

以下是lua脚本代码

Main.lua代码中引入了TestLua脚本

print("Lua Main 主入口")
-- 调用TestLua.lua脚本
require("TestLua")

TestLua.lua脚本如下

print("Test.lua")
intNumber = 1
floatNumber = 1.2
bool = true
str = "abc"

-- 无法通过c#的Gloabl获取lua中的局部变量
local x = 1


using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CallLuaVariable : MonoBehaviour
{
    LuaManager luaManager;
    void Start()
    {
        luaManager = LuaManager.GetInstance();
        luaManager.Init();
        luaManager.DoLuaFile("Main");
        int i = luaManager.Global.Get<int>("intNumber");

        // C# 修改lua的值
        luaManager.Global.Set("floatNumber", 23.45);
        float j = luaManager.Global.Get<float>("floatNumber");

        string k = luaManager.Global.Get<string>("str");
        bool l = luaManager.Global.Get<bool>("bool");

        Debug.Log("C# call lua variable - int = " + i);
        Debug.Log("C# call lua variable - float = " + j);
        Debug.Log("C# call lua variable - sting = " + k);
        Debug.Log("C# call lua variable - bool = " + l);
    }

}

5.C#调用Lua中的函数

函数的分类和调用方式

1.类型:无参无返回值

调用方式–使用委托

  1. UnityAction Unity自带的的不带参数的和返回值的委托
  2. C#自带的Action无参数无返回值的委托, 需要引入系统的命名空间
  3. 自定义的无参数无返回值的委托
  4. lua中的LuaFunction, 使用的时候使用.Call()的方式调用

lua中的脚本

-- 无参无返回值
function test()
	print("无参数-无返回值函数")
end

using System;
using UnityEngine;
using UnityEngine.Events;
using XLua;

// 委托: 无参-无返回值
public delegate void CallFunction();

/// <summary>
/// C# 调用lua中的全局函数
/// </summary>
public class CallLuaFunction : MonoBehaviour
{
    LuaManager luaManager;
    CallFunction cf;
    CallFunction2 cf2;
    void Start()
    {
        luaManager = LuaManager.GetInstance();
        luaManager.Init();
        luaManager.DoLuaFile("Main");

        #region 4种无参无返回值c#调用lua的方法

        // 将lua中的无参无返回值的函数添加到委托中
        cf = luaManager.Global.Get<CallFunction>("test");
        // 执行委托
        cf();

        // Unity自带的委托

        UnityAction ua = luaManager.Global.Get<UnityAction>("test");
        ua();

        // C#System中的委托
        Action ac = luaManager.Global.Get<Action>("test");
        ac();

        // X1ua提供的一种 获取函数的方式 少用 LuaFunction
        LuaFunction lf = luaManager.Global.Get<LuaFunction>("test");
        lf.Call();
        #endregion

    }
}

2.类型: 有参数有返回值

自定义的委托需要点击编辑器上的按钮生成代码才可以被注册
委托: 有参-有返回值

调用方式–使用委托

  1. 使用自定义含有参数含有返回值的委托
  2. 使用C#中自带的Func的委托, 该委托有17个重载, 可以灵活使用
  3. 使用xlua中的委托LuaFunction, 调用的时候, 使用.Call()进行调用, 返回值是一个列表/数组, 使用.Call()[下标]的方式得到返回值

lua中的脚本

-- 有参有返回值
function test1(a)
	print("有参数-有返回值函数" .. a+1)
	return a + 1
end

using System;
using UnityEngine;
using UnityEngine.Events;
using XLua;

// 自定义的委托需要点击编辑器上的按钮生成代码才可以被注册
// 委托: 有参-有返回值
[XLua.CSharpCallLua]
public delegate int CallFunction2(int arg);

public class CallLuaFunction : MonoBehaviour
{
    void Start()
    {
        // 自定义委托-- 需要在xlua中注册--编辑器中点击生成代码
        cf2 = luaManager.Global.Get<CallFunction2>("test1");
        int index = 100;
        Debug.Log(cf2(index));

        // 使用C#的有参有返回值的委托Func, 其中func中最多支持17个参数的委托
        // public delegate TResult Func<in T, out TResult>(T arg); out修饰的TResult是传出参数
        Func<int,int> func = luaManager.Global.Get<Func<int, int>>("test1");
        Debug.Log(func(200));

        // 使用LuaFunction进行有参有返回值的调用, 返回的是一个objec数组
        LuaFunction lf2 = luaManager.Global.Get<LuaFunction>("test1");
        Debug.Log(lf2.Call(300)[0]);
        
    }
}

3.类型: 有多个返回值

自定义的委托需要点击编辑器上的按钮生成代码才可以被注册
委托: 有参–有多个返回值

调用方式–使用委托

  1. 使用自定义含有参数含有返回值的委托
  2. 使用out或者ref来接收, 这需要看你的lua脚本中写的返回值的个数 和 类型
  3. 使用xlua中的委托LuaFunction, 调用的时候, 使用.Call()进行调用, 返回值是一个列表/数组, 使用.Call()[下标]的方式得到返回值

lua中的脚本

-- 有参多返回值
function test2( a )
	print("有参多返回值 " .. a)
	return 100,false,23.4,"China",a
end

CallLuaFunction.cs脚本代码如下

using System;
using UnityEngine;
using UnityEngine.Events;
using XLua;

[XLua.CSharpCallLua]
public delegate int CallFunction3(int arg1, out bool arg2, out float arg3, out string arg4, out int arg5);
[XLua.CSharpCallLua]
public delegate int CallFunction4(int arg1, ref bool arg2, ref float arg3, ref string arg4, ref int arg5);

public class CallLuaFunction : MonoBehaviour
{
    void Start()
    {
        // 自定义委托进行多个值
        // 使用out和ref来接收, 这需要看你的lua脚本中写的返回值的个数 和 类型

        // public delegate int CallFunction3(int arg1, out bool arg2, out float arg3, out string arg4, out int arg5 );
        // 第一个返回int是委托的返回值写了. arg1是传入参数, arg2~arg4是传出参数
        // 这里需要区分变长参数

        // 使用out的情况
        bool a;
        float b;
        string c;
        int d;
        CallFunction3 cf3 = luaManager.Global.Get<CallFunction3>("test2");
        Debug.Log("多个返回值函数调用,使用out的方式,默认返回值:" + cf3(400, out a, out b, out c, out d));
        Debug.Log("返回值如下");
        Debug.Log("多个返回值: " + a);
        Debug.Log("多个返回值: " + b);
        Debug.Log("多个返回值: " + c);
        Debug.Log("多个返回值: " + d);
        
        Debug.Log("-----------------------------------");

        // 使用ref的情况, 需要初始化
        bool a2 = true;
        float b2 = 0.0f;
        string c2 = "";
        int d2 = -1;
        CallFunction4 cf4 = luaManager.Global.Get<CallFunction4>("test2");
        Debug.Log("多个返回值函数调用,使用ref的方式 默认返回值:" + cf4(600, ref a2, ref b2, ref c2, ref d2));
        Debug.Log("返回值如下");
        Debug.Log("多个返回值: " + a2);
        Debug.Log("多个返回值: " + b2);
        Debug.Log("多个返回值: " + c2);
        Debug.Log("多个返回值: " + d2);
        Debug.Log("---------------------------------");

        // 使用LuaFunction的方式
        LuaFunction lf3 = luaManager.Global.Get<LuaFunction>("test2");
        object[] objs = lf3.Call(700);
        for (int i = 0; i < objs.Length; i++)
        {
            Debug.Log("LuaFuncton返回多个值: " + objs[i].ToString());
        }
    }
}

4.类型: 变长参数

自定义的委托需要点击编辑器上的按钮生成代码才可以被注册
委托: 有参–有多个返回值

调用方式–使用委托

  1. 使用自定义含有返回值,只有C#总的params进行变长参数, 如果如果知道是什么类型就用什么类型接收
  2. 使用xlua中的委托LuaFunction, 调用的时候, 使用.Call()进行调用, 返回值是一个列表/数组, 使用.Call()[下标]的方式得到返回值

lua中的代码如下:

-- 有参变长参数
function test3( a, ... )
	print("有参-变长" .. a)
	-- 保存变长参数
	arg = {...}
	for k,v in pairs(arg) do
		 print("key:" .. k .."  " .. "value: " .. tostring(v))
	end
end

CallLuaFunction.cs脚本代码如下:

using System;
using UnityEngine;
using UnityEngine.Events;
using XLua;

public delegate int CallFunction5(int arg1, params object[] args); //变长参数的类型 根据实际情况来定，最保险的就直接objct

public class CallLuaFunction : MonoBehaviour
{
    void Start()
    {
        // 使用C#自带的变长参数params, 需要根据lua中的函数变长参数的类型来确定.
        // 如果不确定的话, 可以直接使用object[], 这就涉及到了装箱拆箱的问题
        Debug.Log("使用C#的变长参数params进行调用lua变长参数的函数");
        CallFunction5 cf5 = luaManager.Global.Get<CallFunction5>("test3");
        cf5(800, "abc", 123, 45.05f, true, false, 'S');
        Debug.Log("------------------------------------------");

        // 使用LuaFunction进行变长参数函数调用
        Debug.Log("使用LuaFunction进行调用lua变长参数的函数");
        LuaFunction lf4 = luaManager.Global.Get<LuaFunction>("test3");
        lf4.Call(900, 131.9f, "Flower is Beautiful", true);
        
    }
}

6.C#调用Lua中的List和Dictionary

CallListDic.cs脚本如下.

关于由于在lua中的List和Dictionary中可以说同类的数据, 也可以是不同类型的数据, 因此, 乳沟知道数据类型就可以使用对应数据类型进行接收. 如果是不同的数据类型, 就需要考虑到了使用object来转换, 这就涉及到了装箱和拆箱的问题.

以下是lua总的代码

-- List的在C#中的映射
testList1 = { 1,2,3,4,5 }
testList2 = { "Fly", true, 0.4, 999 }

-- Dictionary在C#中的映射
testDic1 = {
	-- key的类型是一样的
	["1"] = 1,
	["2"] = 2,
	["3"] = 3,
	["4"] = 4
}

testDic2 = {
	-- key的类型是不一样的, 值的类型也不一样
	["1"] = 1,
	[true] = false,
	[false] = 3.8,
	[2] = 888
}

以下是CallListDic.cs的代码

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CallListDic : MonoBehaviour
{
    LuaManager luaManager;
    void Start()
    {
        luaManager = LuaManager.GetInstance();
        luaManager.Init();
        luaManager.DoLuaFile("Main");


        // 同类型List
        List<int> list1 = luaManager.Global.Get<List<int>>("testList1");
        print("--------------------------------------");
        for (int i = 0; i < list1.Count; i++)
        {
            print(list1[i]);
        }
        list1[0] = 100;// 浅拷贝 不会改变Lua中的内容
        List<int> list2 = luaManager.Global.Get<List<int>>("testList1");
        print(list2[0]);

        // 不指定类型 用object来存
        List<object> list3 = luaManager.Global.Get<List<object>>("testList2");
        for (int i = 0; i < list3.Count; i++)
        {
            print(list3[i]);
        }

        print("--------------------------------------");

        Dictionary<string, int> dic1 = luaManager.Global.Get<Dictionary<string, int>>("testDic1");
        foreach (string item in dic1.Keys)
        {
            print(item + "_" + dic1[item]);
        }
        dic1["1"] = 10000;
        Dictionary<string, int> dic2 = luaManager.Global.Get<Dictionary<string, int>>("testDic");
        print(dic2["1"]);
        // 浅拷贝 不改变Lua中的内容
        print("--------------------------------------");
        Dictionary<object, object> dic3 = luaManager.Global.Get<Dictionary<object, object>>("testDic2");
        foreach (object item in dic3.Keys)
        {
            print("key: " + item + "  Value: " + dic3[item]);
        }
    }
}

7.C#使用类调用lua

C# 调用lua的时候需要将定义和lua总的变量一致, 且C#中的变量是必须是public, 不然, 由于权限的问题无法完成lua和C#中的进行映射

以下是lua中的代码

-- lua中的类
testClass = {
	testInt = 10,
	testFLoat = 12.9,
	testString = "3.14",
	testBool = true,
	testFunc = function()
		print("TestFunc")
	end,
    -- 类中包含另外一个类
	testClassIN = 
	{
		testIn = 999
	}
}

以下是CallLuaClass.cs的代码

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class CalllLuaIn
{
    public int testIn;
}

public class CallLuaCall
{
    public int testInt;
    public float testFloat;
    public string testString;
    public bool testBool;
    public UnityAction testFunc;
    public CalllLuaIn testClassIN;

}
public class CallLuaClass : MonoBehaviour
{
    LuaManager luaManager;
    void Start()
    {
        luaManager = LuaManager.GetInstance();
        luaManager.Init();
        luaManager.DoLuaFile("Main");
        // C# Call lua的时候需要将定义和lua总的变量一致, 且C#中的变量是必须是public, 不然, 由于权限的问题无法完成lua和C#中的进行映射

        CallLuaCall clc = luaManager.Global.Get<CallLuaCall>("testClass");
        Debug.Log("C# Call Lua Class: " + clc.testInt);
        Debug.Log("C# Call Lua Class: " + clc.testFloat);
        Debug.Log("C# Call Lua Class: " + clc.testString);
        Debug.Log("C# Call Lua Class: " + clc.testBool);
        clc.testFunc();
        Debug.Log("类中类变量:" + clc.testClassIN.testIn);
    }

}

8.C#使用接口调用lua

使用接口来接收lua中的表, 需要点击编辑器上的按钮生成代码才可以被注册

C# 调用lua的时候需要将定义的构造器和lua总的变量一致, 且C#中的变量是必须是public, 不然, 由于权限的问题无法完成lua和C#中的进行映射, 由于是构造器的方式, 所以内存上是深拷贝

以下是lua中的代码

-- lua中的类, C#使用接口来调用
testInterface = {
	testInt = 10,
	testFloat = 12.9,
	testString = "3.14",
	testBool = true,
	testFunc = function()
		print("TestFunc")
	end
}

以下是CallLuaInterface.cs中的代码:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XLua;
using UnityEngine.Events;


[CSharpCallLua]
public interface CallLuaInterface
{ 
    // 接口中不能声明属性, 只能是容器
    int testInt { get; set;}
    float testFloat { get; set; }
    string testString { get; set; }
    bool testBool { get; set; }
    UnityAction testFunc { get; set; }
}
public class CallLuaInterface : MonoBehaviour
{
    LuaManager luaManager;
    void Start()
    {
        luaManager = LuaManager.GetInstance();
        luaManager.Init();
        luaManager.DoLuaFile("Main");

        CallLuaInterface clif = luaManager.Global.Get<CallLuaInterface>("testInterface");
        Debug.Log("C# 使用接口来调用lua中的类: " + clif.testInt);
        Debug.Log("C# 使用接口来调用lua中的类: " + clif.testFloat);
        Debug.Log("C# 使用接口来调用lua中的类: " + clif.testString);
        Debug.Log("C# 使用接口来调用lua中的类: " + clif.testBool);
        clif.testFunc();

        clif.testInt = 123456;
        CallLuaInterface clif2 = luaManager.Global.Get<CallLuaInterface>("testInterface");
        Debug.Log("修改C#实例中的变量后, 原来lua的变量修改为: " + clif2.testInt);
        // 注意, 在c#中使用接口来映射lua中的类, 是通过深拷贝进行的, 同时需要清空代码,重新生成代码
    }  
}

9.C#使用lua表调用lua

由于我们的luaManager中可以通过_Global获取lua中的所有数据, 因此表中表, 也是可以通过_Gloabl来获取.

lua中的代码如下

-- lua中的类, C#使用表来调用
testTable = {
	testInt = 10,
	testFloat = 12.9,
	testString = "3.14",
	testBool = true,
	testFunc = function()
		print("TestFunc")
	end
}

需要注意的是, 由于使用的是_Global表来获取里面的子表, 因此, 这是深拷贝.

CallLuaTable.cs代码如下:

using System.Collections;
using System.Collections.Generic;
using XLua;
using UnityEngine;

public class CallLuaTable : MonoBehaviour
{
    LuaManager luaManager;
    void Start()
    {
        luaManager = LuaManager.GetInstance();

        luaManager.Init();
        luaManager.DoLuaFile("Main");
		// 使用_G表获得表
        LuaTable table = luaManager.Global.Get<LuaTable>("testTable");

        Debug.Log(table.Get<int>("testInt"));
        Debug.Log(table.Get<float>("testFloat"));
        Debug.Log(table.Get<bool>("testBool"));
        Debug.Log(table.Get<string>("testString"));
        // 使用xlu中的LuaFunction来获取函数
        table.Get<LuaFunction>("testFunc").Call();

        // 修改值
        // 说明在内存上是深拷贝
        table.Set("testInt", 3306);
        LuaTable table2 = luaManager.Global.Get<LuaTable>("testTable");
        Debug.Log(table2.Get<int>("testInt"));
    }
}
caron4
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#调用Lua - 1、Lua解析器
qq_42705793的博客
10-11 831
Xlua C#调用lua
unity-lua 2.0
09-06
这意味着开发者可以在Lua中直接调用Unity的C#方法，反之亦然，极大地提高了开发效率和代码复用性。 2. 代码热补丁：xlua的亮点之一是它的代码热补丁功能。在游戏发布后，如果发现某些Lua脚本有错误或者需要更新，...
unity----lua调用c#之lua调用c#中的数组，list，字典
oBeiDouXing1的博客
01-28 488
@TOC添加链接描述 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进
Unity3D 基于XLua框架实现Lua组件化开发方式(一)----基于C#调用Lua
qq_37872192的博客
09-18 5647
众所周知Unity的开发语言是C#,并不支持Lua语言，为了解决这一问题出现了诸如Xlua、ULua、ToLua等框架来让unity支持lua，由于为了应对众多游戏经常需要解决的热更新问题，出了两种主流开发模式： 开发语言仍然用C#,用lua做热更新。 开发语言和热更新完全采用lua语言。 其中XLua是腾讯开发的目前行业做游戏热更新最常用的框架，本篇文章就是为了简单介绍两种如何在unity中使用lua语言做到像c#一样的组件化开发模式。 一、git下载xlua框架: 前往github下载xl.
Unity Xlua 之 C#调用Lua(一)
zzzsss123333的博客
03-14 1130
Unity Xlua 之 C#调用Lua(一) 一.Lua解析器(LuaEnv) 执行Lua代码，加载Lua文件执行 public class Lesson01_LuaEnv : MonoBehaviour { private LuaEnv _luaEnv; private void Start() { _luaEnv = new LuaEnv(); _luaEnv.DoString("print('Unity!')"); _luaEn
Unity ToLua 之 C#调用Lua(一)
zzzsss123333的博客
03-27 1587
Unity ToLua 之 C#调用Lua(一) 一.Lua解析器 初始化时相比于XLua需要对虚拟机执行Start方法，释放时需要先检查栈顶元素 public class Lesson01_LuaState : MonoBehaviour { private LuaState _luaState; private void Start() { _luaState = new LuaState(); _luaState.Start();
Unity XLua学习笔记（二）：C#调用Lua
qq_42393139的博客
01-23 1505
上一篇文章： Unity XLua学习笔记（一）：创建脚本，完成准备工作 C#调用Lua中的变量
Unity ToLua 之 C#调用Lua(三)
zzzsss123333的博客
03-27 416
Unity ToLua 之 C#调用Lua(三) ToLua和XLua不同，XLua相当于映射，而ToLua相当于访问（ToLua中对表的操作都是引用） 一.访问List和Dictionary 设置LuaTable都是按引用设置 testList1 = {10,20,30,40} testList2 = {false,"zzs",1,6.6} testDic1 = { ["zzs"] = 1, ["wy"] = 22, ["pnb"] = 333 } testDic2 =
Unity ToLua 之 C#调用Lua(二)
zzzsss123333的博客
03-27 338
Unity ToLua 之 C#调用Lua(二) 一.Lua解析器管理器 public class LuaMgr : SingletonAutoMono<LuaMgr> { private LuaState _luaState; public LuaState LuaState => _luaState; public void Init() { new ToLuaCustomLoader(); _luaState = new
EmmyLua-Unity.zip
12-22
该压缩包“EmmyLua-Unity.zip”包含了实现这一功能所需的所有资源，包括但不限于配置文件、库文件、插件、示例代码等。下面我们将深入探讨EmmyLua与Unity的结合使用，以及其背后的原理和技术细节。 首先，我们要...
EmmyLua-AttachDebugger 可用
03-11
在实际使用中，你需要先从GitHub上下载EmmyLua-AttachDebugger项目，解压后得到emmylua-attachdebugger和EmmyLua-AttachDebugger两个文件或文件夹。然后在Unity项目中配置这个插件，确保其正确加载到lua解释器中。...
EmmyLua-Unity
05-31
它通过编译器自动生成Lua接口，使得开发者可以在Lua中调用Unity的C#函数，同时也可以在C#中调用Lua脚本。ToLua的使用降低了游戏逻辑层和引擎层之间的耦合度，让游戏开发变得更加灵活。 EmmyLua-Unity插件的主要功能...
unity xlua lua5.4.4最新版lua库文件
07-26
在本案例中，我们讨论的是"unity xlua lua5.4.4最新版lua库文件"，这意味着你已经获取了最新的Lua版本5.4.4与Unity结合使用的资源包。 Lua是一种轻量级的嵌入式脚本语言，设计简洁且易于学习。它的语法简洁明了，...
界面控件DevExpress WinForms中文教程：Data Grid（数据网格）简介（一）
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
08-14 964
本文主要为大家介绍界面控件DevExpress WinForms中热门的数据网格组件，欢迎下载最新版体验~
C#学习总结
weixin_43284350的博客
08-08 1565
用追马的时间种草吧
C# 接口
m0_74995879的博客
08-13 346
在 C# 编程中，接口是一种关键的构建块，用于定义类可以实现的公共功能。它提供了一种方式来指定一组方法、属性、事件和索引器的签名，但不提供其实现。这种特性使得接口在构建灵活和可维护的系统时极为重要接口在C#中使用interface关键字定义。接口的定义与类相似，但是不包含任何的实现。接口会指定一组函数成员，但是不实现它们的引用类型。可以看作是一种契约，任何实现该接口的类都必须提供接口中定义的所有成员的具体实现。
C#中的S7协议
最新发布
weixin_64532720的博客
08-16 382
S7协议-S7COMM CTOP->PDU type已知枚举值 0X0E 连接请求 0x0d 连接确认 0x08 断开请求 0x0c 断开确认 0x05 拒绝访问 0x01 加急数据 0x02 加急数据确认 0x04 用户数据 0x07 TPDU错误 0x0f 数据传输 S7Header->ROSCTR已知枚举值 0X01 JOB REQUEST。主站发送请求 0x02
白骑士的C#教学进阶篇 2.4 LINQ查询
JeremyTC的博客
08-14 778
LINQ（Language Integrated Query）是C#中的一个强大特性，它提供了统一的语法来查询和操作各种数据源，如数组、集合、XML和数据库等。LINQ通过一种类似SQL的查询语言，使得数据查询变得更加直观和简洁。在本节中，我们将介绍LINQ的基本语法、查询操作，以及如何在数组、列表和字典等集合中应用LINQ，帮助您掌握这一强大的工具以编写高效的C#代码。
unity lua如何调用c#
06-06
Unity 中的 Lua 脚本可以通过 Unity 提供的 Lua 插件 MoonSharp 来调用 C# 代码。具体步骤如下： 1. 在 Unity 中创建一个 C# 脚本，其中包含需要被 Lua 调用的函数。 2. 在 Unity 中安装 MoonSharp 插件。可以通过 Unity 的 Asset Store 或者 GitHub 上的 MoonSharp 仓库来获取。 3. 在 Lua 脚本中使用 MoonSharp 提供的 API 来加载 C# 脚本，并调用其中的函数。例如： ```lua local MoonSharp = require("MoonSharp.Interpreter") MoonSharp.Interpreter.LoadAssembly("Assembly-CSharp") local MyClass = MoonSharp.Interpreter.GetClassObject("MyClass") local instance = MyClass() instance:MyFunction() ``` 其中，"Assembly-CSharp" 是需要加载的 C# 程序集的名称，"MyClass" 是需要调用的类的名称，"MyFunction" 是需要调用的函数的名称。 需要注意的是，调用 C# 函数时需要使用 Lua 调用 C# 函数的方式来传递参数和获取返回值。具体可以参考 MoonSharp 的文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值