标签：exe match src order pre 服务 分布 基本语法 mirror
档概要: UnrealScript 介绍和简要参考。最初作者是Tim Sweeney (EpicGames)
请一定要查看UnrealScript 的快速参考表和掌握UnrealScriptTOC指南 。
这是一篇描述UnrealScript编程语言的技术文档。它不是指南，也没有提供有用的UnrealScript代码的详细例子。要获得UnrealScript的例子，读者可以参考引擎的源代码，它提供了成千上万行的有效代码，用来解决许多例如AI、运动、武器装备和触发事件等很多问题。最好的入门方式是查看"Actor"、"Object(物体)"、 "Controller(控制器)"、 "Pawn(士兵)" "Weapon(武器)"的脚本。
本文档假设读者使用过C/C++或 Java编程语言、熟悉面向对象程序设计、已经玩过Unreal的游戏并使用过UnrealEd的编辑环境。
对于是面向对象程序设计的新手的程序员，我强烈推荐您去Amazon.com或者书店买一本介绍java编程方面的书。Java和UnrealScript很相似，并且由于它的干净和简单的方法使它成了一种值得学习的极好的语言。
UnrealScript是为开发团队和第三方Unreal开发人员创建的，是一种强大的内置的编程语言，它自然地满足了游戏编程的需要和细小差别。
UnrealScript的主要设计目标:
在UnrealScript开发的早期，我们探索了几个主要的不同的编程语言范例，然后又放弃了，最终开发出了目前的UnrealScript。首先，我们研究使用Sun 和 Microsoft为Windows设计的Java VM(虚拟机) 作为Unreal脚本语言的基础。但最终证明在Unreal的情境中Java并没有提供比C/C++更大的编程好处，反而由于缺乏所需要的语言功能(比如 运算符重载)而增加了一些令人沮丧的限制，另外也证明由于VM过多的任务转换开销和Java垃圾回收器在处理大的对象图形时的低效率导致运行速度特别的慢。其次，我们设计了基于Visual Basic变量的UnrealScript初期实现，它可以工作的很好，但是对于已经习惯于C/C++的程序员来说，它不是那么友好。最终基于我们想将游戏的特定概念映射到语言定义本身的愿望以及获得速度和熟悉度的需要，我们决定将UnrealScript设置为基于C++/Java变种的语言。结果证明这是一个好主意，因为它在很多方面大大地简化了Unreal代码。
对于已经熟悉UnrealScript的人来说，这里是一个自虚幻引擎2后在UnrealScript中所发生的主要改变的简短概要。
class‘MyClass‘.default.variable = 1的操作。class‘SomeClass‘.const.SOMECONST
这个示例说明了一个典型的简单的UnrealScript类，并且它囊括了UnrealScript的语法和功能。注意由于该文档没有和代码同步，所以这个代码可能和现在的Unreal源代码的呈现不一样。
//=====================================================================
// TriggerLight.
// 一个可以通过触发进行开关的光源
//=====================================================================
class TriggerLight extends Light;
//---------------------------------------------------------------------
// 变量
var() float ChangeTime; //光源从开到关所需要的时间
var() bool bInitiallyOn; //它在最初是否是亮的
var() bool bDelayFullOn; // 在到完全的点亮之前是否有延迟
var ELightType InitialType; // 光源的初始类型
var float InitialBrightness; //光源的初始亮度
var float Alpha, Direction;
var actor Trigger;
//---------------------------------------------------------------------
//引擎函数
//在游戏开始播放时调用
function BeginPlay()
{
// 记忆光源的初始类型并为它设置一个新的类型
Disable( ‘Tick‘ );
InitialType = LightType;
InitialBrightness = LightBrightness;
if( bInitiallyOn )
{
Alpha = 1.0;
Direction = 1.0;
}
else
{
LightType = LT_None;
Alpha = 0.0;
Direction = -1.0;
}
}
// 当时间经过时调用
function Tick( float DeltaTime )
{
LightType = InitialType;
Alpha += Direction * DeltaTime / ChangeTime;
if( Alpha > 1.0 )
{
Alpha = 1.0;
Disable( ‘Tick‘ );
if( Trigger != None )
Trigger.ResetTrigger();
}
else if( Alpha < 0.0 )
{
Alpha = 0.0;
Disable( ‘Tick‘ );
LightType = LT_None;
if( Trigger != None )
Trigger.ResetTrigger();
}
if( !bDelayFullOn )
LightBrightness = Alpha * InitialBrightness;
else if( (Direction>0 &amp;amp;&amp;amp; Alpha!=1) || Alpha==0 )
LightBrightness = 0;
else
LightBrightness = InitialBrightness;
}
//---------------------------------------------------------------------
//公有状态
//触发打开光源
state() TriggerTurnsOn
{
function Trigger( actor Other, pawn EventInstigator )
{
Trigger = None;
Direction = 1.0;
Enable( ‘Tick‘ );
}
}
//触发关闭光源
state() TriggerTurnsOff
{
function Trigger( actor Other, pawn EventInstigator )
{
Trigger = None;
Direction = -1.0;
Enable( ‘Tick‘ );
}
}
//触发切换光源的开关
state() TriggerToggle
{
function Trigger( actor Other, pawn EventInstigator )
{
log("Toggle");
Trigger = Other;
Direction *= -1;
Enable( ‘Tick‘ );
}
}
// 触发控制光源
state() TriggerControl
{
function Trigger( actor Other, pawn EventInstigator )
{
Trigger = Other;
if( bInitiallyOn ) Direction = -1.0;
else Direction = 1.0;
Enable( ‘Tick‘ );
}
function UnTrigger( actor Other, pawn EventInstigator )
{
Trigger = Other;
if( bInitiallyOn ) Direction = 1.0;
else Direction = -1.0;
Enable( ‘Tick‘ );
}
}
在这个脚本中要看的主要元素是:
var() 语法来指定，而不是 var 。More Details更多详情
for=、 =while=、 =break=、 =switch=、 =if 等等。
demON, 和 demon 是同样的事情。
Unreal虚拟机有以下几部分组成：服务器、客户端、渲染引擎及引擎支持代码。
Unreal控制着所有的玩家和物体间的游戏性和交互。在一个单人游戏中，Unreal客户端和Unreal服务器在同一台机器上运行；在一个网络游戏中，有一个机器用于专用服务器；所有连接到这个机器上的玩家是客户端。
所有的游戏播放都发生在一个"关卡"中，它是一个包含着几何体和物体的独立环境。尽管UnrealServer可以同时运行多个关卡，每个关卡独立运作并且彼此屏蔽：物体(actors)不能在不同关卡间穿行，而且一个关卡中的物体不能和另一个关卡中的物体进行交流。
在地图中的每个物体都可以或者在玩家的控制下(在网络游戏中可以有很多玩家)或者在脚本的控制下。当一个物体在脚本的控制下时，那么该脚本完全地定义了物体如何移动及如何与其它物体进行交互。
对于世界中所有这些物体的跑动、执行脚本、事件发生，你也许会问它们是如何能理解UnrealScript的执行流程哪。答案如下所示：
为了管理时间，Unreal将游戏播放的每秒钟分隔为"Ticks"。一个Tick是关卡中所有物体更新所使用的最小时间单位。一个tick一般是一秒钟的1/100到 1/10。Tick时间仅受到CPU功率的限制，机器速度越快，tick持续时间越短。
在UnrealScript中的某些命令的执行只需要使用零tick(也就是：它们的执行没有占有任何游戏时间)，也有些命令需要占用很多ticks。需要占用游戏时间的函数称为"latent functions(潜伏的函数)"。一些latent functions函数的例子包括 Sleep , FinishAnim , and MoveTo 。UnrealScript中的Latent functions仅可以从在一个状态的代码中被调用(所以也称作"state code(状态代码)")，而不能从一个函数的代码中(包括在一个状态中定义的函数)被调用。
当一个actor在执行一个latent函数，那个actor的状态执行不会继续直到latent函数执行完毕。然而，其它的actor或者VM可能会调用actor内部的函数。最终的结果是所有的UnrealScript的函数可以在任何时间被调用，甚至在latent 函数没有执行完毕的情况下。
按照传统的编程术语来说，UnrealScript就像在关卡中的每个物体有它们自己的执行"thread(线程)"一样工作。在内部，Unreal不使用Windows线程，因为那将是非常低效的(Windows 95和Windows NT不能高效地处理同时发生的成千上万的线程)。然而，UnrealScript 可以模拟线程。虽然这个事实对于UnrealScript代码是透明的，但当您书写和UnrealScript交互的C++代码时则变得非常显然的。
所有的UnrealScripts将彼此独立地执行，如果有100个鬼怪正在关卡中走动，那么所有的这100个鬼怪的脚本在每个"Tick"中都正在同时地且独立地执行着。
在使用UnrealScript进行工作之前，理解Unreal中物体的高层次的关系是非常重要的。Unreal的架构和其它大多数的游戏架构是有较大的背离的：Unreal是完全地面向对象的(非常像 COM/ActiveX)，它有一个定义明确的对象模型，可以支持高层次的面向对象的概念比如对象图、序列化、对象生命周期和多态性。从游戏历史上来说，尽管很多游戏比如Doom和Quake，已经证明在内容方面有较大的可扩展性，但大多数游戏都被设计成为集成化的，它们的主要功能都是被硬编码的并且是在对象的层次上不能扩展的。Unreal的面向对象的形式有一个很大的好处：主要的新功能和对象类型可以在运行时添加到Unreal中，并且这个扩展是以划分子类的方式进行的，而不是(比如)通过修改一串已有的代码。这种扩展的形式是非常强大的，因为它鼓励Unreal团队共同来创建可以所有人都可以操作的改善。
Object是Unreal中所有对象的父类。在Object类中的所有函数可以在任何地方访问，因为任何东西都继承于Object。Object是一个抽象的基类，它没有做任何有用事情。所有的功能都是由子类提供，比如Texture (一个贴图)，TextBuffer(文字块)和Class (它描述了其它对象的类)。
Actor(继承Object)是Unreal中所有独立运行的游戏对象的父类。Actor包含了所有的一个物体所需要的用于四处运动、和其它物体进行交互、影响环境及做其它与游戏相关的有用的事情的功能。
Pawn(继承Actor)是Unreal中所有的可以使用高层次AI和玩家控制的创造物和玩家的父类。
Class (继承 Object)是一种描述对象的类的特殊类型的object。刚看到时可能是令人疑惑的：一个类是一个对象，而其一个类描述某些的对象。但是这概念是合理的，并且在很多情况下您将会用到Class的对象。例如，当你在UnrealScript产生一个新的actor，你可能会通过Class对象来指定actor的类。
使用UnrealScript，你可以为任何Object类书写代码，但是99%的时候您都是在为从Actor继承的类来写代码。大多数有用的UnrealScript功能是游戏相关的并且是处理actors的。
每个脚本明确地对应一个类，并且脚本是通过声明类、类的父类及任何和该类相关的其它附加信息开始的。最简单的形式是：
class MyClass extends MyParentClass;
这里我声明了一个名为"MyClass"的新类，它继承了"MyParentClass"类的功能。另外，这个类存储在名为"MyPackage"的包中。
每个类继承它父类的所有的变量、函数和状态。然后它可以添加新的变量声明、添加新的函数(或者重写已有函数)、添加新的状态(或者为已有的状态添加功能)。
在UnrealScript中典型的设计类的方法是构造一个继承了具有您所需要的大部分功能的现有类(比如Pawn类，即所有怪物的基类)的新类(比如一个”人身牛头怪物”)。使用这个方法，你从来不需要重新发明新的东西---你可以简单地增加您想自定义的新功能，然而保持所有你不需要进行自定义的现有的功能。这个方法在Unreal中实现AI时显得尤其有用，因为在内置的AI系统中提供了大量的基础功能，您可以把它们作为您自定义的创造物的组成部分。
类的声明可以带有几个可选的影响类的修饰符：
DependsOn 代码行并且类之间通过逗号分界来指定，或者通过为每个类使用单独的 DependsOn 来指定。
NotTransient 关键字覆盖这个标志。Transient 关键字。Config 关键字 并指定一个不同的IniName来改变.ini文件。正常情况下IniName指定了用于存储数据的.ini文件，但是有几个名称具有特殊的意义：
NotEditInlineNew 关键字覆盖这个标志。EditInlineNew 关键字。如果父类没有使用 EditInlineNew 关键字，则该关键字没有影响。NotPlaceable 关键字覆盖这个标志。Placeable 关键字，意味着这个类不能放置UnrealEd中的关卡中等。HideCategories 关键字。DontCollapseCategories 关键字来覆盖这个标志。CollapseCatogories 关键字。Outer 对象。这个关键字必须紧跟在类的声明本身后面。Inherits(ClassName[,ClassName,...]):高级。用于多重继承-指定额外的基类。多个被继承的基类可以通过使用一个 Inherits 并在多个基类之间用逗号分开来指定，或者通过为每个基类分别使用一个=Inherits= 来指定。仅对native类有效。不支持来自两个UObject-derived类的多重继承。
这里是在UnrealScript中的一些实例变量声明的例子：
var int a; //声明了一个整型变量， 名称为"A"的 var byte Table[64]; //声明了一个64个字节的静态数组，名为"Table"的。 var string PlayerName; // 声明了一个字符串变量，名称为"PlayerName"。 var actor Other; //声明了一个可以被赋值为一个Actor实例的引用的变量。 var() float MaxTargetDist; // 声明了名称为"MaxTargetDist"的一个浮点变量，并且它的值可以从UnrealEd的属性窗口中进行修改。
变量在UnrealScript能出现在两种地方：实例变量，它应用于整个对象，在类声明后或者在struct声明内立即出现。局部变量，出现在函数中，仅在函数执行时有效。实例变量使用关键字 var 进行定义。局部变量使用关键字 local进行定义，比如：
function int Foo()
{
local int Count;
Count = 1;
return Count;
}
这里是UnrealScript中支持的内置的变量类型：
0 到 255假LT_None=、 =LT_Pulse=、 =LT_Strobe 等值。
array<Type>:一个 Type 类型的数组。
vector(向量) ；及由倾斜度、偏转度、旋转度组成的rotator 。
None 的值，它和C 语言中的 NULL 指针是等同的：它的意思是这个变量不能指向任何物体。
变量也可以具有其它的额外的修饰符来对其进一步的描述，比如 const 。事实上，将会有很多你在一般的编程语言中没有见过的修饰符，这主要是因为我们想使UnrealScript支持许多游戏-和特定环境中-的专用概念：
out:这个修饰符仅对函数参数有效。请查看函数来获取详细信息。 coerce:这个修饰符仅对函数参数有效。请查看函数来获取详细信息。 optional:这个修饰符仅对函数参数有效。请查看函数来获取详细信息。
在UnrealScript中，你可以使一个实例变量变得可编辑，以便用户可以在UnrealEd中编辑变量的值。这个机制负责了UnrealEd的"Actor Properties"对话框的全部内容，您在那里所看到的全部内容仅是UnrealScript中的一个声明为可以编辑的变量。
声明一个可以编辑的变量的语法如下所示：
var() int MyInteger; //在默认目录中声明了一个可以编辑的整型
var(MyCategory) bool MyBool; //中声明一个可以编辑的整型"MyCategory"
Y您也可以声明一个变量为 editconst ，这意味着这个变量将可以在UnrealEd中看见但 不 可以编辑。注意这仅仅是为了防止变量在编辑器中被改变而不是在脚本中。如果您想使一个变量为真正的 const 但是仍然可以在编辑器中可见，您必须声明它为 const editconst ：
// MyBool在UnrealEd中是可以看见的但却不可编辑 var(MyCategory) editconst bool MyBool; // MyBool变量在UnrealEd中是可见的但不能编辑而且不能通过脚本来改变它的值 var(MyCategory) const editconst bool MyBool; // MyBool变量在UnrealEd中是可见的且可以设置，但不能在脚本中改变他的值 var(MyCategory) const bool MyBool;
数组使用以下语法声明：
var int MyArray[20]; //声明了一个长度为20的整形数组
UnrealScript仅支持一维数组，但你可以通过自己来设置行/类的元素从而来模拟多维数组。要获得关于动态数组的信息，请查看以下部分Advanced Language Features高级的语言功能
UnrealScript struct是把一串变量一起塞入到一个新类型称为struct的超变量的一种方法。UnrealScript structs和C语言中的结构体很像，它可以包含变量、数组及其它的结构体，但UnrealScript structs中不可以包含函数。
你可以按照以下方法来声明一个struct:
//在3D空间的一个点或方向向量
struct Vector
{
var float X;
var float Y;
var float Z;
};
一旦您定义了一个struct，你便可以开始定义那个struct类型的特定变量了：
//声明了一组Vector类型的变量 var Vector Position; var Vector Destination;
要想访问struct中的分量 ，可以按照以下方式使用代码：
function MyFunction()
{
Local Vector A, B, C;
//向量相加
C = A + B;
//仅向量的X成员相加
C.X = A.X + B.X;
// 将向量C传递到一个函数中
SomeFunction( C );
//将向量的某个成员传递到函数中
OtherFunction( A.X, C.Z );
}
你可以像操作其它变量一样来操作Struct变量：你可以赋值变量给它们、也可以传递它们给函数、而且您也可以访问它们的成员。
在Object类中定义了几个Structs，这些在整个的Unreal将一直会使用。你必须熟悉它们的操作，因为它们是脚本的基础构建模块。
Structs也有少许修饰符来影响struct的所有实例。
在UnrealScript中枚举类型的存在，可以方便地声明能够包含一串关键字中的任意一个值的变量。比如，actor类包含着枚举变量=EPhysics=，它描述了Unreal要应用到actor上的物理。这个物理可以设置为已经预先定义的值中的一个，比如 PHYS_None=、 =PHYS_Walking=、 =PHYS_Falling 等。
在内部，枚举变量是作为字符变量存储的。在设计UnrealScript时，并没有认为枚举类型是必需的，但是当看到一个actor得物理模型被设置为 PHYS_Swimming 而不是(比如) =3=，发现它使代码变得如此的易读。
这里是定义枚举类型的示例代码。
//定义了一个具有三个值的枚举类型EColor。
enum EColor
{
CO_Red,
CO_Green,
CO_Blue
};
//现在定义EColor类型的两个变量
var EColor ShirtColor, HatColor;
//可替换地，你可以像这样一起声明变量和枚举类型：
var enum EFruit
{
FRUIT_Apple,
FRUIT_Orange,
FRUIT_Bannana
} FirstFruit, SecondFruit;
在Unreal代码中，我们经常要声明枚举值，像 LT_Steady=、 =PHYS_Falling 等，而不是简单地声明为"Steady" 或 "Falling"。这只是编码风格的问题而不是语言的要求。
UnrealScript仅在枚举类型定义的类及其子类中可以识别没有明确枚举变量名的枚举标签(比如 FRUIT_Apple)。如果你需要引用一个在类的层次的其它地方定义的枚举标签，你必须使它符合要求：
FRUIT_Apple // 如果Unreal不能找到这个枚举标签… EFruit.FRUIT_Apple //那么像这样来使它符合要求
在UnrealScript，你几乎可以为所有的数据类型来指定常量值：
123. 如果你必须以16进制的方式来指定一个整型或字节型常量，使用： 0x123456.789‘MyName‘vect(1.0,2.0,4.0)Rot(0x8000,0x4000,0)texture‘Default‘EnumCount=指定了一个枚举类型的元素个数，比如： =ELightType.EnumCountArrayCount=指定了一个静态数组中的元素的个数，比如：=ArrayCount(Touching)你可以使用"const"关键字来声明一个常量，以后便可以通过常量的名称来引用了。比如：
const LargeNumber=123456; const PI=3.14159; const MyName="Tim"; const Northeast=Vect(1.0,1.0,0.0);
常量可以在类或structs中定义。
如果要访问在另一个类中定义的常量，请使用"class‘classname‘.const.constname"语法，比如：
class‘Pawn‘.const.LargeNumber
你可以声明一个指向一个actor或object的变量，像这样:
var actor A; //一个actor引用 var pawn P; //一个到Pawn类中的一个actor的引用 var texture T; //一个到贴图对像的引用
上面的变量"P"是一个到Pawn类的一个actor的引用。这个变量可以指向属于Pawn的子类的任何actor。比如，P可以指向一个Brute，或者一个Skaarj或Manta。它可以是任何类型的Pawn。然而，P永远不能指向一个Trigger actor(因为Trigger不是Pawn的子类)。
使变量指向一个actor从而获得便利的例子是在Pawn类中的Enemy变量，它指向Pawn正在试图攻击的actor。
当您有一个指向actor的变量时，你可以访问那个actor的变量并且调用它的函数。例如：
//声明指向一个pawn的两个变量
var pawn P, Q;
//这里是一个使用P对象的函数，它显示了关于P对象的信息。
function MyFunction()
{
// 设置P的敌人为Q
P.Enemy = Q;
//告诉P播放这个跑动的动画
P.PlayRunning();
}
指向actors的变量通常或者指向一个有效的actor(任何在关卡中实际存在的actor)或者指向 None 值。None等同于C/C++中的 NULL 指针。然而，在UnrealScript中访问具有 None 引用的变量和函数是安全的；结果通常为0。
注意一个object 或 actor引用是“指向”另一个actor 或 object，它并不“包含”一个真正的actor 或 object对象。在C语言中，一个actor引用等同于指向一个AActor类的对象的指针(在C语言中，你会称它为AActor*)。例如，你可以在世界中有两个鬼怪(monsters)Bob和Fred，它们相互打斗。Bob 的"Enemy"变量将“指向”Fred，并且Fred的"Enemy"变量将“指向”Bob。
和C语言中的指针不同，UnrealScript的对象引用总是安全的可靠的。一个对象引用指向一个不存在的对象或者无效的对象是不可能的(除了特殊情况： None 值)。在UnrealScript中，当一个actor被销毁，那么它的所有引用将被设置为 None 。
在Unreal中，类就像actors、textures(贴图)及 sounds(声音)一样是对象。Class 对象属于名称为"class"的类。在很多情况下，您将需要存储一个到类对象的引用，以便您可以产生一个属于那个类的actor(在编译时不知道那个类是什么)。比如：
var() class C; var actor A; A = Spawn( C ); // 产生一个属于某个任意类C的actor.
现在，一定不要搞乱类C和属于类C的对象O(作为类C的一个“实例”)的角色作用。打一个不太靠谱的比喻，一个类就像一个胡椒粉的研磨工，而那个类的实例就像是胡椒粉。你可以使用胡椒粉的研磨工(类)来转动磨制机器的曲柄(调用Spawn函数)来创建胡椒粉(类的对象)…但是，一个胡椒粉研磨工(一个类)不是胡椒粉(属于这个类的对象)，所以你一定不要尝试去吃它！
当定义一个引用这个类对象的变量时，你可以有选择性地使用语法 class<metaclass> 来限制这个类不能被metaclass 类型(及它的子类)的变量所引用。比如在以下声明中：
var class<actor> ActorClass;
变量ActorClass仅能引用继承类"actor"的类。这对改善编译时的类型检查是有帮助的。比如，Spawn函数采用一个类作为参数，但是仅当这个类是Actor的子类时才有效， class<classlimitor>语法使编译器来执行那个要求。
关于使用动态对象类型转换，你可以这样来动态地转换类的类型：
// 转换SomeFunctionCall()的结果作为Actor类型的一个类(或Actor类的子类) class<actor>( SomeFunctionCall() )
要给一个变量赋值，请使用 "="：
function Test()
{
local int i;
local string s;
local vector v, q;
i = 10; //给一个整型变量i赋值
s = "Hello!"; //给字符型变型变量s赋值
v = q; //赋值向量q的值到v
}
在UnrealScript中，当一个函数或其它表达式需要一个某种类型的数据(比如："float")时，而您指定了一个不同的数据类型(比如：”int”),编译器将会自动转换你给的值为适当的类型。所有数字数据类型(byte、 int 和 float)之间的转换是自动进行的，不需要您做任何操作。
UnrealScript也可以转换许多内置的数据类型为其它的类型，如果在代码中明确地转换它们，用于转换的语法是：
function Test()
{
local int i;
local string s;
local vector v, q;
local rotator r;
s = string(i); //转换字符型i为一个字符串，并赋值给s
s = string(v); //转换向量v为一个字符串，不把它赋值给s
v = q + vector(r); //转换rotator类型的r为向量类型，不把它和q进行相加
}
这里是在UnrealScript您可以使用的不能自动地进行类型转换的完整集合：
"123" 的字符串为 123 。如果字符串不代表一个值，则它的值为 0 。"True" 或 "False" 为 True 和 False=；将会使任何非零数值转换为 =True ；其它任何值转换为 False 。"True" 就是 "False" 。True ；零值为 False 。True 为 1 ；=False= 为 0 。None 则返回 False=；否则为 =True 。
就像上面的简单数据类型的转换函数一样，在UnrealScript中你可以在各种类型之间转换actor和object引用。比如，所有的actors有一个叫"Target"的变量，它是到另一个actor的引用。假如您正在写一个脚本，在脚本中您需要检查并查看Target是否属于"Pawn" actor类的，并且你需要对您的target做一些特殊的处理，但仅当它是一个pawn类时才有效--比如，您需要调用Pawn函数的其中一个。actor的类型转换操作符可以让您完成这个目的。这里是一个例子：
var actor Target;
//...
function TestActorConversions()
{
local Pawn P;
//转换Target的类型为Pawn并把它的值赋予P。如果Target不是一个Pawn(或者Pawn的子类)，那么赋给P的值将会是None。
P = Pawn(Target);
if( P != None )
{
// Target是一个pawn，所以让它的Enemy为Self。
P.Enemy = Self;
}
else
{
// Target不是一个pawn。
}
}
为了执行一个actor转换，输入类的名称并在后面加上你希望转换的actor表达式，并使用圆括号括起。根据这个转换是否合理，转换将或者成功或者失败。在上面的例子中，如果您的Target指向的是一个Trigger对象而不是一个Pawn，表达式Pawn(Target)将会返回"None"值，因为不能将一个Trigger转换为Pawn。然而，如果您的Target指向一个Brute对象，转换将会成功并返回那个Brute，因为Brute是Pawn的子类。
因此，actor类型转换有两个目的：第一，你可以使用它们来判断某个actor引用是否属于某个类。第二，你可以使用它们来将一个actor引用从一个类转换为一个更加明确的类。注意这些转换不会影响您正在转换的actor—它们只是使UnrealScript将对待那个actor引用就像它是一个更加明确的类型一样并且允许您访问这个更加子类中所声明的属性和方法。
另一个类型转换的列子是在Inventory脚本中。每个Inventory actor由一个Pawn所有，尽管它的Owner变量可以指向任何Actor(因为Actor.Owner是一个Actor类型的变量)。所以在Inventory代码中我们会将常看到将一个Owner转换为Pawn类型的现象，比如：
//当销毁时，由engine调用
function Destroyed()
{
//从拥有者的武器装备中移除
if( Pawn(Owner)!=None )
Pawn(Owner).DeleteInventory( Self );
}
在UnrealScript中，你可以声明新的函数及为已存在的函数书写一个新的版本(重写这些函数)。函数可以带有一个或多个参数(可以是UnrealScript支持的任何变量类型)，并且可以可选择地返回一个值。尽管大多数函数是直接在UnrealScript中书写的，您也可以声明可以从UnrealScript中调用的函数，但是在C++中实现并存在于一个DLL文件中。Unreal支持所有可能函数调用组合：C++引擎可以调用脚本函数；脚本可以调用C++函数；而且脚本之间也可以相互调用。
这里是一个简单的函数声明。这个函数有一个vector(向量)作为参数并返回一个浮点型值：
// 用于计算一个vector的大小的函数
function float VectorSize( vector V )
{
return sqrt( V.X * V.X + V.Y * V.Y + V.Z * V.Z );
}
关键词 function 总是在函数声明的前面，后面可以跟随任意的函数返回类型(在这里是 float )，然后是函数名及在括号里所包含的函数参数。
当调用一个函数时，在括弧内的代码将会被执行。在函数内部，您可以声明局部变量(使用关键字 local )，并且可以执行任何UnrealScript代码。可选择的 return 关键字可以使函数立刻地返回一个值。
你可以传递任何UnrealScript类型到一个函数(包括数组)中，并且这个函数可以返回任何类型。
默认情况下，在函数中声明的任何局部变量都将被初始化为0.
函数可以进行递归调用。比如，下面的函数计算了一个数的阶乘
//计算数的阶乘的函数
function int Factorial( int Number )
{
if( Number <= 0 )
return 1;
else
return Number * Factorial( Number - 1 );
}
某些UnrealScript函数是在某些事件发生时由引擎来调用的。比如，当一个actor和另一个actor接触，引擎会调用它的 Touch 函数来告诉它是谁正在接触它。通过书写自定义的 Touch 函数，你可以在接触事件发生时采取特殊的行动：
//当某些东西接触这个actor时则调用这个函数
function Touch( actor Other )
{
Log( "I was touched!")
Other.Message( "You touched me!" );
}
上面的函数解释了几件事情。首先，函数使用 Log 命令向日志文件中写入了一个消息(除了格式规则以外，这和Basic语言的"print"及C语言的"printf"是类似的)。第二，它调用了在Other actor中的"Message"函数。调用在其它actors中的函数在UnrealScript是一个常用的操作，大体上和面向对象的语言比如Java是一致的，因为它为actors间彼此的交流提供了一个简单的方法。
通常当您的调用一个函数时，UnrealScript会制作一个您传入函数的参数的一个本地副本。如果函数修改了某些参数，这对您传入的参数没有任何影响。比如，以下的代码：
function int DoSomething( int x )
{
x = x * 2;
return x;
}
function int DoSomethingElse()
{
local int a, b;
a = 2;
log( "The value of a is " $ a );
b = DoSomething( a );
log( "The value of a is " $ a );
log( "The value of b is " $ b );
}
当调用了DoSomethingElse函数后，产生了以下输出结果：
The value of a is 2 The value of a is 2 The value of b is 4
换句话说，函数DoSomething处理的是我们传递给它的变量a的本地副本，并且它不会影响真正的变量"a"。
out 修饰符告诉函数它应该修改传递给它的变量，而不是修改一个本地副本。这是有用的，比如，如果您有一个需要返回给调用者几个值的函数，你可以让调用者传递几个变量给带有 out 值的函数。
//计算一个向量中的最大值和最小值
function VectorRange( vector V, out float Min, out float Max )
{
//计算最小值
if ( V.X<V.Y && V.X<V.Z ) Min = V.X;
else if( V.Y<V.Z ) Min = V.Y;
else Min = V.Z;
//计算最大值
if ( V.X>V.Y && V.X>V.Z ) Max = V.X;
else if( V.Y>V.Z ) Max = V.Y;
else Max = V.Z;
}
如果没有关键字 out ，那么尝试写出必须返回多个函数值的函数是个令人痛苦的事情。Out参数是通过引用传入的，所以在函数中修改参数的值将会立即影响原始值。这也可以用于多个值的优化，类似于C++中通过指定"const out"类型来实现。
使用 optional 关键字，你可以使某些函数的参数是可选的，这为调用者提供了便利。在UnrealScript函数中，调用者没有指定的可选参数的值时，将被设置为在函数声明是指定的默认值或如果在函数声明时没有指定值时则设置它为0(也就是 0、false、""、none)。对于native函数，可选参数的默认值依赖于函数。比如，Spawn函数有一个可选的参数location 和 rotation，它们默认为actor的位置和旋转度。可选参数的默认值可以通过添加 = value 来指定。比如，function myFunc(optional int x = -1)。
关键字 coerce 强制使调用函数的参数转换为指定的类型(即使通常情况下UnrealScript将不会执行自动转换)。这对处理字符串的函数是有用的，函数将为您自动地将参数转换为字符串。
"函数重写"是指在子类中写一个函数的新的版本。比如，您正在为一个新类型的叫Demon的鬼怪书写脚本。您所创建的Demon类继承了Pawn类。现在，当一个pawn第一次看到一个玩家时，将会调用pawn的"SeePlayer"函数，从而pawn可以开始袭击玩家。这是一个很好的概念，但是当您想在您的新的Demon类中以不同的方式处理"SeePlayer"函数时，你该怎么实现哪？答案便是函数重载。
要重写一个函数，只需要从它的父类中将函数的定义剪切并复制到您的新类中。比如，你可以添加SeePlayer函数到您的新类Demon中。
//类Demon 中的新的Touch函数版本
function SeePlayer( actor SeenPlayer )
{
log( "The demon saw a player" );
//在这里添加中定义的功能…
}
函数重载是有效地创建新的UnrealScript类的关键。您可以创建一个继承已有类的新类。然后，你所需做的便是重载那些你需要进行不同处理的函数。这可以使您在不必写大量的代码的情况下创建一种新的对象。
在UnrealScript中的某些函数是声明为 final 。=final=关键字(在关键字 function 后出现)是说：”这个函数不能被子类重载”。这可以在没有人重载的函数中使用，因为它可以提供更快的脚本代码执行速度。比如，你有一个VectorSize 函数用于计算一个向量的大小。因为绝对没有原因导致任何人来重载它，所以声明它为 final 。另一方面，像 Touch 这样的函数是非常依赖于情境的，所以不能声明它为final。
singular 关键字，紧接在函数声明的前面出现，可以阻止函数对其本身进行递归调用。规则是：如果某个actor已经在一个singular函数中，任何对这个singular的后续调用将会被跳过。这在某些情况下来避免无限的递归循环bug是有利的。例如，如果你尝试着在您的 Bump 函数中移动一个actor, 那个actor将会在移动中撞击另一个actor是有很大的可能的，从而导致了另一个对 Bump 函数的调用等等。你必须细心地避免这种行为，但是如果您没有足够的信心来通过书写代码避免这种潜在的递归情况，那么请使用 singular 关键字。Native:你可以声明UnrealScript函数为 native ，这意味着该函数是可以从UnrealScript中调用的，但是事实上是在C++中实现的。比如，Actor类包含着许多native函数定义，比如：
native(266) final function bool Move( vector Delta );
在关键字 native 后的圆括号内的数字和在C++(使用 AUTOREGISTER_NATIVE macro)中定义的函数的数字是相对应的，并且这仅在运算符函数中有要求。Native函数将存在于DLL文件中，该DLL文件的名称和包含了UnrealScript定义的类的包的名称是一致的。
foreach 命令来在一系列的actors中循环。
event=关键字和UnrealScript中的 =function 具有相同的意思。然而，当您可以使用 unreal -make -h 来从Unreal中导出一个C++头文件时，UnrealEd为每个”event”自动生成一个C++ -> UnrealScript调用存根。这可以自动地保持C++代码和UnrealScript函数同步并消除了向一个UnrealScript函数中传递无效参数的可能性。比如，这些UnrealScript代码：
event Touch( Actor Other )
{ ... }
生成类似于以下的在EngineClasses.h中的代码：
void eventTouch(class AActor* Other)
{
FName N("Touch",FNAME_Intrinsic);
struct {class AActor* Other; } Parms;
Parms.Other=Other;
ProcessEvent(N, &Parms);
}
因此您可以从C++中像这样来调用UnrealScript函数了：
AActor *SomeActor, *OtherActor; SomeActor->eventTouch(OtherActor);
native function int doSomething(string myData) const;
UreanScript支持C/C++/Java中所有的标准的流程控制语句。
"For"循环指在没有满足某个条件之前一直执行循环。例如：
// "for"循环举例
function ForExample()
{
local int i;
log( "Demonstrating the for loop" );
for( i=0; i<4; i++ )
{
log( "The value of i is " $ i );
}
log( "Completed with i=" $ i);
}
这个循环的输出是：
Demonstrating the for loop The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 Completed with i=4
在for循环中，你必须指定3个表达式且它们之间使用分号分隔。第一个表达式用于初始化一个值作为它的初值；第二个表达式给出一个条件用于在每次循环执行前进行条件判断；如果这个表达式为真，则执行循环。如果它为假，则终止循环。第三个条件给出了一个增加循环计数器的表达式。
尽管大多数”for”循环仅仅是更新一个计数器，你也可以通过使用合适的初始化值、终止条件和增量表达式，从而使用”for”循环来做像遍历链表这样的高级的事情。
在所有的流程控制语句中，你可以或者执行一个没有括弧的单独的语句，如下所示：
for( i=0; i<4; i++ ) log( "The value of i is " $ i );
或者你可以执行由括弧包围的多个语句，像这样：
for( i=0; i<4; i++ )
{
log( "The value of i is" );
log( i );
}
"Do"循环是指在某个结束表达式为真的情况下，您可以不断的进行循环。注意Unreal使用 do-until 语法，这和C/Java (它们使用 do-while )是不同的。
// "do"循环举例
function DoExample()
{
local int i;
log( "Demonstrating the do loop" );
do
{
log( "The value of i is " $ i );
i = i + 1;
} until( i == 4 );
log( "Completed with i=" $ i);
}
这个循环的输出结果:
Demonstrating the do loop The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 Completed with i=4
"While"是指当某个起始表达式为真时，您可以不断地进行循环。
// "while"循环举例
function WhileExample()
{
local int i;
log( "Demonstrating the while loop" );
while( i < 4 )
{
log( "The value of i is " $ i );
i = i + 1;
}
log( "Completed with i=" $ i);
}
这个循环的输出是:
Demonstrating the do loop The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 Completed with i=4
"continue"命令将会跳回到循环的开始位置，所以任何continue之后的命令将不会被执行。这可以用于在某些情况下跳过循环代码。
function ContinueExample()
{
local int i;
log( "Demonstrating continue" );
for( i=0; i<4; i++ )
{
if( i == 2 )
continue;
log( "The value of i is " $ i );
}
log( "Completed with i=" $ i );
}
这个循环的输出是:
Demonstrating break The value of i is 0 The value of i is 1 The value of i is 3 Completed with i=4
"break"跳出最近一层循环("For", "Do", 或 "While")。
function BreakExample()
{
local int i;
log( "Demonstrating break" );
for( i=0; i<10; i++ )
{
if( i == 3 )
break;
log( "The value of i is " $ i );
}
log( "Completed with i=" $ i );
}
这个循环的输出是:
Demonstrating break The value of i is 0 The value of i is 1 The value of i is 2 Completed with i=3
注意"break"命令也可以用于跳过执行一个条件语句("switch")的剩余代码。
"If", "Else If", and "Else"使您在满足某些条件是执行相应代码。
// "if"举例
if( LightBrightness < 20 )
log( "My light is dim" );
// "if-else"举例
if( LightBrightness < 20 )
log( "My light is dim" );
else
log( "My light is bright" );
// if-else if-else"举例
if( LightBrightness < 20 )
log( "My light is dim" );
else if( LightBrightness < 40 )
log( "My light is medium" );
else if( LightBrightness < 60 )
log( "My light is kinda bright" );
else
log( "My light is very bright" );
//执行语句带有括弧的"if"判断举例
if( LightType == LT_Steady )
{
log( "Light is steady" );
}
else
{
log( "Light is not steady" );
}
"Case", "Default", 和 "Break"可以使您的轻易地处理一系列的条件判定。
// switch-case举例
function TestSwitch()
{
// 基于LightType的值，执行以下case语句的任意一条，
switch( LightType )
{
case LT_None:
log( "There is no lighting" );
break;
case LT_Steady:
log( "There is steady lighting" );
break;
case LT_Backdrop:
log( "There is backdrop lighting" );
break;
default:
log( "There is dynamic" );
break;
}
}
"switch"由一个或多个"case"语句及一个可选择的"default"语句组成。在一个switch语句后，如果和"case"语句的某一个相匹配则执行该Case语句；如果没有相匹配的case则执行"default"语句；如果既没有相匹配的case语句也没有写default语句，则执行到"select"语句的末尾。
当您在代码中写好了以下的"case"标签，你必须是有一个"break"语句来使执行继续执行到"switch"语句的末尾。如果您不使用"break"，将会继续执行接下来的"case"处理语句。
// Example of switch-case.
function TestSwitch2()
{
switch( LightType )
{
case LT_None:
log( "There is no lighting" );
break;
case LT_Steady: // 将一直执行到case: LT_Backdrop
case LT_Backdrop:
log( "There is lighting" );
break;
default:
log( "Something else" );
break;
}
}
"Goto"命令可以跳转到当前函数或状态的某处的标签。
// "goto"举例
function GotoExample()
{
log( "Starting GotoExample" );
goto Hither;
Yon:
log( "At Yon" );
goto Elsewhere;
Hither:
log( "At Hither" );
goto Yon;
Elsewhere:
log( "At Elsewhere" );
}
The output is输出结果是:
Starting GotoExample At Hither At Yon At Elsewhere
UnrealScript提供了为各种操作提供了很多种类似于C/C++/Java类型的操作符，比如数字相加的操作、比较值的操作以及自增操作等。操作符的完整的集合在Object.u中定义，但是这里有一个简明的概括。这里使一些标准操作符，以优先级为顺序。注意所有的C类型的操作符的优先级和它们在C语言中的优先级是一致的。
| 操作符 | 应用的类型 | 意思 |
|---|---|---|
| @ | string(字符串) | 字符串连接，在两个字符串间有一个附加的空格"string1"@"string2" = "string1 string2" |
| @= | string(字符串) | 字符串连接，在两个字符串间有一个附加的空格，连接并赋值(版本3323 及其后续版本) |
| $ | string(字符串) | 字符串连接 |
| $= | string (字符串) | 字符串连接，连接并赋值(版本3323 及其后续版本) |
| *= | byte, int, float, vector, rotator | 相乘并赋值 |
| /= | byte, int, float, vector, rotator | 相除并赋值 |
| += | byte, int, float, vector | 相加并赋值 |
| -= | byte, int, float, vector | 相减并赋值 |
| || | bool | 逻辑“或“ |
| && | bool | 逻辑“与“ |
| ^^ | bool | 异或 |
| & | int | 按位与 |
| | | int | 按位或 |
| ^ | int | 按位异或 |
| != | All (所有类型) | 不等于 |
| == | All(所有类型) | 等于 |
| < | byte, int, float, string | 小于 |
| > | byte, int, float, string | 大于 |
| <= | byte, int, float, string | 小于等于 |
| >= | byte, int, float, string | 大于等于 |
| ~= | float, string | 约等于(精确到0.0001)，大小写不敏感等式 |
| << | int, vector | 左移(int),正向向量转换(vector) |
| >> | int, vector | 左移(int), 反向向量转换(vector) |
| >>> | 和>>相同 | |
| + | byte, int, float, vector | 加 |
| - | byte, int, float, vector | 减 |
| % | float, int, byte | 求模(除法的余数) |
| * | byte, int, float, vector, rotator | 乘 |
| / | byte, int, float, vector, rotator | 除 |
| Dot | vector | 矢量点积 |
| Cross | vector | 矢量叉积 |
** |
float | 求幂 |
| ClockwiseFrom | int (rotator elements) | 当从第一个参数可以通过第二个参数顺时针旋转得到，则返回true |
上面的表格按照优先顺序列出了操作符(具有相同优先级的分为一组)。当您输入一个复杂的表达式，比如"1*2+3*4"，UnrealScript会自动地按照优先级为操作符分组。因为乘法的优先级比加法高，这个表达式等同于"(1*2)+(3*4)"。
"&&" (逻辑与) 和 "||" (逻辑或)操作符是短路的：如果表达式的结果能够单独地由第一个表达式决定(比如，如果 && 的第一个参数是false)，第二个表达式则不需要进行计算。
关于向量的正向和反向转换，反向变换>>是从本地空间转换为世界空间而正向变换<<是从世界空间转换为本地空间。
比如，如果您有一个向量指向玩家前面64个单位的地方，vect(64,0,0)是在本地玩家坐标的值。如果您想让它在世界空间中，您必须使用玩家的旋转来把它转换为世界坐标，所以您必须通过以下方式来进行进算：
myWorldSpaceVect = my64Vect >> playerPawn.rotation;
当您有一个世界空间的向量并且你想让它呈现在本地玩家空间时，万一您想使用一个向前的rotation。比如，您可能想转换一个汽车actor的世界空间速度到本地空间，从而您可以获得X(前进速度)来把它输出到一个HUD中。
除了标准的操作符，UnrealScript支持一下一元操作符：
新的操作符会不断地增加到引擎中。要获得操作符的完整列表，请查看最新的UnrealScript源代码-尤其是Object类。
为了在UnrealScript中创建一个新的对象，您将会根据这个对象是否是一个Actor来使用这两个函数其中的一个。对于Actors，您将会使用Spawn函数，声明在Actor.uc文件中。对于不是从Actor类派生的类，您必须使用 new 操作符。New操作符的语法和其它的函数不同。除了一个可选择的参数列表，你必须指定新的对象的类及可选择的模板对象。new操作符没有UnrealScript声明，但是这里是函数声明的样子：
native final operator function coerce Object new ( object InOuter, name InName, int InFlags, class InClass, object InTemplate );
新的操作符的实际的语法如下所示：
ObjectVar = new[(InOuter, InName, InFlags)] <class‘InClass‘>[(InTemplate)];
创建类LightFunction的一个对象
function CreateALight()
{
local LightFunction NewObj;
NewObj = new class‘Engine.LightFunction‘;
}
创建一个叫"NewLight"的LightFunction对象，分配这个对象作为它的Outer。
function CreateALight()
{
local LightFunction NewObj;
NewObj = new(Self,‘NewLight‘) class‘Engine.LightFunction‘;
}
在transient包中创建一个叫"NewLight"的新的LightFunction对象，使这个对象作为LightFunctionTemplate变量的值来初始化新的对象的属性：
var LightFunction LightFunctionTemplate;
function CreateALight()
{
local LightFunction NewObj;
NewObj = new(None,‘NewLight‘) class‘Engine.LightFunction‘ (LightFunctionTemplate);
}
defaultproperties
{
Begin Object class="LightFunction" Name=MyLightFunctionArchetype
End Object
LightFunctionTemplate=MyLightFunctionArchetype
}
警告-Min和Max在整数上的应用和C或C++不同。当针对浮点型数据使用这两个函数时不会产生警告 – 您的数字会默认地进行四舍五入处理！对于浮点型，你需要使用函数FMin 和 FMax来进行操作。
With 代替 Match 。SplitStr 发生时分隔 Text 并返回 Text 的剩余部分。如果=bOmitSplitStr=为真，=SplitStr=将会从返回的字符串中被忽略。请查看Unreal 字符串来获取更多的信息。
计时器函数仅在Actor的子类中存在。
您可以创建具有不同触发速率的多个计时器。每个计时器有一个唯一的目标函数(默认为 Timer() )。
GetTimerRate(‘SomeTimer‘) - GetTimerCount(‘SomeTimer‘) 将返回计时器剩余的时间。以下函数可以帮助您调试代码
注意，正如变更列表134102所示，以上的日志功能已经不能获得。它们已经被由UnrealScript 处理器处理的一个关于日志的宏所取代。请查看版本更新信息来获取详情：Upgrading to changelist 134102
要获得更多信息，请查看Unrealscript 处理器页面。
Script Profiler(脚本分析器)能够帮助您了解脚本执行的那些部分占有了大部分的时间。
请查看Unreal的调试工具页面获得更多信息。
如果想获得更多的使用UDE来进行UnrealScript开发和调试的信息，请查看虚幻开发环境页面。
计时器是一种用于安排一个事件随时间变化发生、重复发生的一种机制。以这种方式，当一段固定时间过后，一个Actor能使一个计时器来注册它本身到一个游戏引擎上，从而可以使一个 Timer() 函数被调用或者一次、或者重新发生。
UnrealScript计时器仅仅是在每个Actor内部作为一个structs数组来实现的(一个Actor可以有多个还没有被触发的计时器) 。这个struct包含了在计时器过期前所剩余的时间的数量、计时器到期时所要调用的函数等。
一般游戏主循环每帧ticks每个Actor一次，并且每个Actor的 Tick() 函数包含一个调用函数 UpdateTimers() ，它会检查任何将要过期的计时器并调用它们适当的UnrealScript代码。
时间间隔大小限于每个帧之间的时间间隔长度，但是对硬件和OS资源没有要求。所有的这些是在C++代码中实现的，所以您可以在不必担心可能引起的任何后果的情况下安全地更新成百个UnrealScript计时器。当然，您不会想使所有的计时器同时地过期或者在每一个帧过期，因为当这是计时器被激活时要以较慢的速度执行脚本代码。
从游戏历史来说，游戏开发人员自从游戏发展到"pong"阶段后便开始使用状态这个概念。状态(也被称为“状态机编程”)是使复杂的物体行为更加容易管理的一种常用方式。然而在UnrealScript出现之前，状态在编程语言的层次上还没有得到支持，需要开发人员基于物体的状态来创建C/C++"switch"语句，这样的代码是难于书写和更新的。
UnrealScript在编程语言的层次上支持状态。
在UnrealScript中，世界中的每个actor都处于并仅处于一个状态。它的状态反映了它要执行的动作。比如，移动画刷有几个状态像"StandOpenTimed" 和 "BumpOpenTimed"。Pawns有一些像"Dying"、 "Attacking"、 和 "Wandering"等状态。
在UnrealScript中，你可以针对一个特定的状态来书写函数和代码。这些函数和代码仅当actor在那个状态时被调用。比如，你正在写一个关于怪物的脚本，并正在思考如何处理"SeePlayer"函数，当您在到处巡逻的时候，您想攻击您看到的玩家，当您正在攻击玩家时，您想不停地进行连续攻击。
实现这个目的最容易的方式便是通过定义几个状态(Wandering(到处走动) 和 Attacking(攻击))，并且在每个状态写一个不同版本的"Touch"函数。UnrealScript支持这样做。
在对状态进行深入研究之前，你需要知道状态的两个主要好处和一个复杂性：
这里是一个TriggerLight脚本中的一个状态的例子：
// Trigger打开光源
state() TriggerTurnsOn
{
function Trigger( actor Other, pawn EventInstigator )
{
Trigger = None;
Direction = 1.0;
Enable( ‘Tick‘ );
}
}
// Trigger关闭光源
state() TriggerTurnsOff
{
function Trigger( actor Other, pawn EventInstigator )
{
Trigger = None;
Direction = -1.0;
Enable( ‘Tick‘ );
}
}
这里声明了两个不同的状态(TriggerTurnsOn和TriggerTurnsOff)，并且在每个状态中书写了一个不同版本的Trigger函数。尽管您可以在不使用状态的情况下努力地完成这个实现，但是状态使代码更加的具有模块性和可扩展性：在UnrealScript中，你可以很容易地创建一个现有类的子类、增加新的状态及增加新的函数。如果过你尝试不使用状态来完成这个功能，最终的代码在以后将更加的难于扩展。
一个状态可以声明为可编辑的，意味着用户可以在UnrealEd中设置actor的状态，或者不能设置其状态。如果想定义一个可以编辑的状态，请按照以下方式：
state() MyState
{
//...
}
如果要声明一个不可编辑的状态，请按照：
state MyState
{
//...
}
您也可以通过"auto"关键字来指定一个actor的自动的或者初始的状态。这会导致当新的actor初次被激活时都会被置于那个状态。
auto state MyState
{
//...
}
除了函数，一个状态可以包含一个或多个标签，在其后面可以书写UnrealScript代码，比如：
auto state MyState
{
Begin:
Log( "MyState has just begun!" );
Sleep( 2.0 );
Log( "MyState has finished sleeping" );
goto(‘Begin‘);
}
上面的状态代码输出了信息 "MyState has just begun!" ，接着它停止了2秒钟，然后它输出了信息 "MyState has finished sleeping" 。这个例子中的一个有趣的事情便是调用latent函数"Sleep"：这个函数的调用并不是立即返回，而是在一定量的游戏时间过去后才返回。Latent函数仅能在状态代码中并且不能从函数中调用。Latent函数可以帮助您管理包括一段时间的经过在内的一系列复杂的事件。
所有的状态代码都是以标签定义开始；在上面的例子中标签命名为"Begin"。标签提供了一个进入状态代码的方便的入口点。你可以在状态代码中使用任何标签名称，但是"Begin"标签式专用的：它是那个状态的默认入口点。
所有的actor都有三个主要的latent函数可以使用：
Pawn类为动作定义了几个重要的latent函数比如在世界中导航及短期运动。请查看单独的AI文档来获得它们用途的描述。
3个native UnrealScript函数在书写状态代码时尤其地有用：
这里是到目前为止所讨论的状态概念的示例：
//这是一个自动的状态
auto state Idle
{
//当被另一个actor触摸时…
function Touch( actor Other )
{
log( "I was touched, so I‘m going to Attacking" );
GotoState( ‘Attacking‘ );
Log( "I have gone to the Attacking state" );
}
Begin:
log( "I am idle..." );
sleep( 10 );
goto ‘Begin‘;
}
//攻击状态
state Attacking
{
Begin:
Log( "I am executing the attacking state code" );
//...
}
当您运行这个程序然后触摸那个actor，你会看到：
I am idle... I am idle... I am idle... I was touched, so I‘m going to Attacking I have gone to the Attacking state I am executing the attacking state code
请确保您理解了GotoState的这个重要的方面：当你从一个函数中调用GotoState函数，它不会立刻跳转到目标状态，而是当给函数的执行返回到状态代码时才会跳转到目标状态。
在UnrealScript中，当您创建一个现有类的子类时，您的新类继承了父类的所有变量、函数及状态。这很好理解。
然而，对UnrealScript编程模型的状态抽象给继承及其范围规则增加了额外的复杂性。
这里是所有重载规则的一个例子：
// 这里是一个示例父类
class MyParentClass extends Actor;
// 一个非状态函数
function MyInstanceFunction()
{
log( "Executing MyInstanceFunction" );
}
// 一个状态
state MyState
{
//状态函数
function MyStateFunction()
{
Log( "Executing MyStateFunction" );
}
// "Begin"标签
Begin:
Log("Beginning MyState");
}
// 这里是一个示例子类
class MyChildClass extends MyParentClass;
// 这里我重载了一个非状态函数
function MyInstanceFunction()
{
Log( "Executing MyInstanceFunction in child class" );
}
//这里我重新声明了MyState状态，以便我可以重载MyStateFunction函数。
state MyState
{
//这里我重载了MyStateFunction函数
function MyStateFunction()
{
Log( "Executing MyStateFunction" );
}
//这里我重载了"Begin"标签
Begin:
Log( "Beginning MyState in MyChildClass" );
}
当您在一个或多个状态中、及在一个或多个父类中有一个全局执行的函数，你需要理解在给定的环境中应该调用哪个版本的函数。范围规则解决了这些复杂的情况：
如果一个状态没有重载父类中具有相同名称的状态，那么你可以随意地使用"extends"关键字来使该状态在当前类的所存在的状态上进行扩展。这是有用的，比如，在您有一组类似的状态的情况时(比如MeleeAttacking 和 RangeAttacking)，它们有很多共有的功能。在这种情况下你可以像这样声明一个作为基类的Attacking状态：
// 基类的Attacking状态
state Attacking
{
//在这里粘贴基类函数...
}
//近处袭击
state MeleeAttacking extends Attacking
{
// 在这里粘贴序列化的函数...
}
//远处袭击
state RangeAttacking extends Attacking
{
//在这里粘贴序列化的函数...
}
状态可以选择使用 ignores 修饰符来忽略函数，语法如下所示：
//声明一个状态
state Retreating
{
//忽略以下信息...
ignores Touch, UnTouch, MyFunction;
// 在这里粘贴函数...
}
您可以从它的"state"变量、类型"name"变量来说明一个actor在哪个特定的状态中。
通过使用 GotoState(‘‘) 函数使一个actor处在"no state(没有状态)"中是可以实现的。当一个actor在"no state(没有状态)"时，仅可以调用它的全觉(非状态)函数。
无论您什么时候使用 GotoState 命令来设置一个actor的状态，引擎都可以调用两个专用的通知函数，如果您已经定义了它们：_EndState()_ 和 BeginState() 。 EndState 在新的状态开始之前将会在当前的状态中立刻被调用，BeginState 在新的状态开始后将立刻被调用。这些函数为您的状态可能需要进行的任何特定状态的初始化和清除提供了方便。
使用正常的状态变换时，当你从一个状态到另一个状态后，便不能再回到先前的状态。但是通过使用状态栈使这个功能可以实现。调用 PushState 函数将会转换到放在栈的顶部的新状态，当前的状态将会被冻结。当调用PopState 时，将会恢复先前的状态并继续从 PushState 被调用的点开始继续执行。 当在状态代码内部使用PushState 时，它是作为latent函数的，所以和您在函数中调用 PushState 的代码执行行为是不同的。从函数中调用 PushState 将不会中断代码的执行(就像在一个函数中使用GotoState一样)，然而当从状态代码中调用它时将会暂停代码的执行，直到子状态被弹出为止(同样也和在状态代码中调用GotoState类似)。
一个状态只能被放到栈中一次，尝试将同一个状态压入堆栈两次将会失败。 PushState 就像 GotoState 那样进行使用，它需要一个状态名称和一个可选的作为状态入口的标签。新的状态将会接受到一个 PushedState 时间，但前的状态受到一个 PausedState 的事件。当调用 PopState 后，当前状态将收到一个 PoppedState 事件并且新的状态(在栈中这个状态的下一个状态)将会收到 ContinuedState 。
state FirstState
{
function Myfunction()
{
doSomething();
PushState(‘SecondState‘);
//只要我们在一个函数(不是latent功能)中，它将立即被执行。
JustPushedSecondState();
}
Begin:
doSomething();
PushState(‘SecondState‘);
// 只要我们在一个状态代码快中，一旦SecondState被弹出，这将立即执行。(latent 功能)
JustPoppedSecondState();
}
state SecondState
{
event PushState()
{
//我们被压入，回到第一个状态
PopState();
}
}
使用函数 IsInState ，你将可以检验一个某个状态是否在堆栈中。这个函数仅检查状态的名称，因此不能用于检查父类的状态。
state BaseState
{
...
}
state ExtendedState extends BaseState
{
...
}
如果活动的状态是 ExtendedState ，那么 IsInState(‘BaseState‘) 将会返回false。当然，如果 BaseState 在栈上，调用 IsInState(‘BaseState‘, true) 将会返回true。
关于在UnrealScript中的复制的更多信息，请查看[https://udn.epicgames.com/Three/NetworkingOverview#UnrealScript:%20the%20Replication%20Statement][Networking Overview 网络概述]]页面。
UnrealScript 的 foreach 命令使处理大组的actor变得容易，比如在一个关卡或者在一个actor附近特定距离内的所有actor。"foreach"和一个叫"iterator"的用于在一系列的actor中全部地循环处理的特殊类型函数协同工作。
这里是一个 foreach 示例：
//显示关卡中的所有的光源
function Something()
{
local actor A;
// 循环全部处理关卡中的所有的actor
log( "Lights:" );
foreach AllActors( class ‘Actor‘, A )
{
if( A.LightType != LT_None )
log( A );
}
}
在所有的 foreach 中的第一个参数都是一个常量类，它指定了要搜索的actor的类型。你可以用这个来限定搜索，比如，仅搜索所有的Pawns。
在 foreach 中的第二个参数是一个变量，在 foreach 循环过程中的每个迭代期间中这个变量都会被赋予一个actor值。
这里是和"foreach"进行协同工作的所有的迭代函数。
AllActors ( class<actor> BaseClass, out actor Actor, optional name MatchTag ) 循环迭代处理关卡中所有的actors。如果你指定一个可选的MatchTag(匹配标签)，则仅包括actor的"Tag"变量和您所指定的标签相匹配的actors。
DynamicActors( class<actor> BaseClass, out actor Actor ) 循环迭代所有的从关卡启动后产生的actors，忽略关卡启动时放置到关卡中的actors。
ChildActors( class<actor> BaseClass, out actor Actor ) 循环迭代这个actor所拥有的所有的actors。
BasedActors( class<actor> BaseClass, out actor Actor ) 循环迭代使用这个actor作为基类的所有actors。
TouchingActors( class<actor> BaseClass, out actor Actor ) 循环迭代接触这个actor的所有actors。
TraceActors( class<actor> BaseClass, out actor Actor, out vector HitLoc, out vector HitNorm, vector End, optional vector Start, optional vector Extent ) 循环迭代所有接触从开始点(Start)到结束点(End)之间并且碰撞范围盒为 Extent的轨迹线的actors。在每次迭代中，HitLoc设置为碰撞位置，HitNorm设置为一个向外指的碰撞法线。
OverlappingActors( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc, optional bool bIgnoreHidden ) 循环迭代在指定位置的指定半径内的所有的actors(或如果没有指定，则是这个actor的位置)。
VisibleActors( class<actor> BaseClass, out actor Actor, optional float Radius, optional vector Loc ) 循环迭代在指定位置可以看到的所有actors(或者如果没有指定位置，则是指这个actor的位置)。
VisibleCollidingActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc, optional bool bIgnoreHidden ); 返回在某个半径内的并且这些actors从一个位置(默认为调用者的位置)到那个actor的位置的轨迹不会碰撞世界中的所有碰撞(bCollideActors==true) actors。由于这个函数使用了碰撞散列函数，所以它要比 AllActors()快很多。
CollidingActors ( class<actor> BaseClass, out actor Actor, float Radius, optional vector Loc ); 返回在某个半径内的碰撞(bCollideActors==true) actors。由于它使用了碰撞散列函数，所以在处理小半径时将比 AllActors() 函数快很多。_注意_：迭代函数是特定类的所有成员，所以如果您想在一个非Actor类的函数中使用一个迭代器，你则必须有一个actor类的变量，使用以下语法：
foreach ActorVar.DynamicActors(class‘Pawn‘, P)所以在一个交互作用的类中，你可以这样做：
foreach ViewportOwner.Actor.DynamicActors(class‘Pawn‘, P)注意: 迭代器现在也支持动态数组，你可以在 Advanced Language Features 高级语言功能部分获得相关信息。
在复杂的编程情况下，你经常需要调用一个函数的指定版本，而不是在当前范围内的一个函数版本。为了处理这些情况，UnrealScript提供了以下关键字：
Global:调用最子类的全局(非状态) 函数版本 Super:调用函数在父类中的相应的版本，根据特定的情境被调用的函数可以是一个状态或者非状态函数。 Super(classname):调用指定类中的相应的函数,根据特定的情境被调用的函数可以是一个状态或者非状态函数。
结合使用多个调用修饰符(也就是 Super(Actor).Global.Touch )是无效的。
这里是一些调用修饰符的示例：
class MyClass extends Pawn;
function MyExample( actor Other )
{
Super(Pawn).Touch( Other );
Global.Touch( Other );
Super.Touch( Other );
}
作为一个附加例子，BeginPlay()在一个actor将要进入一个要播放的游戏时被调用。BeginPlay()函数在Actor类中实现而且它包含着需要执行的某些重要的功能。现在，假如您想在新类MyClass中重载BeginPlay()函数，来增加某些新的功能。为了安全地实现上述功能，您需要调用父类的BeginPlay()函数。
class MyClass extends Pawn;
function BeginPlay()
{
//调用父类的BeginPlay函数(很重要)
Super.BeginPlay();
//现在您可以自定义BeginPlay的内容
//...
}
在一个变量类中的静态函数可以通过以下语法调用：
var class C;
var class<Pawn> PC;
class‘SkaarjTrooper‘.static.SomeFunction(); //在一个特定的调用一个静态函数
PC.static.SomeFunction(); //在一个变量类中调用一个静态函数
class<Pawn>(C).static.SomeFunction(); //在一个进行类型转换的类中调用一个静态函数
UnrealEd允许关卡设计人员修改一个物体的类的变量的默认值。当属于这个类的一个新actor产生，它的所有的变量都会被初始化为这些默认值。有时，手动地将一个变量重置为默认值是有帮助的。比如，当一个玩家投射掉一个武器装备，那么武器装备代码需要将actor的某些值重置为默认值。在UnrealScript中，您可以通过使用"Default"关键字来访问一个类的默认变量，比如：
var() float Health, Stamina;
//...
//重置所有变量为它们的默认值
function ResetToDefaults()
{
//重置健康状况和精力
Health = Default.Health;
Stamina = Default.Stamina;
}
如果您有一个类的引用(一个 class 或 class<classlimitor> 类型的变量)，您便可以访问它所引用的类的默认属性，而不需要有那个类的一个对象。这个语法适用于和class类型等同的其它任何表达式。
var class C; var class<Pawn> PC; Health = class‘Spotlight‘.default.LightBrightness; // 访问在Spotlight中的LightBrightness的默认值 Health = PC.default.Health; //访问变量类PC的Health的默认值 Health = class<Pawn>(C).default.Health; //访问类型转换表达式中Health的默认值
除了在UnrealEd中通过一个属性窗口来设置一个Actor的属性的默认值，你也可以通过在类中的defaultproperties(默认属性)语句块中放置特殊的赋值表达式来设置成员变量的默认值。
defaultproperties(默认属性)语句块的语法和标准的unrealscript语法略有不同：
ArrayProp(0)=Value1 ArrayProp(1)=Value2 ORArrayProp[0]=Value1 ArrayProp[1]=Value2
ArrayProp=(Value1,Value2,Value3) ORArrayProp(0)=Value1 ArrayProp(1)=Value2 ArrayProp(2)=Value3 ORArrayProp.Add(Value1) ArrayProp.Add(Value2) ArrayProp.Add(Value3)
NameProp=‘Value‘ ORNameProp=Value
ObjectProp=ObjectClass‘ObjectName‘
Begin Object class="ObjectClass" Name=ObjectName VarName=Value ... End Object ObjectProperty=ObjectName
StructProperty=(InnerStructPropertyA=Value1,InnerStructPropertyB=Value2) ORStructProperty={( InnerStructPropertyA=Value1, InnerStructPropertyB=Value2 )}注意: 某些类型当在一个struct默认值中使用时需要不同的语法。
StructProperty=(StaticArray[0]=Value,StaticArrayProp[1]=Value)StructProperty=(DynamicArray=(Value,Value))StructProperty=(NameProperty="Value")
Array.Empty - 清除整个数组Array.Add(element) -在数组尾端添加元素Array.Remove(element) -从数组中删除元素，这将移除所有出现该元素的地方。Array.RemoveIndex(index) -删除指定索引的元素Array.Replace(elm1, elm2) - 用elm2代替elm1。所有出现的地方都会被替换。如果没有找到elm1将会弹出一个警告。
Consider the following example (based on Actor.uc):
defaultproperties
{
//对象
MessageClass=class‘LocalMessage‘
//声明了一个SpriteComponent类的内联子对象，命名为"Sprite"
Begin Object class="SpriteComponent" Name=Sprite
//这里指定的值将覆盖SpriteComponent类的默认值。
Sprite=Texture2D‘EngineResources.S_Actor‘
HiddenGame=true
End Object
//进行操作
Components.Add(Sprite)
// 声明一个CylinderComponent类名称为"CollisionCylinder"的内联子对象。
Begin Object class="CylinderComponent" Name=CollisionCylinder
// 这里指定的值将覆盖CylinderComponent类自己的值
CollisionRadius=10
CollisionHeight=10
AlwaysLoadOnClient=True
AlwaysLoadOnServer=True
End Object
//进行操作
Components.Add(CollisionCylinder)
CollisionComponent=CollisionCylinder
//行首的‘+‘和行尾的‘f‘字符将会被忽略)
DrawScale=00001.000000
Mass=+00100.000000
NetPriority=00001.f
//整型
NetUpdateFrequency=100
//枚举
Role=ROLE_Authority
RemoteRole=ROLE_None
// structs
DrawScale3D=(X=1,Y=1,Z=1)
//布尔型
bJustTeleported=true
bMovable=true
bHiddenEdGroup=false
bReplicateMovement=true
// names
InitialState=None
//动态数组(在这里是一个类的动态数组)
SupportedEvents(0)=class‘SeqEvent_Touch‘
SupportedEvents(1)=class‘SeqEvent_UnTouch‘
SupportedEvents(2)=class‘SeqEvent_Destroyed‘
SupportedEvents(3)=class‘SeqEvent_TakeDamage‘
}
当您在UnrealScript中声明一个struct时，您可以为struct的属性随意地指定默认值。任何时候在UnrealScript中使用这个struct时，它的成员函数将会使用这些值进行初始化。语法和一个类的defaultproperties(默认属性)块的语法相同 – 唯一的不同是这个语句块名称为 structdefaultproperties 。比如：
struct LinearColor
{
var() config float R, G, B, A;
structdefaultproperties
{
A=1.f
}
};
任何时候当您在UnrealScript中声明一个LinearColor变量，它的 A 属性的值将被设置为1.f。当使用structdefaultproperties时需要理解的另一个重要事情是类的默认值会覆盖struct的默认值。如果您有一个LinearColor类型的类成员变量，那么您在类defaultproperties中分配给成员变量的任何值将会覆盖struct中的默认值。
var LinearColor NormalColor, DarkColor;
defaultproperties
{
NormalColor=(R=1.f,B=1.f,G=1.f) // 这个属性的A的值将是1.0f
DarkColor=(R=1.f,B=1.f,G=1.f,A=0.2f) //这个属性的A的值将是0.2f
}
先前我们所讲的数组是指静态数组。它意味着数组的大小(数组中有多少个元素)是在编译时设置的并且是不能改变的。动态数组和静态数组都有以下共同的特征：
为了适应数组元素变化的需要，动态数组提供了一种使静态数组的功能具有在运行时改变元素数量的能力的方法。如果想使用动态数组，我们需要指导几件事情。
首先是变量的声明。声明一个动态数组和声明其它的unrealscript变量是非常相似的(也就是var/local 类型 变量名)。对于动态数组，类型可以使用关键字 array 来指定，后面跟着由尖括号括起的数组类型。如果数组类型也包含尖括号(比如 class<Actor> )，你必须在类型的结束括号和数组的结束括号之间加入空格，否则编译器会把这两个结束括号作为 >> 操作符来处理。比如 声明一个叫IntList的动态整型数组: var array<int> IntList; 声明一个类型为class<PlayerController> 名称为 Players的动态数组: var array<class< PlayerController> > Players;。
当脚本开始运行时，IntList将从0元素开始。动态数组所支持的方法允许我们向数组中添加元素、取出元素及任意地增加或降低数组的长度。调用这些方法的语法是(使用我们的IntList为例子)： IntList.MethodName() 。以下是动态数组提供的方法：
动态数组也有一个变量叫 Length ，它是指动态数组的当前长度(元素的个数)。 我们不仅能读取这个Length变量，并且我们可以直接设置它，从而允许我们修改数组中元素的数量。当您直接修改Length变量时，在数组长度中的所有改变都在数组的末端发生。比如，如果我们设置 IntList.Length = 5，然后我们在设置IntList.Length = 10，那么我们刚刚添加的额外的5个元素会添加到数组的末端，同时保持我们原始的5个元素及其它们的值。如果我们降低Length，元素也会被从数组的末端拿掉。注意当您想一个数组增加元素时，不管是通过Insert()函数还是通过增加长度，元素都会被初始化为它的变量类型的默认值(ints为0，类的引用为None等)。 值得注意的是您也可以通过设置元素的索引比当前的Length值大来增加动态数组的长度。这将和您设置Length的值为较大的值来扩展数组是一样的。
注意 – 动态数组的成员Length是不能通过‘++‘, ‘--‘, ‘+=‘, or ‘-=‘来进行增量/减量运算的，也不能将Length作为一个输出参数传递给一个函数(那个函数能够改变它的值)。由于这样做使Length不再是精确的，从而会导致内存泄露和崩溃；仅能通过使用 ‘=‘ 操作符来设置Length(并设置设置一个元素所在的索引大于Length)来适当地修改动态数组的实际长度。
注意:不支持array<bool>类型！
最后的一个注意点 – 不能 复制动态数组。你可以通过使用一个函数来避开这个问题。这个函数是可以复制的函数并且有两个参数，一个是动态数组的一个索引及那个索引处所存储的值。然而，你也必须要考虑在客户端和服务器的一个时间间隔内元素不一样的后果。
动态数组现在支持 ‘foreach‘ 操作符来进行简单的迭代操作。基本语法是 ‘foreach ArrayVariable(out ArrayItem,optional out ItemIndex) {}‘，在那里每次迭代将会增加索引的值并输出那项，如果可选项的属性提供了，也输出它的索引。
function IterateThroughArray(array<string> SomeArray)
{
local string ArrayItem;
local int Index;
foreach SomeArray(ArrayItem)
{
`log("Array iterator test #1:"@ArrayItem);
}
foreach SomeArray(ArrayItem,Index)
{
`log("Array iterator test #2:"@ArrayItem@Index);
}
}
要获得关于接口的更多信息，请查看UnrealScript 接口页面。
要获得关于如何使用Delegates的信息，请查看UnrealScript Delegates页面。
要获得关于native类的更多信息，请查看编译 Native类 和 创建 Native 类页面。
在游戏中(In-game)和在编辑器(in-editor)中的功能可以通过属性元数据来进行扩展。
在UnrealScript中任何一个元数据都可以按照以下方式连接到一个属性上：
变量:
var float MyVar<TAG=VALUE>
枚举型:
enum EMyEnum
{
EME_ValA<TAG=VALUE>,
EME_ValB<TAG=VALUE>,
};
For a class类:
请查看以下的UnProg3邮件列表链接：https://udn.epicgames.com/lists/showpost.PHP?id=24834&list=unprog3
您可以为同样的属性使用多个元数据说明，在多个说明间使用字符 | 作为分隔。
比如:
var() LinearColor DrawColor<DisplayName=Draw Color|EditCondition=bOverrideDrawColor>;
这里是当前支持的元数据标签及它们的功能:
<ToolTip=TEXT_STRING>
在编辑器属性窗口中，当鼠标放到相应的属性上时，使 TEXT_STRING 作为工具提示出现。
注意: 最新添加了支持，脚本编辑器可以将 /** VALUE */ 注释自动地翻译为ToolTip的元数据。
<DisplayName=TEXT_STRING>
使属性的名称在编辑器的属性窗口中显示为 TEXT_STRING 而不是它的真实名称。
举例:
Var() bool bEnableSpawning<DisplayName=Spawning Enabled>;
警告: 如果您在编辑器的复选框中修改UPropertyInputCombo 为排序枚举值，那么在枚举类型中使用DisplayName 将会引起问题
请查看一下的UnProg3 邮件列表链接：https://udn.epicgames.com/lists/showpost.php?list=unprog3&id=24302
<EditCondition=ConditionalPropertyName>
这允许您基于另一个属性(Boolean)的值来设置编辑器的属性的可编辑状态为启用的还是禁用的。
比如，您有在UnrealScript类MyPackage.MyClass中有一下设置：
/**启用或禁用 spawning*/ Var() bool bEnableSpawning; /**设置 AIs 的产生速率。只有设置bEnableSpawning = TRUE的时候才有效。 */ Var() float RespawnsPerSecond<EditCondition=bEnableSpawning>;
当bEnableSpawning为false时，在编辑器中的RespawnsPerSecond将被灰掉。这使事情对于设计者来说不再那么令人迷惑。
重要:这个原数据设置需要可控变量(RespawnsPerSecond)使用一个绑定(WxCustomPropertyItem_ConditionalItem)的自定义属性项。
为了启用它，你需要在Editor.ini加入它，如下所示：
[UnrealEd.CustomPropertyItemBindings] CustomPropertyClasses=(PropertyPathName=" MyPackage.MyClass: RespawnsPerSecond ",PropertyItemClassName="WxCustomPropertyItem_ConditionalItem")
要获得关于这个更多的信息，请查看https://udn.epicgames.com/lists/showpost.php?list=unprog3&id=30824
<FriendlyName=TEXT_STRING>
不确定这个是否仅在内部使用，并且并不希望您在 UNREALSCRIPT使用它，或许Epic可以澄清这个问题？
<AllowAbstract>
如果显示在一个类的属性上，则用于编辑那个属性的编辑器下拉框将会包含抽象类。如果不显示，它们将仅包含具体的类。在这个元数据说明中没有必要指定一个值比如True 或 False。
<AutoComment=BOOLEAN_VALUE>
当给Kismet序列动作(Kismet Sequence Action)添加一个属性时，属性及它的当前的值将会自动地作为注释出现动作的上方。如果想看到效果，可以在脚本中放置一个新的"Gate"序列动作，在这个类中的bOpen和AutoCloseCount都使用了这个元数据选项。
要想获得更多的关于UnrealScript在底层是如何实现的信息 – 从Compile Process 编译过程到Execution执行到最终的Byte Code字节代码的展示 – 请查看UnrealScript Implementation UnrealScript的实现页面。
UnrealScript的设计可以在不破坏二进制兼容性的情况下使包文件中的类随着时间不断地扩展。这里所说的二进制数据兼容性是指“所依赖的二进制文件可以无误地进行加载并连接”；而您所修改的代码是否向您设计的那样工作是一个单独的问题。需要特别说明的是，可以安全地进行修改的种类如下所示：
其它的改变一般都是不安全的，包括(但不限于)：
垃圾 回收. Unreal中的所有objects和actors都是用一个类似于Java VM的树形结构遍历的垃圾回收器进行垃圾回收。Unreal垃圾回收器使用UObject类的序列化函数来递归地确定每个活动的对象在引用哪些其它的对象。因此，对象不必明确地进行删除，因为当它们不被引用时，垃圾回收器最终会对它们进行回收。尽管这个方法对删除laten没有引用的对象有副面影响，但是它的效率远远地高于把那种很少发生删除的情况在内的引用算在内。
UnrealScript 是 基于 字节代码的. UnrealScript代码编译成为一系列类似于p-code(移植码)或Java字节代码。这使UnrealScript具有平台独立性，这可以使Unreal的客户端和服务器端组件直接地移植到其它的平台上，也就是Macintosh或Unix，并且所有的版本通过执行相同的脚本都可以很容易地进行交互操作。
Unreal as a 虚拟 机. 虚幻引擎可以被看成一个3D游戏方面的虚拟机，就像Java语言和它的内置 Java类层次结构为网页开发脚本定义了一个虚拟机一样。Unreal虚拟机天生具有可移植性(由于在不同的模块中分离出了所有的平台独立代码)和可扩展性(由于可扩展的类的层次结构)。然而，目前我们没有想过要把Unreal VM文档化到那种足以让其它人可以用来创建独立的但兼容的实现的程度。
The UnrealScript 编译器 是 需要编译三遍.不像C++, UnrealScript编译要进行独立的三遍，第一遍，对变量、struct、枚举型、常量、状态及函数声明进行分析和记忆；构建了每个类的概要。在第二遍，将脚本代码编译为字节代码。这使得在这两遍中对带有循环依赖的复杂的脚本层次进行完全地编译和连接，没有独立的连接阶段。第三个阶段使用在.uc文件的 defaultproperties 语句块指定的值来分析并导入类的默认属性
持久的 actor 状态. 在Unreal中值得重点注意的是，因为用户可以在任何时间内保存游戏，所有actors的状态包括它们的脚本执行状态仅能在当所有的actors都处在UnrealScript栈的最低的层次时才能进行保存。这个持久的要求是latent函数仅能从状态代码中进行调用的背后的原因：状态代码在栈中尽可能低的层次上执行，因此可以非常容易被序列化。函数代码可以存在于任何栈级别，并在可以使(比如)C++ 的native函数在栈中处于它的下面，那显然不能保存到硬盘并在稍后进行恢复。
*Unrealfiles(Unreal文件)是Unreal的本地二进制文件 *. Unrealfiles包括一个索引、特定Unreal包内objects的序列化存储。Unrealfiles类似于DLL文件，它们可以包含到其它Unrealfiles存储的其它objects的引用。这个方法使在因特网上通过预先确定的包来发布Unreal内容成为可能，从而节约了下载时间(通过永远只能对一个特定的包进行一次下载)。
为什么 UnrealScript 不 支持 静态 变量. C++支持静态变量的很好的原因是忠实于低层次语言的根源，Java支持静态变量的原因似乎并没有彻底地想好，在UnrealScript中不支持静态变量是由于它们的作用范围在序列化、出处及多个关卡方面的含糊性：静态变量是否需要具有全局性，意味着所有的静态变量的值在所有活动的Unreal关卡中是一样的？它们是否在每一个包中？它们是否应该在每个关卡中？如果这样，那么它们如何进行序列化哪 – 使用在它的.u文件中的类还是使用它.unr文件中的关卡？它们在每个基类中都是唯一的或者子类是否有他们自己的静态变量的值？在UnrealScript中，我们通过不定义静态变量作为一个语言功能来回避了这个问题，把它留给了程序员来管理，程序员可以通过创建包含它们的类或在一个真实的对象中暴露它们来管理它们像静态变量还是像全局变量。
这里我们描述了关于如何更高效地书写UnrealScript代码的几个主题，使我们可以充分地利用UnrealScript优势而避免它的缺陷。
尽可能多地使用latent 函数(像FinishAnim和Sleep函数). 通过把您的代码逻辑流程基于latent函数，您正创建着有动画驱动或有时间驱动的代码，它们在UnrealScript中是非常地高效的。
当您在测试脚本时，请关注您的Unreal 日志.在运行时通常会在日志文件中生成一些有用的警告来通知您正在发生的非致命问题。
提防会引起无限递归的代码.比如，"Move"命令移动actor，当您在碰撞某物时调用您的Bump()函数。因此，如果您在一个Bump函数中使用一个Move命令，那么请小心，您便有进入无限递归的危险。无限递归和无线循环是UnrealScript不能很好处理的两个错误情形。
在服务器端产生和销毁actors 是相当昂贵的操作，在网络游戏中则更加的昂贵，因为产生和销毁actors 会占用网络带宽.请您合理的使用它们，把actors当成”非常重”的物体对待。比如，不要尝试通过产生100个独立的actors来创建一个粒子系统并使用物理代码让它们在不同的轨道进行发射。那将会导致运行非常非常的慢。
尽可能地使用UnrealScript 的面向对象兼容性能.通过重载现有的函数和状态来创建新的功能会使干净的代码更容易进行修改及更容易和其他人的代码进行集成。避免使用传统的C技术，比如基于一个actor或state的类来使用一个switch()语句，因为这样的代码在您增加一个新类及修改一些东西时更容易被破坏。
UnrealScript的.u包文件是严格地按照.ini文件的EditPackages列表进行编译的,所以每个包仅能引用本包中及在它前面编译的包中的物体，而不能引用在它后面编译的包中的物体。如果您发现需要在包之间进行循环引用，有两个解决方案：
标签：exe match src order pre 服务 分布 基本语法 mirror
原文地址：http://www.cnblogs.com/wodehao0808/p/6104427.html
