Unity XLua 官方教程学习

一、Lua 文件加载

1. 执行字符串

using UnityEngine;
using XLua;

public class ByString : MonoBehaviour {
    LuaEnv luaenv = null;
    // Use this for initialization
    void Start () {
        luaenv = new LuaEnv();
        // 执行代码块，输出 hello world
        luaenv.DoString("print('hello world')");
    }
    
    // Update is called once per frame
    void Update () {
        if (luaenv != null)
        {
            // 清楚 Lua 未手动释放的 LuaBase 对象
            luaenv.Tick();
        }
    }

    void OnDestroy()
    {
        // 销毁
        luaenv.Dispose();
    }
}

　　其中 Dostring 函数返回值即为代码块里 return 语句的返回值。

2. 加载 Lua 文件

luaenv = new LuaEnv();
// 加载 byfile Lua 文件
luaenv.DoString("require 'byfile'");

　　其中 Lua 文件代码为：

print('hello world')

　　需要注意的是因为 Resource 只支持有限的后缀，放 Resources 下 lua 文件得加上 txt 后缀，如：byfile.lua.txt。

3. 自定义 Loader

void Start()
{
    luaenv = new LuaEnv();
    // 自定义 loader
    luaenv.AddLoader((ref string filename) => {
        // 若要加载 InMemory
            if (filename == "InMemory")
            {
                string script = "return {ccc = 9999}";
                // 将字符串转换成byte[]
                return System.Text.Encoding.UTF8.GetBytes(script);
            }
            return null;
        });
    // 执行代码块，访问table中的常量ccc
    luaenv.DoString("print('InMemory.ccc=', require('InMemory').ccc)");
}

　　通过 Addloader 可以注册个回调，该回调参数是字符串，返回一个 byte 数组。lua 代码里调用 require 时，参数就会传给回调。

　　注意，require 返回一个由模块常量和函数组成的table。

二、C# 访问 Lua

　　其中 lua 代码如下：

a = 1
b = 'hello world'
c = true

d = {
    f1 = 12, f2 = 34, 
    1, 2, 3,
    add = function(self, a, b) 
        print('d.add called')
        return a + b 
    end
}

function e()
    print('i am e')
end

function f(a, b)
    print('a', a, 'b', b)
    return 1, {f1 = 1024}
end
        
function ret_e()
    print('ret_e called')
    return e
end

　　其中包含常量，表和函数。C# 代码如下：

public class DClass
{
    public int f1;          // 属性与Xlua里的对应
    public int f2;
}
    
[CSharpCallLua]
public interface ItfD
{
    int f1 { get; set; }
    int f2 { get; set; }
    int add(int a, int b);
}

// 生成代码
// 若有多个参数，可用 out 属性接收剩下的返回
[CSharpCallLua]
public delegate int FDelegate(int a, string b, out DClass c);

[CSharpCallLua]
public delegate Action GetE();

// Use this for initialization
void Start()
{
    luaenv = new LuaEnv();
    luaenv.DoString(script);

    // 访问全局常量
    Debug.Log("_G.a = " + luaenv.Global.Get<int>("a"));         // 1
    Debug.Log("_G.b = " + luaenv.Global.Get<string>("b"));      // hello world
    Debug.Log("_G.c = " + luaenv.Global.Get<bool>("c"));        // Ture

    // 访问全局的 table
    // 映射到普通的class或struct
    //映射到有对应字段的class，值拷贝，class字段的修改不会影响到table，反之也不会
    DClass d = luaenv.Global.Get<DClass>("d");
    Debug.Log("_G.d = {f1=" + d.f1 + ", f2=" + d.f2 + "}");     // 12 34

    // 映射有 key 的 
    Dictionary<string, double> d1 = luaenv.Global.Get<Dictionary<string, double>>("d");//映射到Dictionary<string, double>，值拷贝
    Debug.Log("_G.d = {f1=" + d1["f1"] + ", f2=" + d1["f2"] + "}, d.Count=" + d1.Count);    // 12 34 2

    // 映射没有 key 的
    List<double> d2 = luaenv.Global.Get<List<double>>("d"); //映射到List<double>，值拷贝
    Debug.Log("_G.d.len = " + d2.Count);                // 3

    // 映射到一个 interface
    // 要在 interface 定义前加 [CSharpCallLua]
    ItfD d3 = luaenv.Global.Get<ItfD>("d"); //映射到interface实例，by ref，这个要求interface加到生成列表，否则会返回null，建议用法
    d3.f2 = 1000;               // 外部修改会影响 Lua 内的值
    Debug.Log("_G.d = {f1=" + d3.f1 + ", f2=" + d3.f2 + "}");       // 12 1000
    Debug.Log("_G.d:add(1, 2)=" + d3.add(1, 2));                    // d.add called

    //映射到LuaTable，by ref
    LuaTable d4 = luaenv.Global.Get<LuaTable>("d");
    Debug.Log("_G.d = {f1=" + d4.Get<int>("f1") + ", f2=" + d4.Get<int>("f2") + "}");

    // 访问一个全局的函数
    // 映射到 delegate
    Action e = luaenv.Global.Get<Action>("e");//映射到一个delgate，要求delegate加到生成列表，否则返回null，建议用法
    e();                        // i am e

    FDelegate f = luaenv.Global.Get<FDelegate>("f");
    DClass d_ret;
    // 多值返回，可用out接收多余的参数
    // 输出 a 100 b John
    int f_ret = f(100, "John", out d_ret);//lua的多返回值映射：从左往右映射到c#的输出参数，输出参数包括返回值，out参数，ref参数
    // table只含有常量f1,所以f2赋值为0
    Debug.Log("ret.d = {f1=" + d_ret.f1 + ", f2=" + d_ret.f2 + "}, ret=" + f_ret);      // 1024 0 1

    GetE ret_e = luaenv.Global.Get<GetE>("ret_e");//delegate可以返回更复杂的类型，甚至是另外一个delegate
    e = ret_e();
    e();

    // 映射到 LuaFunction
    LuaFunction d_e = luaenv.Global.Get<LuaFunction>("e");
    // Call 函数可以传任意类型，任意个数的参数
    d_e.Call();

}

　　访问 lua 全局数据，特别是 table 以及 function，代价比较大，建议尽量少做，比如在初始化时调用获取一次后，保存下来，后续直接使用即可。

三、Lua 调用 C#

　　其中 C# 代码如下：

namespace Tutorial
{
    [LuaCallCSharp]
    public class BaseClass
    {
        public static void BSFunc()
        {
            Debug.Log("Driven Static Func, BSF = "+ BSF);
        }

        public static int BSF = 1;

        public void BMFunc()
        {
            Debug.Log("Driven Member Func, BMF = " + BMF);
        }

        public int BMF { get; set; }
    }

    public struct Param1
    {
        public int x;
        public string y;
    }

    [LuaCallCSharp]
    public enum TestEnum
    {
        E1,
        E2
    }

    [LuaCallCSharp]
    public class DrivenClass : BaseClass
    {
        [LuaCallCSharp]
        public enum TestEnumInner
        {
            E3,
            E4
        }

        public void DMFunc()
        {
            Debug.Log("Driven Member Func, DMF = " + DMF);
        }

        public int DMF { get; set; }

        public double ComplexFunc(Param1 p1, ref int p2, out string p3, Action luafunc, out Action csfunc)
        {
            Debug.Log("P1 = {x=" + p1.x + ",y=" + p1.y + "},p2 = "+ p2);
            luafunc();
            p2 = p2 * p1.x;
            p3 = "hello " + p1.y;
            csfunc = () =>
            {
                Debug.Log("csharp callback invoked!");
            };
            return 1.23;
        }

        public void TestFunc(int i)
        {
            Debug.Log("TestFunc(int i)");
        }

        public void TestFunc(string i)
        {
            Debug.Log("TestFunc(string i)");
        }

        public static DrivenClass operator +(DrivenClass a, DrivenClass b)
        {
            DrivenClass ret = new DrivenClass();
            ret.DMF = a.DMF + b.DMF;
            return ret;
        }

        public void DefaultValueFunc(int a = 100, string b = "cccc", string c = null)
        {
            UnityEngine.Debug.Log("DefaultValueFunc: a=" + a + ",b=" + b + ",c=" + c);
        }

        public void VariableParamsFunc(int a, params string[] strs)
        {
            UnityEngine.Debug.Log("VariableParamsFunc: a =" + a);
            foreach (var str in strs)
            {
                UnityEngine.Debug.Log("str:" + str);
            }
        }

        public TestEnum EnumTestFunc(TestEnum e)
        {
            Debug.Log("EnumTestFunc: e=" + e);
            return TestEnum.E2;
        }

        public Action<string> TestDelegate = (param) =>
        {
            Debug.Log("TestDelegate in c#:" + param);
        };

        public event Action TestEvent;

        public void CallEvent()
        {
            TestEvent();
        }

        public ulong TestLong(long n)
        {
            return (ulong)(n + 1);
        }

        class InnerCalc : ICalc
        {
            public int add(int a, int b)
            {
                return a + b;
            }

            public int id = 100;
        }

        public ICalc GetCalc()
        {
            return new InnerCalc();
        }

        public void GenericMethod<T>()
        {
            Debug.Log("GenericMethod<" + typeof(T) + ">");
        }
    }

    [LuaCallCSharp]
    public interface ICalc
    {
        int add(int a, int b);
    }

    [LuaCallCSharp]
    public static class DrivenClassExtensions
    {
        public static int GetSomeData(this DrivenClass obj)
        {
            Debug.Log("GetSomeData ret = " + obj.DMF);
            return obj.DMF;
        }

        public static int GetSomeBaseData(this BaseClass obj)
        {
            Debug.Log("GetSomeBaseData ret = " + obj.BMF);
            return obj.BMF;
        }

        public static void GenericMethodOfString(this DrivenClass obj)
        {
            obj.GenericMethod<string>();
        }
    }
}

　　其中可变参数可用  params string[] strs 实现。要在 Lua 直接访问什么，记得在定义前加上  [LuaCallCSharp] 

　　对应的 lua 代码为：

function demo()
    -- new C#对象
    -- 没有new,所有C#相关的都放在CS下
    local newGameObj = CS.UnityEngine.GameObject()
    -- 创建一个名为helloworld的物体
    local newGameObj2 = CS.UnityEngine.GameObject('helloworld')
    print(newGameObj, newGameObj2)

    --访问静态属性，方法
    local GameObject = CS.UnityEngine.GameObject
    print('UnityEngine.Time.deltaTime:', CS.UnityEngine.Time.deltaTime) --读静态属性
    CS.UnityEngine.Time.timeScale = 0.5 --写静态属性
    -- 查找物体 helloworld
    print('helloworld', GameObject.Find('helloworld')) --静态方法调用

    --访问成员属性，方法
    local DrivenClass = CS.Tutorial.DrivenClass
    local testobj = DrivenClass()
    testobj.DMF = 1024--设置成员属性
    print(testobj.DMF)--读取成员属性
    -- 输出 DMF=1024
    testobj:DMFunc()--成员方法 使用冒号

    --基类属性，方法
    print(DrivenClass.BSF)--读基类静态属性 1
    DrivenClass.BSF = 2048--写基类静态属性
    DrivenClass.BSFunc();--基类静态方法 2048
    -- BMF 初始为0
    print(testobj.BMF)--读基类成员属性 0
    testobj.BMF = 4096--写基类成员属性
    testobj:BMFunc()--基类方法调用 4096

    --复杂方法调用
    -- 参数处理规则：C#的普通参数和ref修饰的算一个参数，out不算，从左往右顺序
    -- 返回值处理规则：返回值(如果有)算第一个,out,ref修饰的参数算一个,从左往右
    local ret, p2, p3, csfunc = testobj:ComplexFunc({x=3, y = 'john'}, 100, function()
       print('i am lua callback')
    end)
    print('ComplexFunc ret:', ret, p2, p3, csfunc)
    csfunc()

   --重载方法调用
   testobj:TestFunc(100)
   testobj:TestFunc('hello')

   --操作符
   local testobj2 = DrivenClass()
   testobj2.DMF = 2048
   -- 输出DMF=1024+2048=3072
   print('(testobj + testobj2).DMF = ', (testobj + testobj2).DMF)

   --默认值
   testobj:DefaultValueFunc(1)
   testobj:DefaultValueFunc(3, 'hello', 'john')

   --可变参数
   testobj:VariableParamsFunc(5, 'hello', 'john')

   --Extension methods
   print(testobj:GetSomeData())
   print(testobj:GetSomeBaseData()) --访问基类的Extension methods
   testobj:GenericMethodOfString()  --通过Extension methods实现访问泛化方法

   --枚举类型
   -- 返回E2
   local e = testobj:EnumTestFunc(CS.Tutorial.TestEnum.E1)
   -- 输出枚举类型格式为 E2:1
   print(e, e == CS.Tutorial.TestEnum.E2)
   -- 整数或者字符串到枚举类型的转换
   print(CS.Tutorial.TestEnum.__CastFrom(1), CS.Tutorial.TestEnum.__CastFrom('E1'))
   print(CS.Tutorial.DrivenClass.TestEnumInner.E3)
   assert(CS.Tutorial.BaseClass.TestEnumInner == nil)

   --委托
   testobj.TestDelegate('hello') --直接调用
   local function lua_delegate(str)
       print('TestDelegate in lua:', str)
   end
   testobj.TestDelegate = lua_delegate + testobj.TestDelegate --combine，这里演示的是C#delegate作为右值，左值也支持
   testobj.TestDelegate('hello')
   testobj.TestDelegate = testobj.TestDelegate - lua_delegate --remove
   testobj.TestDelegate('hello')

   --事件
   local function lua_event_callback1() print('lua_event_callback1') end
   local function lua_event_callback2() print('lua_event_callback2') end
   -- 增加回调事件
   testobj:TestEvent('+', lua_event_callback1)
   testobj:CallEvent()
   testobj:TestEvent('+', lua_event_callback2)
   testobj:CallEvent()
   -- 移除回调事件
   testobj:TestEvent('-', lua_event_callback1)
   testobj:CallEvent()
   testobj:TestEvent('-', lua_event_callback2)

   --64位支持
   local l = testobj:TestLong(11)
   print(type(l), l, l + 100, 10000 + l)

   --typeof
   -- 增加粒子系统
   newGameObj:AddComponent(typeof(CS.UnityEngine.ParticleSystem))

   --cast 强转
   -- 返回 InnerCalc 类
   local calc = testobj:GetCalc()
   print('assess instance of InnerCalc via reflection', calc:add(1, 2))
   assert(calc.id == 100)
   -- 强转
   cast(calc, typeof(CS.Tutorial.ICalc))
   print('cast to interface ICalc', calc:add(1, 2))
   assert(calc.id == nil)
end

demo()

--协程下使用
local co = coroutine.create(function()
   print('------------------------------------------------------')
   demo()
end)
assert(coroutine.resume(co))

　　其中 assert 函数用于有错误时抛出异常。

　　注意，C# 的 int, float, double 都对应于 lua 的 number，重载时会无法区分。