在你的游戏中应用LUA

本文转自zx9597446的Blog,
欢迎对Lua感兴趣的朋友互相交流, mailto: zx9597446@sina.com 

在你的游戏中应用Lua（1）：在你的游戏代码中运行解释器

  通常，你希望在你的游戏开始的时候读取一些信息，以配置你的游戏，这些信息通常都是放到一个文本文件中，在你的游戏启动的时候，你需要打开这个文件，然后解析字符串，找到所需要的信息。

  是的，或许你认为这样就足够了，为什么还要使用Lua呢？

  应用于“配置”这个目的，Lua提供给你更为强大，也更为灵活的表达方式，在上一种方式中，你无法根据某些条件来配置你的游戏，Lua提供给你灵活的表达方式，你可以类似于这样来配置你的游戏：

if player:is_dead() then
do_something()
else
do_else()
end

更为重要的是，在你做了一些修改之后，完全不需要重新编译你的游戏代码。

通常，在游戏中你并不需要一个单独的解释器，你需要在游戏来运行解释器，下面，让我们来看看，如何在你的代码中运行解释器：

//这是lua所需的三个头文件
//当然，你需要链接到正确的lib
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

int main(int argc, char *argv[])
{
lua_State *L = lua_open();
luaopen_base(L); 
luaopen_io(L);

const char *buf = "print('hello, world!')";

lua_dostring(buf);

lua_close(L);

return 0;
}

程序输出：hello, world!

有时你需要执行一段字符串，有时你可能需要执行一个文件，当你需要执行一个文件时，你可以这么做：
lua_dofile(L, "test.lua");

看，非常简单吧。







在你的游戏中应用Lua（1）：Getting Value

在上一篇文章我们能够在我们的游戏代码中执行Lua解释器，下面让我们来看看如何从脚本中取得我们所需要的信息。

首先，让我来简单的解释一下Lua解释器的工作机制，Lua解释器自身维护一个运行时栈，通过这个运行时栈，Lua解释器向主机程序传递参数，所以我们可以这样来得到一个脚本变量的值：

lua_pushstring(L, "var"); //将变量的名字放入栈
lua_gettatbl(L, LUA_GLOBALSINDEX);变量的值现在栈顶

假设你在脚本中有一个变量 var = 100
你可以这样来得到这个变量值：
int var = lua_tonumber(L, -1);

怎么样，是不是很简单？

Lua定义了一个宏让你简单的取得一个变量的值：
lua_getglobal(L, name)

我们可以这样来取得一个变量的值：
lua_getglobal(L, "var"); //变量的值现在栈顶
int var = lua_tonumber(L, -1);

完整的测试代码如下：

#include "lua.h"
#inculde "lauxlib.h"
#include "lualib.h"

int main(int argc, char *argv[])
{
lua_State *L = lua_open();
luaopen_base(L);
luaopen_io(L);

const char *buf = "var = 100";

lua_dostring(L, buf);

lua_getglobal(L, "var");
int var = lua_tonumber(L, -1);

assert(var == 100);

lua_close(L);

return 0;
} 






在你的游戏中应用Lua（1）：调用函数

假设你在脚本中定义了一个函数：

function main(number)
number = number + 1
return number
end

在你的游戏代码中，你希望在某个时刻调用这个函数取得它的返回值。

在Lua中，函数等同于变量，所以你可以这样来取得这个函数：

lua_getglobal(L, "main");//函数现在栈顶

现在，我们可以调用这个函数，并传递给它正确的参数：

lua_pushnumber(L, 100); //将参数压栈
lua_pcall(L, 1, 1, 0); //调用函数，有一个参数，一个返回值
//返回值现在栈顶
int result = lua_tonumber(L, -1);

result 就是函数的返回值

完整的测试代码如下：

#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

int main(int argc, char *argv[])
{
lua_State *L = lua_open();
luaopen_base(L);

const char *buf = "function main(number) number = number + 1 return number end";

lua_dostring(buf);

lua_getglobal(L, "main");
lua_pushnumber(L, 100);
lua_pcall(L, 1, 1, 0);

int result = lua_tonumber(L, -1);

assert(result == 101);

lua_close(L);

return 0;
}





在你的游戏中应用Lua（2）：扩展Lua


Lua本身定位在一种轻量级的，灵活的，可扩充的脚本语言，这意味着你可以自由的扩充Lua，为你自己的游戏量身定做一个脚本语言。

你可以在主机程序中向脚本提供你自定的api，供脚本调用。

Lua定义了一种类型：lua_CFunction，这是一个函数指针，它的原型是：
typedef int (*lua_CFunction) (lua_State *L);

这意味着只有这种类型的函数才能向Lua注册。

首先，我们定义一个函数

int foo(lua_State *L)
{
//首先取出脚本执行这个函数时压入栈的参数
//假设这个函数提供一个参数，有两个返回值

//get the first parameter
const char *par = lua_tostring(L, -1);

printf("%s/n", par);

//push the first result
lua_pushnumber(L, 100);

//push the second result
lua_pushnumber(L, 200);

//return 2 result
return 2;
}

我们可以在脚本中这样调用这个函数

r1, r2 = foo("hello")

print(r1..r2)

完整的测试代码如下：

#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

int foo(lua_State *L)
{
//首先取出脚本执行这个函数时压入栈的参数
//假设这个函数提供一个参数，有两个返回值

//get the first parameter
const char *par = lua_tostring(L, -1);

printf("%s/n", par);

//push the first result
lua_pushnumber(L, 100);

//push the second result
lua_pushnumber(L, 200);

//return 2 result
return 2;
}

int main(int argc, char *argv[])
{
lua_State *L = lua_open();
luaopen_base(L);
luaopen_io(L);

const char *buf = "r1, r2 = foo("hello") print(r1..r2)";

lua_dostring(L, buf);

lua_close(L);

return 0;
}

程序输出：
hello
100200




在你的游戏中应用Lua（3）：using lua in cpp


lua和主机程序交换参数是通过一个运行时栈来进行的，运行时栈的信息放在一个lua_State的结构中，lua提供的api都需要一个lua_State*的指针，除了一个：

lua_open();

这个函数将返回一个lua_State*型的指针，在你的游戏代码中，你可以仅仅拥有一个这样的指针，也可以有多个这样的指针。

最后，你需要释放这个指针，通过函数：

lua_close(L);

注意这个事实，在你的主机程序中，open()与close()永远是成对出现的，在c++中，如果有一些事情是成对出现的，这通常意味着你需要一个构造函数和一个析构函数，所以，我们首先对lua_State做一下封装：

#ifndef LUA_EXTRALIBS
#define LUA_EXTRALIBS /* empty */
#endif

static const luaL_reg lualibs[] = 
{
{"base", luaopen_base},
{"table", luaopen_table},
{"io", luaopen_io},
{"string", luaopen_string},
{"math", luaopen_math},
{"debug", luaopen_debug},
{"loadlib", luaopen_loadlib},
/* add your libraries here */
LUA_EXTRALIBS
{NULL, NULL}
};

这是lua提供给用户的一些辅助的lib，在使用lua_State的时候，你可以选择打开或者关闭它。

完整的类实现如下：


//lua_State
class state
{
public:
state(bool bOpenStdLib = false)
:
err_fn(0)
{
L = lua_open();

assert(L);

if (bOpenStdLib)
{
open_stdlib();
}
}

~state()
{
lua_setgcthreshold(L, 0);
lua_close(L);
}

void open_stdlib()
{
assert(L);

const luaL_reg *lib = lualibs;
for (; lib->func; lib++) 
{
lib->func(L); /* open library */
lua_settop(L, 0); /* discard any results */
}
}

lua_State* get_handle()
{
return L;
}

int error_fn()
{
return err_fn;
}

private:
lua_State *L;

int err_fn;
};


通常我们仅仅在游戏代码中使用一个lua_State*的指针，所以我们为它实现一个单件，默认打开所有lua提供的lib:


//return the global instance
state* lua_state()
{
static state L(true);

return &L;
}




在你的游戏中应用Lua（3）：using lua in cpp（封装栈操作）　

前面提到了lua与主机程序是通过一个运行时栈来交换信息的，所以我们把对栈的访问做一下简单的封装。

我们利用从c++的函数重载机制对这些操作做封装，重载提供给我们一种以统一的方式来处理操作的机制。

向lua传递信息是通过压栈的操作来完成的，所以我们定义一些Push()函数：

inline void Push(lua_State *L, int value);
inline void Push(lua_State *L, bool value);
...

对应简单的c++内建类型，我们实现出相同的Push函数，至于函数内部的实现是非常的简单，只要利用lua提供的api来实现即可，例如：

inline void Push(lua_State *L, int value)
{
lua_pushnumber(L, value);
}

这种方式带来的好处是，在我们的代码中我们可以以一种统一的方式来处理压栈操作，如果有一种类型没有定义相关的压栈操作，将产生一个编译期错误。

后面我会提到，如何将一个用户自定义类型的指针传递到lua中，在那种情况下，我们的基本代码无须改变，只要添加一个相应的Push()函数即可。

记住close-open原则吧，它的意思是对修改是封闭的，对扩充是开放的，好的类库设计允许你扩充它，而无须修改它的实现，甚至无须重新编译。

《c++泛型设计新思维》一书提到了一种技术叫type2type，它的本质是很简单：

template <typename T>
struct type2type
{
typedef T U;
};

正如你看到的，它并没有任何数据成员，它的存在只是为了携带类型信息。

类型到类型的映射在应用于重载函数时是非常有用的，应用type2type，可以实现编译期的分派。

下面看看我们如何在从栈中取得lua信息时应用type2type：

测试类型：由于lua的类型系统与c++是不相同的，所以，我们要对栈中的信息做一下类型检测。

inline bool Match(type2type<bool>, lua_State *L, int idx)
{
return lua_type(L, idx) == LUA_TBOOLEAN;
}

类似的，我们要为cpp的内建类型提供相应的Match函数：

inline bool Match(type2type<int>, lua_State *L, int idx);
inline bool Match(type2type<const char*>, lua_State *L, int idx);

...

可以看出，type2type的存在只是为了在调用Match时决议到正确的函数上，由于它没有任何成员，所以不存在运行时的成本。

同样，我们为cpp内建类型提供Get()函数：

inline bool Get(type2type<bool>, lua_State *L, int idx)
{
return lua_toboolean(L, idx);
}

inline int Get(type2type<int>, lua_State *L, int idx)
{
return static_cast<int>(lua_tonumber(L, idx));
}

...

我想你可能注意到了，在int Get(type2type<int>)中有一个转型的动作，由于lua的类型系统与cpp的类型不同，所以转型动作必须的。

除此之外，在Get重载函数（s）中还有一个小小的细节，每个Get的函数的返回值是不相同的，因为重载机制是依靠参数的不同来识别的，而不是返回值。

前面说的都是一些基础的封装，下来我们将介绍如何向lua注册一个多参数的c函数。还记得吗？利用lua的api只能注册int (*ua_CFunction)(lua_State *)型的c函数，别忘记了，lua是用c写的。




在你的游戏中应用Lua（3）：using lua in cpp（注册不同类型的c函数）之一　

前面说到，我们可以利用lua提供的api，向脚本提供我们自己的函数，在lua中，只有lua_CFunction类型的函数才能直接向lua注册，lua_CFunction实际上是一个函数指针：
typedef int (*lua_CFunction)(lua_State *L);

而在实际的应用中，我们可能需要向lua注册各种参数和返回值类型的函数，例如，提供一个add脚本函数，返回两个值的和：

int add(int x, int y);

为了实现这个目的，首先，我们定义个lua_CFunction类型的函数：

int add_proxy(lua_State *L)
{
//取得参数
if (!Match(TypeWrapper<int>(), L, -1))
return 0;
if (!Match(TypeWrapper<int>(), L, -2))
return 0;

  int x = Get(TypeWrapper<int>(), L, -1);
  int y = Get(TypeWrapper<int>(), L, -1);
  
  //调用真正的函数
  int result = add(x, y);
  
  //返回结果
  Push(result);
  
  return 1;
}

现在，我们可以向lua注册这个函数：

lua_pushstring(L, “add”);
lua_pushcclosure(L, add_proxy, 0);
lua_settable(L, LUA_GLOBALINDEX);

在脚本中可以这样调用这个函数：

print(add(100, 200))

从上面的步骤可以看出，如果需要向lua注册一个非lua_CFunction类型的函数，需要：
1． 为该函数实现一个封装调用。
2． 在封装调用函数中从lua栈中取得提供的参数。
3． 使用参数调用该函数。
4． 向lua传递其结果。

注意，我们目前只是针对全局c函数，类的成员函数暂时不涉及，在cpp中，类的静态成员函数与c函数类似。

假设我们有多个非lua_CFunction类型的函数向lua注册，我们需要为每一个函数重复上面的步骤，产生一个封装调用，可以看出，这些步骤大多是机械的，因此，我们需要一种方式自动的实现上面的步骤。

首先看步骤1，在cpp中，产生这样一个封装调用的函数的最佳的方式是使用template，我们需要提供一个lua_CFunction类型的模板函数，在这个函数中调用真正的向脚本注册的函数，类似于这样：
template <typename Func>
inline int register_proxy(lua_State *L)

现在的问题在于：我们要在这个函数中调用真正的函数，那么我们必须要在这个函数中取得一个函数指针，然而，lua_CFunction类型的函数又不允许你在增加别的参数来提供这个函数指针，现在该怎么让regisger_proxy函数知道我们真正要注册的函数呢？

在oop中，似乎可以使用类来解决这个问题：

template <Func>
struct register_helper
{
explicit register_helper(Func fn) : m_func(fn)
{}
int register_proxy(lua_State *L);

protected:
Func m_func;
};

可是不要忘记，lua_CFunction类型指向的是一个c函数，而不是一个成员函数，他们的调用方式是不一样的，如果将上面的int register_proxy()设置为静态成员函数也不行，因为我们需要访问类的成员变量m_func;

让我们再观察一下lua_CFunction类型的函数：

int register_proxy(lua_State *L);

我们看到，这里面有一个lua_State*型的指针，我们能不能将真正的函数指针放到这里面存储，到真正调用的时候，再从里面取出来呢？

Lua提供了一个api可以存储用户数据：
Lua_newuserdata(L, size)

在适当的时刻，我们可以再取出这个数据：

lua_touserdata(L, idx)

ok，现在传递函数指针的问题我们已经解决了，后面再看第二步：取得参数。





在你的游戏中应用Lua（3）：using lua in cpp（注册不同类型的c函数）之二

在解决了传递函数指针的问题之后，让我们来看看调用函数时会有一些什么样的问题。

首 先，当我们通过函数指针调用这个函数的时候，由于我们面对的是未知类型的函数，也就是说，我们并不知道参数的个数，参数的类型，还有返回值的类型，所以我 们不能直接从lua栈中取得参数，当然，我们可以通过运行时测试栈中的信息来得到lua传递进来的参数的个数和类型，这意味着我们在稍后通过函数指针调用 函数时也需要动态的根据参数的个数和类型来决议到正确的函数，这样，除了运行时的成本，cpp提供给我们的强类型检查机制的好处也剩不了多少了，我们需要 的是一种静态的编译时的“多态”。

在cpp中，至少有两种方法可以实现这点。最直接简单的是使用函数重载，还有一种是利用模板特化机制。

简单的介绍一下模板特化：

在cpp中，可以针对一个模板函数或者模板类写出一些特化版本，编译器在匹配模板参数时会寻找最合适的一个版本。类似于这样：

templat <typename T>
T foo()
{
T tmp();
return tmp;
}

//提供特化版本
template <>
int foo()
{
return 100;
}

在main()函数中，我们可以显示指定使用哪个版本的foo：

int main(int argc, char **argv)
{
cout << foo<int>() << endl;
return 0;
}

程序将输出100，而不是0，以上代码在 g++中编译通过，由于vc6对于模板的支持不是很好，所以有一些模板的技术在vc6中可能不能编译通过。

所以最好使用重载来解决这个问题，在封装函数调用中，我们首先取得这个函数指针，然后，我们要提供一个Call函数来真正调用这个函数，类似于这样：
//伪代码
int Call(pfn, lua_State *L, int idx)

可是我们并不知道这个函数指针的类型，现在该怎么写呢？别忘记了，我们的register_proxy()是一个模板函数，它有一个参数表示了这个指针的类型：

template <typename Func>
int register_proxy(lua_State *L)
{
//伪代码，通过L参数取得这个指针
unsigned char *buffer = get_pointer(L);

//对这个指针做强制类型转化，调用Call函数
return Call(*(Func*)buffer, L, 1);
}

由重载函数Call调用真正的函数，这样，我们可以使用lua api注册相关的函数，下来我们提供一个注册的函数：

template <typename Func>
void lua_pushdirectclosure(Func fn, lua_State *L, int nUpvalue)
{
//伪代码，向L存储函数指针
save_pointer(L);

//向lua提供我们的register_proxy函数
lua_pushcclosure(L, register_proxy<Func>, nUpvalue + 1);
}

再定义相关的注册宏：
#define lua_register_directclosure(L, func) /
lua_pushstring(L, #func);
lua_pushdirectclosure(func, L, 1);
lua_settable(L, LUA_GLOBALINDEX)

现在，假设我们有一个int add(int x, int y)这样的函数，我们可以直接向lua注册：

lua_register_directclosure(L, add);

看，最后使用起来很方便吧，我们再也不用手写那么多的封装调用的代码啦，不过问题还没有完，后面我们还得解决Call函数的问题。




在你的游戏中应用Lua（3）：using lua in cpp（注册不同类型的c函数）之三　


下面，让我们集中精力来解决Call重载函数的问题吧。

前面已经说过来，Call重载函数接受一个函数指针，然后从lua栈中根据函数指针的类型，取得相关的参数，并调用这个函数，然后将返回值压入lua栈，类似于这样：

//伪代码
int Call(pfn, lua_State *L, int idx)

现在的问题是pfn该如何声明？我们知道这是一个函数指针，然而其参数，以及返回值都是未知的类型，如果我们知道返回值和参数的类型，我们可以用一个typedef来声明它：

typedef void (*pfn)();

int Call(pfn fn, lua_State *L, int idx);

我们知道的返回值以及参数的类型只是一个模板参数T，在cpp中，我们不能这样写：

template <typename T>
typedef T (*Func) ();

一种解决办法是使用类模板：

template <typename T>
struct CallHelper
{
typedef T (*Func) ();
};

然后在Call中引用它：

template <typename T>
int Call(typename CallHelper::Func fn, lua_State *L, int idx)

注意typename关键字，如果没有这个关键字，在g++中会产生一个编译警告，它的意思是告诉编译器，CallHelper：：Func是一个类型，而不是变量。

如果我们这样来解决，就需要在CallHelper中为每种情况大量定义各种类型的函数指针，还有一种方法，写法比较古怪，考虑一个函数中参数的声明：

void (int n);

首先是类型，然后是变量，而应用于函数指针上：

typedef void (*pfn) ();
void (pfn fn);

事实上，可以将typedef直接在参数表中写出来：

void (void (*pfn)() );

这样，我们的Call函数可以直接这样写：

//针对没有参数的Call函数
template <typename RT>
int Call(RT (*Func) () , lua_State *L, int idx);
{
//调用Func
RT ret = (*Func)();

//将返回值交给lua
Push（L, ret）；

//告诉lua有多少个返回值
return 1;
}

//针对有一个参数的Call
template <typename T, typename P1>
int Call(RT (*Func)(), lua_State *L, int idx)
{
//从lua中取得参数
if (!Match(TypeWrapper<P1>(), L, -1)
return 0;

RT ret = (*Func) (Get(TypeWrapper<P1>(), L, -1));

Push(L, ret);
return 1;
}

按照上面的写法，我们可以提供任意参数个数的Call函数，现在回到最初的时候，我们的函数指针要通过lua_State *L来存储，这只要利用lua提供的api就可以了，还记得我们的lua_pushdirectclosure函数吗：

template <typename Func>
void lua_pushdirectclosure(Func fn, lua_State *L, int nUpvalue)
{
//伪代码，向L存储函数指针
save_pointer(L);

//向lua提供我们的register_proxy函数
lua_pushcclosure(L, register_proxy<Func>, nUpvalue + 1);
}

其中，save_pointer(L)可以这样实现：

void save_pointer(lua_State *L)
{
unsigned char* buffer = (unsigned char*)lua_newuserdata(L, sizeof(func));
memcpy(buffer, &func, sizeof(func));
}


而在register_proxy函数中：

template <typename Func>
int register_proxy(lua_State *L)
{
//伪代码，通过L参数取得这个指针
unsigned char *buffer = get_pointer(L);
//对这个指针做强制类型转化，调用Call函数
return Call(*(Func*)buffer, L, 1);
}
get_pointer函数可以这样实现：

unsigned char* get_pointer(lua_State *L)
{
  return (unsigned char*) lua_touserdata(L, lua_upvalueindex(1));
}

这一点能够有效运作主要依赖于这样一个事实：

我们在lua栈中保存这个指针之后，在没有对栈做任何操作的情况下，又把它从栈中取了出来，所以不会弄乱lua栈中的信息，记住，lua栈中的数据是由用户保证来清空的。

到现在，我们已经可以向lua注册任意个参数的c函数了，只需简单的一行代码：

lua_register_directclosure(L, func)就可以啦。







在你的游戏中应用Lua（3）：Using Lua in cpp(基本数据类型、指针和引用)之一

Using Lua in cpp(基本数据类型、指针和引用)

前面介绍的都是针对cpp中的内建基本数据类型，然而，即使是这样，在面对指针和引用的时候，情况也会变得复杂起来。

使用前面我们已经完成的宏lua_register_directclosure只能注册by value形式的参数的函数，当参数中存在指针和引用的时候（再强调一次，目前只针对基本数据类型）：

1、 如果是一个指针，通常实现函数的意图是以这个指针传递出一个结果来。
2、 如果是一个引用，同上。
3、 如果是一个const指针，通常只有面对char*的时候才使用const，实现函数的意图是，不会改变这个参数的内容。其它情况一般都避免出现使用const指针。
4、 如果是一个const引用，对于基本数据类型来说，一般都避免出现这种情况。

Lua和cpp都允许函数用某种方式返回多个值，对于cpp来说，多个返回值是通过上述的第1和第2种情况返回的，对于lua来说，多个返回值可以直接返回：

--in Lua
function swap(x, y)
tmp = x
x = y
y = tmp

return x, y
end

x = 100
y = 200

x, y = swap(x, y)

print(x..y)

程序输出：200100

同样的，在主机程序中，我们也可以向Lua返回多个值：

int swap(lua_State *L)
{
//取得两个参数
int x = Get(TypeWrapper<int>(), L, -1);
int y = Get(TypeWrapper<int>(), L, -2);

//交换值
int tmp = x;
x = y;
y = tmp;

//向Lua返回值
Push(L, x);
Push(L, y);

  //告诉Lua我们返回了多少个值
return 2;
}

现在我们可以在Lua中这样调用这个函数：

x = 100
y = 200

x, y = swap(x, y)

在我们的register_proxy函数中只能对基本数据类型的by value方式有效，根据我们上面的分析，如果我们能够在编译期知道，对于一个模板参数T：
1、 这是一个基本的数据类型，还是一个用户自定义的数据类型？
2、 这是一个普通的指针，还是一个iterator？
3、 这是一个引用吗？
4、 这是一个const 普通指针吗？
5、 这是一个const 引用吗？

如果我们能知道这些，那么，根据我们上面的分析，我们希望：（只针对基本数据类型）
1、 如果这是一个指针，我们希望把指针所指的内容返回给Lua。
2、 如果这是一个引用，我们希望把引用的指返回给Lua。
3、 如果这是const指针，我们希望将从Lua栈中取得的参数传递
          给调用函数。
4、 如果这是一个const引用，我们也希望把从Lua栈中取得的参
          数传递给调用函数。