◆ static var matrix : Matrix4x4

描述：设置用于渲染所有gizmos的矩阵。

类方法

◆ Static function DrawCube(center:Vector3,size:Vector3):void

描述:用center和size绘制一个立方体.
function OnDrawGizmosSelected()

{
        //在变换位置处绘制一个变透明的蓝色立方体
        Gizmos.color=Color(1,0,0,5);
        Gizmos.DrawCube(transform.position,Vector3(1,1,1));
}

◆ Static function DrawGUITexture(screenRect:Rect,texture:Texture,mat:Material=null):void

描述：在屏幕坐标下绘制一个纹理。用于GUI背景。

◆ Static function DrawGUITexture(screenRect:Rect,texture:Texture,leftBorder:int,rightBorder:int,topBorder:int,bottomBorder:int,mat:Material=null):void

描述:在屏幕坐标下绘制一个纹理。用于GUI背景。

◆ Static function Drawicon(center:Vector3,name:string):void
描述:在世界位置center处绘制一个图标.
这个图标被命名为name并放置在Assets/Gizmos文件夹或Unity.app/Resoutces文件夹.DrawIcon允许你在游戏中快速选择重要的物体。
//在物体位置处绘制光源灯泡图标.
//因为我们在OnDrawGizmos函数内部调用它,在场景视图中
//这个图标总是可点选的.
function OnDrawGizmos()

{
     Gizmos DrawIcon(transform.position,”Light Gizmo.tiff”);
}

◆ Static function DrawLine(from:Vector3,to:Vector3):void

描述:绘制一条线从from到to.
Var Larget:Transform;
function OnDrawGizmosSelected()

{
        if(target != null)
        {
              //从transform到target绘制一条蓝色的线
              Gizmos.color = Color.blue;
              Gizmos.DrawLine(transform.position,target.position);
        }
}

◆ static function DrawRay(r:Ray):void
static function DrawRay(from:Vector3,direction:Vector3):void
描述:绘制一个射线从from开始到from + direction.

 function OnDrawGizmosSelected()

{
    Gizmos.color = Color.red;
    Direction = transform.TransformDirection(Vector3.forward)*5;
    Gizmos.DrawRay(transform.positon,direction);
}

◆ Static function DrawSphere(center:Vector3,radius:flont):void

描述:用center和randins绘制一个球体.
Function OnDrawGizmosSelected()

{
      //在变换位置处绘制一个黄色的球体
      Gizmos.color = Color.yellow;
      Gizmos.DrawSphere(transtorm.position,1);
}

◆ Static function DrawWireCube(center:Vector3, size: Vector3):void

描述:用center和radius绘制一个线框立方体.
Function OnDrawGizmosSelected(){
     //在变换位置处绘制一个黄色立方体
     Gizmos.color = Color.yellow;
     Gizmos.DrawWireCube (transtorm.position, Vector3(1,1,1));
}

◆ Static function DrawWireSphere(center:Vector3,radius:float):void

描述:用center和radius绘制一个线框球体.
Var explosionRadius = 5.0;
Function OnDrawGizmosSelected()

{
     //选中的时候显示爆炸路径

     Gizmos.color = Color.white;
     Gizmos.DrawSphere(transtorm.position,explpsionRadius);
}

Graphics    类

  Unity绘制函数的原始接口。
  这个是高级快捷地进去Unity优化网格绘制的地方。只限于Unity Pro.

类方法

◆  static function DrawMesh(mesh:Mesh, position: Vector3, rotation: Quaternion, material: Material, layer: int, camera: Camera=null, submeshIndex: int, properties: MaterialPropertyBlock=null): void

◆  static function DrawMesh(mesh:Mesh,matrix:Matrix4x4,material:Material,layer:int,
camera:Camera = null,submeshIndex:int,properties:MaterialPropertyBlock=null):
void

参数

mesh                    用于绘制的Mesh.
position                 网格的位置。
rotation                 网格的旋转。
matrix                   网格的变换矩阵（由位置，旋转和变换x组合）
material                 使用的Material.
layer                      使用的Layer.
Camera                   如果是null(缺省)，该网格将在所有相机中被绘制，否则它将只会在给定的相机中渲染。
submeshIndex                 那个子网格被渲染。这只是在网格使用了多个材质的时候使用。
Properties                        在网格绘制前应用到才子的额外材质属性。参考MaterialPropertyBlock.

描述:绘制一个网格
DrawMesh     在一帧中绘制一个网格。这个网格将受到光照的影响，可以投射接收阴影并被投射器影响。就像它是某个物体的一部分。他可以绘制于所有相机，或者只是特定的一些相机
 在你想创建人景的网格，而又不想过多的创建和管理游戏物体的时候使用DrawMesh.注意，DrawMesh不会立即绘制网格；它仅仅提交它用于渲染。网格将被作为普通渲染过程的一部分。如果想立即绘制一个网格。使用Graphics.DrawMeshNow。
因为DrawMesh不会立即绘制网格，在调用这个函数之间修改材质属性并会使材质使用它们。如果你想绘制一系列相同材质的网格，但是稍微有些不同的属性（例如，改变每个网格的颜色），那么使用MaterialPropertyBlock参数。
参见：MateralPropertyBlock.

◆  Static  function DrawMeshNow(mesh:Mesh,position:Vector3,rotation:Quatemion):void

描述：在给定的position,用给定的rotation绘制一个mesh。
这个函数将设置模型视矩阵并绘制网络。当前设置材质的pass可以被使用（参考Setpass）

◆  Static function DrawMeshNow(mesh:Mesh,position:Vector3,rotation:Quatemion,materallndex:int):void
描述：在给定的position，用给定的rotation和一个materialIndex绘制一个mesh.

◆  Static function  DrawMeshNow(mesh:Mesh,matrx:Matrix4x4):void

描述:用给定的matrix绘制一个mesh.
如果这个矩阵有一个负的缩放这个函数将不会正确渲染物体。

◆  Static function DrawMeshNow(mesh:Mesh,matrx:Matrix4x4,materialIndex:int):void

描述：用给定的matrix和materialIndex绘制一个mesh.
如果这个矩阵有一个负的缩放这个函数将不会正确渲染物体。

◆  Static function DrawTexture(screenRect:Rect,texture:Texture,mat:Material = null):void

描述：在屏幕坐标下绘制一个纹理。

◆  Static function DrawTexture(screenRect:Rect,texture:Texture,leftBorder:int,rughtBord:int,topBorder:int,bottomBorder:int,mat:Material=null):void
描述：在屏幕坐标下绘制一个纹理。

◆  Static function DrawTexture(screenRect:Rect,texture:Texture,sourceRect:Rect,leftBorder:int,rughtBord:int,topBorder:int,bottomBorder:int,mat:Material=null):void
描述：在屏幕坐标下绘制一个纹理

◆  static function DrawTexture(screenReet:Rect,texture:Texture,sourceRect:Rect,leftBordr:int.rightBrder:int.topBorder:int,bottomBorder:int,color:Bolor,mat:Material=null):void
描述：在屏幕坐标下绘制一个纹理。

Hashtable  类

函数

◆  function Add(key:Object, value:Object)：void

描述：添加指定的键和值到哈希表。

◆  function Clear():void

描述：数量被设置为0，并且从该集合中元素到其他对象的引用也将被释放，容量没有改变。///这个方法是O(n)操作，这里n是元素数量。
◆  function Contains(key:object):bool
描述：决定该哈希表中是否包含指定的键。
◆  function ContainsKey (key:object):bool
描述：从哈希表中移除指定键的元素。
◆  function Remove(key:object):void
描述：从哈希表中移除指定键的元素。
HostData
类
这个是用来保存单个主机信息的数据结构。
从master服务器取回的主机列表，使用这个类表示单个主机。
变量
◆  var comment:string
描述：一个多用途的注释（可以保存数据）

◆  var conneetedfPlaycrs:int
描述：当前连接的玩家
◆  var gameName:stting
描述：游戏的名称（像John Doe‘s Game）
◆  var gameType:string
描述：游戏类型（像MyUniqueGameType）
◆  var ip:string[]
描述：服务器IP地址
◆  var passwordProtected:bool
描述：服务器需要密码吗？
◆  var playerLimit:int
描述：最大玩家限制
◆  var port:int
描述：服务器端口
◆  var nseNat:bool
描述：这个服务器需要NAT穿透吗？
input
类
到输入系统的接口。
使用这个类读取在Input Manager中设置的轴。
使用Input.GetAxis用下面的缺省轴读取轴心："Horizontal"和"Vertical"被映射到摇杆，A，W,S,D和方向键，"Mouse X"和"Mouse Y"被映射到鼠标添量，"Fire1"，"Fine2"，"Fine3"映射到Ctrl，Alt，Cmd键和鼠标的三键或腰杆按钮。新的输入轴可以在Input Manager中添加。
如果你在为任何一种运动行为使用输入，那么使用Inpur.GetAxis。它给你一种平滑的可配置的输入，这个输入可以被映射到键盘，摇杆或鼠标。
使用Input.GetButton用于像事件一样的行为，不要将它用于移动，Input.GetAxis将使脚本代码更小更简单。
类变量
◆  static var anyKey:bool
描述：当前按住了任何键或鼠标按钮吗？（读取）
◆  static var anyKeyDown:bool
描述：用户按下任何键或鼠标按钮返回（Rend Only）。直到用户释放所用键/按钮并再次接下任何键/按钮时才返回真。
◆ static var input: String
描述：返回这一帧中键盘的输入（只读）。
只有ASCII可以包含在inputString中。
该字符串可以包含两个能被处理的特殊字符：字符“\b”代表退格。
*符"\n"表示回车。
//显示如何从键盘读取输入
//（例如，用户输入它的名字）。
//你需要附加这个脚本到一个GUTText物体。function Updarc(){
for (var c;char in Input inputString){
//退格，移除最后一个字符
if(c=="\b") {
iftguiText.Lcngth.text.Substring(0,guiText.text Length-1);
}
//结束
efse if (e=="\n"){
prinr("Uscr cntered his name:"+guiText,text);
}
//正常的文本输入.附加到尾部
elsc
}
guiText.text+=c;
}
}
}
◆  static var mousePosition:Vcctor3
描述:当前鼠标在像素坐标下的位置。
屏幕或窗体的左下为(0,0)，屏幕或窗体的左上为(Screen.width,Screen.height).
var particle:GamcObject,
function Update() {
if (lnput,GctButtonDown{"Firel")){
//从当前鼠标坐标处创建一个射线
var ray=Camera.main.ScreenPointToRay(Input mousePositicn);
if{Physics.Raycast(ray)) {
//如果碰到创建一个粒子
Instontiatc(particlc,transfonn.position,transfonn.rotation);
}
}
}
类方法
◆  static function CetAxis(axinName:string):float
描述：设置由axinName确实虚拟轴的值。
对于键盘和摇杆输入，这个值将在-1...1。
一个非常简单的行驶在x-z平面的汽车。
var spced=10.0;
var cotatinnSpeed=100.0;
function update()
}
//获取水平和垂直轴，
//默认滴它们被映射到方向键
//这个值的范围在-1到1
var transtation=loput.getaxis("vertical")*spccd;
var rotation=inpul getaxis ("horizontal"*rotarionspeed)
//使它以10米/秒速度移动而不是10米/帧
translation*=time delta time
//沿着物体的Z轴移动变换
transtorm.transtate(1010translation);
//绕着Y轴旋转
transform.rotate(0.rotation.0);
}
//指定一个鼠标查看
var horizontalspccd=2.0;
var verticelspeed=2.0
function update()
{
获取鼠标增量，这个没有在范围-1...1之间
var h=horizontalspeed*inpul.getaxis("mouse X");
var v=verticalspeed*input.getaxis("mouse Y");
transform.rotate(v.h.0);
}
◆static function getaxisraw(axisname:string):float
描述：设置由axisname确定虚拟轴的值，并且没有使用平滑过滤，
对于键盘和摇杆输入，这个值将在-1...1的范围内。因为输入没有被平滑，
总是-1，0或1.如果你想自己处理所有键盘输入的平滑，这个是很有用的。
function update(){
var speed=input.getaxisraw("horizoatal"*time deta time);
transform rotate(0.speed.0);
}
◆static function getbutton(button name:string):bool
描述：当时由button name 确定的虚按钮被按住时返回真。
考虑自动开火-这个将在按钮被按住时一直返回真。
//如果每0.5秒实例化一个projcctile,
//如果firel按钮（默认为Ctrl）被按下
var projectile : GameObject;
var fireRate : float = 0.5;
private var nextFire : float = 0.0;

function Update ()

{
     if (Input.GetButton ("Fire1") &&  Time.time > nextFire)

     {
         nextFire = Time.time + fireRate;
         var clone : GameObject =
         Instantiate(projectile, transform.position, transform.rotation) as GameObject;
     }
}

只有使用这个实现事件行为例如，射击，使用input.getaxis 用于任意类型的移动行为
◆static function getbuttondown(button name:steing):bool
描述：当由：button name 确定的虚拟按钮被按下时返回真。
知道用户释放并再次按下时返回真。
//当用户按下firel按钮时实黎化一个projcctile
var projectile:gameobject;
function update(){
if(input getbution down("firel")){
elone=instantiate(projectile,transforrn,position.transforn.rotinon);
}
}
只使用这个实现事件行为例如，射击，使用lnput.GetAxis用于任意类型的移动行为。
◆  static function GetButton Up(buttonName:string):bool
描述：当由buttonName确定的虚拟按钮被释放时返回真.
直到用户按下按钮并再次松开时返回真。
//当用户按下Fire;按钮时实例化一个projectile.
var projectile:GameObject;
function Update O;
if(lnput GetButtonUp("Firel")){
clcne=lnstantiate{projectile,transtorm.position,transform.rotation);
  }
}
只使用这个实现事件行为例如，射击。使用lnput.GetAXis用于任意类型的移动行为，
◆  static funcrion GetKey(name:string):bool
描述：当用户按住由name确定的键时返回真，考虑自动开火。
键标识列表参考输入管理器。在处理输入时建议使用lnput.GetAxis和lnput.GetButton
因为它允许端用户定义这些键.
funcrion Update(){
if(lnput.GetKey("up")){
   print("up arrow key is held down");
}
if(lnput.GetKey("down"))
}
   print("down arrow key is held down");
  }
}
◆  static junction GetKey(key:keyGode):bool
描述：当用户按住由key KeyCode枚举参数确定的键时返回真.
funcrion Update(){
if(lnput.GetKey(KeyCode.UpArrow))}
   print("up arrow key is held down");
}
if(lnput.GetKey(KeyCode.DownArrow)){
   print("down arrow key is held down");
   }
}
◆  static function GetkeyDown(name:string):bool
描述：当用户开始按下由name确的键时返回真.
直到用户释放按钮并再次按下时返回真.
键标示列表参考lnput Manager.在处理输入时建议使用lnput.GetAxis和Input.GetBUtton
function Update();
if(input GetkeyDown("space"))
   print("space key was pressed");
  }
}
static function GetKeyDown(Key:KeyCode):bool
描述：当用户按下由Key KeyCode枚举参数确定的键时返回真.
function Update();
 if{lnput GetKeyDown(KeyCode.Space))
print("space key was pressed");
}
}
◆  static function GetKeyUp(name:sting):bool
描述：当用户释放由name确定的键时返向真.
直到用户按下按钮并再次松开时返向真。
键标示列表参考lntpot Manager.在处理输入时建议使用lnput.GetAxis和lnput.GetButton
因为它允许端用户定义这些键.
function Update();{
if(lnput.GetKeyUp("space");
  }
}
◆  static function GetKeyUP(Key:KeyCode):bool
描述：当用户释放由Key KeyCde 校举参数确定的键时返回真.
function Update(){
if(lnput,GetKeyUp(KeyCode.Space));
  print("space key was feleased");
  }
}
◆  statie function GetMouseButton(button:int):bool
描述：返回给定的鼠标按钮是否被按住。
/button/值为0表示左键，1表示右键，2表示中键.
◆  statie function GetMouseButtonDown(button:int)bool
描述：用户按下给定的鼠标按钮时返回真.
直到用户释放按钮并再次按下它时才返回真.button值为0表示中键左键，1表示右键，2表示中键.
◆  statie function GetMouseButtonUp(button:int)bool
描述：用户释放给定的鼠标按钮时返回真.
直到用户释放按钮并再次释放它时才返回真.button值为0表示中键左键，1表示右键，2表示中键.
◆  statie function ResetlnputAxes();Void
描述：重置所有输入。在ReaetlnputAxes之后所有轴将返回0并且所有按钮返回0.
这可用于当重生玩家，并且当你不想任何来自键盘的输入还处于按下时。
lnpu.ReaetlnputAxes();
jointDrive
结构
关节如何沿着本地X轴移动
变量
◆  var maximumForce:float
描述：用于向指定的方向推动物体的力的量。仅在Mode包含Velocity时使用。
◆  var mode:jointDriveMode
描述：驱动是否尝试到这个位置和/或速度.
◆  var positionDamper:float
描述：位置弹簧的阻力强度，只用于mode包含位置的时候.
◆  var positionSpring:float
描述：朝着定义的方向推动的一个阻力强度。只用于mode包含位置的时候.
Jointlimits
结构
jointlimits被Hingejoint使用来限制关节角度.
参见:Hingejoint
变量
◆  var max:float
描述：关节的上限。当关节角度或位置的上限。
关节将使用力来约束它。
//设置最小链接角度为20度
hingejoint.limits.max=40;
◆  var maxBounce:float
描述：当关节碰到关节的上限时关节的弹力。
//设置关节反弹时的上限
hingejoint.limits.maxBounce=1;
◆  var min:float
描述：关节的下限。当关节角度或位置的下限。
关节将使用力来约束它。
//设置最小链接角度为20度
hingejoint.limits.min=20;
◆  var minBounce:float
描述：当关节碰到关节的下限时关节的弹力。
 //关节反弹时的下限
hingejoint.limits.minBounce=1;
jointMotor
结构
jointMotor用来旋转一个关节
例如：Hingejoint可以被告知以制定的速度和力旋转。关节然后用给定的最大力试图到达这个速度，参见：
变量
◆  var force：float
描述：动力将应用最大为force的力以便取得targetvelocity
◆  var freeSpin：bool
描述：如果freeSpin被启用动力将只加速而不会减速
◆  var targetvelocity：float
描述：动力将应用最大为force的力以便取得targetvelocity
Jointspring
结构
变量
◆  var damper：float
描述：用语阻尼弹簧的阻尼力。
◆  var spring：float
描述：用于达到目标位置的弹力
◆  var targetposition：float
描述：关节试图到达的目的位置
这里一个hingehoint目标位置是目标角度
Keyframe
结构
一个关键帧它可以插入动画的曲线
变量
◆  var in tangent:float
描述：在曲线上从下一个点到这个点时描述切线。
参加：outtangent
◆  var outtangent:float
描述：在曲线上从这个点到下一个点时描述切线。
参见：intangent
◆  var time：float
描述：关键帧时间
在一个2D图形中，你可以把这当做x值
参见：value
◆  var value：float
描述：该动画曲线在关键帧处的值
参见：time
构造函数
◆  static function keyframe（time：float，value：float）：keyfranie
描述：创建一个关键帧
◆  static function keyframe（time：float，value：float,intangent:float,outangent:float):keyframe
描述：创建一个关键帧
layermask
结构
layermask允许你在检视面板中显示layermask弹出菜单
类似与camera，cullingmask。layermasks 可以选择性地过滤物体，例如当投射射线，
//使用层蒙板投射一个射线
//它可以在检视面板中修改
var mask larermask=
function Update(){
if(Physics.Raycast(transform.position, transform.forward, 100, mask.value))
{
Debug.Log(“Hit something”;
}
}
变量
◆  var valuc：vin
描述：转化层蒙板的值为一个整形值
//使用层蒙板投射一个射线
//它可以在检视面板中修改
var mask：lnyermask=-1
fonction update（）{
if{physics.rayeast（transforn.position.transform.forwatd.100.mask.value))
{
Debug
}
}
类方法
◆  static function LayerToName（layer ：in）：string
描述：给定一个层的数字。返回内置的或在tag Maneger中定义的层名称。
◆  static function NameToLayer（layerName ：string）：int
描述：给定一个层的名字。返回内置的或在tag Maneger中定义的层索引。
◆  static implicit function LayerMask(intva1:int):layermask
描述：隐式转化一个整数位已个层蒙板
Lightmapdata
类
光照贴图数据
一个场景可以有多个光照贴图储存在这里，renderer组建可以使用这些光照贴图，这就使得它能够在多个物体上使用相同的材质，而每个物体可以使用不同的光照贴图或同一个光照贴图的不同部分。
参见，linghrmapsettings类 renderer lightmapindex 属性
变量
◆  var lightmap:texture2D
描述：光照贴图的纹理
参见：lightmspsettings 类 renderer lighunaplndex属性
linghtmapsettings
类
储存这个场景的光照图
一个场景可以有多个光照贴图储存在这里，renderer组件可以使用这些光照贴图，这就使得它能够在多个物体上使用相同的材质，而每个物体可以使用不同的光照贴图或同一个光照贴图的不同部分。
参见：lightmapdata类renderer.lightmaplndex属性
类变量
◆  sartic var lightmaps:lightmapdata[]
描述：光照贴图数组
参见：lightmapdata类renderer.lightmaplndex属性。
Masterserver
类，主服务器用来使服务器和客服端匹配。
你可以建立以个游戏主机或为你的游戏类型取回主机列表。这里的这个函数用来与主服务器通信，主服务器位于不同的服务器上，如果必要这个服务器可以被定制，主服务器的概览和技术描述：参见master server manual page
类变量
◆  static var dedicatedserver:bool
描述:申明这台机器为专用服务器。
如果作为一个服务器运行，连接数定义了玩家的数量，当在主服务器上注册的时候这个被报告，默认情况下主服务器假定这个实例不是专用服务器，因此玩家数会增加1（占用服务器上的一个\“chent”\）如果不希望，这个变量可以设置为假，然后知有连接数被报告为玩家数。
function startserver{}{
nerwork lnitializeserver(32.25002):
masrerserver.dedicatedserver=true;
masterserver.registerhost("myuniquegametype","johndoes game","133tgame for all");
}
◆static var ip address:string
描述：主服务器的IP地址。
默认地这个是由unity技术运行的服务器。
function
masterserver ip address="127.0.0.1";
master server.port=10002;
}
◆static var port:int
描述：主服务器的链接端口。
默认地这个是由unity技术云顶的服务器，
masterserver.ipaddress="127.0.0.1";
master server.port=100021;
}
◆static var updaterate:int
描述：为主服务器主机信息更新设置最小更新速率。
通常，主机更新只在主机信息被改变的时候发生（如连接的玩家）。更新率定义了主机更新之间的最小时间量，缺省值为60秒（检查更新）因此，如果以个主机更新呗发送然后一些域在10秒后改变，然后更新可能会在50秒之后发送（在下一次检查到改变的时候）。如果这个被设置为0，以后就没有更新被发送，只发送初始注册信息。
function startserver()
{
network lnitialigeserver(32.25002);
//在初始化注册之后没有主机信息更新
Masterserver.updaterate=0;
masterserver,registerhost("myuniquegametype","johndoes game","133tgame forall");
}
类方法
◆static function clearhostlist():void
描述：清楚由masterserver.pollhostlist接收到的主机列表。
如果你想更新列表并想确保你不使用较旧的数据时，使用这个，
function awakc()
{
//确保类表是空的并请求一个新的列表
masterserver clearhostlist();
masterserver.requesthostlist("myuniquegametype");
}
function lpdate()
{
//如果任何主机被接收，显示游戏名称，再次清理主机列表，}
if(masterserver.pollhostlist(),length!=0){
var hostdata;hostdata[]=masterserver.pollhostlist();
for(var i:int=0;i<hostdata.length;i++){
    debug,log("game name:"+hostdata[i]gamename);
}
masterserver,clearhostlist()
}
}
◆static function pollhostlist():hostdata[]
描述：使用master server.requeshostlist接收最新的主机列表
使用masterserver.clearhostlist清理当前主机列表。这样你可以确定返回的列表时最新的。
  function awaket(){
//确保列表时空的并请求一个新的列表
masterserver .clearhostlist();
masterserver.requesrhostlist("larustest"):
;
function update()
;
//如果任何主机被接收，显示游戏名称，再次清理主机列表；
if(masterserver.pollhostlist()length!=0){
varhostdata hostdata[]=masterserver.pollhostlist();
for(var i:int=0;i<hostdata.length;i++){
debug.log("game name"+hostdata[i].gamename);
}
masterserver.clearhostlist()
}
◆static function registerhost(gametypename:string,gamename:string.comment:string=""):void
描述：在主服务器注册这个服务器。
如果主服务器地址信息尚未改变，缺省的主服务器将被使用。
function ongui()
{
if(guilayout.button("stnrt server")){
//如果没有公有IP地址，使用NAT穿透
network。usenat=！network.havepublicaddrss();
network.lnitializeserver(32.25002);
masterserver.registerhost("myuniquegametype","johndoes game","133tgame for all");
}
}
◆static function RequestHosList(gameTypeName:string):void
描述：从主服务器请求一个主机列表。
当它完成的时候，这个列表可以通过MasterServer.PollHcstList使用。
function Awakc(){
//确保列表时空的并请求一个新的列表
MastcrScrver.RequestHostList();
MastcrScrver.RequestHostList("LarusTcst");
}
function Update()
}
//如果任何主机被接收，显示游戏名称，再次清理主机列表。
if(MastcrScrvcr.PollHcstLisx().length!=0)}
var hostData:HostData[]=MasterSer.pollHostList();
for (var i:int=();i<hostData.length;i++){
Debug.Log("Game namc;"+hostData[i].gamceName);
}
MastcrScrvcr.ClearHostList();
}
}
static function UnregisterHost():void
描述：从主服务器注销这个服务器。
如果服务器没有被注销或已经被注销，不做任何事。
function OnGUt() {
if(GUILayout.Button("Disconnect")){
Nctwork,Disconnect();
NastcrServer.UnregisterHost();
}
}
MaterialPropertyBlock
类
应用的一块材质值。
MateriaIPropcrtyBlock被Graphics.DrawMesh使用。当你想用相同的材质（但有稍微有些不同的属性）绘制多个物体时，使用这个。例如，如果你想稍微改变每个网络的颜色时。
出于性能原因，属性块只能包含有限数量的属性值。两个4x4矩阵，六个向量颜色或12个浮点数可以存储在这个块中，存储空间时共享，所以存储一个矩阵留下两倍少的空间来
 
存储向量和浮点数。
Graphics。DrawMesh 拷贝传递的属性块，因此最有效的方法是使用它来创建一个快并为所有DrawMesh 调用使用它。使用Clear来清除块的值，AddFloat，AddVector，AddColot，AddMatrix来添加值。
参见：Graphics，DrawMesh，Matcrial。
函数
◆  function AddColor(name：string，value:Colo):void

◆  function AddColor(nameID:int，value:Colo):void

描述：添加一个颜色材质属性。
出于性能原因，属性块只能包含有限量的属性值。两个4x4矩阵，六个向量/颜色或12个浮点数可以存储在这个块中。存储空间时共享，使用存储一个矩阵留下两个倍少的空间来存储向量和浮点数。当块的存储空间填满后，额外的Add调用将被忽略。
使用nameID的函数变量体更快，如果你重复添加相同名称的属性，使用Shader.propertyToID来获取不同的标示，并传递这个标示到AddColor。
◆  function AddFloat(name：string，value:float):void
◆  function AddFloat(nameID:int，value:float):void
描述：添加一个浮点材质属性。
出于性能原因，属性块只能包含有限数量的属性值。两个4x4矩形，六个向量/颜色或存12个浮点数可以存储在这个块中，存储空间是共享，所以存储一个矩阵留下两倍少的空间来存储向量和浮点数。当块的存储空间填满后，额外的Add调用将被忽略。
使用nameID的函数变体更快，如果你重复添加相同名称的属性，使用Shader.PropertyToID来获取不同的标示，并传递这个标示到AddFloat。
◆  function AddMatrix(name：string，value:Matrix4x4):void
◆  function AddMatrix(nameID:int，value:Matrix4x4):void

描述：添加一个矩阵材质属性。
处于性能原因，属性块只能包含有限数量的属性值。两个4x4矩阵，六个向量/颜色或12个浮点数可以存储在这个块中。存储空间时共享，所以存储一个矩阵留下两倍少的空间来存储向量和浮点数。当块的存储空间填满后，额外的Add调用将被忽略。
使用nameID的函数变体更快，如果你重复添加相同名称的属性，使用Shader.PropertyToID来获取不同的标示，并传递这个标示到AddMatrix。
◆  function AddVector(name：string，value:Vector4):void
◆  function AddVector(nameID:int，value:Vector4):void
描述：添加一个向量材质属性。
出于性能原因，属性块只能包含有限数量的属性值。两个4x4矩阵，六个向量/颜色或12个浮点数可以存储在这个块中。存储空间是共享，所以存储一个矩阵留下两倍少的空间来存储向量和浮点数。当块的存储空间填满后，额外的Add调用将被忽略。
使用nameID的函数变体更快，如果你重复添加相同名称的属性，使用
Shader.ProrertyToLD来获取不同的标示，并传递这个标示到AddVector。
◆  function Clear():void
描述，清除材质属性值。
GrawMesh 拷贝传递的属性块，因此最有效的方式是使用它来创建一个块并为
所有DrawMesh调用使用它。使用Clear来清除块的值,ADDFloat,AddVector,AddColor,AddMatrix来添加值.
Mathf
结构
常用数学函数的集合。
类变量
 ◆  static var Deg2Rad:float
 描述：度到弧度的转化常量（只读）。
 这个等于（PI*2)/360.
//转化30度为弧度
var deg=30.0;
var od=dcg*Mathf.Deg2Rad;
参见：Rad2Deg常量。
◆  static varEpsilon:float
描述：一个小的浮点数值（只读）
比较小于它的值没有多人意见，因为浮点数是不精确的。
print(MathfEpsilon);
◆  static var Infinity:float
描述：表示正无穷（只读）.
◆  static var NegativeIntinity:float
描述：表示负无穷（只读）.
◆  staic var PI:float
描述：3.14159265358979...值（只读）.
◆  static var Rad2deg:float
描述：弧度到度的转化常量（只读）.
这个等于360、（PI*2）.
 转化1弧度为度
var rad=1.0;
var deg=rad*Mathf.Rad2Deg.
参见：Deg2Rad常量
类方法
◆  staric function Abs(f:float):float
描述：返回f的绝对值。
//打印10.5
print(Mathf.Abs(-10.5)).
◆  staric function Abs(value:int):int
描述：返回value的绝对值。
//打印10
print(Mathf.Abs(-10));
◆  staric function Acos(f:float):float
描述:返回f的反余弦_一个弧度角它的余弦是f.
print(Mathf.AcOS(0.5);
◆  staric function Approximately(a:float,b:float):bool
描述：比较两个浮点数值看看它们是否近似。
由于浮点数值不精确，不建议使用等操作来比较它们。例如，1.0==10.0/10.0也许不会返回真。
if(Mathf.Approximately(1.0,10.0/10.0))
print("same");
◆  static function Asin(f:float):float
描述：返回f的反正弦_一个弧度角它的正弦是f.
print(Matht.Asin(0.5));
◆  staric function Atan(f:float):float
描述：返回f的反切_一个弧度角它的正切是f.
print(Mathf.Atan(0.5));
◆  staic function Atan2(y:float,x:float):float
描述：返回一个弧度角它的Tan为y/x。
返回的值是一个角度，该角表示x轴和开始于零并终结在（x,y）处的向量之间的角度。
//通常使用transform.lookAt.
//但这可以给你更多的对角度的控制
vartatget:Transform;
function Update()
{
var relativ=transfom.lnverseTeansformPoint(target.position);
var angle=Mathf.Atan2(reative,reative.z)*Mathf.Rad2Deg;
transform.Rotate(0,angle,0);
}
◆  static function Ceil(f:fioat):float
描述：返回大于等于f的最小整数.
◆  static function CeilTolnt(f:fioat):int
描述：返回大于等于f的最小整数.
◆  static function Clamp(value:float,min:float,max:float):float
描述：在一个最小的浮点数和最大的浮点数之间截剪。
//随着时间设置变换位置
//但是不会小于1或大于3
function Update()
{
transtorm,position.x=Mathf.Clamp(lime.time.1.0,3.0);
}
◆  staric function Clamp(value:int,min:int,max:int):int
描述：在min和max之间裁剪值并返回裁剪后的值。
//在1到3之间裁剪10，
//打印3到控制台
prnt(Mathf.Clamp(10,1,3))
◆  static function Clamp01(value;float):float
描述：在0和1之间裁剪值并返回裁剪后的值。
//随着时间设置变换位置
//但是不会小于0或大于1
function Update(){
transform.position.x=Mathf.Clamp01(Time.time);
}
◆  staic function ClosestPowerOflwo(value:int):int
描述：返回最直接的2的幂次值。
例如。7返回8或者19返回16
◆  staric function Cos(f:float):float
描述：返回弧度f的余弦值.
print(Mathf.Cos(3));
◆  staic function EXP(power:float):float
描述：返回e的特定次幂。
print(Mathf.Cos(6));
◆  static function Floor(f:float):float
描述:返回小于f的最大整数.
◆  static function FloorTolnt(f:float):int
描述：返回小于f的最大整数.
◆  static function lnverseLerp(from:float,to:float,value:float):float
描述：在两个值之间计算Lerp参数.
varwalkSpeed=5.0;
varunSpeed=10.0;
var speed=8.0;
//参数现在是3/5
vvar parameter=Mathf.laverseLerp(walkSpeed,runSpeed,speed);
◆  staic tunchon Lerp(a:float,b:float,t:float):float
描述：基本t在a到b之间插值。t本裁剪到0到1之间。
当t为0时返回from . 当t为1时返回to .当t=0.5时返回a和b的平均。
var minimum = 10.0;
var maximum = 20.0;
// 在一秒内从minimum渐变到maximum
Function Update()
{
transform.position.x = Mathf.lerp(minimum,maximum,Time.time);
}
◆ static function LerpAngle(a:float,b:float,t:float):float
描述：与Lerp相同，但是当它们可绕360度时确保插值正确，
变量a和b被认为是度。
//以2为底6的对数
//打印2.584963
print(Mathf.Log(6,2));
◆ static function Log(f:float):float
描述：返回一个数以自然（以e为底）对数。
//10的自然对数
//打印4.60517
print(Mathf.Log(10));
◆ static function Log10(f:float):float
描述：返回一个数以10为底的对数。
//以10为底100的对数
//打印2
print(Mathf.Log10(100));
◆ static function Max(a:float,b:float):float
描述：返回两个值中较大的一个。
//打印2
print(Mathf.Max(1,2));
◆ static function Max(a:int,b:int):int
描述：返回两个值中较大的一个。
//打印2
print(Mathf.Max(1,2));
◆ static function Min(a:float,b:float):float
描述：返回两个值中较小的一个。
//打印1
print(Mathf.Min(1,2));
◆ static function Min(a:int,b:int):int
描述：返回两个值中较小的一个。
//打印1
print(Mathf.Min(1,2));
◆ static function PingPong(t:float,length:float):float 
描述：来回改变t值，t值不会超过length，也不会小于0，只会在length和0之间循环。
function Update()
{
//让x位置在0到3之间循环
transform.position.x = Mahtf.PingPong(Time.time,3);
}
◆ static function Pow(f:float,p:float):float
描述：返回f的p次方。
print(Mahtf.Pow(6,1.8));
◆ static function Repeat(t:float,length:float):float
描述：使t值循环，不大于length不小于0。它与操作模板类似，但可以使用浮点数。
function Update()
{
//让x位置在0到3之间循环
transform.position.x = Mahtf.Repeat(Time.time,3);
}
◆ static function Sign(f:float):float
描述：返回f的符号。
当f为正或为0则返回1，为负返回-1。
◆ static function Sin(f:float):float
描述：返回以f为弧度的sin值。
print(Mahtf.Sin(3));
◆ static function SmoothDamp(current:float,target:float,ref currentVelocity:float,smoothTime:float,maxSpeed:float = Mahtf.Infinity,deltaTime:float =Time.deltaTime):float
描述：逐步的向期望值变化。
这个值就像被一个不会崩溃的弹簧防震器所影响。这个函数可以用来平滑任何类型的值，位置，颜色，标量。最常用于让一个跟随摄像机的速度变的平滑。
current就是当前位置。target是我们希望达到的位置。currentVelocity是当前速度，这个值在你访问这个函数的时候会被随时修改。smoothTime是要到达目标位置的近似时间，实际到达目标时要快一些。maxSpeed可以让你随意的设定最大速度。deltaTime是上次访问该函
数到现在的时间。缺省为Time.deltaTime。
//平滑到目标高度
var target : Transform;
var smoothTime = 0.3;
private var yVelocity = 0.0;
function Update ()
{
var newPosition = Mathf.SmoothDamp(transform.position.y, target.position.y,yVelocity, smoothTime);
transform.position.y = newPosition;
}
◆ Static function SmoothDampAngle(current: float, target: float, ref currentVelocity): float, smoothTime: float, maxSpeed: float=Mathf.Infinity, deltaTime: float=Time.deltaTime): float
描述： 基于Game Programming Gems4章节1.10
随着时间逐渐的改变一个角度为目的的角度。这个值被像弹簧阻尼一样的函数平滑。这个函数可以用来平滑任何一种值，位置，颜色，标量。最常见的是平滑一个跟随摄像机。
current是当前位置。target是我们试图到达的位置。currentVelocity是当前速度，这个值在每次你调用这个函数的时候都被修改。smoothTime是到达目的地近似时间，实际的时间将更短。maxSpeed为允许的最大速度。deltaTime为从上次调用该函数到现在的时间。缺省为Time.deltaTime。
//一个简单的平滑跟随摄像机。
//跟随目标的朝向
var target : Transform;
var smooth = 0.3;
var distance = 5.0;
private var yVelocity = 0.0;
function Update ()
{
//从目前的y角度变换到目标y角度
var yAngle = Mathf.SmoothDampAngle(transform.eulerAngles.y,target.eulerAngles.y, yVelocity, smooth);
//target的位置
var position = target.position;
//然后，新角度之后的距离便宜
position += Quaternion.Euler(0, angle, 0) * Vector3 (0, 0, -distance);
//应用位置
transform.position = position;
//看向目标
transform.LookAt(target);
}
◆ static function SmoothStep (from : float, to : float, t : float) : float
描述：在min与max中插值并在限定处渐入渐出
◆ static function Sqrt (f : float) : float 
描述：返回f的平方根  
print(Mathf.Sqrt(10));
◆ static function Tan (f : float) : float 
描述：返回弧度f的正切值 
print(Mathf.Tan(0.5));
Matrix4x4
一个标准的4x4变换矩阵。
一个变换矩阵可以执行任意的线形3D变换（例如，评议，旋转，缩放，切边等等）并且偷师变化使用齐次坐标。脚本中很少使用矩阵：最常用Vector3，Quaternion，而且Transform类的功能更简单。单纯的矩阵用于特殊情况，如设置非标准相机投影。
 参考任何图形学教程获取关于变换矩阵的深入揭示。
 在Unity中，Matrix4x4被Transform，Camera，Material和GL函数使用。
变量
◆ var inverse : Matrix4x4
描述：返回该矩阵的逆（只读）
如果用原始矩阵诚意逆矩阵结果为identity矩阵。
如果一些矩阵以一个特定的方式变换响亮，逆矩阵可以将他们变换回去。例如worldToLoclaMatrix和localToWorldMatrix是互逆的。
◆ var this[row : int,column : int]:float
描述：访问[row,column]处的元素。
row和column必须在0到3之间，矩阵是一个4x4的数组，你可以通过使用这个函数访问单个的元素。
注意标准数学符号-row是第一个索引。
◆ var this[index : int]:float
描述：按顺序索引存取元素（包括在0..15）
矩阵是一个4x4的数组，所以它的总数为16,。你可以使用一维索引来存取单个元素。index是row+column*4
◆ var transpose : Matrix4x4
描述：返回这个矩阵的转置（只读）。
转置矩阵是将原矩阵行列交换得到的（沿主对角线翻转）
函数
◆ function GetColumn(i : int):Vector4
描述：获取矩阵的一列。
第i列作为Vector4返回，i必须在0到3之间。
参见：SetColumn
◆ function GetRow(i : int):Vector4
描述：返回矩阵的一行。
第i行作为Vector4返回，i必须在0到3之间。
参见：SetRow
◆ function MultiplyPoint (v : Vector3):Vector3
描述：通过这个矩阵变换位置。
返回由任意矩阵变化得到的位置v。如果这个矩阵是一个正规的3D变换矩阵，使用MultiplyPoint3x4比它更快。MultiplyPoint是较慢的，但是能处理投影变换。
参见：MultiplyPoint，MultiplyVector。
◆ function MultiplyPoint3x4(v : Vector3):Vector3
描述：通过这个矩阵变换位置（快）。
返回由当前变换矩阵变换得到的位置v。这个函数是MultiplyPoint的快速版，但是它只能处理常规的3D变化。Multiplypoint是较慢的，但是能处理投影变换。
参见：MultiplyPoint，MultiplyVector。
◆ function MultiplyVector(v : Vector3):Vector3
描述：通过这个矩阵变换方向。
这个函数类似于MultiplyPoint，但它是变换方向而不是位置。变换方向时，只考虑矩阵的旋转部分。
参见：MultiplyPoint，MultiplyPoint3x4。
◆ function SectColumn(i : int,v:vector4):void
描述：设置矩阵的一列。
使用这个来构建一个变换矩阵，这个矩阵使用right，up和forward向量。
//从变换构建一个矩阵
var matrix = Matrix4x4();
//从变换构建一个矩阵
function Start ()
{
matrix.SetColumn (0, transform.right);
matrix.SetColumn (1, transform.up);
matrix.SetColumn (2, transform.forward);
var p = transform.position;
matrix.SetColumn (3, Vector4 (p.x, p.y, p.z, 1));
}
//设置第i列为v。i必须在0到3之间。
参见：GetColumn
◆ function SetRow(i : int,v:Vector4):void
描述：设置矩阵的一行。
设置第i行为v。i必须在0到3之间。
参见：GetRow
◆ function SetTRS(pos : Vector3, q:Quaternon, s:Vector3):void
描述：设置这个矩阵为一个变换，旋转和缩放矩阵。
当前的矩阵本修改一遍具有位置pos，旋转q和缩放s。
◆ function ToString():string
描述：返回已格式化的该矩阵的字符串。
类变量
◆ static var identity : Matrix4x4
描述：返回单位矩阵（只读）。
这个矩阵在使用的时候不会影响任何东西。它的主对角线上全是1，其他位置全是0。
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
参见：zero变量。

◆ static var zero : Matrix4x4
描述：返回所有元素都为零的矩阵（只读）。
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
参见：identity变量。
类方法
◆ static operator * (lhs : Matrix4x4,rhs : Matrix4x4) : Matrix4x4
描述：两个矩阵相乘。
返回lhs * rhs。
◆ static operator * (lhs : Matrix4x4,v:Vector4):Vector4
描述：由矩阵来变换一个Vector4。
◆ static function Ortho(left : float,right : float,bottom : float,top : float,zNear : float,zFar : float):Matirx4x4
描述：创建一个正交投影矩阵。
返回的矩阵是视口ledt到right，bottom到top的区域，zNear和zFar深度裁剪面板。
如果你想使用正交来做像素修正渲染，最好使用GL.LoadPixelMatrix，因为它会为Direct3D渲染器运用适当的half-texel便宜。
参见：GL.LoadPixelMatrix，GL.LoadProjectionMatrix，GUI.matrix
◆ static function Perspective(fov : float,aspect : float,zNear : float,zFar : float):Matrix4x4
描述：创建一个透视投影矩阵。
fov为透视矩阵的垂直视野，aspect为宽高比，zNear和zFar设置为深度裁剪面板。
参见：GL.LoadPixelMatrix，GL.LoadProjectionMatrix，GUI.matrix
◆ static function Scale(v:Vector3):Matrix4x4
 描述：穿件一个缩放矩阵。
 返回沿着坐标轴被响亮v缩放的矩阵，该矩阵看起来像这样：
v x 0 0 0
0 v y 0 0
0 0 v z 0
0 0 0 1
◆ static function TRS(pos:Vector3,q:Quaternion,s:Vector3):Matrix4x4
 描述：创建一个变换，旋转和缩放矩阵。
返回的矩阵具有位置pos，旋转q和缩放s。
NetworkMessageInfo
这个数据结构包含一个刚收到的来自网络的消息。
它揭示了它从哪来，发送的时间和由什么网络视图发送的。
变量
◆ var networkView : NetworkView
描述：发送这个消息的NetworkView
◆ var sender : NetworkPlayer
 描述：发送这个网络信息（拥有者）的玩家。
◆ var TimeStamp : double
描述：当消息被发送时的时间戳，以秒计。
时间邮戳可以用于实现插值或者连续刘宝的预测，时间戳被作为双精度数传递，以避免游戏运行长一段时间后溢出。内置的时间戳被设置为32位整数，以毫秒为精度以便节省带宽。时间戳现对于Network.time自动调整。因此Network.time-messageInfo.timeStamp是抱在传输时花费的时间。
var something : float;
var transitTime: double;
function OnSerializeNetworkView (stream : BitStream, info : NetworkMessageInfo) {
var horizontalInput : float = 0.0;
if (stream.isWriting) {
// 发送
horizontalInput = transform.position.x;stream.Serialize (horizontalInput);
} else {
// 接收
transitTime = Network.time - info.timestamp;
stream.Serialize (horizontalInput);
something = horizontalInput;
}
}
function OnGUI() {
GUILayout.Label("Last transmission time: "+ transitTime);
}
NetworkPlayer
 NetworkPlayer是一个数据结构，通过它你可以通过网络定位其他玩家。
例如，你可以直接发送一个消息给其他玩家。
变量
◆ var externalIP : string
描述：返回网络接口的外部IP地址。这个只能在建立了外接连接以后才能输入。
◆ var externalPort : int
描述：返回网络接口的外部接口。这个只能在建立了外接连接以后才能输入。
◆ var ipAddress : string
描述：该玩家的IP地址。
◆ var port : int
描述：该玩家的端口号。
构造函数
◆ static function NetworkPlayer(ip : string , port : int) : NetworkPlayer
描述：
函数
◆ function ToString() : string
描述：返回该网络玩家的指数。
类方法
◆ static operator != (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述：如果两个NetworkPlayers不是同一个玩家返回真
◆ static operator == (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述：如果两个NetworkPlayers是同一个玩家返回真
NetworkPlayer
 NetworkPlayer是一个数据结构，通过它你可以通过网络定位其他玩家。
例如，你可以直接发送一个消息给其他玩家。
变量
◆ var externalIP : string
描述：返回网络接口的外部IP地址。这个只能在建立了外接连接以后才能输入。
◆ var externalPort : int
描述：返回网络接口的外部接口。这个只能在建立了外接连接以后才能输入。
◆ var ipAddress : string
描述：该玩家的IP地址。
◆ var port : int
描述：该玩家的端口号。
构造函数
◆ static function NetworkPlayer(ip : string , port : int) : NetworkPlayer
描述：
函数
◆ function ToString() : string
描述：返回该网络玩家的指数。
类方法
◆ static operator != (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述：如果两个NetworkPlayers不是同一个玩家返回真
◆ static operator == (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述：如果两个NetworkPlayers是同一个玩家返回真
NetworkViewID
 在一个多玩家游戏中，NetworkViewID是用于网络视实例的唯一标识符。
这个是重要的，因为这个在所有客户端是唯一的数字，并且客户端自己可以产生这些数字，否则网络同步将被断开。
变量
◆ var isMine : bool
描述：如果是被我实例化的，返回真。
◆ var owner : NetworkPlayer
描述：拥有NetworkView的NetworkPlayer。可以是服务器。
函数
◆ function ToString() : string
描述：返回NetworkViewID中的格式化字符串细节。
类方法
◆ static operator != (lhs : NetworkViewID,rhs : NetworkViewID):bool
描述：如果两个NetworkViewIDs不是同一个玩家返回真
◆ static operator == (lhs : NetworkViewID,rhs : NetworkViewID):bool
描述：如果两个NetworkViewIDs是同一个玩家返回真
Network
类
网络类是网络实现的核心并提供核心函数。
这个类定义了网络接口和所有网络参数。你可以使用它来设置一个服务器或链接到一个服务器并有一些列辅助函数来帮助你完成这些功能。获取更多关于编辑器中的信息请参考Network Maner component reference。
消息传递
◆ function OnConnectedToServer() : void
描述：当成功链接到服务器上时，在客户端调用这个函数。
function OnConnectedToServer() {
Debug.Log("Connected to server");
}//发送本地玩家名称到服务器
◆ function OnDisconnectedFromServer(mode : NetworkDisconnection):void
描述：客户端从服务器上断开时在客户端上调用，但当连接被断开时在服务器上调用。
当链接丢失或被服务器断开时，在客户端调用这个函数。NetworkDisconnection枚举将标示连接是否断开或是否连接丢失。连接成功断开时再服务器上调用这个函数（在Network.Disconnect之后）。
function OnDisconnectedFromServer(info : NetworkDisconnection) {
if (Network.isServer) {
Debug.Log("Local server connection disconnected");
}
else {
if (info == NetworkDisconnection.LostConnection)
Debug.Log("Lost connection to the server");
else
Debug.Log("Successfully diconnected from the server");
}
}
◆ function OnFailedToConnect(error : NetworkConnectionError):void
描述：当连接因为某些原因失败时，在客户端上调用该函数。
失败的原因作为NetworkConnectionError枚举传入。
function OnFailedToConnect(error: NetworkConnectionError){
Debug.Log("Could not connect to server: "+ error);
}
◆ function OnFailedToConnectToMasterServer(error : NetworkConnectionError):void
描述：当连接到主服务器出现问题时，在客户端或服务器端调用该函数。
错误原因作为NetworkConnectionError枚举传入。
function OnFailedToConnectToMasterServer(info: NetworkConnectionError){
Debug.Log("Could not connect to master server: "+ info);
}
◆ function OnNetworkInstantiate(info : NetworkMessageInfo):void
描述：当一个物体使用NetworkInstantiate进行网络初始化时在该物体上调用这个函数。这个对于禁用或启用一个已经初始化的物体组件来说是非常有用的，它们的行为取决于他们是本地还是远端。注意：在NetworkMessageInfo里的networkView属性不能在OnNetworkInstantiate里使用。
function OnNetworkInstantiate (info : NetworkMessageInfo) {
Debug.Log("New object instantiated by " + info.sender);
}
 描述：当一个新的玩家成功连接时再服务器上调用这个函数。
private var playerCount: int = 0;
function OnPlayerConnected(player: NetworkPlayer) {
Debug.Log("Player " + playerCount++ + " connected from " + player.ipAddress + ":" + player.port);
}// 用玩家信息构建一个数据结构
◆ function OnPlayerDisconnected(player : NetworkPlayer) : void
描述：当玩家从服务器断开时再服务器上调用这个函数。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ function OnSerializeNetworkView(stream : BitStream, info : NetworkMessageInfo) : void
描述：用来在一个被网络视架空的抄本中自定义变量同步。
它自动决定被序列化的变量是否应该发送或接收。这个依赖于谁拥有这个物体，例如，拥有者发送，而其他所有的接收。
//该物体的生命值信息
var currentHealth : int;
function OnSerializeNetworkView(stream : BitStream, info : NetworkMessageInfo){
var health : int = 0;
if (stream.isWriting){
health = currentHealth;
stream.Serialize(health);
}
else{
stream.Serialize(health);
currentHealth = health;
}
}
◆ function OnServerInitialized() : void
描述：当Network . InitializeServer 被调用并完成时，在服务器上调用这个函数。
function OnServerInitialized() {
Debug.Log("Server initialized and ready");
}
类变量
◆ static var connections : NetworkPlayer[]
描述：所有连接上的玩家。在客户端中，该变量只包含服务器。
function OnGUI() {
if (GUILayout.Button ("Disconnect first player")) {
if (Network.connections.length > 0) {
Debug.Log("Disconnecting: "+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
}
}
}
◆ static var ConnectionTesterIP:string
描述：用在Network.TestConnection中的连接测试的IP地址。
function ResetIP() {
Network.connectionTesterIP = "127.0.0.1";
Network.connectionTesterPort = 10000;
}
◆ static var connectionTesterPort:int
描述：用在Network.TestConnection中的连接测试的IP端口。
function ResetIP() {
Network.connectionTesterIP = "127.0.0.1";
Network.connectionTesterPort = 10000;
}
◆ static var incomingPassword:string
描述：为这个服务器设置密码（对于进入的连接）。这个必须与客户端上Network.Connect中的相同，传递””表示没有密码（默认）。
function ConnectToServer () {
Network.Connect("127.0.0.1", 25000, "HolyMoly");
}
function LaunchServer () {
Network.incomingPassword = "HolyMoly";
Network.InitializeServer(32, 25000);
}
◆ static var isClinet:bool
描述：如果你的端类型是客户端则返回真。
function OnGUI() {
if (Network.isServer)
GUILayout.Label("Running as a server");
else if (Network.isClient)
GUILayout.Label("Running as a client");
}
◆ static var isMessageQueueRunning:bool
描述：启用或禁用网络消息处理。如果这个被禁用，没有RPC调用或网络视同步会替代。Network level loading有如何使用这个函数的例子。
◆ static var isServer:bool
描述如果你的端类型是服务器端则返回真。
function OnGUI() {
if (Network.isServer)
GUILayout.Label("Running as a server");
else if (Network.isClient)
GUILayout.Label("Running as a client");
}
◆ static var maxConnections:int
描述：设置允许的连接/玩家的最大数量。设置0，以为这没有心的连接可以被建立。但现有保持连接。设置为-1表示最大连接数被设置为与当前开发的连接数相同。在这种情况下，如果一个玩家掉线，那么这个空位还是为他开放的。这个不能设置为高于Network.InitializeServer设置的连接数。
function StartGameNow() {
// 不允许更多玩家
Network.maxConnections = -1;
}
◆ static var minimumAllocatableViewIDs:int
描述：在ViewIDc池中获取或设置服务器分配给客户端ViewID的最小数。当玩家使用新的数字连接并被刷新时，ViewID池被分配给每个玩家。服务器和客户端应该同步这个值。在服务器上设置的更高，将会发送比它们真正需要的更多视ID数到客户端。在客户端上设置更高，意味着它们需要更多视ID。例如当池需要的ID数，服务器中并不包含足够的数量，则会在一行中使用两次。默认值为100。如果一个游戏通过网络实例化大量新的物体，例如每秒超过100个的网络实例，那么这个值需要被设置的更高。
function Awake () {
// 使用更大的视ID池来分配
Network.minimumAllocatableViewIDs = 500;
}
◆ static var natFacilitatorIP:string 
描述：NAT穿透辅助的IP地址。通常这与服务器相同。
function ResetIP() {
Network.natFacilitatorIP = "127.0.0.1";
Network.natFacilitatorPort = 10001;
}
static var natFacilitatorPort:int 
描述：NAT穿透辅助的端口。
function ResetIP() {
Network.natFacilitatorIP = "127.0.0.1";
Network.natFacilitatorPort = 10001;
}
◆ static var peerType:NetworkPeerType
描述：端类型状态。例如，断开连接，连接，服务器或客户端。
function OnGUI() {
if (Network.peerType == NetworkPeerType.Disconnected)
GUILayout.Label("Not Connected");
else if (Network.peerType == NetworkPeerType.Connecting)
GUILayout.Label("Connecting");
else
GUILayout.Label("Network started");
}
◆ static var player:NetworkPlayer 
描述：获取本地NetworkPlayer实例。
◆ static var ProxyIP:string
描述：代理服务器的IP地址。
 
function Awake(){
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
}
◆ static var proxyPassword:string
描述：设置代理服务器密码。可以制作你自己的代理服务器。在这种情况下，你也许想用密码保护它。然后Unity玩家必须正确的设置这个值。
function Awake(){
//设置自定义代理服务器地址和密码
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
Network.proxyPassword = "secret";
}
◆ static var proxyPort:int  描述：代理服务器的端口。
function Awake(){
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
}
◆ static var sendRate:float  描述：用于所有网络视的默认网络更新发送速率。
function Awake () {
//增加默认的发送速率
Network.sendRate = 25;
}
◆ static var sendRate:float
描述：获取当前网络时间（秒）。这个可以用来比较NetworkMessageInfo中返回的时间。这个实例脚本需要附加到一个带有网络视的物体上，并使网络视监视这个脚本。它管理时间，发送这个物体的同步X位置消息。
var something : float;
var transitTime: double;
function OnSerializeNetworkView (stream : BitStream, info : NetworkMessageInfo) {
var horizontalInput : float = 0.0;
if (stream.isWriting) {//发送
horizontalInput = transform.position.x;
stream.Serialize (horizontalInput);
}
 else {//接收
transitTime = Network.time - info.timestamp;
stream.Serialize (horizontalInput);
something = horizontalInput;
}
}
function OnGUI() {
GUILayout.Label("Last transmission time: "+ transitTime);
}
◆ static var useNat:bool
 
描述：当连接（客户端）或接收连接（服务器）时，我们应该使用NAT穿透吗？如果这个在在服务器上设置，只有具有NAT穿透的客户端才能连接到它。但是如果服务器有一个NAT地址，这个需要打开以便连接。有些路由器不知道如何做NAT穿透。因此对于这些玩家唯一的方法就是修改路由器以便打开合适的转发端口（游戏端口）。参考Network.TestConnection和Network.TestConnectionNAT获取如何自动检测端用户的方法。
function OnGUI() {
if (GUILayout.Button ("Start Server"))
{
//如果没有共有IP地址，使用NAT穿透
Network.useNat = !Network.HavePublicAddress();
Network.InitializeServer(32, 25002);
MasterServer.RegisterHost("MyUniqueGameType", "JohnDoes game", "l33t game for all");
}
}
◆ static var useProxy:bool
描述：标示是否需要代理服务器支持，在这种情况下流量通过代理服务器被延迟。代理伺服器是一种与服务器和客户端连接性问题的解决方案。当机器有一个非NAT穿透能力的路由器，其连接的选择非常优先。一个游戏不能没有外部连接（只有客户端在本地网络中）。通过使用代理服务器，该机器可以具有完全的连接性，但是额外的代价是所有的流量都会被延迟。一个没有NAT穿透能力的客户端通过代理能够连接到任何服务器，只要代理服务器正确的设置。官方并不提供代理服务器为公众使用。所以你需要自己建立代理服务器。当然，用共有IP地址设置代理服务器并保证有大量可用带宽是明智的。当作为客户端运行时，只要启用Network .useProxy就可以。想往常昂使用Network . Connect连接到服务器。所有通过代理服务器的流量将被延迟。服务器的外部IP和内部IP还像往常一样工作。这样如果它们位于同一网络中，客户端可以直接连接到它而不需要代理。作为一个服务器运行时，OnServerInitialized(NetworkPlayer)返回一个NetworkPlayer结果表明游戏服务器中转的IP端口，代理服务器分配给游戏服务器的端口是什么。这个是其他客户端可以连接到的IP端口。当连接到服务器时，客户端不会将这个服务器与其他服务器区别对待。严格的说，它们不需要知道这个服务器得到代理服务器的帮助。当使用主服务器时，你不能只依赖于它在使用代理服务器时为服务器注册的IP端口。服务器使用的代理服务器的IP地址和端口，可以防止在数据域的注释中来发送给主服务器。从主服务器接收主机信息的客户端可以去除注释域并查看它是否能够为那个主机使用另一个可选的IP端口。
重要：你不应该同时为连接到它的服务器和客户端启用代理支持，会发生意想不到的事情。
var imaserver: boolean;
var serverIP: String;
var serverPort: int;
var serverUsesNAT: boolean;
function Awake(){
//设置自定义代理服务器地址
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
if (imaserver)
StartServerWithProxy();
else
ConnectToServerWithProxy();
}
function StartServerWithProxy(){
Network.useProxy = true;
Network.InitializeServer(2,25000);
}
function OnServerInitialized(player: NetworkPlayer){
if (Network.useProxy)
Debug.Log ("Successfully started server with proxy support. We are connectable through "+ player.ipAddress + ":" + player.port);
}
function OnFailedToConnect(msg: NetworkConnectionError){
if (Network.useProxy && imaserver){
Debug.LogError("Failed to connect to proxy server: " + msg);
}
}
function ConnectToServerWithProxy(){
Network.useProxy = true;
Network.useNat = serverUsesNAT;
Network.Connect(serverIP, serverPort);
}
function OnConnectedToServer(){
Debug.Log("Connected successfully to server");
}
类方法
◆ static function AllocateViewID():NetworkViewID
描述：查询下一个可用的网络视ID数并分配它（保留）。这个数字又可以被赋予一个实例化物体的网络视。注意，为了使其可正常工作，必须有一个NetworkView附加到这个物体，这个物体必须有这个脚本并必须使这个脚本作为它的观察属性。必须有一个Cube预设，带有一个NetworkView它监视某些东西（例如该Cube的Transform）。脚本中的cubePrefab变量必须设置为立方体预设。使用智能的AllocateViewID是最简单的方法。如果有超过一个NetworkView附加在初始化的Cube上着将变得更复杂。
var cubePrefab : Transform;
function OnGUI (){
if (GUILayout.Button("SpawnBox")){
var viewID = Network.AllocateViewID();
networkView.RPC("SpawnBox", RPCMode.AllBuffered, viewID, transform.position);
}
}
@RPC
function SpawnBox (viewID : NetworkViewID, location : Vector3) {
//实例化本地的prefab
var clone : Transform;
clone = Instantiate(cubePrefab, location, Quaternion.identity);
var nView : NetworkView;
nView = clone.GetComponent(NetworkView);
nView.viewID = viewID;
}
◆ static function CloseConnection (target : NetworkPlayer, sendDisconnectionNotification : bool) : void 
描述：关闭与其他系统的连接。/target/定义连接到的那个系统将被关闭，如果我们是客户端，连接到服务器的连接将会关闭。如果我们是服务器目标玩家，将会被踢出。sednDisconnectionNotification启用或禁用通知将被发送到另一端。如果禁用连接被丢弃，如果没有断开连接通知被发送到远端，那么之后的连接将被丢弃。
function OnGUI() {
if (GUILayout.Button ("Disconnect from server")) {
if (Network.connections.length == 1) {
Debug.Log("Disconnecting: "+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
}
else if (Network.connections.length == 0)
Debug.Log("No one is connected");
else if (Network.connections.length > 1)
Debug.Log("Too many connections. Are we running a server?");
}
if (GUILayout.Button ("Disconnect first player")) {
if (Network.connections.length > 0) {
Debug.Log("Disconnecting: "+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
}
}
}
◆ static function Connect (IP:string, remotePort:int, password:string = ""):NetworkConnectionError
描述：连接到特定的主机（IP或域名）和服务器端口。参数是主机的IP地址，点IP地址或一个域名。remotePort，指定连接到远端机器的端口。password，它是一个可选的用于服务器的密码。这个密码必须设置为与服务器的Network.incomingPassword相同。
function ConnectToServer () {
Network.Connect("127.0.0.1", 25000);
}
◆ static function Connect(IPs:string[], remotePort:int, password:string = ""):NetworkConnectionError
描述：该函数与Network.Connect类似，但是可以接受一个IP地址数组。当从一个主服务器的主机信息返回多个内部IP地址时，IP数据结构可以被直接传入这个函数。它将实际的连接到相应ping的第一个IP（可连接）。
◆ static function Destroy (viewID : NetworkViewID) : void
描述：跨网络销毁与该视ID相关的物体。本地的于远端的都会被销毁。
var timer : float;
function Awake () {
timer = Time.time;
}
//通过网络销毁拥有该脚本的物体
//其必须具备NetworkView属性
function Update() {
if (Time.time - timer >
2)
{
Network.Destroy(GetComponent(NetworkView).viewID);
}
}
function Update() {
if (Time.time - timer > 2){
Network.Destroy(GetComponent(NetworkView).viewID);
}
}
◆ static function Destroy (gameObject : GameObject) : void
描述：跨网络销毁该物体。本地的与远端的都会被销毁。
var timer : float;
function Awake () {
timer = Time.time;
}//通过网络销毁拥有该脚本的物体
function Update() {
if (Time.time - timer > 2){
Network.Destroy(gameObject);
}
}
◆ static function DestroyPlayerObjects (playerID : NetworkPlayer) : void
描述：基于视ID销毁所有属于这个玩家的所有物体。这个只能在服务器上调用。例如，清理一个已断开的玩家留下的网络物体。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ static function Disconnect (timeout : int = 200) : void
描述：关闭所有开放的连接并关闭网络接口。timeout参数表示网络接口在未收到信号的情况下，多长时间会关闭。网络状态，入安全和密码，也会被重置。
function OnGUI() {
if (GUILayout.Button ("Disconnect")) {
Network.Disconnect();
MasterServer.UnregisterHost();
}
}
◆ static function GetAveragePing (player : NetworkPlayer) : int
描述：到给定player的最后平均ping时间，以毫秒计。如果没有发现玩家，返回-1。Ping会每隔几秒自动发出。
function OnGUI() {
var i: int;
GUILayout.Label("Player ping values");
for (i=0; i < Network.connections.length; i++) {
GUILayout.Label("Player " + Network.connections[i] + " - " + Network.GetAveragePing(Network.connections[i]) + " ms");
}
}、

◆ static function GetLastPing (player : NetworkPlayer) : int
描述：到给定player的最后平均ping时间，以毫秒计。
如果没有发现玩家，返回-1。Ping会每隔几秒自动发出。
function OnGUI() {
var i: int;
GUILayout.Label("Player ping values");
for (i=0; i < Network.connections.length; i++) {
GUILayout.Label("Player " + Network.connections[i] + " - " + Network.GetLastPing(Network.connections[i]) + " ms");
}
}
◆ static function HavePublicAddress () : bool
描述：检查该机器是否有一个公共IP地址。检查所有接口来获取Ipv4公共地址。如发现返回真。
function OnGUI() {
if (GUILayout.Button ("Start Server")){
// 如果没有公共IP地址，使用NAT穿透
Network.useNat = !Network.HavePublicAddress();
Network.InitializeServer(32, 25002);
MasterServer.RegisterHost("MyUniqueGameType", "JohnDoes game", "l33t game for all");
}
}
◆ static function InitializeSecurity () : void
描述：初始化安全层。你需要再Network.InitializeServer调用之后在服务器上调用这个函数。不要再客户端调用该函数你的在线游戏达到一定知名度时就有人试图作弊。你讲需要再游戏层和网络层处理这个。如果你希望使用它们，Unity可以通过提供安全连接处理网络层。
使用AES加密，阻止未授权读取并阻止重复攻击，添加CRC来检测数据篡改，使用随机的、加密的SYNCookies来组织未授权登录，使用RSA加密保护这个AES密钥
大多数游戏将使用安全连接。然后，它们会向每个数据包添加15自己并需要时间计算，所以你也许想限制使用此功能。
function Start (){
Network.InitializeSecurity();
Network.InitializeServer(32, 25000);
}
◆ static function InitializeServer (connections:int,listenPort:int) : NetworkConnectionError
描述：初始化安全层。connections是允许进入的连接或玩家的数量。listenPort是我们要监听的端口。
function LaunchServer () {
Network.incomingPassword = "HolyMoly";
Network.InitializeServer(32, 25000);
}
◆ static function Instantiate (prefab:Object, position:Vector3, rotation:Quaternion, group:int):Object
描述：网络实例化预设。给定的预设将在所有的客户端上初始化。同步被自动设置所以没有额外的工作需要做。位置、旋转和网络组数值作为给定的参数。这是一个RPC调用，因此
 
当Network.RemoveRPCs为这个组调用的使用，这个物体将被移除。注意在编辑器中必须设置playerPrefab，你能在Object.Instantiate物体参考中获取更多实例化信息。
//当成功连接到服务器上时
//立即实例化新连接的玩家角色
var playerPrefab : Transform;
function OnConnectedToServer (){
Network.Instantiate(playerPrefab, transform.position, transform.rotation, 0);
}
◆ static function RemoveRPCs (playerID : NetworkPlayer) : void
描述：移除所有属于这个玩家ID的RPC函数。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ static function RemoveRPCs (playerID : NetworkPlayer, group : int) : void
描述：移除所有属于这个玩家ID并给予给定组的所有RPC函数。
◆ static function RemoveRPCs (viewID : NetworkViewID) : void
描述：移除所有与这个视ID数相关的RPC函数调用。
◆ static function RemoveRPCsInGroup (group : int) : void
描述：移除所有属于给定组数值的RPC函数。
◆ static function SetLevelPrefix (prefix : int) : void
描述：设置关卡前缀，然后所有网络视ID都会使用该前缀。此处提供了一些保护，可以防止来自前一个关卡的旧的网络更新影响新的关卡。此处可以设置为任何数字并随着新关卡的加载而增加。这不会带来额外的网络负担，只会稍微减小网络视ID池。Network level loading有如何使用该函数的例子。
◆ static function SetReceivingEnabled (player : NetworkPlayer, group : int, enabled : bool) : void
描述：启用或禁用特定组中来自特定玩家的信息接收。在你不希望任何网络消息进入的时候可以使用这个函数，然后在你准备好的时候启用。例如，可用于停止网络消息，知道关卡被加载。
//停止接收来自所有玩家（客户端）的组0的信息
for (var player : NetworkPlayer in Network.connections)
Network.SetReceivingEnabled(player, 0, false);
◆ static function SetSendingEnabled (group : int, enabled : bool) : void
描述：启用或禁用特定网络组上的信息传输和RPC调用。当你知道你不发送任何有用的信息到其他客户端时，可以设置这个。例如在你完全你家在关卡之前。Network level loading中有例子。
static function SetSendingEnabled (player : NetworkPlayer, group : int, enabled : bool) : void
描述：基于目标玩家和网络组启用或禁用消息传说和RPC调用。当在客户端使用时，唯一可能的NetworkPlayer就是服务器。
◆ static function TestConnection (forceTest : bool = false) : ConnectionTesterStatus
描述：测试这个机器的网络连接。执行两种测试，这取决机器有公用IP还是只有一个私有IP。公用IP测试主要用于服务器，不需要测试具有公用地址的客户端。为了公用IP测试成功，必须开启一个服务器实例。一个测试服务器将尝试连接到本地服务器的IP地址和端口，因此它被显示在服务器中位可连接状态。如果不是，那么防火墙是最有可能阻断服务端口的。服务器实例需要运行以便测试服务器能连接到它。另一个试验检测NAT穿透能力。服务器和客户端都可以进行，无需任何事先设定。如果用于服务器NAT测试失败，那么不设置端口转发是一个坏主意。本地LAN网络之外的客户端将不能连接。如果测试失败，客户端就不能使用NAT连接到服务器，这些服务器将不会提供给用户作为主机。这个函数是异步的，并可能不会返回有效结果。因为这个测试需要一些时间来完成（1-2秒）。测试完成后，测试的结果只在函数被再次调用时返回。这样，频繁访问该函数是安全的。如果需要其他的测试，入网络连接已改变，那么forcTest参数应该为真。该函数返回一个ConnectionTesterStatus枚举。
//是否应该在主机列表上隐藏NAT主机？
private var filterNATHosts = false;
private var doneProbingPublicIP = false;
function OnGUI (){
//开始/轮询连接测试
//在标签上显示结果并按照结果做出相应的反应
natCapable = Network.TestConnection();
if (natCapable == -2)
GUILayout.Label("Problem determining NAT capabilities");
else if (natCapable == -1)
GUILayout.Label("Undetermined NAT capabilities");
else if (natCapable == 0){
GUILayout.Label("Cannot do NAT punchthrough, " +"filtering NAT enabled hosts for client connections, " +"impossible to run a server.");
filterNATHosts = true;
Network.useNat = false;
}
else if (natCapable == 1){
if (doneProbingPublicIP)
GUILayout.Label("Non-connectable public IP address (port "+ serverPort +" blocked), NAT unchthrough can circumvent the firewall.");
else
GUILayout.Label("NAT punchthrough capable. " +"Enabling NAT punchthrough functionality.");
//一旦服务器开始NAT功能被启用
//客户端是否开启这个基于主机是否需要
Network.useNat = true;
}
else if (natCapable == 2){
GUILayout.Label("Directly connectable public IP address.");
Network.useNat = false;
}
else if (natCapable == 3){
GUILayout.Label("Non-connectble public IP address (port " + serverPort +" blocked), running a 
server is impossible.");
Network.useNat = false;
if (!doneProbingPublicIP){
natCapable = Network.TestConnectionNAT();
doneProbingPublicIP = true;
}
}
else if (natCapable == 4){
GUILayout.Label("Public IP address but server not initialized, "+"it must be started to check server accessibility.");
Network.useNat = false;
}
if (GUILayout.Button ("Retest connection")){
Debug.Log("Redoing connection test");
doneProbingPublicIP = false;
natCapable = Network.TestConnection(true);
}
}
◆ static function TestConnectionNAT () : ConnectionTesterStatus
描述：测试NAT穿透的连接性。这个就像Network.TestConnection，只不过NAT穿透是强制的，即使该机器有一个公用地址。请参考Network.TestConnection。
Object
类
Unity所涉及的所有物体的基类。任何从Object继承的公有变量将作为一个目标显示在监视面板中，允许你从GUI中设置。
变量
◆ var hideFlags : HideFlags 描述：该物体是否被隐藏，保存在场景中或被用户修改。
◆ var name : string
描述：对象的名称。组件与游戏物体和所有附加的组件共享相同名称。
//改变物体的名称为Hello
name = "Hello";
函数
◆ function GetInstanceID () : int 描述：返回该物体的实例id。一个物体的实例ID总是唯一。
描述：返回该物体的实例id。
一个物体的实例id总是唯一的。
print(GetInstanceID());
类方法
◆ static function Destroy (obj : Object, t : float = 0.0F) : void
描述：移除一个游戏物体，组件或资源。物体obj将被小火或者t秒后被销毁。如果obj是一个Component它将被从GameObject中移除。如果obj是一个GameObject它将销毁这个GameObject，以及它的组件和所子对象。实际的销毁总是推迟到下个Update来临时，但总在渲染前完成。
//销毁这个游戏物体
Destroy (gameObject);
//从物体上移除该脚本
Destroy (this);
//从游戏物体上移除刚体组件
Destroy (rigidbody);
//加载该游戏物体后5秒删除
Destroy (gameObject, 5);
//当玩家按下Ctrl时移除名为FoooScript的脚本
function Update () {
if (Input.GetButton ("Fire1") && GetComponent (FooScript))
Destroy (GetComponent (FooScript));
}
◆ static function DestroyImmediate (obj : Object, allowDestroyingAssets : bool = false) : void

描述：立即销毁物体。强烈建议使用Destroy代替它。该函数应该只在编写编辑器代码时使用，因为延迟的销毁将不会再编辑器模式调用。游戏代码中建议使用Destroy。Destroy总是延迟的（但是在同一帧执行）。小心使用该函数，因为它能永久的销毁资源。
◆ static function DontDestroyOnLoad (target : Object) : void
描述：加载新场景时确保物体target不被自动销毁。当加载一个新的关卡时，场景中的所有物体都会被销毁，然后心关卡中的物体将被加载。为了在关卡加载的时候保持物体在上面调用DontDestroyOnLoad。如果物体是一个组件或游戏物体，那么它的整个变换层次将不会被销毁。
//保证该游戏物体及其变化子物体在载入新场景时不会被销毁。
function Awake () {
DontDestroyOnLoad (this);
}
◆ static function FindObjectOfType (type : Type) : Object
描述：返回第一个类型为Type的已激活加载的物体。参见Object.FindObjectsOfType 。
◆ static function FindObjectsOfType (type : Type) : Object[]
描述：返回所有类型为Type的已激活加载的物体。
参见Object.FindObjectsOfType 。
它将返回任何资源（网格、纹理、预设等）或已激活加载的物体。
//当点击该物体，它将禁用场景中所有铰链中的弹簧。
function onm ouseDown () {
hinges = FindObjectsOfType (HingeJoint);
for (var hinge : HingeJoint in hinges) {
hinge.useSpring = false;
}
}
c#版
public class Something : MonoBehaviour{
void onm ouseDown(){
HingeJoint[] hinges = FindObjectsOfType<HingeJoint>();
for (HingeJoint hinge in hinges) {
hinge.useSpring = false;
}
}
}
◆ static function Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object
描述：克隆original物体并返回该克隆。防御position兵设置旋转为rotation，然后返回该克隆。本职上与cmd-d相同，并移动到给定位置。如果一个游戏物体、组件或脚本实例被传入，Instantiate将克隆整个游戏物体层次，所有的子对象也被克隆。所有游戏物体被激活。参加：预设实例化的深入讨论。
//实例化预设的10个拷贝，间隔为2单位。
var prefab : Transform;
for (var i=0;i<10;i++) {
Instantiate (prefab, Vector3(i * 2.0, 0, 0), Quaternion.identity);
}
Instantiate更多常用于实例化投射物、AI敌人，粒子爆炸或b破损的物体。
//实例化一个刚体，然后设置速度。
var projectile : Rigidbody;
function Update () {
//按下ctrl时，发射一个物体
if (Input.GetButtonDown("Fire1")) {
//以该变化位置与旋转实例化投射物
var clone : Rigidbody;
clone = Instantiate(projectile, transform.position, transform.rotation);
//沿当前物体Z轴，给克隆体一个初始速度
clone.velocity = transform.TransformDirection (Vector3.forward * 10);
}
}
实例化也能直接克隆脚本实例。整个游戏物体层级将被克隆，并且克隆脚本的实例将被返回。
//初始化一个附加了Missile脚本的预设
var projectile : Missile;
function Update () {
//按下ctrl时，发射一个物体
if (Input.GetButtonDown("Fire1")) {
//以该变化位置与传转实例化投射物
var clone : Missile;
clone = Instantiate(projectile, transform.position, transform.rotation);
//设置火箭超市销毁为5秒
clone.timeoutDestructor = 5;
}
}
克隆一个物体之后可以使用GetComponet来设置附加到克隆物体上的特定组件的属性。
◆ static function Instantiate (original : Object) : Object
描述：克隆original物体并返回该克隆。这个函数保留克隆物体的位置与赋值命令相同（cmd-d）。
//当任何刚体进入这个触发器时实例化预设。
//它保留预设的原始位置与旋转。
var prefab : Transform;
function OnTriggerEnter () {
Instantiate (prefab);
}
◆ static operator != (x : Object, y : Object) : bool 
描述：比较两个物体是否不同。
var target : Transform;
function Update (){
//如果target不同于我们的变换。
if (target != transform){
print("Another object");
}
}
◆ static operator == (x : Object, y : Object) : bool 
描述：比较两个物体是否相同。
var target : Collider;
function OnTriggerEnter (trigger : Collider){
if (trigger == target)
print("We hit the target trigger");
}
var target : Transform;
function Update (){
//该物体已被销毁。
if (target == null)
return;
}
◆ static implicit function bool (exists : Object) : bool 
描述：这个物体是否存在？
if（rigidbody）
等同于
if（rigidbody != null）
AnimationClip
类，继承自Object。
存贮基于动画的关键帧。
AnimationClip被Animation使用来播放动画。
变量
◆ var frameRate : float
描述：关键帧被残阳的帧率。这个与用来制作动画/模型的动画程序相同。
//打印动画剪辑的帧率到控制台。
print(animation["walk"].clip.frameRate);
◆ var length : float 
描述：动画播放的描述。
animation.Play(animation.clip);
//等待动画完成。
yield WaitForSeconds (animation.clip.length);
◆ var wrapMode : WrapMode 
描述：在动画状态中设定默认的卷模式。
构造函数
◆ static function AnimationClip () : AnimationClip 
描述：创建一个新的动画剪辑。
函数
◆ function AddEvent (evt : AnimationEvent) : void
描述：创建一个新的动画剪辑。这将添加这个时间直到退出播放模式或玩家退出。如果你想从编辑器添加一个固定的剪辑到AnimationEvent，使用UnityEditorAnimationUtility.SetAnimationEvents。
◆ function ClearCurves () : void 
描述：从剪辑中清理所有曲线。
◆ function SetCurve (relativePath : string, type : Type, propertyName : string, curve : AnimationCurve) : void
参数
relativePath  应用这个曲线的游戏物体的路径。relativePath被格式化为一个路径名。入：“root/spine/leftArm”如果relativePath为空，表示该动画剪辑所附加的游戏物体。
type  被进行动画处理的组件的类类型。
propertyName 被动画处理的属性的名称或路径。
curve 动画曲线。
描述：给动画指定一个特定的曲线属性。如果曲线为null该曲线将被移除。如果曲线为null该曲线将被移除。如果曲线属性已经存在，则会被替换。通常的名称是：“localPostion.x”，“localPostion.y”，“localPostion.z”，“localRotation.x”，“localRotation.y”，“localRotation.z”，“localRotation.w”，“localScale.x”，“localScale.y”，“localScale.z”。出于性能考虑Transform的位置、旋转和缩放只能被所谓一个动画属性。
 
//对x坐标的位置进行动画处理
function Start (){
//创建曲线
var curve = AnimationCurve.Linear(0, 1, 2, 3);
//用曲线创建剪辑
var clip = new AnimationClip();
clip.SetCurve("", Transform, "localPosition.x", curve);
//添加并播放剪辑
animation.AddClip(clip, "test");
animation.Play("test");
}
@script RequireComponent(Animation)
Material属性可以使用shader到处的名称制作动画属性。通常的属性名称是：“_MainTex”，“_BumpMap”，“_LightMap”，“_Color”，“_SpecColor”，“_Emmission”。
Float属性“PropertyName”
Vector4属性“PropertyName.x”“PropertyName.x” “PropertyName.x” “PropertyName.x” Color属性“PropertyName.r”“PropertyName.g”“PropertyName.b”“PropertyName.a”
UV旋转属性“PropertyName.rotation”；UB便宜和缩放“PropertyName.offset.x”“PropertyName.offset.y”“PropertyName.scale.x”“PropertyName.scale.y”
对于在同一个Renderer上的多个索引材质，你可以像这样加前缀“[1]._MainTex.offset.y”。
//对alpha值和主要材质地平线补偿进行动画处理
function Start () {
var clip = new AnimationClip ();
clip.SetCurve ("", typeof(Material), "_Color.a",AnimationCurve (Keyframe(0, 0, 0, 0), Keyframe(1, 1, 0, 0)));
clip.SetCurve ("", typeof(Material), "_MainTex.offset.x",AnimationCurve.Linear(0, 1, 2, 3));
animation.AddClip (clip, clip.name);
animation.Play(clip.name);
}
@script RequireComponent(Animation)
继承的成员
继承的变量 
name 对象名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectsOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AssetBundle

类，继承自Object。AssetBundles让你通过WWW类流式加载额外的资源并在运行时实例化它们。AssetBundles通过BuildPipeline.BuildAssetBundle创建。参见：WWW.assetBundle ，Loading Resources at Runtime ，BuildPipeline.BuildPlayer
function Start () {
var www = new WWW ("http://myserver/myBundle.unity3d");
yield www;
//获取指定的主资源并实例化
Instantiate(www.assetBundle.mainAsset);
}
变量
◆ var mainAsset : Object
描述：竹资源在构建资源boundle时指定（只读）。该功能可以方便的找到bundle内的主资源。例如，你也许想将预设一个角色并包括所有纹理、材质、网格和动画文件。但是完全操纵角色的预设应该是你的mainAsset并且可以被容易的访问。
function Start () {
var www = new WWW ("http://myserver/myBundle.unity3d");
yield www;
//获取指定的主资源并实例化
Instantiate(www.assetBundle.mainAsset);
}
函数
◆ function Contains (name : string) : bool 
描述：如果AssetBundle的名称中包含特定的对象则进行检索。如果包含则返回真。
◆ function Load (name : string) : Object 
描述：从bundle中加载名为name的物体。
◆ function Load (name : string, type : Type) : Object
描述：从bundle中加载名为name的type类物体。
◆ function LoadAll (type : Type) : Object[ ]
描述：加载所有包含在资源bundle中且继承自type的物体。
◆ function LoadAll () : Object[ ]
描述：加载包含在资源bundle中的所有物体。
◆ function Unload (unloadAllLoadedObjects : bool) : void
描述：写在bundle中的所有资源。Unload释放bundle中所有序列化数据。当unloadAllLoaderObjects为假，bundle内的序列化数据将被写在，但是任何从这个bundle中实例化的物体都将完好。当然，你不能从这个bundle中加载更多物体。当unloadAllLoaderObjects为真，所有从该bundle中加载的物体也将被销毁。如果
场景中有游戏物体引用该资源，那么引用也会丢失。
继承的成员
继承的变量 
name 对象名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectsOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AudioClip
类，继承自Object。音频数据的容器。一个AudioClip以压缩或未压缩的格式存储音频文件。AudioClips被AudioSources参考或引用来播放声音。参见组件参考的AudioClip.component。
变量
◆ var isReadyToPlay : bool
描述：有没流式音频剪辑准备播放？（只读）如果AudioClip是从网站上下载的，此变量用来判断下载到的数据是否足够不间断的播放。对于不是来自web的流的AudioClips，该值总是真。
function Start (){
www=new WWW(url);
audio.clip=www.audioClip;
}
function Update (){
if(!audio.isPlaying && audio.clip.isReadyToPlay)
audio.Play();
}
◆ var length : float
 描述：音频剪辑的长度，以秒计（只读）。
audio.Play();
//等待音频播放完成
yield.WaitForSeconds(audio.clip.length);
继承的成员
继承的变量