[转贴]jass语言教程

xh526

前言语言概述
0. 教程对象
本教程适用于没有接触过计算机语言的人。由于jass非常简单，所以对学过一种中高级语言的人完全没有难度，而本教程对j语言的各部分都介绍的比较详细，所以没有必要学。如果只会用行号的basic（不包括vb、vbscript、ASP）的话，那还是看看这篇教程吧（不过可以略过很多部分）。
如果是完全没有接触过编程的话，建议第一遍通读，大体掌握jass语言的结构，然后再由基础到高级一步步的提高。
基础篇是对于语言的基本结构的介绍，首先要掌握好里面的关键部分，打好这个基础后，可以跟随高级篇里面的范例一步步的学jass的应用。
1. jass的特点
jass语言是一个语法非常简单的语言，语法结构上比较接近basic，同时也引用了许多c的东西。
2. 如何学习和使用jass
在trigger editor窗口中，我们可以很容易的把一个t转成j，方法是Edit(alt+e)->Conver to Custom Text(x)，然后我们就可以在已有的j的基础上进行编辑。
由于we里的文本编辑器功能不够丰富，另外，we的容错机制比较差（j的错误太多容易导致直接关闭），所以这里推荐两个专门用于jass编辑的工具：jass editor（汉化版）和jass workshop（by soarchin）。两个工具各有各的特点，后面会在涉及到的部分提到。
另外还需要得到cj和bj两个接口函数库，这个在je和jw中均有提供
3. jass和trigger的关系
在地图编辑过程中，绝大多数用j能够完成的东西也能够用t来完成。事实上，所有的t最后都会转化成j，trigger只是面向we的独特体系。具体的说，war3提供的API有common.j和blizzad.j两个文件，其中c.j是纯粹的接口，而blz.j是对cj里面接口函数的封装，主要面向trigger editor，t生成的j代码中，绝大多数函数都是bj里的。
4. 为什么要学习j
a.用heavylock等工具压缩后，trigger和j面向we的部分被删除了，只留下script.j里面干净的j部分，为了研究别人的map，就要能读懂别人的代码；
b.t虽然能完成几乎所有的功能，但是对于内存释放和另外一些功能实现的能力太差；
c.虽然t看似是一个语法结构完整的可读性比较高的语句，但是因为常常语句太长导致可读性大大下降，而j可以更方便的体现逻辑性，事实上j的可读性更强；
d.用j可以写出比t效率高很多的代码，当然这是在对计算机工作原理比较了解的前提下。
   

xh526

第一章 jass基础
0. 本章概述
本章介绍jass语言的最基本内容，包括注释、基本数据类型、变量、数组、基本运算符、运算的优先级、常量、基本运算法则
首先在这里说明一点，jass是区分大小写的，也就是说，jass不会认为“a”和“A”是同一种东西
-----------------------------------------
1. 注释（comment）
注释符号：//
不论是we的语法检查器还是war3，“//”之后该行的内容将被忽略
-----------------------------------------
2. 数据类型：
jass虽然不大，但是提供的功能足够丰富，共提供了6种基本数据类型：
1) integer ： 32位有符号整数型（4byte） 取值范围：[-2147483648, 2147483647] (2^31+符号位)
2) real ： 实数型（单精度浮点型，4byte） 取值范围：[1.5*10^(-45), 3.4*10^38]
3) boolean ： 布尔型（1byte） 记录 true（真）或 false（假）
4) string ： 字符串型（不定长） 用来记录字符
5) handle ： 数据指针型 是jass语法的一个基础类型，相当于passcal中的pointer类型，由它可以派生出其他数据类型的指针。用来指向内存中的一个数据地址
6) code ： 函数指针型 用于指向内存中的函数地址
* 其他数据类型： 1.16有81种，1.17又新增5种，都是由继承handle而来，在common.j最开始的部分，
声明形式如下：
type ****** extends handle //此处即使不是handle，也是其他由handle继承而来的类型


2 JASS语言教程
3. 变量：
知道了jass的基础数据类型，下面我们要了解如何使用这些数据。首先就是要对数据进行存取，基本的办法就是使用变量。什么是变量呢？就是war3在运行的时候在内存中申请一块数据空间，用来存取数据的。
1) 变量的类型：分全局变量和局域变量两种，在j中最常用的是局域变量
2) 变量的命名：
首先要给变量一个独特名字，作为这个变量的标志，以便在以后的使用过程中访问。
变量名称必须以英文字母开头，变量名中可以包括：大小写英文字母（A~Z, a~z）、数字(0~9)、下划线（_），其它符号会被认为非法（不要用中文命名变量名）。
we会自动给全局变量加上“udg_”前缀，在jass中使用全局变量的时候直接手动输入“udg_”前缀即可访问全局变量。

xh526

第二章 jass语法结构
0. 本章概述
本章介绍jass语言的基本语句，包括判断、循环、判断和循环的嵌套、数组-----------------------------------------1. jass的判断语句
与大多数的语言一样，jass使用了if作为判断语句。jass的if与passcal的判断语法相似（这里不得不b4 basic一下，赋值与判断相等居然都使用“=”，否则的话这里把basic也加进去了）。语法：
a)
if 判断式 then
...
<else
...>
endif 当 判断式 的值为 true 的时候，执行语句
若出现else，则为当 判断式 的值为 true 则执行到 else 之前的语句，否则的话，执行 else 到 endif 之间的语句
if 判断式 then
...
elseif 判断式 then
...
elseif 判断式 then
...
<else
...>
endif 实现多重判断，不做更多的解释了。
-----------------------------------------2. jass的循环语句
一般的语言会提供for循环和loop循环两种循环，另外还有结构化语言中不提倡使用的goto这个转向语句。for循环实际上是一种最简单情况的loop循环，而靠goto控制的转向可以用loop来完成。遗憾的是jass没有提供另外两个循环中非常方便的关键字continue和break，不过靠if和exitwhen也可以完成的。语法：
loop
...
exitwhen 表达式
...
<exitwhen 表达式>
...
endloop 当表达式的值为true的时候，退出该循环。需要说明的是，可以有不止一个exitwhen，并且exitwhen可以在 loop中的任意位置。在使用循环的时候，要注意避免死循环。所谓死循环，就是一直循环下去不会满足退出的条件，这在使用loop循环的过程中非常常见，例如： set i=1
loop
exitwhen i>5
... //中间忘记了set i=i+1
endloop war3有针对死循环的容错机制，当达到一定循环次数的时候会自动退出function，也就是说endloop后的语句不会被执行。
-----------------------------------------3. 判断与循环的嵌套
往往一个判断或者一次循环不能够满足我们想要做的事情，这个时候就涉及到了嵌套。嵌套不难理解，就是在一个判断或循环中，使用了另外一个判断或循环，如： loop
...
if ... then
loop
...
endloop
else
if ... then
...
endif
endif
...
loop
...
endloop
endloop 为什么要把嵌套单独拿出来讲一节，就是因为对初学编程的人来说，使用嵌套的时候常常会出现一些错误。一旦出现了嵌套，一定要先结束里层，然后再结束外层，如下面的语法是不正确的： loop
if ... then
...
endloop
...
endif 可能看到我前面写的东西，各位也比较喜欢空格了吧。在循环和判断的时候用空格来缩进，这样能够更直观的现实逻辑关系，使代码的可读性大大加强。但是缩进也可能导致一些主观的判断错误，例如： if ... then
...
if .... then
...
else
...
endif 在储存的时候这段代码会报错。问题比较容易，自己看吧（j需要endif的语法结构事实上能够比较好的避免大多数问题，像在c里面考试还会常常出这类的题hoho）。-----------------------------------------4. 数组的使用
有些时候，你会不会觉得一些重复的操作很烦呢？比如把一个单位身上的物品丢在一个地方，过一段时间之后再放回身上，例如： local unit u = GetTriggerUnit()
3 JASS语言教程
local item item1 = UnitItemInSlotBJ(u, 1)
local item item2 = UnitItemInSlotBJ(u, 2)
local item item3 = UnitItemInSlotBJ(u, 3)
local item item4 = UnitItemInSlotBJ(u, 4)
local item item5 = UnitItemInSlotBJ(u, 5)
local item item6 = UnitItemInSlotBJ(u, 6)
... 这种时候，我们可以用一个array（数组）来表示一组东西。1) 数组的声明：
数组也是变量，所以也有全局和局域之分。全局的数组只要在全局变量的设置中，把array勾上就可以了，实际上是在变量的声明过程中，在变量类型和变量名称之间加入array关键字： local item array items* 补充：在全局变量的声明中，还有个size选项，那个选项实际上是假的，只是你自己输入一个数字提示自己这个数组应该有多大而以。jass为了防止mapper不熟练使用数组产生的bug，采用了自动增加数组长度的方式。2) 数组的引用：
使用方括号“[]”作为数组的索引，如访问index=1的变量 set item[1] = CreateItem(...) 数组索引的最低值为0，最高值俺没测试过，不过估计没谁那么疯狂，不断的往数组里面添东西。
结合if判断和loop循环，数组可以减少我们大量的重复工作。------------

xh526

第三章 过程、函数，Trigger与指针
0. 本章概述
本章设计到jass语言中更复杂的一些东西，熟练使用好这些东西，你将体会到更多作图的乐趣。从本章开始，我会尽量结合自己在作图的一些经历，配合范例讲解j的实际应用

-----------------------------------------

1. function概述
结构化语言的特点就是，使用判断、循环和独立的过程来完成所有的功能。function是一段用来完成一个独立功能的代码，使用好j，就要学会用好function

1) function的构成
一段function，由声明、函数体两部分构成：

function 名称 takes [nothing | 参数列] returns [nothing | 返回类型] //声明
... // 函数体部分
<return [返回值]>
endfunction //标志一段function的结束

2) function的分类

a) 过程与函数
在passcal中，声明一段函数只用这个关键字，而声明过程则用另一个关键字；在c中，则直接使用变量类型来声明函数，可以把无返回类型的函数（void类型）理解成过程。我在这里沿用passcal的概念，将不返回值的函数定义为过程。

b) 常函数与变函数
常函数返回一个固定的值，而变函数则根据参数的不同和函数体内的运算。常函数是在function的声明前加constant关键字：

constant function

c) API与自定义function
API（Application Programming Interface，应用程序接口）是指包含在common.j中的函数，该部分函数实际上是一些已经由系统封装好的函数，用户只要知道function名、功能、参数，就可以利用这部分function做到自己想要做的事情，通常 API是实现用户无法通过自定义function来实现的功能，在cj中，API的声明形式如下：

native CreateItem takes integer itemid, real x, real y returns item

自定义function是指用户在使用过程中，自己定义的一些过程或函数，如我们用到一个地图初始化的trigger中注册trigger的部分：

function InitTrig_MapInit takes nothing returns nothing
set gg_trg_MapInit = CreateTrigger( )
call TriggerAddAction( gg_trg_MapInit, function Trig_MapInit_Actions )
endfunction

3) function的参数
在function的声明中，takes与returns之间的部分为参数部分。
nothing关键字表示无参数。传递参数的时候，要写明传递的参数的类型和参数在函数过程中的名称，如传递几个参数，不同参数之间用逗号（,）隔开：

xh526

4 JASS语言教程

a. function **** takes integer i returns **** //传递一个integer型参数
b. function **** takes real x, real y returns **** //传递两个real型参数
b. function **** takes nothing returns **** //不传递参数

4) function的返回值类型
返回值类型是在声明中returns后面的部分。
如使用nothing关键字，则表示不返回任何数值，该function为一个过程。函数只能有一个返回类型，可使用任何在cj中声明的变量类型：

a. function **** takes **** returns integer //返回integer型
b. function **** takes **** returns nothing //过程


-----------------------------------------

2. function的使用

1) 过程体与函数体
过程体由变量声明、代码两部分组成。变量声明部分是对本地变量的声明，前面已经介绍过，用local关键字来声明
函数体除了过程体以外，还需要有返回函数值的语句，这是函数与过程的区别。

2) function的可见度
只有一个function在前面已经声明过，后面的代码才能使用这个function。一个function对整个map都是可见的。

3) 调用function，传递参数，在function中使用参数，取得函数返回值
我们定义了一个function，那么如何在后面的过程中使用呢？
对于过程和函数，都可以使用下面的方法来调用：

call 名称(<参数列>)

参数列中参数的数量必须与声明中的数量相同，并且类型一一对应，如有一个函数：

function xyz takes integer a, real b, string c returns integer
...
endfunction

我们在调用这个函数的时候，必须如下形式传递：

call xyz(1,0.5,"c")

传递的参数可以是数值（如1 0.5 "a"等）、常量（如bj_PI、UNIT_STATE_LIFE等）、变量。在function使用参数的时候，直接使用声明function时候的变量名称：

function *** takes integer i, integer j returns ***
local integer a = i + 1
set j = j + a
....
endfunction

需要说明的是，参数的传递都是按值传递的，假如有这样2个funciton：

function add1 takes integer i returns nothing
set i=i+1
endfunction

function b takes nothing returns nothing
local integer t = 1
local force foc = GetPlayersAll()
call add1(t)
call DisplayTextToPlayer(foc, I2S(t))
call DestroyForce(foc)
set foc = null
endfunction

那么函数b的最后在屏幕上的显示结果将是“1”，换句话说，add1函数在创建的时候，首先申请了一个整数的空间并命名为i，然后把b函数传递来的值复制给i，在add1函数使用完毕之后，i的数值被销毁，而b函数传递的t的值并没有改变。
这样的话，我们如何得到函数的计算结果呢？通过返回值！如上一段函数，把add1改为：

function add1 takes integer i returns integer
return i+1
endfunction

其中，return就是返回语句。return有两个功能，第一是推出函数，第二是返回函数结果。在过程中，可以不使用return，但是一旦使用，不能接任何参数；在function中，至少要有一个return加返回值用来返回函数值。调用函数时，不加call则返回函数值，也就是说，我们可以把调用的函数看成一个变量：

set i=add1(i)
call DisplayTextToForce(GetPlayersAll(),add1(i))
call add1( add1(i) )

* 注意：
return的参数不是用括号（“()”）来传递，而是用空格。因为return后面的语句都不会被继续执行，所以常常被用来提前退出function。

* 补充：
得到函数返回值的速度要比变量慢很多，所以不推荐使用常函数。

4) function的执行过程
当我们在一段代码a中调用function b的时候，a会首先把参数传递给b，然后把控制权交给b，b把所有的东西都处理完之后，再把控制权交回给a。也就是说，一条语句调用一个function，就意味着只有那个function所有语句都执行完毕之后，才会继续运行调用语句后面的语句。

xh526

5 JASS语言教程

-----------------------------------------

3. Trigger（触发）
可能各位会奇怪，明明是一篇jass的教程，怎么突然把trigger又拿出来了而且作为一部分内容呢？实际上，在war3中，trigger 是一种function的一种特殊执行方式。刚才已经说了，当调用函数的时候，系统会等待这个函数执行完之后才执行下一段代码；前面也介绍过， function是语言的主体，trigger只能看作是辅助function完成功能的一部分。所以这一节我将对trigger的工作原理做一个介绍。  

1) trigger的构成

现在我们随便创建一个t，加入event（事件）和conditions，然后转化成j来看：

//condition
function Trig_Untitled_Trigger_001_Conditions takes nothing returns boolean
if ( not ( IsUnitType(GetTriggerUnit(), UNIT_TYPE_STRUCTURE) == true ) ) then
return false
endif
return true
endfunction

//action
function Trig_Untitled_Trigger_001_Actions takes nothing returns nothing
call DisplayTextToForce( GetPlayersAll(), "TRIGSTR_2565" )
endfunction

//Regist
function InitTrig_Untitled_Trigger_001 takes nothing returns nothing
set gg_trg_Untitled_Trigger_001 = CreateTrigger( ) //1
call TriggerRegisterAnyUnitEventBJ( gg_trg_Untitled_Trigger_001, EVENT_PLAYER_UNIT_DEATH ) //2
call TriggerAddCondition( gg_trg_Untitled_Trigger_001, Condition( function Trig_Untitled_Trigger_001_Conditions ) ) //3
call TriggerAddAction( gg_trg_Untitled_Trigger_001, function Trig_Untitled_Trigger_001_Actions ) //4
endfunction

前面已经说过了，函数必须在前面声明过才能被引用。在这个“Untitled Trigger 001”中，conditon部分用来判断是否满足trigger的条件，action部分是这个t的主体，那么event在哪里呢？就是在最下面我标注成Regist的部分了。好了，我们现在就开始研究这部分每条语句的功能：
语句1用来创建一个trigger，如果打开这个map的.j文件，我们会发现在globals部分会有这么一句：

trigger gg_trg_Untitled_Trigger_001 = null

换句话说，实际上这个trigger也是一个全局变量。在我们通过trigger editor创建一条t的时候，we会自动在全局变量中加上一个类型为trigger的带gg_trg_前缀的变量，t命名中的空格将被转化成下划线。这条语句是给  gg_trg_Untitled_Trigger_001 创建一个trigger。
再来看语句2，这条语句的意思是，为所有的unit注册一个事件，这个事件用EVENT_PLAYER_UNIT_DEATH常量来表示。打开bj，我们可以看到这样的声明：

function TriggerRegisterAnyUnitEventBJ takes trigger trig, playerunitevent whichEvent returns nothing
local integer index

set index = 0
loop
call TriggerRegisterPlayerUnitEvent(trig, Player(index), whichEvent, null)

set index = index + 1
exitwhen index == bj_MAX_PLAYER_SLOTS
endloop
endfunction

也就是说，当我们注册了一个任何unit身上发生的事件的时候，实际上是为游戏中所有的player都注册了一个PlayerUnit事件。可以看到，所谓的AnyUnitEvent事件是个效率非常低的事件。
语句3和语句4看字面意思就很容易理解了，分别是给 gg_trg_Untitled_Trigger_001 这个trigger加上条件和事件。要注意的是，condition函数无参数，返回类型为boolean，action函数无参数无返回值。
好了，看了这写，相信你也大概明白一个trigger的工作原理了吧？

2) trigger的执行过程
首先，trigger需要有一个trigger类型的变量。trigger类型是个指针，所以要创建一个trigger的实体，并让这个变量指向这个实体（下一节会深入谈一下指针类型变量），这个时候我们就要用到CreateTrigger()函数

xh526

6 JASS语言教程
这时候，已经在war3的执行队列中添加了一个trigger，但是war3在执行的时候并不会理他。想要war3理它的话要怎么办呢？这个时候就要为trigger注册，告诉war3，在这个这个事件发生的时候，你就要理这个trigger。
然后在trigger注册的事件发生的时候，war3会首先检查，这个trigger是否注册了condition，如果注册了就判断 condition是否满足。满足了之后，war3会进行下一步，看看这个trigger有没有action，如果有的话就执行action。这里要说明的是，一个trigger可以有多个conditions和actions函数，只要注册了，war3会检查每一个conditions，如果每个 conditions都满足的话，则会执行每个actions。换句话说，conditions之间的逻辑关系是and。除非是比较特殊的控制，否则不建议使用多个conditions或actions，这样会增加代码的控制难度。
没有conditions的t会直接运行actions。
trigger是有单独的进程的，一个t的运行不阻碍其他t的执行。

3) 常用的trigger函数与功能
这里我会对经常用到的几个trigger函数做简要的说明：
打开cj，我们可以找到管理trigger类型的API部分：

//创建一个trigger
native CreateTrigger takes nothing returns trigger

//销毁一个trigger，销毁这个t后，这个t将永远不会被再次使用，但不会中断已经运行中的t
native DestroyTrigger takes trigger whichTrigger returns nothing

//使一个trigger失效，也就是说，war3会忽略这个t
native DisableTrigger takes trigger whichTrigger returns nothing

//使一个已经被disable的trigger生效
native EnableTrigger takes trigger whichTrigger returns nothing

//判断一个trigger是否出于有效的状态
native IsTriggerEnabled takes trigger whichTrigger returns boolean

//立即触发一个trigger
native TriggerExecute takes trigger whichTrigger returns nothing

下面结合两个范例来消化前面学过的东西

<<<<<<<<<<<<<<<<<< <<<<<<<< 范例 1 >>>>>>>> >>>>>>>>>>>>>>>>>>>

前面已经说过，function是线性运行的，而trigger是并行运行的，那么假如我在做一个既能的时候，想要生成一个范围内的效果。但是如果在程序中用PolledWait执行的时候会发现，实际上的时间没法和真实的技能效果时间对应上，那么怎么解决呢？
一般的方法是另外做一个trigger用来产生效果，在技能触发了t之后，使用来显示效果的t生效，然后再在本段t中进行伤害，到了一定时间之后在将那个效果t禁止。
用j的话，我们可以利用trigger的工作原理，将两段代码合并在一起。
首先，我们需要一个使function立即执行并不等待function结束的功能，下面介绍这个功能的实现：

// 参数用来传递一个function
function RunFunctionAsTrigger takes code cFun returns nothing
//申请一个居于的trigger，因为我们只要求这个trigger运行一次，所以不需要全局变量
local trigger trg = CreateTrigger()

//把参数传递来的function作为新创建的trigger的action
call TriggerAddAction(trg, cFun)
//立即触发这个trigger，实际上就是让function作为另外一个进程运行，不需要等待执行结束
call TriggerExecute(trg)
//由于这个trigger已经在运行中，我们不再需要它了，所以马上毁掉这个trigger，并释放内存
call DestroyTrigger(trg)
set trg = null
endfunction

第二步，我们要想要在一定范围内持续出现一个效果，那么这个效果应该是每一定时间出现的，所以要创建第二个基础函数。另外考虑到，这个trigger持续一段时间后怎么结束呢？所以要让这个function有返回类型：

//传递一个function的参数，一个real型是说明多少秒之后执行，bool型说明是否只执行一次

xh526

7 JASS语言教程
function RunFunctionAsTriggerWithTimer takes code cFun, real timeout, boolean periodic returns trigger
//与前面的过程一样，只对变动部分进行讲解
local trigger trg = CreateTrigger()

call TriggerAddAction(trg, cFun)
//给这个trigger注册一个事件，这个函数的意思就是用于多少秒的时候执行，是否只执行一次
call TriggerRegisterTimerEvent(trg,timeout,periodic)

//返回我们做好的这个trigger
return trg
endfunction

准备工作已经做好了，以后实现类似功能的时候，我们都可以调用这两个函数。使用j的好处就是，我们可以把大量重复的工作封装成function，用到这个功能的时候，只要调用这个function就可以了，而不用一遍一遍的复制，做重复的工作。
下面的是在一定范围内不断产生lich的frost nova的效果：

//用来产生效果，围绕一点(udg_fFSLocX,udg_fFSLocY)（两个都是全局变量），产生一个效果
function FSEffectWithTimer takes nothing returns nothing
//随机产生一个x和y，可以看成近似一个圆，因为出现在这个圆之外是个小概率事件
local real x = udg_fFSLocX+GetRandomReal(0,400)*SinBJ(GetRandomReal(-180,180))
local real y = udg_fFSLocY+GetRandomReal(0,400)*SinBJ(GetRandomReal(-180,180))
//产生效果
local effect eff = AddSpecialEffect("Abilities\\\\Spells\\\\Undead\\\\FrostNova\\\\FrostNovaTarget.mdl",x,y)

//等待2秒
call PolledWait(2)
//销毁效果，释放内存
call DestroyEffect(eff)
set eff = null
endfunction

//用于在技能中拿来RunFunctionAsTrigger的
function FrostSpaceEffect takes nothing returns nothing
//把效果函数注册成每0.1秒运行一次，即每0.1秒产生一个效果
local trigger trg = RunFunctionAsTriggerWithTimer(function FSEffectWithTimer, 0.1, true)

//等待5秒
call PolledWait(5)
//摧毁效果trigger，释放内存
call DestroyTrigger(trg)
set trg = null
endfunction

好了，现在你可以做一个技能，然后把上述的jass放到里面，看看效果如何了：）

>>>>>>>>>>>>>>>>>> >>>>>>>>> 结束 <<<<<<<< <<<<<<<<<<<<<<<<<<

<<<<<<<<<<<<<<<<<< <<<<<<<< 范例 2 >>>>>>>> >>>>>>>>>>>>>>>>>>>

在这个范例中，我将带大家实现一个多重物品栏的功能。
准备知识：
在war3种，blz为每个unit和item都提供了一个integer型的UserData，让各位mapper可以很方便的做一些事情（有点像windows标准控件的tag属性）。

思路：
首先是要在hero使用技能的时候触发这个trigger，然后把hero身上的item移走物品，下次的时候再把物品取回来，所以我们要给物品创建一个数组来保存。一个物品栏有6个物品，每个hero有n1个物品栏，又有n2个hero，可是jass只提供了1维数组，怎么做呢？聪明的你一定想到了x*a*b+y*b+z的办法，的确这样，我们就给每个hero一个特定的整数标志，每个物品栏一个数字，这样就可以了。下面是利用unit的 userdata的实现方法。这个方法共支持8个物品栏

全局变量：
integer udg_iUnitIndex //用来使每个unit有独特的id
item array udg_itemGoods //用来存取所有的物品栏中的物品

函数：

//unit物品栏ID:使用userdata的1-3 bit；共支持2^3=8个物品栏，如果想再多的话，就把里面的数字乘以2就可以得到16个了
//用来读取物品栏id：
function fiGetUnitDataGoodsID takes unit whichUnit returns integer
//由于只是用0~7这几个数，所以我们只要去modulo（模，可理解为余数）就可以了
return ModuloInteger( GetUnitUserData( whichUnit ), 8 )

xh526

8 JASS语言教程
endfunction

//用来存放物品栏id：
function pSetUnitDataGoodsID takes unit whichUnit, integer newData returns nothing
local integer it = GetUnitUserData( whichUnit )
//新的id只要用newData再加上原来的数字除以8的整数部分乘以8就够了
call SetUnitUserData( whichUnit, ( it/8*8 + newData )
endfunction


//Unit - UnitID:7~ bit；用来记录单独的Unit
function fiGetUnitDataID takes unit whichUnit returns integer
//只要整数部分就可以了
return GetUnitUserData( whichUnit )/8
endfunction

function pSetUnitDataID takes unit whichUnit, integer newData returns nothing
local integer it = GetUnitUserData( whichUnit )
//将新的数字乘以8之后，再加上余数部分就可以了
call SetUnitUserData( whichUnit, newData*8+ModuloInteger( it, 8 ) )
endfunction

下一步，我们要设定一个全局变量，在每个hero出现的时候，加上这么两句：
set udg_iUnitIndex = udg_iUnitIndex + 1
call pSetUnitDataID( udg_iUnitIndex )

然后是unit切换物品栏的action：

//得到当前的unit
local unit u = GetTriggerUnit()
//得到下一个物品栏的id，由于只是0~7这几个数字，所以只要在每次+1之后取除以8的余数就可以了
local integer index = ModuloInteger(fiGetUnitDataGoodsID(u)+1,8)
//得到userdata，由于这个data已经有独立的unit的id和item的id，所以不用分别取了
local integer id = GetUnitUserData(u)
local integer i = 0
local integer it

//保存当前身上的物品，并丢在隐藏的地方
loop
exitwhen i>5
set it = id*6+i
//设定物品为当前物品栏第几栏的物品
set udg_itemGoods[it] = UnitItemInSlot(u, i)
//移到地图隐蔽处
call SetItemPositionLoc(udg_itemGoods[it],udg_locItemTemp)
call TriggerSleepAction(0)
//使物品无敌
call SetItemInvulnerable(udg_itemGoods[it],true)
//使物品不可见
call SetItemVisible(udg_itemGoods[it],false)
set i = i + 1
endloop

//设定下一个物品栏标号
call pSetUnitDataGoodsID(u,index)
set id = GetUnitUserData(u)
set i = 0
//取回物品
loop
exitwhen i>5
set it = id*6+i
//使物品可见
call SetItemVisible(udg_itemGoods[it],true)
//使物品不无敌
call SetItemInvulnerable(udg_itemGoods[it],false)
call TriggerSleepAction(0)
//放回物品栏
call UnitAddItem(u,udg_itemGoods[it])
set i = i + 1
endloop

* 补充： ModuloInteger是bj函数：
function ModuloInteger takes integer dividend, integer divisor returns integer
local integer modulus = dividend - (dividend / divisor) * divisor

if (modulus < 0) then
set modulus = modulus + divisor
endif

return modulus
endfunction

前面介绍过if语句的速度要比运算满很多，因为我们这个函数里面不涉及到负数，所以在这里我们可以自定义一个自己的函数：
function MyModuloInteger takes integer dividend, integer divisor returns integer
return dividend - (dividend / divisor) * divisor
endfunction

xh526

9 JASS语言教程
前面已经说过，指针用来指向内存中的一块内存区域，这块区域有可能是个自定义类型的变量，有可能是一个function（code），有可能指向一个复合的单位（如unit，包括在we中看到的所有数据，这种类型应该是war3中最复杂的）……
在使用指针类型的时候，我们不能进行数学运算，只能通过API函数来存取。而在war3中，所有的单位都是只给一个句柄，如unit、item、region、camera……在给指针类型赋值的时候，大多数的函数过程是这样的：
首先分配给这种指针类型所指向的实体类型申请一块内存空间，然后把照着参数把相应的资料给这个实体变量，然后再返回这个变量在内存中的地址，也就是指针变量，最后这个被赋值的变量指向那块内存地址。如果在一段函数中使用了指针类型得到了一个值，使用完之后不做任何处理的话，那块被占用的内存虽然不会再使用了，但是由于前面已经申请了，所以系统会认为这块内存是被占用了的，不会再动用这块内存空间，这就是所谓的内存泄漏问题。
t虽然能够完成绝大部分的功能，但是对于内存处理这部分却是无能为力。例如存在最严重的就是location变量的内存泄漏问题，虽然一次才8个字节，但是常常我们一次性就使用了大量的location，导致时间越长，内存泄露越多。用j的话，就一定要记住：
释放内存！
什么样的变量需要释放内存呢？我们可以在je的搜索栏输入destroy和remove，destroy中的绝大部分都是需要释放内存的（也有少部分一旦释放，就是去了我们原来想要的效果了，例如fogmodifier类型），remove中location是一定要释放的，region和 rect就要根据具体情况了，否则也会跟fogmodifier出现一样的情况，这些东西就要靠经验了。
最后要说的是，既然指针变量要用API，那么应该怎样得到自己想要的函数呢？最好要先对jass的API有一定的了解，例如soarchin 写的API函数介绍（本教程不会提供jass的API函数介绍）。在最开始使用的时候，可以利用we的t，现做一个自己想要的语句，然后转成j，把语句拿过来用——不过要注意的是，trigger编辑器使用的绝大部分是bj里面的函数，最明显的是带有BJ后缀或者Swap(ped)后缀，一般都会有对应的 cj函数，而两者几乎无差别（这个最好用jw来看）。等熟练一些之后，你就会发现一些blz的命名规则了，如判断一个unit，就是IsUnit***，得到unit的一个什么东西，就GetUnit****，设置就是SetUnit***，想要得到一个group，就GetUnits***，得到 force就GetPlayers***……总之这个要靠经验的，旁边开着个金山词霸，基本上就能把一个函数的功能猜个八九不离十。当然，最好还是看看 jass API的中文介绍，这个最保险，然后可以照着别人的jass学习。了解了jass的动作原理后，你会发现通过jass来学习别人的东西要比看别人的trigger来学习快很多——我经常是把t的演示先转成j然后再看的。

-----------------------------------------

第三章结束
本章剖析了jass的工作原理，熟练掌握了这三章的内容，实际上你就已经是个jass高手了，剩下的只差实际做几个东西的经验和对API函数的了解和熟练程度了。

xh526

进阶高级



本章设计到jass语言中更复杂的一些东西，熟练使用好这些东西，你将体会到更多作图的乐趣。从本章开始，我会尽量结合自己在作图的一些经历，配合范例讲解j的实际应用
-----------------------------------------
1. function概述
结构化语言的特点就是，使用判断、循环和独立的过程来完成所有的功能。function是一段用来完成一个独立功能的代码，使用好j，就要学会用好function
1) function的构成
一段function，由声明、函数体两部分构成：
function 名称 takes [nothing | 参数列] returns [nothing | 返回类型] //声明
... // 函数体部分
<return [返回值]>
endfunction //标志一段function的结束
2) function的分类
a) 过程与函数
在passcal中，声明一段函数只用这个关键字，而声明过程则用另一个关键字；在c中，则直接使用变量类型来声明函数，可以把无返回类型的函数（void类型）理解成过程。我在这里沿用passcal的概念，将不返回值的函数定义为过程。
常函数与变函数
常函数返回一个固定的值，而变函数则根据参数的不同和函数体内的运算。常函数是在function的声明前加constant关键字：
constant function
c) API与自定义function
API（Application Programming Interface，应用程序接口）是指包含在common.j中的函数，该部分函数实际上是一些已经由系统封装好的函数，用户只要知道function名、功能、参数，就可以利用这部分function做到自己想要做的事情，通常API 是实现用户无法通过自定义function来实现的功能，在cj中，
API的声明形式如下：
native CreateItem takes integer itemid, real x, real y returns item
自定义function是指用户在使用过程中，自己定义的一些过程或函数，如我们用到一个地图初始化的trigger中注册trigger的部分：
function InitTrig_MapInit takes nothing returns nothing
set gg_trg_MapInit = CreateTrigger( )
call TriggerAddAction( gg_trg_MapInit, function Trig_MapInit_Actions )
endfunction
3) function的参数
在function的声明中，takes与returns之间的部分为参数部分。
nothing关键字表示无参数。传递参数的时候，要写明传递的参数的类型和参数在函数过程中的名称，如传递几个参数，不同参数之间用逗号（,）隔开：
a. function **** takes integer i returns **** //传递一个integer型参数
b. function **** takes real x, real y returns **** //传递两个real型参数
b. function **** takes nothing returns **** //不传递参数
4) function的返回值类型
返回值类型是在声明中returns后面的部分。
如使用nothing关键字，则表示不返回任何数值，该function为一个过程。函数只能有一个返回类型，可使用任何在cj中声明的变量类型：
a. function **** takes **** returns integer //返回integer型
b. function **** takes **** returns nothing //过程

-----------------------------------------
2. function的使用
1) 过程体与函数体
过程体由变量声明、代码两部分组成。变量声明部分是对本地变量的声明，前面已经介绍过，用local关键字来声明
函数体除了过程体以外，还需要有返回函数值的语句，这是函数与过程的区别。
2) function的可见度
只有一个function在前面已经声明过，后面的代码才能使用这个function。一个function对整个map都是可见的。
3) 调用function，传递参数，在function中使用参数，取得函数返回值
我们定义了一个function，那么如何在后面的过程中使用呢？
对于过程和函数，都可以使用下面的方法来调用：
call 名称(<参数列>)
参数列中参数的数量必须与声明中的数量相同，并且类型一一对应，如有一个函数：
function xyz takes integer a, real b, string c returns integer
...
endfunction
我们在调用这个函数的时候，必须如下形式传递：
call xyz(1,0.5,"c")
传递的参数可以是数值（如1 0.5 "a"等）、常量（如bj_PI、UNIT_STATE_LIFE等）、变量。在function使用参数的时候，直接使用声明function时候的变量名称：
function *** takes integer i, integer j returns ***
local integer a = i + 1
set j = j + a
....
endfunction
需要说明的是，参数的传递都是按值传递的，假如有这样2个funciton：
function add1 takes integer i ret





补充资料：
1. 全局变量与局域变量的差别
2. 两个jass的示例
下面结合两个范例来消化前面学过的东西



范例 1


前面已经说过，function是线性运行的，而trigger是并行运行的，那么假如我在做一个既能的时候，想要生成一个范围内的效果。但是如果在程序中用PolledWait执行的时候会发现，实际上的时间没法和真实的技能效果时间对应上，那么怎么解决呢？
一般的方法是另外做一个trigger用来产生效果，在技能触发了t之后，使用来显示效果的t生效，然后再在本段t中进行伤害，到了一定时间之后在将那个效果t禁止。
用j的话，我们可以利用trigger的工作原理，将两段代码合并在一起。
首先，我们需要一个使function立即执行并不等待function结束的功能，下面介绍这个功能的实现：
// 参数用来传递一个function
function RunFunctionAsTrigger takes code cFun returns nothing
//申请一个居于的trigger，因为我们只要求这个trigger运行一次，所以不需要全局变量
local trigger trg = CreateTrigger()

//把参数传递来的function作为新创建的trigger的action
call TriggerAddAction(trg, cFun)
//立即触发这个trigger，实际上就是让function作为另外一个进程运行，不需要等待执行结束
call TriggerExecute(trg)
//由于这个trigger已经在运行中，我们不再需要它了，所以马上毁掉这个trigger，并释放内存
call DestroyTrigger(trg)
set trg = null
endfunction
第二步，我们要想要在一定范围内持续出现一个效果，那么这个效果应该是每一定时间出现的，所以要创建第二个基础函数。另外考虑到，这个trigger持续一段时间后怎么结束呢？所以要让这个function有返回类型：
//传递一个function的参数，一个real型是说明多少秒之后执行，bool型说明是否只执行一次
function RunFunctionAsTriggerWithTimer takes code cFun, real timeout, boolean periodic
returns trigger
//与前面的过程一样，只对变动部分进行讲解
local trigger trg = CreateTrigger()

call TriggerAddAction(trg, cFun)
//给这个trigger注册一个事件，这个函数的意思就是用于多少秒的时候执行，是否只执行一次
call TriggerRegisterTimerEvent(trg,timeout,periodic)

//返回我们做好的这个trigger
return trg
endfunction
准备工作已经做好了，以后实现类似功能的时候，我们都可以调用这两个函数。使用j的好处就是，我们可以把大量重复的工作封装成function，用到这个功能的时候，只要调用这个function就可以了，而不用一遍一遍的复制，做重复的工作。
下面的是在一定范围内不断产生lich的frost nova的效果：
//用来产生效果，围绕一点(udg_fFSLocX,udg_fFSLocY)（两个都是全局变量），产生一个效果
function FSEffectWithTimer takes nothing returns nothing
//随机产生一个x和y，可以看成近似一个圆，因为出现在这个圆之外是个小概率事件
local real x = udg_fFSLocX+GetRandomReal(0,400)*SinBJ(GetRandomReal(-180,180))
local real y = udg_fFSLocY+GetRandomReal(0,400)*SinBJ(GetRandomReal(-180,180))
//产生效果
local effect eff = AddSpecialEffect("Abilities\\\\Spells\\\\Undead\\\\FrostNova\\\\FrostNovaTarget.mdl",x,y)

//等待2秒
call PolledWait(2)
//销毁效果，释放内存
call DestroyEffect(eff)
set eff = null
endfunction
//用于在技能中拿来RunFunctionAsTrigger的
function FrostSpaceEffect takes nothing returns nothing
//把效果函数注册成每0.1秒运行一次，即每0.1秒产生一个效果
local trigger trg = RunFunctionAsTriggerWithTimer(function FSEffectWithTimer, 0.1, true)

//等待5秒
call PolledWait(5)
//摧毁效果trigger，释放内存
call DestroyTrigger(trg)
set trg = null
endfunction
好了，现在你可以做一个技能，然后把上述的jass放到里面，看看效果如何了：）




* 补充：在全局变量的声明中，还有个size选项，那个选项实际上是假的，只是你自己输入一个数字提示自己这个数组应该有多大而以。jass为了防止mapper不熟练使用数组产生的bug，采用了自动增加数组长度的方式。这个好像要分情况吧，我试过用timerdialog的数组，只有[0] 和[1]是有效的其它都没效，这个很明显的size有关

zhuzeitou

恩，真是eGust的jass教程，lz转的很辛苦………………
但是，jass区在就有了

xh526

白转了

地域坠魔

没关系..方正我也看不懂......