lua脚本在游戏中的应用

Green

一，为什么要在游戏中使用脚本语言？

要解释这个问题首先我们先来了解一下脚本语言的特性：
1，学习门槛低，快速上手。
2，开发成本低，可维护性强。
3，动态语言，灵活性高。
        相对于C/C++这类高复杂性、高风险的编译型语言来说，Lua脚本做为一种轻量级的动态语言，简单的语言特性，精简的核心和基础库，使得语言的学习门槛大大的降低，即使是没有任何游戏经验的人都能快速上手，开发游戏功能。实际上游戏设计是一种十分繁杂的工作，C/C++虽然给我们带来极大的高效性，但同时也不能忽视其复杂性，极易产生BUG，而且对于开发人员的要求非常高。从语言的的抽象层面来说C/C++的抽象低更加适合于底层逻辑的支持，而Lua脚本抽象层次高，更加适合游戏逻辑的实现。脚本语言运行在虚拟机之上，而虚拟机运行在游戏逻辑之上，作为一种解释型语言，我们可以随时修改并及时体现在游戏之中，快速完成开发。C/C++却做不到，对一个巨大的游戏工程，每次修改都需要重新编译，成本很高。设想一下，如果所有的功能都是使用C/C++实现的话，那么对开发人员来说简直是一场灾难。
二，如何在游戏中使用Lua脚本？

‍这里就不理论一大堆了，直接手把手教。‍
1，进入Lua官方网站下载Source源代码
2，在Visual Studio在新建一个解决方案名为Lua2Game

3，在Lua2Game解决方案下新建一个空项目，命名为LuaDll，将从Lua官网下载的源代码src中除luac.c文件之外的源代码拷贝到LuaDll工程，配置项目属性，常规->配置类型为静态库（lib）然后编译LuaDll项目。（luac.c是编译器，lua.c是解释器也就是lua虚拟机）
4，在Lua2Game解决方案下新建一个空项目，命名为Game，配置项目属性，常规->配置类型为应用程序（.exe）, 这就是游戏demo。在项目属性中，链接器-> 输入->附加依赖项中加入../Debug/LuaDll.lib
5，在项目Game中实现脚本引擎CLuaScript（实现C/C++与Lua脚本的互相访问）
LuaScript.h

#ifndef __LUA_SCRIPT_H__
#define __LUA_SCRIPT_H__
#include "GameDef.h"
class CLuaScript
{
public:
CLuaScript();
~CLuaScript();
public:
    //实现C/C++对Lua脚本的调用
boolLoadScript(const char* szFileName); //实现lua脚本加载和编译
//调用Lua函数
boolCallFunction(char* cFuncName, int nResults, char* cFormat, va_list vlist);
boolCallFunction(const char* cFuncName, int nResults, char* cFormat, ...);
private:
voidRegisterLuaLib(); //注册lua各种基础库
boolRegisterFunctions(TLua_Funcs Funcs[], int n);//将游戏接口注册到lua脚本
private:
lua_State*m_LuaState; //state 脚本和C\C++搞基就靠它了
boolm_IsLoadScript;
};

#endif

LuaScript.cpp

#include <iostream>
#include "LuaScript.h"
CLuaScript::CLuaScript()
{
m_LuaState = luaL_newstate();
if (!m_LuaState)
{
std::cout << "m_LuaState new state failed!" << std::endl;
return;
}
RegisterLuaLib();//注册lua标准库
RegisterFunctions(g_GameFunc, g_GetGameFuncSize());//注册c\c++脚本接口
m_IsLoadScript = false;
}
CLuaScript::~CLuaScript()
{
if (m_LuaState)
{
lua_close(m_LuaState);
m_LuaState = NULL;
}
m_IsLoadScript = false;
}
void CLuaScript::RegisterLuaLib()
{
if (!m_LuaState)
{
return;
}
luaL_openlibs(m_LuaState);
}
bool CLuaScript::RegisterFunctions(TLua_Funcs Funcs[], int n)
{
if (!m_LuaState)
{
return false;
}
for (int i = 0; i < n; i++)
lua_register(m_LuaState, Funcs[i].name, Funcs[i].func);
return true;
}
bool CLuaScript::LoadScript(const char* szFileName)
{
if (!szFileName || szFileName[0] == '\0')
{
std::cout << "Lua script file illegal!" << std::endl;
return false;
}
if (!m_LuaState)
return false;
m_IsLoadScript = (luaL_dofile(m_LuaState, szFileName) == LUA_OK);
if (!m_IsLoadScript)
{
std::cout << "<LUA_LOAD_ERROR>"<< lua_tostring(m_LuaState, -1) << std::endl;
lua_pop(m_LuaState, 1);
}
return m_IsLoadScript;
}
bool CLuaScript::CallFunction(char* cFuncName, int nResults, char* cFormat, va_list vlist)
{
if (!m_LuaState || !m_IsLoadScript)
return false;
doublenNumber= 0;
int nInteger= 0;
char*cString= NULL;
void*pPoint= NULL;
int i= 0;
int nArgnum= 0;
lua_CFunction CFunc = NULL;
lua_getglobal(m_LuaState, cFuncName); //在堆栈中加入需要调用的函数名
while (cFormat[i] != '\0')
{
switch (cFormat[i])
{
case 'n'://输入的数据是double形 NUMBER，Lua来说是Double型
{
nNumber = va_arg(vlist, double);
lua_pushnumber(m_LuaState, nNumber);
nArgnum++;
}
break;
case 'd'://输入的数据为整形
{
nInteger = va_arg(vlist, int);
lua_pushinteger(m_LuaState, nInteger);
nArgnum++;
}
break;
case 's'://字符串型
{
cString = va_arg(vlist, char *);
lua_pushstring(m_LuaState, cString);
nArgnum++;
}
break;
case 'N'://NULL
{
lua_pushnil(m_LuaState);
nArgnum++;
}
break;
case 'f'://输入的是CFun形，即内部函数形
{
CFunc = va_arg(vlist, lua_CFunction);
lua_pushcfunction(m_LuaState, CFunc);
nArgnum++;
}
break;
case 'v'://输入的是堆栈中Index为nIndex的数据类型
{
nNumber = va_arg(vlist, int);
int nIndex1 = (int)nNumber;
lua_pushvalue(m_LuaState, nIndex1);
nArgnum++;
}
break;
}
i++;
}
int nRetcode = lua_pcall(m_LuaState, nArgnum, nResults, 0);
if (nRetcode != 0)
{
std::cout << "<LUA_CALL_FUNC_ERROR>" << lua_tostring(m_LuaState, -1) << std::endl;
lua_pop(m_LuaState, 1);
return false;
}
returntrue;
}

bool CLuaScript::CallFunction(const char* cFuncName, int nResults, char* cFormat, ...)
{
bool bResult = false;
va_list vlist;
va_start(vlist, cFormat);
bResult = CallFunction((char*)cFuncName, nResults, cFormat, vlist);
va_end(vlist);
return bResult;
}

6，定义用于实现定义给lua脚本的游戏接口

GameDef.h

#ifndef __GAME_DEF_H__
#define __GAME_DEF_H__
extern "C"{
#include "../../LuaDll/src/lua.h"
#include "../../LuaDll/src/lauxlib.h"
#include "../../LuaDll/src/lualib.h"
}

struct TLua_Funcs
{
const char *name;
lua_CFunction func;
};
extern TLua_Funcs g_GameFunc[];
extern int g_GetGameFuncSize();
#endif

GameDef.cpp

#include "GameDef.h"
#include <direct.h>
#include <iostream>
#include "Core.h"
using namespace std;

int LuaSayHello(lua_State* L)
{
cout << "Lua call c/c++:SayHello()" << endl;
cout << "Hello Everyone!" << endl;
if (lua_gettop(L) < 3)
return 0;
const char* szName = lua_tostring(L, 1);
int nParam1 = lua_tonumber(L, 2);
int nParam2 = lua_tonumber(L, 3);
cout << "My name is " << szName << endl;
lua_pushnumber(L, nParam1 / nParam2);
return 1;
}
int LuaStopGame(lua_State* L)
{
cout << "Lua call c/c++:StopGame()" << endl;
cout << "Game is over!" << endl;
g_Core.SetRunState(false);
return 0;
}
//脚本接口
TLua_Funcs g_GameFunc[] = {
{ "SayHello", LuaSayHello },
{ "StopGame", LuaStopGame },
};
int g_GetGameFuncSize()
{
return sizeof(g_GameFunc) / sizeof(TLua_Funcs);
}

7，模拟游戏主逻辑
Core.h

#ifndef __CORE_H__
#define __CORE_H__
#include "GameDef.h"
#include "LuaScript.h"
class CCore
{
public:
CCore();
~CCore();
public:
boolInitialize();
voidUninitialize();
boolBreathe();
voidSetRunState(bool bRunning);
private:
CLuaScript* m_Script;
boolm_bIsRuning;
};
extern CCore g_Core;
#endif

Core.cpp

#include "Core.h"
#include <time.h>
#include <iostream>
using namespace std;
CCore g_Core;
CCore::CCore()
{
m_Script = NULL;
m_bIsRuning = true;
}
CCore::~CCore()
{
if (m_Script)
{
delete m_Script;
m_Script = NULL;
}
}
bool CCore::Initialize()
{
//do something
return true;
}
void CCore::Uninitialize()
{
//do something
}
void CCore::SetRunState(bool bRunning)
{
m_bIsRuning = bRunning;
}
bool CCore::Breathe()
{
if (!m_bIsRuning)
return false;
static size_t c = 0;
size_t now = time(NULL);
if (now - c > 3)
{
c = now;
if (!m_Script)
{
m_Script = new CLuaScript;
}
if (m_Script)
{
    //游戏调用lua脚本
m_Script->LoadScript("./../test.lua"); 
//调用脚本函数，请参看下面第9点test.lua脚本
m_Script->CallFunction("main", 1, "sdd", "luaer", c, c / 18);
}
else
{
std::cout << "new CLuaScript failed!" << std::endl;
m_bIsRuning = false;
}
}
return true;
}

8，最后是实现mian函数（也就是游戏的服务器）

#include <iostream>
#include "Core.h"
using namespace std;
int main(int argc, char* argv[])
{
if (!g_Core.Initialize())
{
g_Core.Uninitialize();
return 0;
}
std::cout << "-----------------Start game!!!-----------------" << std::endl;
while (1)
{
if (!g_Core.Breathe())
break;
}
std::cout << "-----------------Game over!!!-----------------" << std::endl;
g_Core.Uninitialize();
system("PAUSE");
return 1;
}

9，在工程目录下创建test.lua脚本给游戏调用

function main(szName, num1, num2)
print("main()", szName, num1, num2); --调用lua基础库函数
local nRet = SayHello(szName, num1, num2); --调用游戏接口并返回结果
print("nRet =", nRet);
local nRand = math.random(100);
print("nRand =", nRand)
if nRand > 80 then
StopGame(); --停止游戏
end
return 1;
end

运行结果：

-----------------Start game!!!-----------------
main()  luaer   1410876602    78382033
Lua call c/c++:SayHello()
Hello Everyone!
My name is luaer
nRet =  18
nRand = 1
main()  luaer   1410876606    78382033
Lua call c/c++:SayHello()
Hello Everyone!
My name is luaer
nRet =  18
nRand = 57
main()  luaer   1410876610    78382033
Lua call c/c++:SayHello()
Hello Everyone!
My name is luaer
nRet =  18
nRand = 20
main()  luaer   1410876614    78382034
Lua call c/c++:SayHello()
Hello Everyone!
My name is luaer
nRet =  18
nRand = 81
Lua call c/c++:StopGame()
Game is over!
-----------------Game over!!!-----------------
Press any key to continue . . .

Demo工程的完整版本可以通过Git@OSC上获得：Lua2Game （VS2013工程）
也可以在github上获得。
剩下的问题以及相关原理，在以后的博客中补充：
1，C/C++和Lua是如何进行通信的？
2，C/C++如何调用Lua脚本？（参照CallFunction的实现）
3，Lua脚本如何调用游戏接口API？（参照RegisterFunctions的实现）
4，Lua脚本常用的C语言API
突然觉得要讲一件事说清楚还真是个技术活，想到要码字就头疼~~~~
如有任何疑问，欢迎提出讨论，谢谢~~