作者： 沐楓
在這篇文章中，我想向大家介紹如何進行Lua程序設計。我假設大家都學過至少一門編程語言，比如Basic或C，特別是C。因為Lua的最大用途是在宿主程序中作為腳本使用的。
Lua 的語法比較簡單，學習起來也比較省力，但功能卻并不弱。
在Lua中，一切都是變量，除了關鍵字。請記住這句話。
I. 首先是注釋
寫一個程序，總是少不了注釋的。
在Lua中，你可以使用單行注釋和多行注釋。
單行注釋中，連續兩個減號"--"表示注釋的開始，一直延續到行末為止。相當于C++語言中的"//"。
多行注釋中，由"--[["表示注釋開始，并且一直延續到"]]"為止。這種注釋相當于C語言中的"/*…*/"。在注釋當中，"[["和"]]"是可以嵌套的。
II. Lua編程
經典的"Hello world"的程序總是被用來開始介紹一種語言。在Lua中，寫一個這樣的程序很簡單：
print("Hello world")
在Lua中，語句之間可以用分號"；"隔開，也可以用空白隔開。一般來說，如果多個語句寫在同一行的話，建議總是用分號隔開。
Lua 有好幾種程序控制語句，如：
條件控制：if 條件 then … elseif 條件 then … else … end
While循環：while 條件 do … end
Repeat循環：repeat … until 條件
For循環：for 變量 = 初值，終點值，步進 do … end
For循環：for 變量1，變量2，… ，變量N in表或枚舉函數 do … end
注意一下，for的循環變量總是只作用于for的局部變量，你也可以省略步進值，這時候，for循環會使用1作為步進值。
你可以用break來中止一個循環。
如果你有程序設計的基礎，比如你學過Basic，C之類的，你會覺得Lua也不難。但Lua有幾個地方是明顯不同于這些程序設計語言的，所以請特別注意。
�。Z句塊
語句塊在C++中是用"{"和"}"括起來的，在Lua中，它是用do 和 end 括起來的。比如：
do print("Hello") end
你可以在 函數 中和 語句塊 中定局部變量。
�。x值語句
賦值語句在Lua被強化了。它可以同時給多個變量賦值。
例如：
a,b,c,d=1,2,3,4
甚至是：
a,b=b,a -- 多么方便的交換變量功能啊。
在默認情況下，變量總是認為是全局的。假如你要定義局部變量，則在第一次賦值的時候，需要用local說明。比如：
local a,b,c = 1,2,3 -- a,b,c都是局部變量
�。當抵颠\算
和C語言一樣，支持 +, -, *, /。但Lua還多了一個"^"。這表示指數乘方運算。比如2^3 結果為8, 2^4結果為16。
連接兩個字符串，可以用".."運處符。如：
"This a " .. "string." -- 等于 "this a string"
�。容^運算
< > <= >= == ~=
分別表示 小于，大于，不大于，不小于，相等，不相等
所有這些操作符總是返回true或false。
對于Table，Function和Userdata類型的數據，只有 == 和 ~=可以用。相等表示兩個變量引用的是同一個數據。比如：
a={1,2}
b=a
print(a==b, a~=b) -- true, false
a={1,2}
b={1,2}
print(a==b, a~=b) -- false, true
�。壿嬤\算
and, or, not
其中，and 和 or 與C語言區別特別大。
在這里，請先記住，在Lua中，只有false和nil才計算為false，其它任何數據都計算為true，0也是true！
and 和 or的運算結果不是true和false，而是和它的兩個操作數相關。
a and b：如果a為false，則返回a；否則返回b
a or b：如果 a 為true，則返回a；否則返回b
舉幾個例子：
print(4 and 5) --> 5
print(nil and 13) --> nil
print(false and 13) --> false
print(4 or 5) --> 4
print(false or 5) --> 5
在Lua中這是很有用的特性，也是比較令人混洧的特性。
我們可以模擬C語言中的語句：x = a? b : c，在Lua中，可以寫成：x = a and b or c。
最有用的語句是： x = x or v，它相當于：if not x then x = v end 。
�。\算符優先級，從高到低順序如下：
^
not - （一元運算）
* /
+ -
..（字符串連接）
< > <= >= ~= ==
and
or
III. 關鍵字
關鍵字是不能做為變量的。Lua的關鍵字不多，就以下幾個：
and break do else elseif
end false for function if
in local nil not or
repeat return then true until while
IV. 變量類型
怎么確定一個變量是什么類型的呢？大家可以用type()函數來檢查。Lua支持的類型有以下幾種：
Nil 空值，所有沒有使用過的變量，都是nil。nil既是值，又是類型。
Boolean 布爾值
Number 數值，在Lua里，數值相當于C語言的double
String 字符串，如果你愿意的話，字符串是可以包含''字符的
Table 關系表類型，這個類型功能比較強大，我們在后面慢慢說。
Function 函數類型，不要懷疑，函數也是一種類型，也就是說，所有的函數，它本身就是一個變量。
Userdata 嗯，這個類型專門用來和Lua的宿主打交道的。宿主通常是用C和C++來編寫的，在這種情況下，Userdata可以是宿主的任意數據類型，常用的有Struct和指針。
Thread 線程類型，在Lua中沒有真正的線程。Lua中可以將一個函數分成幾部份運行。如果感興趣的話，可以去看看Lua的文檔。
V. 變量的定義
所有的語言，都要用到變量。在Lua中，不管你在什么地方使用變量，都不需要聲明，并且所有的這些變量總是全局變量，除非，你在前面加上"local"。
這一點要特別注意，因為你可能想在函數里使用局部變量，卻忘了用local來說明。
至于變量名字，它是大小寫相關的。也就是說，A和a是兩個不同的變量。
定義一個變量的方法就是賦值。"＝"操作就是用來賦值的
我們一起來定義幾種常用類型的變量吧。
A. Nil
正如前面所說的，沒有使用過的變量的值，都是Nil。有時候我們也需要將一個變量清除，這時候，我們可以直接給變量賦以nil值。如：
var1=nil -- 請注意 nil 一定要小寫
B. Boolean
布爾值通常是用在進行條件判斷的時候。布爾值有兩種：true 和 false。在Lua中，只有false和nil才被計算為false，而所有任何其它類型的值，都是true。比如0，空串等等，都是true。不要被C語言的習慣所誤導，0在Lua中的的確確是true。你也可以直接給一個變量賦以Boolean類型的值，如：
varboolean = true
C. Number
在Lua中，是沒有整數類型的，也不需要。一般情況下，只要數值不是很大（比如不超過100,000,000,000,000），是不會產生舍入誤差的。在很多CPU上，實數的運算并不比整數慢。
實數的表示方法，同C語言類似，如：
4 0.4 4.57e-3 0.3e12 5e+20
D. String
字符串，總是一種非常常用的高級類型。在Lua中，你可以非常方便的定義很長很長的字符串。
字符串在Lua中有幾種方法來表示，最通用的方法，是用雙引號或單引號來括起一個字符串的，如：
"This is a string."
和C語言相同的，它支持一些轉義字符，列表如下：
a bell
b back space
f form feed
n newline
r carriage return
t horizontal tab
v vertical tab
\ backslash
" double quote
' single quote
[ left square bracket
] right square bracket
由于這種字符串只能寫在一行中，因此，不可避免的要用到轉義字符。加入了轉義字符的串，看起來實在是不敢恭維，比如：
"one linennext linen"in quotes", 'in quotes'"
一大堆的""符號讓人看起來很倒胃口。如果你與我有同感，那么，我們在Lua中，可以用另一種表示方法：用"[["和"]]"將多行的字符串括起來，如：
page = [[
<HTML>
<HEAD>
<TITLE>An HTML Page</TITLE>
</HEAD>
<BODY>
<A HREF="http://www.lua.org">Lua</A>
[[a text between double brackets]]
</BODY>
</HTML>
]]
值得注意的是，在這種字符串中，如果含有單獨使用的"[["或"]]"就仍然得用"["或"]"來避免歧義。當然，這種情況是極少會發生的。
E. Table
關系表類型，這是一個很強大的類型。我們可以把這個類型看作是一個數組。只是C語言的數組，只能用正整數來作索引；在Lua中，你可以用任意類型來作數組的索引，除了nil。同樣，在C語言中，數組的內容只允許一種類型；在Lua中，你也可以用任意類型的值來作數組的內容，除了nil。
Table的定義很簡單，它的主要特征是用"{"和"}"來括起一系列數據元素的。比如：
T1 = {} -- 定義一個空表
T1[1]=10 -- 然后我們就可以象C語言一樣來使用它了。
T1["John"]={Age=27, Gender="Male"}
這一句相當于：
T1["John"]={} -- 必須先定義成一個表，還記得未定義的變量是nil類型嗎
T1["John"]["Age"]=27
T1["John"]["Gender"]="Male"
當表的索引是字符串的時候，我們可以簡寫成：
T1.John={}
T1.John.Age=27
T1.John.Gender="Male"
或
T1.John{Age=27, Gender="Male"}
這是一個很強的特性。
在定義表的時候，我們可以把所有的數據內容一起寫在"{"和"}"之間，這樣子是非常方便，而且很好看。比如，前面的T1的定義，我們可以這么寫：
T1=
{
10, -- 相當于 [1] = 10
[100] = 40,
John= -- 如果你原意，你還可以寫成：["John"] =
{
Age=27, -- 如果你原意，你還可以寫成：["Age"] =27
Gender=Male -- 如果你原意，你還可以寫成：["Gender"] =Male
},
20 -- 相當于 [2] = 20
}
看起來很漂亮，不是嗎？我們在寫的時候，需要注意三點：
第一，所有元素之間，總是用逗號"，"隔開；
第二，所有索引值都需要用"["和"]"括起來；如果是字符串，還可以去掉引號和中括號；
第三，如果不寫索引，則索引就會被認為是數字，并按順序自動從1往后編；
表類型的構造是如此的方便，以致于常常被人用來代替配置文件。是的，不用懷疑，它比ini文件要漂亮，并且強大的多。
F. Function
函數，在Lua中，函數的定義也很簡單。典型的定義如下：
function add(a,b) -- add 是函數名字，a和b是參數名字
return a+b -- return 用來返回函數的運行結果
end
請注意，return語言一定要寫在end之前。假如你非要在中間放上一句return，那么請寫成：do return end。
還記得前面說過，函數也是變量類型嗎？上面的函數定義，其實相當于：
add = function (a,b) return a+b end
當你重新給add賦值時，它就不再表示這個函數了。你甚至可以賦給add任意數據，包括nil （這樣，你就清除了add變量）。Function是不是很象C語言的函數指針呢？
和C語言一樣，Lua的函數可以接受可變參數個數，它同樣是用"…"來定義的，比如：
function sum (a,b,…)
如果想取得…所代表的參數，可以在函數中訪問arg局部變量（表類型）得到。
如 sum(1,2,3,4)
則，在函數中，a = 1, b = 2, arg = {3, 4}
更可貴的是，它可以同時返回多個結果，比如：
function s()
return 1,2,3,4
end
a,b,c,d = s() -- 此時，a = 1, b = 2, c = 3, d = 4
前面說過，表類型可以擁有任意類型的值，包括函數！因此，有一個很強大的特性是，擁有函數的表，哦，我想更恰當的應該說是對象吧。Lua可以使用面向對象編程了。不信？那我舉例如下：
t =
{
Age = 27
add = function(self, n) self.Age = self.Age+n end
}
print(t.Age) -- 27
t.add(t, 10)
print(t.Age) -- 37
不過，t.add(t,10) 這一句實在是有點土對吧？沒關系，在Lua中，你可以簡寫成：
t:add(10) -- 相當于 t.add(t,10)
G. Userdata 和 Thread
這兩個類型的話題，超出了本文的內容，就不打算細說了。
VI. 結束語
就這么結束了嗎？當然不是，接下來，需要用Lua解釋器，來幫助你理解和實踐了。這篇小文只是幫助你大體了解Lua的語法。如果你有編程基礎，相信會很快對Lua上手了。
就象C語言一樣，Lua提供了相當多的標準函數來增強語言的功能。使用這些標準函數，你可以很方便的操作各種數據類型，并處理輸入輸出。有關這方面的信息，你可以參考《Programming in Lua 》一書，你可以在網絡上直接觀看電子版，網址為：http://www.lua.org/pil/index.html
當然，Lua的最強大的功能是能與宿主程序親蜜無間的合作，因此，下一篇文章，我會告訴大家，如何在你的程序中使用Lua語言作為腳本，使你的程序和Lua腳本進行交互。
---------------------------------------------------------------------------------------------------------
使用流程
1. 函數的使用
以下程序演示了如何在Lua中使用函數, 及局部變量
例e02.lua
-- functions
function pythagorean(a, b)
local c2 = a^2 + b^2
return sqrt(c2)
end
print(pythagorean(3,4))
運行結果
5
程序說明
在Lua中函數的定義格式為:
function 函數名(參數)
...
end
與Pascal語言不同, end不需要與begin配對, 只需要在函數結束后打個end就可以了.
本例函數的作用是已知直角三角形直角邊, 求斜邊長度. 參數a,b分別表示直角邊長,
在函數內定義了local形變量用于存儲斜邊的平方. 與C語言相同, 定義在函數內的代
碼不會被直接執行, 只有主程序調用時才會被執行.
local表示定義一個局部變量, 如果不加local剛表示c2為一個全局變量, local的作用域
是在最里層的end和其配對的關鍵字之間, 如if ... end, while ... end等。全局變量的
作用域是整個程序。
2. 循環語句
例e03.lua
-- Loops
for i=1,5 do
print("i is now " .. i)
end
運行結果
i is now 1
i is now 2
i is now 3
i is now 4
i is now 5
程序說明
這里偶們用到了for語句
for 變量 = 參數1, 參數2, 參數3 do
循環體
end
變量將以參數3為步長, 由參數1變化到參數2
例如:
for i=1,f(x) do print(i) end
for i=10,1,-1 do print(i) end
這里print("i is now " .. i)中，偶們用到了..，這是用來連接兩個字符串的，
偶在(1)的試試看中提到的，不知道你們答對了沒有。
雖然這里i是一個整型量，Lua在處理的時候會自動轉成字符串型，不需偶們費心。
3. 條件分支語句
例e04.lua
-- Loops and conditionals
for i=1,5 do
print(“i is now “ .. i)
if i < 2 then
print(“small”)
elseif i < 4 then
print(“medium”)
else
print(“big”)
end
end
運行結果
i is now 1
small
i is now 2
medium
i is now 3
medium
i is now 4
big
i is now 5
big
程序說明
if else用法比較簡單, 類似于C語言, 不過此處需要注意的是整個if只需要一個end,
哪怕用了多個elseif, 也是一個end.
例如
if op == "+" then
r = a + b
elseif op == "-" then
r = a - b
elseif op == "*" then
r = a*b
elseif op == "/" then
r = a/b
else
error("invalid operation")
end
4.試試看
Lua中除了for循環以外, 還支持多種循環, 請用while...do和repeat...until改寫本文中的for程序
----------------------------------------------------------------------------------------------------------
數組的使用
1.簡介
Lua語言只有一種基本數據結構, 那就是table, 所有其他數據結構如數組啦,
類啦, 都可以由table實現.
2.table的下標
例e05.lua
-- Arrays
myData = {}
myData[0] = “foo”
myData[1] = 42
-- Hash tables
myData[“bar”] = “baz”
-- Iterate through the
-- structure
for key, value in myData do
print(key .. “=“ .. value)
end
輸出結果
0=foo
1=42
bar=baz
程序說明
首先定義了一個table myData={}, 然后用數字作為下標賦了兩個值給它. 這種
定義方法類似于C中的數組, 但與數組不同的是, 每個數組元素不需要為相同類型,
就像本例中一個為整型, 一個為字符串.
程序第二部分, 以字符串做為下標, 又向table內增加了一個元素. 這種table非常
像STL里面的map. table下標可以為Lua所支持的任意基本類型, 除了nil值以外.
Lua對Table占用內存的處理是自動的, 如下面這段代碼
a = {}
a["x"] = 10
b = a -- `b' refers to the same table as `a'
print(b["x"]) --> 10
b["x"] = 20
print(a["x"]) --> 20
a = nil -- now only `b' still refers to the table
b = nil -- now there are no references left to the table
b和a都指向相同的table, 只占用一塊內存, 當執行到a = nil時, b仍然指向table,
而當執行到b=nil時, 因為沒有指向table的變量了, 所以Lua會自動釋放table所占內存
3.Table的嵌套
Table的使用還可以嵌套，如下例
例e06.lua
-- Table ‘constructor’
myPolygon = {
color=“blue”,
thickness=2,
npoints=4;
{x=0, y=0},
{x=-10, y=0},
{x=-5, y=4},
{x=0, y=4}
}
-- Print the color
print(myPolygon[“color”])
-- Print it again using dot
-- notation
print(myPolygon.color)
-- The points are accessible
-- in myPolygon[1] to myPolygon[4]
-- Print the second point’s x
-- coordinate
print(myPolygon[2].x)
程序說明
首先建立一個table, 與上一例不同的是，在table的constructor里面有{x=0,y=0},
這是什么意思呢？ 這其實就是一個小table, 定義在了大table之內, 小table的
table名省略了.
最后一行myPolygon[2].x，就是大table里面小table的訪問方式.
-----------------------------------------------------------------------------------------------------------
如何簡化你的宏.
雖然以上介紹讓我們了解道宏可以完成非常強大的功能，但暴雪實在太小氣了，僅僅只給我們255個字符來編寫宏的內容，假如你的宏的功能比較羅嗦，那就很麻煩了，所以以下我介紹一下一些簡化宏的小技巧：
1、定義全局變量
看完之前Lua介紹的人該都知道把，在Lua里，所有的變量都是全局變量，也就是說任何一個變量只要你在開始游戲后做過定義，那么到游戲結束時只要你不重新定義他都是有效的。但為了不讓我們自己不混淆做全局用的變量和局部使用的變量，我們可以采用大小寫區分的辦法，即大寫一律做為全局變量使用，小寫都用局部變量。
這樣，我們可以在一個宏里把自己常用的魔法/技能都定義成變量來表示，比如我是個術士，就可以這樣：
F="腐蝕術(等級 3)" X="獻祭(等級 3)".......
之后，我們要使用這樣魔法的時候，只要直接用F或X來代替就可以了，連""都可以省掉，是不是很方便呢~
或者還可以把一些常見的API函數變量也自己定義：
T="target" P="player".....
使用的時候和上面一樣。
2、自定義函數
說實在話，魔獸的有些函數實在長的過頭，很多時候珍貴的字節都給函數占去了。所以必要的時候我們就得用自定義函數的方法去簡化這些函數。
自定義函數的語句為：
function 函數名稱(函數變量1、函數變量2....) return 函數返回值 end
比如，使用法術的這個函數是CastByName()，我們可以在宏里這樣寫：
/scirpt function C(a) CastByName(a) end
運行后，我們其他宏使用法術就只要直接用C()就可以了，是不是很方便呢？
或是說話的函數：
/script function S(a) SendChatMessage(a,"SAY") end
之后你要控制人物說話就用S()就可以了。
如果是有返回值的函數：
/script
function N(a)
return UNitName(a) --return之后就是表示函數的返回值,但return必須在end前面.
end
如果以后你要調用目標的名字，直接用 x=N("target")，如果按前面第一點定義了全局變量的話，更簡單x=N(T)。
這樣，我們就可以把重要的字節都用在宏的判斷內容上，而不是沉長的函數上了。如果你還有什么更好的簡化方法，可以跟貼哦。
-------------------------------------------------------------------------------------------------------
關于背包物品使用整理類的宏的制作
由于游戲提供的函數無法直接由物品名稱調用該物品，所以通常簡單的使用物品宏是比較麻煩的，一定要把使用的物品放在背包內特定的位置
；或則大多術士都需要的問題，能隨時監視自己的靈魂碎片（當然，有插件可以做到這一點）。
以下我寫寫關于如何制作這類宏：
首先，我們要在背包里找到自己需要的東西，必須用循環里遍歷這些包。由于放的位置有2個參數，1個是包的編號，一個是包內槽位的編號，
所以我們需要一個循環嵌套來搜索：
以下假設我們身上都是16格的包：
for bag=0,4,1 do --包的編號為從右到左，0,1,2,3,4
for cw=1,16,1 do --槽位的編號為上到下，左到右 1,2,3,4,5......16
.............. --這里我們可以寫如判斷物品是否為我們需要的東西的語句
end --表示內循環結束
end --外循環結束
或者用其他方式做這個循環：
While循環：while 條件 do … end
Repeat循環：repeat … until 條件
然后，要處理的是物品的判斷：
我們有兩個函數可以使用
GetContainerItemLink() 和 GetContainerItemInfo()
這兩個函數使用的變量都是2個，一個是包的編號，一個是槽位的編號，但他們的返回值不同
GetContainerItemLink()是返回一個帶著物品名字的連接，如果你用聊天函數把返回值說出來就可以看到，說出來的不光是物品的名稱，還是
一個可以連接到物品詳細內容窗口的連接。
比如，你的包里4，1的位置放了一塊熊肉，那么用/script SendChatMessage(GetContainerItemLink(4,1),"SAY")后，就可以看到自己說“[熊
肉]”，而且用鼠標點一下說的內容，還可以彈出一個描寫這塊肉的窗口。
但要注意，直接用"[熊肉]"這樣字符串來判斷這個物品是不行的，例如：
if GetContainerItemLink(4,1)=="[熊肉]" then ..... end
這個判斷是無效的。
正確的方法是，先把要做判斷的物品的賦一個變量，再用變量做出判斷：
rou=GetContainerItemLink(4,1) --把物品連接值賦給rou
if GetContainerItemLink(4,1)==rou then ..... end --現在就可以正常判斷物品了
最后要注意的是，這個函數無法對術士的靈魂碎片做出正確的判斷，意思就是，雖然靈魂碎片用這個函數顯示出來是一樣的，但這個函數卻認
為所有的靈魂碎片都是不同的東西，即你把這個靈魂碎片的連接賦給一個變量后，這個變量就只能判斷這個靈魂碎片，其他的靈魂碎片就無法
作出判斷，奇怪把。所以要判斷靈魂碎片，就必須用到第二個函數GetContainerItemInfo()
GetContainerItemInfo()的返回值非常多，幾乎所有的物品信息都可以返回，但我們這里判斷只用它返回的第一個值。
我們可以先用聊天函數來看看第一個返回值是什么樣子的：
/script
a=GetContainerItemInfo(4,1)
SendChatMessage(a,"SAY")
可以看到，返回值相當長的英文，但物品的關鍵字是在后面。
這樣，我們就有2種方法來使用這個函數來判斷物品。
1、和前一個函數的方法一樣，用變量存儲值后再判斷，前提是要把判斷的物品放在特定的位置賦一下值。
2、只使用特定物品，把物品的判斷關鍵字寫在函數里，然后用string.find()來判斷他。
例子：某物品的關鍵字是bd
if string.find(GetContainerItemInfo(4,1),bd) then .....end --判斷包1，4位置是否存在關鍵字為bd物品。
接著要處理的是物品的使用和交換。
使用特定背包位置的物品函數：UseContainerItem(index,slot)
這個好理解，不用多解釋了把。
拾取/放下物品的函數：PickupContainerItem(index,slot)
這個函數有意思，你鼠標上沒抓著東西的時候就是幫你拿起特定位置的物品，有的話就變成放下物品到特定的位置并交換拿起該位置的物品。
所以要完成2個物品在包內的交換要使用3次這個函數：
PickupContainerItem(4,1) --拿起4，1位置的物品
PickupContainerItem(1,4) --放在1，4位置并拿起1，4位置的物品
PickupContainerItem(4,1) --把1，4位置的物品放在4，1位置
好拉，把以上幾點組合后宏就基本完成了：
下面的例子是關于靈魂碎片的整理，把前4個包的靈魂碎片全放到最后一個包內：
/script
bag=0 cw=1 sc=1 --定義好變量，bag是包的編號，cw表示查找包的槽位，sc指向最后一個包內的槽位
for bag=0,3,1 do --從0號包開始，到3號包結束，最后一個包不搜索。
for cw=1,16,1 do --這里假設所有的包都是16個槽位的，如果沒那么多槽位的包也可以用。
if GetContainerItemLink(bag,cw)~=nil --判斷這個槽位是否是空的，是空就直接跳到下一個槽位
then
if string.find(GetContainerItemInfo(bag,cw),"Gem") --判斷這個槽位里是否是靈魂碎片，Gem為靈魂碎片的關鍵字
then
while string.find(GetContainerItemInfo(4,sc),"Gem") do sc=sc+1 end
--這是一個小循環，用于判斷最后一個包里原來是否已經有靈魂碎片，有的話就指向包的下一個槽位
PickupContainerItem(bag,cw)
PickupContainerItem(4,sc)
PickupContainerItem(bag,cw) --這3句控制靈魂碎片和最后一個包內物品的交換
sc=sc+1 --重要，不能忘記這個，每放置好一個碎片后就要把最后一個包的
槽位指針指向下一個槽位，上面的小循環是無法判斷剛剛放好的碎片的。
end
end
end
end -循環結束
完了么，當然不行。。。因為宏的限制是255個字。所以要簡化我們的宏。
最長的內容估計就是函數了，就先從簡化函數開始：
建立以下宏：
/script function P(c,d) PickupContainerItem(c,d) end
/script function I(e,f) if GetContainerItemInfo(e,f) then return string.find(GetContainerItemInfo(e,f),"Gem") else return nil end end
原來的宏就變成了：
/script
bag=0 cw=1 sc=1
for bag=0,3,1 do
for cw=1,16,1 do
if G(bag,cw)~=nil
then
if I(bag,cw)
then
while I(4,sc) do sc=sc+1 end
P(bag,cw)
P(4,sc)
P(bag,cw)
sc=sc+1
end
end
end
end
多余的變量定義和過長的變量都可以更改：
/script
s=1
for g=0,3 do
for w=1,16 do
if G(g,w)
then
if I(g,w)
then
while I(4,s) do s=s+1 end
P(g,w)
P(4,s)
P(g,w)
s=s+1
end
end
end
end
現在寫的下了吧。呵呵，至于使用物品的宏我雖然已經寫好了，但沒有測試過，等測試沒問題后再放出來把。有興趣的朋友也可以自己寫寫。
但要注意一點，使用物品的宏只要找到物品就可以馬上跳出循環，所以用Repeat循環做比較合適
文章來源于領測軟件測試網 http://www.kjueaiud.com/
