前言：
每当自己想要放弃的时候，可以告诉自己再多撑一天、一个星期、一个月，再多撑一年吧。你会发现拒绝退场的结果令人惊讶！
--摘自短篇原创文学
----------------------------------------------------------分 割 线-----------------------------------------------------------------
说到脚本语言，我们脑海之中跳出像Python，LUA，Ruby这样的语言！可以这么说，任何大型游戏都有自己的脚本系统，所有如果我们想要做出一款比较好一点的游戏，那么脚本语言也是我们所必须要掌握的。Lua语言也是由于他的很多特点，比如高效，轻量，接口干净，可以与C语言进行较好的交互等，也正因为这些特点，学起来也比较快！红遍全球的wow就是采用的Lua脚本语言（虽然我没玩过这游戏，不过看别人玩过，貌似现在玩的人少了）。虽然它已经没有当初的辉煌了，不过经典还是经典！
为什么要使用Lua脚本语言
刚刚简单介绍了一下Lua脚本语言，接下来我们要说一说我们为什么要用它，换句话说我们为什么在游戏之中要使用脚本语言。众所周知，Lua脚本是一个很轻量级的脚本，也是号称性能最高的脚本，我们都很清楚，性能对于一个游戏是多么重要！国产单机游戏的招牌大作《仙剑奇侠传六》剧情，人物都还不错，可是性能方面，优化方面总是提不上去，从问世就被玩家一直诟病（不知道现在的情况怎么样了）！前不久听说仙剑奇侠传七已经立项了，而且很有可能采用的是大名鼎鼎的虚幻引擎，所以在画面的表现上可能更真实了，可能会更加接近国外的那么次时代的大作（之前的仙剑好像用的是RenderWare引擎，其实个人感觉其实之前的几代画面也不错），我个人觉得引擎固然重要，但是能让引擎服务于游戏，而不是游戏服务于引擎（现在的市面上就不少打着采用什么什么很有名的游戏引擎，但是实际的游戏性缺很差，完全是为了贴合这些著名的引擎而设计出来的游戏，自然没有什么游戏性可言了）！作为仙剑的忠实粉丝，希望这次不要大家失望哦！
扯了一些其他的内容，回归正题吧！游戏之中为什么要用脚本语言！原因可能有以下三点吧！
首先学习门槛低，哪怕是新人也可以快速上手！
其次就是开发成本低，可维护性比较强！
最后就是它是一种动态语言，灵活性很高！
相比较C/C++这样的高复杂性、高风险的编译型语言来说，Lua作为一种轻量级的动态语言，简单的语言特性，精简的基础以及基础库，使得语言学习的门槛大大降低。C++在开发过程之中的要求特别高，它的高效性也造成了它的高复杂性，极易产生Bug，对于开发人员的要求就很高了！从语言的抽象层次来说C/C++抽象低，所以C/C++更加适合底层逻辑的支持，而Lua脚本抽象层次高，更加适合游戏逻辑的实现。脚本语言运行在虚拟机之上，而虚拟机又运行在游戏逻辑之上，Lua作为一种解释型语言，我们可以随时修改并把它体现在游戏之中，以便于快速完成开发。很可惜C/C++做不到，如果说有一个大型的游戏工程，每次修改都需要重新编译，这样下来的成本会很高。所以说如果一个游戏之中所有的功能都使用C/C++来实现，那么对于游戏开发人员来说是一个噩梦！
关于运用的场景来说，举个例子就是当你在希望在游戏开始的时候读取一些信息，以配置你的游戏。通常来说，这些内容都是放到一个文本文件之中，当你的游戏启动的时候，你需要打开这个文件，然后解析字符串，找到所需要的信息。
就目前来说Lua语言在嵌入式开发和游戏开发过程之中运用的最多了！
Lua中的一些知识点
主要讲一下Lua语言之中的一些语法上的小知识，也算是一些比较基础的知识吧。
变 量
关于变量---Lua的数字只有Double类型的，64bits，即使是这样，Lua处理数据的速度并不慢，而且语法也很简单，假设我们想要有一个变量var，那么可以这样写：
var = 1024
var = 3.0
var = 3.1416
var = 314.16e-2
var = 0.31416E1
var = 0xff
var = 0x56 在Lua之中变量没有预定义的类型，任何变量都可以包含任何类型的值，其他类型大家都可以很容易理解，需要注意一下的就是nil类型了，它的功能主要就是区别于其他任何值，一个全局变量在第一次赋值之前的默认值就是nil，将nil赋予一个全局变量就等同与删除它，所以这点需要说明一下。
字符串的话，在Lua之中你可以用单引号，也可以用双引号，如下面的方式（这几种方式是完全相同的）
a = 'alo\n123"'
a = "alo\n123\""
a = '\97lo\10\04923"'
a = [[alo
123"]]在Lua之中，有一种类型是不得不说的---就是Table（表），它实现了"关联数组"，所谓的“关联数组”是一种具有特殊索引方式的数组。不仅可以通过整数来索引它，还可以使用字符串或者其他类型的值（出了nil）来索引它。table是Lua中主要的同事也是仅有的数据结构的机制，具有强大的功能，它没有固定的大小，你可以动态地添加任意元素到一个table之中。通俗点说的话，所谓Table其实就是一个Key Value的数据结构，它很像Javascript中的Object，或是PHP中的数组，在别的语言里叫Dict或Map，或者你可以想一下STL之中的Map（不过还是有很大差别的，STL之中Map是基于红黑树来实现的）
创建一个简单的Table如下：
person = {name="Yasuo", age=20, handsome=True}t = {[20]=100, ['name']="Yasuo", [sex]="男"}arr1 = {[1]=10, [2]=20, [3]=30, [4]=40, [5]=50}
arr2 = {"hello", 10, "Yasuo", function() print("www.csdn.con") end}for i=1, #arr1 do
print(arr1[i])
end上面的程序之中#arr的意思就是arr的长度，还有一点就是Lua也是用Table来管理全局变量的，Lua把这些全局变量放在了一个叫“_G”的Table里。关于变量的先说这么多！
语 句
---if-else分支语句：
if age == 40 and sex =="Male" then
print("Man")
elseif age > 60 and sex ~="Female" then
print("old man without country!")
elseif age < 20 then
io.write("too young, too naive!\n")
else
local age = io.read()
print("Your age is "..age)
end2.-- 我们在C/C++之中做输入输出的时候经常是采用scanf（cin），printf（cout）函数从标准输入、标准输出来进行读写。但是在Lua之中使用read、write函数，不过挺类似的io库的分别从stdin和stdout读写的read和write函数。
3.-- 我们在Lua之中使用..作为拼接操作符。
4.-- 在条件表达式之中我们使用and，or，not作为关键字，不过也有些差别，有兴趣可以去了解一下。
----for循环语句：
for语句有两种形式，一种是数字型for和泛型for
先来看看数字型for，来个典型的示例：
for i=1,10 do --顺序打印1到10
print(i)
end
for i=1,10, 1 do --顺序打印1到10
print(i)
end
for i=10,1,-1 do --逆序打印1到10
print(i)
end
a = {1, 2, 3, 4}
for i,v in ipairs(a) do --结果输出1 2 3 4
print(v)
end
在Lua之中还提供了一个pairs，虽然与ipairs类似，不过通过下面的例子就可以看出不同。
a = {1, 2, 3, 4}
b = {1, 2, 3, 4, ["5"] = 5}
for i,v in ipairs(a) do --结果输出1 2 3 4
print(v)
end
print(" ")
for i,v in ipairs(b) do --结果还是1 2 3 4
print(v)
end
print(" ")
for k,v in pairs(b) do --结果输出1 2 3 4 5
print(v)
end
--- until循环：
sum = 2
repeat
sum = sum ^ 2 --幂操作
print(sum)
until sum >1000
function fib(n)
if n < 2 then return 1 end
return fib(n - 2) + fib(n - 1)
end这里有必要说一下，Lua之中函数是可以返回多个值的，如下：
function getUserInfo(id)
print(id)
return "Yasuo", 20, "163.com", "http://www.baidu.com"
end
name, age, email, website, n= getUserInfo()Lua之中面向对象
关于这部分内容，我之前看到一个总结地比较好的人的讲解，在这里我直接先拿过来用了！由于原文被多次转载了，所以就不知道地址了，所有有兴趣的可以去网上搜一下！
要理解Lua之中的面向对象，首先我们要来了解一下Lua之中的MetaTable和MetaMethod，它们是Lua中的重要的语法，MetaTable主要是用来做一些类似于C++重载操作符式的功能。
比如，我们有两个分数：
fraction_a = {numerator=2, denominator=3}
fraction_b = {numerator=4, denominator=7}
fraction_op={}
function fraction_op.__add(f1, f2)
ret = {}
ret.numerator = f1.numerator * f2.denominator + f2.numerator * f1.denominator
ret.denominator = f1.denominator * f2.denominator
return ret
end
setmetatable(fraction_a, fraction_op)
setmetatable(fraction_b, fraction_op)fraction_s = fraction_a + fraction_b__add(a, b) 对应表达式 a + b
__sub(a, b) 对应表达式 a - b
__mul(a, b) 对应表达式 a * b
__div(a, b) 对应表达式 a / b
__mod(a, b) 对应表达式 a % b
__pow(a, b) 对应表达式 a ^ b
__unm(a) 对应表达式 -a
__concat(a, b) 对应表达式 a .. b
__len(a) 对应表达式 #a
__eq(a, b) 对应表达式 a == b
__lt(a, b) 对应表达式 a < b
__le(a, b) 对应表达式 a <= b
__index(a, b) 对应表达式 a.b
__newindex(a, b, c) 对应表达式 a.b = c
__call(a, ...) 对应表达式 a(...)所谓__index，说得明确一点，如果我们有两个对象a和b，我们想让b作为a的prototype只需要：
setmetatable(a, {__index = b})Window_Prototype = {x=0, y=0, width=100, height=100}
MyWin = {title="Hello"}
setmetatable(MyWin, {__index = Window_Prototype})有了以上的基础，我们可以来说说所谓的Lua的面向对象。
Person={}
function Person:new(p)
local obj = p
if (obj == nil) then
obj = {name="Yasuo", age=20, handsome=true}
end
self.__index = self
return setmetatable(obj, self)
end
function Person:toString()
return self.name .." : ".. self.age .." : ".. (self.handsome and "handsome" or "ugly")
end上面我们可以看到有一个new方法和一个toString的方法。其中：
1）self 就是 Person，Person:new(p)，相当于Person.new(self, p)
2）new方法的self.__index = self 的意图是怕self被扩展后改写，所以，让其保持原样
3）setmetatable这个函数返回的是第一个参数的值。
于是：我们可以这样调用：
me = Person:new()
print(me:toString())
kf = Person:new{name="King's fucking", age=70, handsome=false}
print(kf:toString())Student = Person:new()
function Student:new()
newObj = {year = 2013}
self.__index = self
return setmetatable(newObj, self)
end
function Student:toString()
return "Student : ".. self.year.." : " .. self.name
end如何灵活运用Lua
上面说了那么多，不过最终还是要归结到一个用字上面！由于在“配置”方面，Lua可以给你更加灵活的表达方式，这也是Lua受青睐的原因之一吧！你可以像以下这样配置：
if player:is_dead() then
do_something()
else
do_else()
end 所以接下来就要说一说有关于Lua与C/C++的交互了，关于这方面的内容，就得先从最基本的Lua解释器的工作机制来说起，简单的说就是Lua解释器自身维护一个运行时栈，通过这个运行时栈，Lua解释器向主机程序传递参数，所以很多时候我们都是对这个栈来进行操作。
所以提供了一系列的C API来进行相关的操作，下面给出常用的API
luaL_newstate函数用于初始化一个lua_State实例
luaL_openlibs函数用于打开Lua中的所有标准库，如io库、string库等。
luaL_loadbuffer编译了buff中的Lua代码，如果没有错误，则返回0，同时将编译后的程序块压入虚拟栈中。
lua_pcall函数会将程序块从栈中弹出，并在保护模式下运行该程序块。执行成功返回0，否则将错误信息压入栈中。
lua_tostring函数中的-1，表示栈顶的索引值，栈底的索引值为1，以此类推。该函数将返回栈顶的错误信息，但是不会将其从栈中弹出。
lua_pop是一个宏，用于从虚拟栈中弹出指定数量的元素，这里的1表示仅弹出栈顶的元素。
lua_close用于释放状态指针所引用的资源。
入栈操作：
Lua针对每种C类型，都有一个C API函数与之对应，如：
void lua_pushnil(lua_State* L); --nil值
void lua_pushboolean(lua_State* L, int b); --布尔值
void lua_pushnumber(lua_State* L, lua_Number n); --浮点数
void lua_pushinteger(lua_State* L, lua_Integer n); --整型
void lua_pushlstring(lua_State* L, const char* s, size_t len); --指定长度的内存数据
void lua_pushstring(lua_State* L, const char* s); --以零结尾的字符串，其长度可由strlen得出。
出栈操作：
API使用“索引”来引用栈中的元素，第一个压入栈的为1，第二个为2，依此类推。我们也可以使用负数作为索引值，其中-1表示为栈顶元素，-2为栈顶下面的元素，同样依此类推。
Lua提供了一组特定的函数用于检查返回元素的类型，如：
int lua_isboolean (lua_State *L, int index);
int lua_iscfunction (lua_State *L, int index);
int lua_isfunction (lua_State *L, int index);
int lua_isnil (lua_State *L, int index);
int lua_islightuserdata (lua_State *L, int index);
int lua_isnumber (lua_State *L, int index);
int lua_isstring (lua_State *L, int index);
int lua_istable (lua_State *L, int index);
int lua_isuserdata (lua_State *L, int index);
以上函数，成功返回1，否则返回0。需要特别指出的是，对于lua_isnumber而言，不会检查值是否为数字类型，而是检查值是否能转换为数字类型。
如何才能得到一个脚本变量的值呢？
lua_pushstring(L, "var"); //将变量的名字放入栈
lua_gettatbl(L, LUA_GLOBALSINDEX);//变量的值现在栈顶假设你在脚本中有一个变量 var = 100，而且刚刚入了栈，如何得到这个值呢？我们可以这样
int var = lua_tonumber(L, -1);
lua_getglobal(L, name) lua_getglobal(L, "var"); //变量的值现在栈顶
int var = lua_tonumber(L, -1); #include <iostream>
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
int main()
{
//lua_State *L = lua_open();
//1.创建一个state
lua_State * L = luaL_newstate();
//打开标准库
luaL_openlibs(L);
//2.入栈操作
lua_pushstring(L, "You are so cool!");
lua_pushnumber(L, 20);
//3.取值操作
if(lua_isstring(L, 1))
{
std::cout<<lua_tostring(L, 1)<<std::endl;
}
if(lua_isnumber(L, 2))
{
std::cout<<lua_tonumber(L, 2)<<std::endl;
}
//4.关闭state
lua_close(L);
return 0;
}You are so cool！
20
如何调用函数
关于这个问题，先来说一说如何在VS之中调用Lua之中定义的函数！我们用例子来讲比较好！
假设在Lua文件之中定义了一个函数Inc()，该Lua文件名字为“MyWork.lua”。
function Inc(number)
number = number + 1
return number
end #include <iostream>
#include <io.h>
#include <string>
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
int main()
{
lua_State * L = luaL_newstate();
if (luaL_dofile(L,"MyWork.lua"))//返回0，读取没有错误，返回1，读取发生错误，（同一目录下）路径为相对路径
{
printf("error\n");
}
lua_getglobal(L, "Inc"); //函数现在栈顶
lua_pushnumber(L, 100); //压入参数
lua_pcall(L, 1, 1, 0); //调用函数，有一个参数，一个返回值
int result = (int)lua_tonumber(L, -1); //获取栈顶元素的值
printf("%d\n", result);
return 0;
}最后我们来看一看如何在Lua之中调用VS之中定义的函数，假设我们在VS之中定义的函数如下：
static int dir(lua_State * L) //该函数是获取当前路径下的所有文件名称
{
std::cout << "[C++] dir C++ dir" << std::endl;
std::string to_search = luaL_checkstring(L, 1); //获取路径
long hfilehandle = 0; //用于查找文件的句柄
struct _finddata_t fileinfo;
std::string pathName, ret;
hfilehandle = _findfirst(pathName.assign(to_search).append("\\*").c_str(), &fileinfo); //获取句柄
if(-1 == hfilehandle)
return -1;
do
{
ret.append(fileinfo.name);
ret.append("\n");
} while (!_findnext(hfilehandle, &fileinfo));
_findclose(hfilehandle); //关闭
lua_pushstring(L, ret.c_str()); //将结果压回去
return 1; //返回值为1个
}print(dir("."))int main()
{
lua_State * L = luaL_newstate(); //创建state环境
luaL_openlibs(L); //打开标准库
//注册函数方法一
std::cout << "[C++] Pushing the C++ function" << std::endl;
lua_pushcfunction(L, dir); //进行函数的注册
lua_setglobal(L, "dir");
//注册函数方法二
//lua_register(L, "dir", dir);
if (luaL_dofile(L,"MyWork.lua")) //读取Lua文件
{
printf("error\n");
}
lua_close(L);
return 0;
}
注：我的Lua文件与VS文件都放在同一目录之下！
好了，这次关于Lua的内容就说这么多了！如果还想深入了解，可以仔细看看《Lua程序设计》这本书，或者读一读更加深层次的有关于Lua的用书！
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
