1.總覽。

多人遊戲基本結構：Clent/Server，分為Authoritative Server和Non-Authoritative Server兩種，前者客戶端發送消息，服務器端反饋結果，好處是有效防止客戶端作弊，並統一不同客戶端之間的物理表現和互動狀況，缺陷是存在網絡延時，很有可能每發出一個命令要過一段時間才能接收到反饋。解決方法是client-side prediction客戶端預測，客戶端預測服務器的反饋，但不能做出關鍵性事件的預測，比如某個怪物的死亡。關於client-side prediction技術可以到網上查閱相關資料，這裡不贅述。

Non-Authoritative Sever有客戶端自己處理用戶輸入和對像邏輯，不需要要client-side prediction技術。這種情況服務器端要處理的數據量相對比較小。

網絡通信的方法：Remote Procedure Calls（RPC，遠程進程調用）和State Synchronization（狀態同步）。

NAT punchthrough：網絡連接可能是複雜的，比如中間要通過一個帶公共IP的NAT路由器，怎樣把NAT的內部私有IP和外部計算機連接？可以利用一個叫做Facilitator的服務器和private IP接觸並獲知其所用的IP地址和端口號。另外，內部防火牆玩家可以更改設置，外部防火牆也可以使用這種NAT punchthrough技術穿透。

Minimizing Network Bandwidth：最小化網絡開支，只傳輸絕對重要的數據，比如客戶端完全可以獨立處理角色模型而不需要服務器發送數據來同步。另外記住，你可以使用一個自帶關卡標示的RPC調用來讓所有客戶端同時裝載這個關卡。

2.基礎函數。

建立服務器：Network.InitializeServer().

函數原型：static function InitializeServer (connections : int, listenPort : int, useNat : boolean) : NetworkConnectionError
其中connections是允許連接數，useNat是否允許NAT punchthrough連接。

一個初始化例子：

public class example : MonoBehaviour {
    void LaunchServer() {
        Network.incomingPassword = "HolyMoly";
        bool useNat = !Network.HavePublicAddress();
        Network.InitializeServer(32, 25000, useNat);
    }
}

其中Network.HavePublicAddress()查看是否擁有IPV4公共IP.這是簡單那的測試方法，另外一個更值得研究的方法是Network.TestConnction().

建立連接到服務器：Network.Connect().
熟悉一下Network類總是有好處。

使用Network View組件進行通信，這一點很重要，它讓你可以使用RPC調用和State Synchronization.每個組件有一個唯一的NetworkViewID，每個數據包都對應發送到一個由NetworkViewID指定的Network View所鏈接的對象上。當使用Network.Instantiate()創建Network對像時，會自動分配Network View，不用開發者操心。當然你也通過RPG調用在每個客戶機上實例化一個Network View對象，然後使用Network.AllocateViewID()函數手動分配NetworkViewID。

當你向一個對像添加NetworkView組件，並指定狀態同步，需要選擇NetworkView所監視的組件，這可以是該對象的transform,animation,script,或是rigidbody.如果不使用狀態同步而只是用PRC調用，則state Synchronization設為off即可，只要有一個Network View（不論是否開啟state Synchronization）你都可以使用RPC.

設置state Synchronization為Reliable Delta Compression，為可靠傳輸，數據按序發送接收。

同步監視對象是script時，需要使用OnSerializeNetworkView顯式化序列數據：

function OnSerializeNetworkView (stream : BitStream, info : NetworkMessageInfo) {
     var horizontalInput : float = Input.GetAxis ("Horizontal");
     stream.Serialize (horizontalInput);
}

此代碼當你本地更新或收到stream的更改時總是寫horizontalInput的值。有時候你在本地更新和收到更新時，需要做不同的事情，此時敲入如下代碼：

function OnSerializeNetworkView (stream : BitStream, info : NetworkMessageInfo) {
     var horizontalInput : float = 0.0;
     if (stream.isWriting) {
          // Sending
          horizontalInput = Input.GetAxis ("Horizontal");
          stream.Serialize (horizontalInput);
     } else {
          // Receiving
          stream.Serialize (horizontalInput);
          // ... do something meaningful with the received variable
     }
}

在C#Script中Serialize()的參數是ref類型，在參數horizontalInput的前面加上引用符號ref即可。

OnSerializeNetworkView的調用頻率在Network Manager的SendRate裡設置，默認是15/s.

3.RPC和狀態同步。

如果要調用RPC，所調用函數必須帶有@RPC屬性，如下：

var playerBullet : GameObject;
function Update () {
     if (Input.GetButtonDown ("Fire1")) {
          networkView.RPC ("PlayerFire", RPCMode.All);
     }
}
@RPC
function PlayerFire () {
     Instantiate (playerBullet, playerBullet.transform.position, playerBullet.transform.rotation);
}

RPC調用是可靠的有序的通信。

以下是使用Network.AllocateViewID()手動分配ViewID的實例，其中使用RPC調用實例化cubePrefab的遠程調用，ViewID作為該遠程調用的參數傳遞：

public class example : MonoBehaviour {
    public Transform cubePrefab;
    void OnGUI() {
        if (GUILayout.Button("SpawnBox")) {
            NetworkViewID viewID = Network.AllocateViewID();
            networkView.RPC("SpawnBox", RPCMode.AllBuffered, viewID, transform.position);
        }
    }
[RPC]
    void SpawnBox(NetworkViewID viewID, Vector3 location) {
        Transform clone;
        clone = Instantiate(cubePrefab, location, Quaternion.identity) as Transform as Transform;
        NetworkView nView;
        nView = clone.GetComponent();
        nView.viewID = viewID;
    }
}

那麼，RPC（Remote Procedure Call）的規則和定義到底是什麼？
RPC是某對象的腳本組件中包含的聲明為[RPC]的（JS為@RPC）函數，這個對象必須包含一個Network View組件，並且監視對象是該腳本組件。這樣，其他腳本就可以從遠程通過這個對象調用該RPC.

RPC函數的參數個數任意，但是為了減少網絡消耗提高網絡性能，個數最好優化到最少。
RPC調用（Network.RPC()）的參數還應加上RPC函數名稱（string）和RPCMode（接收對象，包括All,Allbuffered,Others,Server等等），接下來才是RPC函數的參數。

RPC調用可以用來在所有客戶端上執行某個事件，或者在兩個特定的部分之間傳遞事件訊息，你也可以創造性的發揮。比如，一個遊戲服務器只有當4個客戶端連接上才開始遊戲，當第四個客戶端連上以後，服務器可以向所有客戶端同時發送RPC從而開始遊戲。一個客戶端可以向所有客戶端發送RPC告知他拿到了某個物品。服務器可以在客戶端連接時發送RPC讓客戶端執行初始化，比如給它一個player number，出生地點，隊伍顏色，等等。客戶端可以發送RPC定制它的啟動設置，比如顏色偏好，已購物品等等。

NetworkMessageInfo結構體中包含timestamp時間戳和sender發送者兩個數據成員。在RPC函數的參數列表中加入一項NetworkMessageInfo，可自動獲取該訊息，而在RPC調用中不用顯示列出該參數。

@RPC
function PrintText (text : String, info : NetworkMessageInfo)
{
    Debug.Log(text + " from " + info.sender);
}

RPC Buffer：使用buffer模式可以讓你之前發送的RPC被新連接的客戶端接受。比如向當前玩家發送裝載某個關卡的RPC，過段時間新玩家連接到遊戲，需要裝載當前其他玩家正在進行的關卡。這時新連接的玩家不會錯過裝載該關卡的RPC，因為它被緩存了起來。另外還可以刷新buffer，比如開始新的關卡後新連接的玩家不如從之前的關卡開始一個一個裝載。

State Synchronization的一些細節：
如前所述，狀態同步的對象只能是以下四種類型之一：transform,animation,rigidbody和monobehaviour（也就是script），其中script的需要用onSerializeNetworkView()函數顯示指定監視的變量數據。BitStream.Serialize()可接受的參數可以是bool,char,short,int,float,Quaternion,Vector3和NetworkPlayer.詳情參考官方script手冊中的
BitStream.Serialize().

關於狀態同步兩種方式的選擇：

Reliable Delta Compressed：在屬性級別自動對比當前狀態（比如position和rotation是transform的兩個不同屬性，如果其中之一發生變動，只發送該變動數據），如果無變動則不發送。Unity會利用ACK和NACK來保證UDP包的發送可靠性，丟失的包會等待重傳（是的，Unity傳輸層使用的是UDP協議）。缺陷是網絡不好會導致明顯延時。

Unreliable：不保證可靠性，因此它不是僅僅發送更改的部分數據保留未更改的部分，而是每次更新都發送所有的數據，不管某部分改動還是未改動。這種模式用於遊戲每幀都在變動的情況，比如賽車遊戲。

綜上，遊戲變化頻繁且迅速，而丟一兩個包無關緊要，這時候選擇Unreliable，如果不是頻繁變化，為了節省帶寬，建議選擇Reliable Delta Compressed.

4.Network.Instantiate.

此方法在每個客戶機上實例化一個prefab，並且是buffered型RPC，這樣當一個新的客戶機連接到服務器後，會自動實例化一個prefab.
函數原型：static function Instantiate (prefab : Object, position : Vector3, rotation : Quaternion, group : int) : Object
其中group（組）可以用來設置消息的過濾，如果不需要這個功能則設置為0.

調用此RPC的例子：

public class example : MonoBehaviour {
    public Transform playerPrefab;
    void OnConnectedToServer() {
        Network.Instantiate(playerPrefab, transform.position, transform.rotation, 0);
    }
}

可以用Network.RemoveRPCs()函數來去掉buffer區的Network.Instantiate()函數。你可以去掉特定組的RPC（如果Instantiate指定了組的話），也可以去掉第一個NetworkView ID的RPC，因為當實例化發生的時候RPC消息是與第一個Network View連接的。
函數原型：static function RemoveRPCs (playerID : NetworkPlayer, group : int) : void

從RPC buffer裡去掉Instantiation的例子：

public class example : MonoBehaviour {
    void OnNetworkInstantiate(NetworkMessageInfo info) {
        Debug.Log(networkView.viewID + " spawned");
        if (Network.isServer) {
            Network.RemoveRPCs(networkView.viewID);
            Network.Destroy(gameObject);
        }
    }
}

組的作用：讓特定（組）的客戶端只能收到特定的消息。比如，如果兩個玩家分隔在物理上互不影響的兩個區域，但是可以進行聊天。這時候他們之間遊戲狀態數據的交換就很有限，但是要保留聊天功能。物理上的遊戲對象的實例化就應該和提供聊天功能的對象的實例化分開，設定為不同的組。

5.Master Server：

在Master Server中可以顯示所有的服務器，這樣客戶端可以在這裡選擇適合的服務器，另外Master Server隱藏端口和IP，解決連接問題，比如防火牆和NAT的punchthrough.
每個遊戲需要向Master Server提交一個Game Type（注意避免和別的遊戲重複），當客戶端選擇好Game Type，Master Server會提供一個包含遊戲人數、可能設置密碼的運行中遊戲列表。
這兩個方法分別是：MasterServer.RegisterHost()（Host端）和MasterServer.RequestHostList()（客戶端）.
函數原型：static function RegisterHost (gameTypeName : String, gameName : String, comment : String = "") : void

RegisterHost的例子：

public class example : MonoBehaviour {
    void OnGUI() {
        if (GUILayout.Button("Start Server")) {
            bool useNat = !Network.HavePublicAddress();
            Network.InitializeServer(32, 25002, useNat);
            MasterServer.RegisterHost("MyUniqueGameType", "JohnDoes game", "l33t game for all");
        }
    }
}

函數原型：static function RequestHostList (gameTypeName : String) : void

RequestHostList的例子：

public class example : MonoBehaviour
{
    void Awake()
    {
        MasterServer.ClearHostList();
        MasterServer.RequestHostList("LarusTest");
    }
    void Update()
    {
        if (MasterServer.PollHostList().Length != 0)
        {
            HostData[] hostData = MasterServer.PollHostList();
            int i = 0;
            while (i < hostData.Length)
            {
                Debug.Log("Game name: " + hostData[i].gameName);
                i++;
            }
            MasterServer.ClearHostList();
        }
    }
}

上面的代碼使用ClearHostList()清除掉由PollHostList()獲取的HostList，然後Request新的HostList，把新的HostList通過PollHostList()存儲在HostData數組中，其中HostData是保存HostList中數據的數據結構，其成員變量如下圖：

HostData結構的數據成員列表

以下是連接MasterServer的進程實例：

function Awake() {
     MasterServer.RequestHostList("MadBubbleSmashGame");
}
function OnGUI() {
     var data : HostData[] = MasterServer.PollHostList();
     // Go through all the hosts in the host list
     for (var element in data)
     {
          GUILayout.BeginHorizontal();
          var name = element.gameName + " " + element.connectedPlayers + " / " + element.playerLimit;
          GUILayout.Label(name);
          GUILayout.Space(5);
          var hostInfo;
          hostInfo = "[";
          for (var host in element.ip)
               hostInfo = hostInfo + host + ":" + element.port + " ";
          hostInfo = hostInfo + "]";
          GUILayout.Label(hostInfo);
          GUILayout.Space(5);
          GUILayout.Label(element.comment);
          GUILayout.Space(5);
          GUILayout.FlexibleSpace();
          if (GUILayout.Button("Connect"))
          {
               // Connect to HostData struct, internally the correct method is used (GUID when using NAT).
               Network.Connect(element);
          }
          GUILayout.EndHorizontal();
     }
}

可以繼續向其中添加ping值和地理位置等訊息，這裡不再贅述。

關於NAT punchthrough，如果某個客戶端設備在NAT中且沒有NAT punchthrough技術，可以依賴Facilitator，如果做服務器的客戶端和其他客戶端都能連接到這個Facilitator，那麼服務器和客戶端就能進行通信，前提是Facilitator使用外部IP和端口。Master Server可以提供這個外部IP和端口，所以一般Master Sever同時擔當Faciliator的角色，此時默認兩者擁有共同的IP地址。使用MasterServer.ipAddress,MasterServer.port,Network.natFacilitatorIP,Network.natFacilitatorPort修改IP地址和端口號。

Unity提供默認的Master Server服務，但是你也可以自己組建一個Mater Server.方法詳見
官網。

6.Debug.

在Network Manager中可以設置debug級別為看到所有進出的交通訊息。

NetworkManager設置

在Inspector和Hierarchy裡觀察遊戲對象的建立以及ViewID等。
Unity可以雙開，你可以讓它運行不同的project.在windows環境只需要再打開一個Unity並打開一個新的project即可。在Mac OS X環境需要在終端輸入以下命令：

/Applications/Unity/Unity.app/Contents/MacOS/Unity -projectPath "/Users/MyUser/MyProjectFolder/"
/Applications/Unity/Unity.app/Contents/MacOS/Unity -projectPath "/Users/MyUser/MyOtherProjectFolder/"

在對Network進行debug的時候，要選中Run In Background選項，因為當你運行兩個實例並在其中一個上debug，另一個會失去焦點，你要確保在後台它也能運行。在Project Setting>Player裡面設置，也可以直接使用Apllication.runInBackground = true語句打開該功能。

在Player設置面板中選中Run In Background

基礎部分學習到此結束，下篇文章學習多人遊戲中的關卡裝載，帶寬優化以及連接測試等。

這篇筆記學習三個問題：多人遊戲的level loading，連接測試以及帶寬優化。

一.關卡裝載。

必須瞭解的函數：

1.RequireComponent()

//JavaScript實例
// Mark the PlayerScript as requiring a rigidbody in the game object.
//指定此script綁定的對象必須包含rigidbody組件，沒有則自動添加
@script RequireComponent(Rigidbody)
function FixedUpdate() {
    rigidbody.AddForce(Vector3.up);
}

//C#實例
[RequireComponent (typeof (Rigidbody))]
public class PlayerScript : MonoBehaviour {
    void FixedUpdate()  {
        rigidbody.AddForce(Vector3.up);
    }
}

2.DontDestroyOnLoad()

當裝載一個新的level，舊場景的對象會被銷毀，調用此函數可以在裝載新level時保留某個對象，如果這個對象是GameObject或者Component那麼它的整個transform層都將被保留。

//C#代碼
public class example : MonoBehaviour {
    void Awake() {
        DontDestroyOnLoad(transform.gameObject);
    }
}

3.Network.peerType

Network類的一個數據成員，返回值是NetworkPeerType的枚舉類型，其值有NetworkPeerType.Disconnected//無客戶端連接且沒有初始化服務器
NetworkPeerType.Connecting//正在連接服務器
NetworkPeerType.Server//正在做為服務器運行
NetworkPeerType.Client//正在作為客戶端運行

4.Network.RemoveRPCsInGroup()

清除某個組的RPC buffer的所有RPC調用。

5.Network.SetSendingEnabled (group : int, enabled : boolean)

開啟或關閉某個組的Network View的消息或RPC發送。比如要開始裝載某個新level，與舊level相關的消息或RPC就可以停止發送。

6.Network.IsMessageQueueRunning()

開啟或關閉消息隊列的運行，如果關閉則RPC調用不再執行，狀態同步機制也不工作。

7.Network.SetLevelPrefix(prefix: int)

為所有Network ViewID設置一個前綴。這將有效防止舊level的數據和新levle的數據互相干擾，這一效果不會造成網絡帶寬負擔，但是由於Network ViewID添加了前綴，導致ID池數量有所減少。

8.Object.FindObjectsOfType(type:Type)

返回一個活動的對象列表（數組）。不返回assets和非活動的對象。這個函數會導致系統變慢，建議不要在每幀都使用，大多數情況下你都可以使用Singleton模式（參見C#設計模式）作為替代。

//C#實例
public class example : MonoBehaviour {
    void OnMouseDown() {
        HingeJoint[] hinges = FindObjectsOfType(typeof(HingeJoint)) as HingeJoint[];
        foreach (HingeJoint hinge in hinges) {
            hinge.useSpring = false;
        }
    }
}

9.SendMessage()

GameObject.SendMessage(methodName : string, value : object = null, options : SendMessageOptions = SendMessageOptions.RequireReceiver)
Component.SendMessage(methodName : string, value : object = null, options : SendMessageOptions = SendMessageOptions.RequireReceiver)

調用methodName所指向的方法，若沒有傳遞任何參數被調用的方法可以選擇忽略。當SendMessageOptions設置為RequireReceiver時，若沒有組件接收該調用消息，則列印一條錯誤訊息。

//C#實例
public class example : MonoBehaviour {
    void ApplyDamage(float damage) {
        print(damage);
    }
    void Example() {
        gameObject.SendMessage("ApplyDamage", 5.0F);
    }
}

這些函數在下面的例子中會被用到。

以下是一個簡單的多人遊戲關卡裝載的例子，在關卡裝載過程中必須確保不處理其他的network消息，在裝載完畢一切就緒之前任何消息不得發送。關卡一旦裝載好以後會自動發送一條消息到所有的腳本，通知它們關卡已經裝載完畢。SetLevelPrefix()函數保證自動過濾與新裝載關卡無關的network數據更新，這些無關數據更新可能是比如說上一個關卡的數據。本例還利用組功能分隔開遊戲數據和關卡裝載通信數據。組0用於遊戲數據交通，而組1用於關卡裝載。當關卡正在裝載的時候，關閉組0開啟組1.

//Javascript實例
var supportedNetworkLevels : String[] = [ "mylevel" ];
var disconnectedLevel : String = "loader";
private var lastLevelPrefix = 0;

function Awake ()
{
    // Network level loading is done in a separate channel.
    DontDestroyOnLoad(this);
    networkView.group = 1;
    Application.LoadLevel(disconnectedLevel);
}

function OnGUI ()
{
     if (Network.peerType != NetworkPeerType.Disconnected)
     {
          GUILayout.BeginArea(Rect(0, Screen.height - 30, Screen.width, 30));
          GUILayout.BeginHorizontal();
          for (var level in supportedNetworkLevels)
          {
               if (GUILayout.Button(level))
               {
                    Network.RemoveRPCsInGroup(0);
                    Network.RemoveRPCsInGroup(1);
                    networkView.RPC( "LoadLevel", RPCMode.AllBuffered, level, lastLevelPrefix + 1);
               }
          }
          GUILayout.FlexibleSpace();
          GUILayout.EndHorizontal();
          GUILayout.EndArea();
     }
}

@RPC
function LoadLevel (level : String, levelPrefix : int)
{
     lastLevelPrefix = levelPrefix;
          // There is no reason to send any more data over the network on the default channel,
          // because we are about to load the level, thus all those objects will get deleted anyway
          Network.SetSendingEnabled(0, false);
          // We need to stop receiving because first the level must be loaded first.
          // Once the level is loaded, rpc's and other state update attached to objects in the level are allowed to fire
          Network.isMessageQueueRunning = false;
          // All network views loaded from a level will get a prefix into their NetworkViewID.
          // This will prevent old updates from clients leaking into a newly created scene.
          Network.SetLevelPrefix(levelPrefix);
          Application.LoadLevel(level);
          yield;
          yield;
          // Allow receiving data again
          Network.isMessageQueueRunning = true;
          // Now the level has been loaded and we can start sending out data to clients
          Network.SetSendingEnabled(0, true);
          for (var go in FindObjectsOfType(GameObject))
               go.SendMessage("OnNetworkLoadedLevel", SendMessageOptions.DontRequireReceiver);
}

function OnDisconnectedFromServer ()
{
     Application.LoadLevel(disconnectedLevel);
}
@script RequireComponent(NetworkView)

二.連接測試。

Network.TestConnection (forceTest : boolean = false) : ConnectionTesterStatus
此函數用於測試網絡連接狀況。
返回值類型ConnectionTesterStatus是枚舉類型，其值如下表所示。

ConnectionTesterStatus的可能取值

其中PublicIPIsConnectable，PublicIPPortBlocked以及PublicIPNoServerStarted是測試是否具有公共IP的結果，這個測試主要用於作為服務器運行的情形，因為即使沒有Public IP，客戶端通過NAT punchthough或者Facilitator等還是可以連接到服務器，但是要作為服務器運行就需要有Public IP.此項測試需要有一個已運行的服務器實例，然後測試服務器嘗試連接該服務器的指定IP和端口。

最下面4項是測試是否具備NAT punchthrough的能力，這個測試既用於服務器也用於客戶端，不需要提前進行設置。其中Full cone type和Address-restricted cone type支持完整的NAT punchthrough功能，Port retricted不能連接到Symmetric，但可以連接到另外三種，Symmetric則只能與前兩種連接。

此函數提供的網絡連接測試功能具有非同步性，上一次調用的測試結果下一次調用才能獲得結果。而且為了保證已完成的測試不被重複進行，下一次測試（比如網絡狀況發生變化時需要進行重新測試）需要給參數forceTest賦值true.

下面是一個javascript寫的測試實例：

var testStatus = "Testing network connection capabilities.";
var testMessage = "Test in progress";
var shouldEnableNatMessage : String = "";
var doneTesting = false;
var probingPublicIP = false;
var serverPort = 9999;
var connectionTestResult = ConnectionTesterStatus.Undetermined;
// Indicates if the useNat parameter be enabled when starting a server
var useNat = false;

function OnGUI() {
    GUILayout.Label("Current Status: " + testStatus);
    GUILayout.Label("Test result : " + testMessage);
    GUILayout.Label(shouldEnableNatMessage);
    if (!doneTesting)
        TestConnection();
}

function TestConnection() {
    // Start/Poll the connection test, report the results in a label and
    // react to the results accordingly
    connectionTestResult = Network.TestConnection();
    switch (connectionTestResult) {
        case ConnectionTesterStatus.Error:
            testMessage = "Problem determining NAT capabilities";
            doneTesting = true;
            break;
        case ConnectionTesterStatus.Undetermined:
            testMessage = "Undetermined NAT capabilities";
            doneTesting = false;
            break;
        case ConnectionTesterStatus.PublicIPIsConnectable:
            testMessage = "Directly connectable public IP address.";
            useNat = false;
            doneTesting = true;
            break;
        // This case is a bit special as we now need to check if we can
        // circumvent the blocking by using NAT punchthrough
        case ConnectionTesterStatus.PublicIPPortBlocked:
            testMessage = "Non-connectable public IP address (port " +
                serverPort +" blocked), running a server is impossible.";
            useNat = false;
            // If no NAT punchthrough test has been performed on this public
            // IP, force a test
            if (!probingPublicIP) {
                connectionTestResult = Network.TestConnectionNAT();
                probingPublicIP = true;
                testStatus = "Testing if blocked public IP can be circumvented";
                timer = Time.time + 10;
            }
            // NAT punchthrough test was performed but we still get blocked
            else if (Time.time > timer) {
                probingPublicIP = false;         // reset
                useNat = true;
                doneTesting = true;
            }
            break;
        case ConnectionTesterStatus.PublicIPNoServerStarted:
            testMessage = "Public IP address but server not initialized, "+
                "it must be started to check server accessibility. Restart "+
                "connection test when ready.";
            break;
        case ConnectionTesterStatus.LimitedNATPunchthroughPortRestricted:
            testMessage = "Limited NAT punchthrough capabilities. Cannot "+
                "connect to all types of NAT servers. Running a server "+
                "is ill advised as not everyone can connect.";
            useNat = true;
            doneTesting = true;
            break;
        case ConnectionTesterStatus.LimitedNATPunchthroughSymmetric:
            testMessage = "Limited NAT punchthrough capabilities. Cannot "+
                "connect to all types of NAT servers. Running a server "+
                "is ill advised as not everyone can connect.";
            useNat = true;
            doneTesting = true;
            break;
        case ConnectionTesterStatus.NATpunchthroughAddressRestrictedCone:
        case ConnectionTesterStatus.NATpunchthroughFullCone:
            testMessage = "NAT punchthrough capable. Can connect to all "+
                "servers and receive connections from all clients. Enabling "+
                "NAT punchthrough functionality.";
            useNat = true;
            doneTesting = true;
            break;
        default:
            testMessage = "Error in test routine, got " + connectionTestResult;
    }
    if (doneTesting) {
        if (useNat)
            shouldEnableNatMessage = "When starting a server the NAT "+
                "punchthrough feature should be enabled (useNat parameter)";
        else
            shouldEnableNatMessage = "NAT punchthrough not needed";
        testStatus = "Done testing";
    }
}

如果Server和Client的NAT類型可以被提前獲知，那麼可以不用TestConnection()函數，自己就能寫出一個簡單的比較函數，只要其中之一不是Symmetric類型，兩台機器就可以進行連接。

javascript的例子如下：

function CanConnectTo(type1: ConnectionTesterStatus, type2: ConnectionTesterStatus) : boolean
{
    if (type1 == ConnectionTesterStatus.LimitedNATPunchthroughPortRestricted &&
        type2 == ConnectionTesterStatus.LimitedNATPunchthroughSymmetric)
        return false;
    else if (type1 == ConnectionTesterStatus.LimitedNATPunchthroughSymmetric &&
        type2 == ConnectionTesterStatus.LimitedNATPunchthroughPortRestricted)
        return false;
    else if (type1 == ConnectionTesterStatus.LimitedNATPunchthroughSymmetric &&
        type2 == ConnectionTesterStatus.LimitedNATPunchthroughSymmetric)
        return false;
    return true;
}

其中用到的一些函數和變量：

1.Network.TestConnectionNAT(forceTest : boolean = false)

專用於測試NAT punchthrough，即使機器沒有NAT IP（內部IP）地址，而擁有一個外部公共地址。

2.Time.time

Time.time的值是遊戲開始運行到當前的時間。下面是一個利用Time.time實現子彈按一定時間間隔連續發射的例子：

public class example : MonoBehaviour {
    public GameObject projectile;
    public float fireRate = 0.5F;
    private float nextFire = 0.0F;
    void Update() {
        if (Input.GetButton("Fire1") && Time.time > nextFire) {
            nextFire = Time.time + fireRate;
            GameObject clone = Instantiate(projectile, transform.position, transform.rotation) as GameObject;
        }
    }
}

三.優化帶寬。

帶寬的使用量取決於你是否使用Reliable Delta Compressed或者Unreliable類型的狀態同步機制。Unreliable模式下，整個被同步的對象在每次同步更新以後都按序傳送，同步更新頻率取決於Network.sendRate的值，默認情形下這個值為15.Unreliable模式下數據更新非常頻繁但是不保證數據包的送達，如果有丟包處理方法是簡單的忽略。此模式用於遊戲舞台變化非常頻繁迅速，並且少量的丟包可忽略的情形。Unreliable的帶寬使用量還是比較大的，減少帶寬的方法可以是降低數據傳送率，15的默認值對一般遊戲來說是個合適的取值。

Reliable Delta Compressed模式下數據按序傳輸，且保證數據包不丟失，如果有丟包現象，會等待數據包重傳，如果數據包沒有按序到達，會存入緩衝等待尚未到達的數據。數據等待重傳會一定程度的降低數據傳輸效率，但是因為數據是Delta Compressed，只有更改的數據才會被更新同步，如果數據無變化則沒有數據包傳送。所以Reliable Delta Compressed模式的效果取決於遊戲的場景變化頻繁程度。

另一個問題是，什麼樣的數據需要被同步？這是一個足夠遊戲設計者發揮創意的問題，處理的好壞可以決定帶寬的優化情況。一個例子是動畫數據的同步，如果動畫組件被Network View組件監視，動畫屬性的變化會被嚴格同步，動畫的每一幀在每個客戶端都表現相同。雖然這在某些情況下是可取的，但是一般情況下角色只需要知道角色處於走路，跳躍，跑步等等什麼樣的狀態就足夠，僅僅發送需要播放哪些動畫幀的訊息即可完成同步。這比同步整個動畫組件要節省帶寬得多。

再者，什麼時候需要同步？當兩個玩家在分隔在地圖兩個不同的區域，他們在一段時間內不能見到彼此，那麼這時候的同步完全沒有多大必要。而在地圖一個區域內物理上有機會互相接觸的玩家則需要同步。這樣可以節省部分帶寬。這個概念被稱為相關集（Relevant Sets），即在某個特定時間，某個特定的客戶端只與整個遊戲的一個子集（subset）相關。根據客戶端的相關集來進行數據同步可以使用RPC調用，後者可以對同步進行更多的控制。

在關卡裝載的過程中不需要擔心數據同步佔用帶寬的優化問題，因為每個玩家只需等待其他玩家都裝載完畢即可，所以在關卡裝載時常常涉及到傳輸大量的數據，比如圖像和音頻數據等。