在你的游戲中應用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棧中取得的參
? ? ? ? ? 數傳遞給調用函數。