Unity3d多人网络（从圣典拷贝来的，先看看，因为我觉得这位仁兄比我翻译得好,我也对这个教程作一些修改
From:http://game.ceeger.com/forum/read.php?tid=428&page=3
我一直认为unity需要一个好一点的多人网络的教程。当我开始用unity网络功能的时候，我感觉unity自带的例子太混乱了；一个好的网络功能的例子应该包括源文件，这样你可以迅速找到你需要的资料。由于这个想法，我决定参加UniKnowledge比赛并且终于完成了一个网络功能的教程，我希望这个教程包括了你所需要的所有的内容。
这个教程介绍了很多案例；从最小的细节一直到真正的FPS游戏。我建议你从头到尾看一遍这个教程，不过如果你学东西很快的话，也可以自己看一下这些案例，如果需要更多细节，再回过头来看一下这个文档。
About the author
这个教程由M2H的Mike
Hergaarden（Leepo）所写。我们已经使用unity两年多了，不过我们真正用unity进行正规开发只有最近的几个月。我们在最开始就在关注多人游戏的功能。实际上我们的第一个游戏就是多人在线游戏；其实很简单！我们的多人游戏有：Crashdrive
3D, Cratemania, Surrounded by Death, Verdun Online
还有最近我们正在搞的Hyberon。
希望你能够享受这个教程。如果你你搞出什么名堂来，记得和我们联络哦。
How to use this tutorial
和文档一起的还有一个压缩包，里面是教程中用到的案例的源文件。我们假设你已经知道怎么用unity编辑器和脚本，如果你不熟悉这些，请先去看unity的视频教程。
多人游戏的debug很麻烦，因为你有两个机器在跑（服务器和客户端）这个项目。所以我们建议你在学习这个教程的时候，在编辑器里跑服务器端，在web里跑客户端。
如果你想把教程中的源文件用在自己的项目里，注意这些文件已经针对教程进行了设置。在你自己的项目里，要确保Run in
background选项被选中，这可以让你把服务器端在后端激活，避免进入睡眠状态。这样的话你就可以再后端跑服务器。不然的话你就没办法在跑客户端的时候同时在后端跑服务器。你可以打开这个选项在：Edit-Project
settings-Player.
1:Connect &Disconnect
让我们开始吧
1.打开教程的第一个场景：这个场景在：Tutorial1/Tutorial_1. 这个场景包括了一个摄像机，一个游戏物体和它的脚本，还有另一个物体用来显示场景标题。
2.Build一个webplayer然后运行
3.在编辑器里也开始跑同一个场景，然后点击：Start a server（用默认的IP和端口）
4.在webplayer里点击：Connect as client
5.你应该可以在你的两个项目里都看到：Connection status：Client！ 还有：Connection
status：Server! 恭喜啦，连接上了!
简单吧；幸运的是这个脚本一点都不难。看一下脚本：Tutorial 1/Connect.js .
这个例子里用到的所有的代码都在OnGUI（）函数里，看下这个函数，然后确定你明白这个函数是怎么工作的。这段代码挺简单的（如果你看的懂代码的话，嘿嘿），不过我们还是大致看一下这部分代码。
var connectToIP :
String = "127.0.0.1";
var connectPort : int = 25001;
//Obviously the GUI is for both
client&servers (mixed!)function OnGUI ()
(Network.peerType ==
NetworkPeerType.Disconnected)
//We are currently disconnected: Not a client
&GUILayout.Label("Connection
status: Disconnected");
connectToIP = GUILayout.TextField(connectToIP,
GUILayout.MinWidth(100));
connectPort =
parseInt(GUILayout.TextField(connectPort.ToString()));
GUILayout.BeginVertical();
&if (GUILayout.Button ("Connect as client"))
//Connect to the "connectToIP" and
"connectPort" as entered via the GUI
&&&&&&&&&&&
//Ignore the NAT for
&Network.Connect(connectToIP,
connectPort);
&if (GUILayout.Button ("Start Server"))
//Start a server for 32 clients using the "connectPort" given via
//Ignore the nat for
&Network.InitializeServer(32, connectPort);
&GUILayout.EndVertical();&&
&{&&&&&&&&&
//We've got a connection(s)!
(Network.peerType ==
NetworkPeerType.Connecting)
&&&&&&&&&&&&
GUILayout.Label("Connection status: Connecting");
&&&&&&&&&else
if (Network.peerType == NetworkPeerType.Client)
&& GUILayout.Label("Connection
status: Client!");
&& GUILayout.Label("Ping to
server: "+Network.GetAveragePing(&
Network.connections[0] )
&else if (Network.peerType ==
NetworkPeerType.Server)
&& GUILayout.Label("Connection
status: Server!");
&&&&&&&&&&&
&GUILayout.Label("Connections:
"+Network.connections.length);
&&&&&&&&&&&&
if(Network.connections.length&=1)&&&&&
&&&&&&&&&&&&
&&&&&&&&&&&&&&&&
&GUILayout.Label("Ping to first player:
"+Network.GetAveragePing(& Network.connections[0]
&&&&&&&&&&&&&
if (GUILayout.Button ("Disconnect"))
&&&&&&&&&&&&
&Network.Disconnect(200);
// NONE of the functions
below is of any use in this demo, the code below is only used for
demonstration.
// First ensure you understand the code in the OnGUI() function
//Client functions called by
Unityfunction
OnConnectedToServer()
&Debug.Log("This CLIENT has connected to a
server");&
OnDisconnectedFromServer(info :
NetworkDisconnection)
Debug.Log("This SERVER OR CLIENT has disconnected from a
OnFailedToConnect(error:
NetworkConnectionError)
&Debug.Log("Could not connect to server: "+
//Server functions called by
Unityfunction
OnPlayerConnected(player: NetworkPlayer)
Debug.Log("Player connected from: " + player.ipAddress +":" +
player.port);
OnServerInitialized()
&Debug.Log("Server initialized and ready");
OnPlayerDisconnected(player: NetworkPlayer)
Debug.Log("Player disconnected from: " + player.ipAddress+":" +
player.port);
// OTHERS:
// To have a full overview of all network functions called by
// the next four have been added here too, but they can be ignored
OnFailedToConnectToMasterServer(info:
NetworkConnectionError)
&Debug.Log("Could not connect to master server: "+
OnNetworkInstantiate (info :
NetworkMessageInfo)
Debug.Log("New object instantiated by " + info.sender);
OnSerializeNetworkView(stream : BitStream, info :
NetworkMessageInfo)
{&//Custom code here (your code!)}
脚本最上面的两个参数（connectToIP 和
connectPort）是用来对应GUI对话框里的用户输入，当用户点击链接按钮的时候，它们就会被调用。GUI函数分为4个部分：服务器，客户端已连接，客户端连接中，客户端断开。我们直接使用unity提供的状态：Network.peer.Type
来查看当前的链接状态。我们调用Network.Connect函数用来把客户端连接到服务器端，这个函数包含IP，端口还有密码（可选项）作为参数。建立一个服务器也差不多，我们调用另一个函数：Network.InitializeServer。这个函数包含端口和允许的最大连接数量作为参数。注意这里，你在服务器运行的时候，总是可以把连接数调低，但是没有办法超过在服务器初始化时所设置的数值。在你连接服务器或者初始化服务器之前，还有一个选项需要注意：Network.useNat
你应该能在connection/initializing函数的代码上方看到它。
connection（Network.useNat）
我们设置Network.useNat为false因为我们不想用Network
Address Translation(网络地址转换)。NAT
在客户端处在路由器之后的时候很有用（内部局域网）。这个网络Demo应该只在局域网中运行；你肯定没办法连接你朋友家（除非你朋友有个无限制的防火墙/路由器）关于NAT的更多信息请看连接：
现在，最后的一段代码；这十来个函数，会被unity自行调用。其实你不需要它们，就算你把它们都删了，这个Demo还是一样能跑。前六个客户端和服务器端的函数应该很好懂；它们只被客户端或者服务器端调用，如果你想调用这些函数传送的参数，自己去查查unity的手册吧。
最后的三个函数不一样，OnFailedToConnectToMasterServer当你不能连接到主服务器的时候被客户端调用，主服务器的信息在后面会提到。OnNetworkInstantiate被实例化的物体调用，这个在后面也会被提到。OnSerializeNetworkView是我们用来在服务器和客户端之间传送信息的两个方法之一。RPC调用你自己定义的网络信息或网络函数。下一个教程里我们会看一下序列化还有RPC调用。
教程的最后看一下这几个函数：Network.Messages Sent，Class Variables 和Class
现在你知道在哪里能找到这些参考信息了，恩~用户手册。我们已经大致介绍了大概75%的信息了，爽吧！
Tutorial 2:
Sending messages
Tutorial 2A：服务器播放，客户端监视，非实例化。
Tutorial 2/Tutorial 2A1
不要让这些标题吓到了，打开场景：Tutorial 2/Tutorial 2A1.
教程1中网络连接的脚本，现在已经放在：Connect物体上了。另外PlayerCube物体被赋予了Tutorial2A1.js脚本和NetworkView组件。每一个物体，只要需要接受或者发送网络信息的，都需要一个NetworkView组件。你可以在整个游戏中只使用一个NetworkView组件，然后用脚本引用它。但是这样太麻烦了，最简单就是给每个需要网络功能的物体都加一个组件。
Tutorial2A1.js脚本:
Update(){&
run this on the server&&
if(Network.isServer)
{&&&&&&&&&//Only
the server can move the
cube!&&&&&&&&&&&&var
moveDirection : Vector3 = new
Vector3(-1*Input.GetAxis("Vertical"),0,Input.GetAxis("Horizontal"));
var speed : float = 5;
&&&&&&&&transform.Translate(speed
* moveDirection * Time.deltaTime);//now really move!
}跑一下这个demo，服务器和客户端都打开。客户端应该能看到服务器移动方块物体。神奇吧，其实这一切就是使用了NetworkView组件的observing（观察）参数，它监视了这个方块的移动。现在看一下方块物体上的Tutorial
2A1.js脚本。这段代码只能在服务器上跑（因为用了Network.isServer来检查是否为服务器端）：当服务器端的玩家移动方块，它就会立刻移动。不过你也能看到客户端上方块的移动特别卡，但是不要担心，我们回头会解决这个问题，现在先讲最基本的内容。
现在，怎么让客户端知道服务器端的物体移动了呢？看一下附加在物体上的NetworkView组件。它检测了物体的transform（变换）属性。也就是说unity会自动发送物体的变换属性（包括了位置，旋转角度和缩放的Vector3数值）。它只会把信息从服务器端发送到客户端，反之就不行，因为服务器端独占了NetworkView的功能。客户端就不能发送信息，只能够接收。
我们看一下NetworkView的其他选项，稍微总结一下。PlayerCube物体的Networkview组件中，State
synchronization选项，被设定为Reliable
compressed。这说明只有被观察的参数发生改变的时候，它才会发送信息。如果服务器端15分钟都诶有移动方块物体，它就绝对不会发送任何信息，智能吧~。如果设置成Unreliable，无论参数有没有变，它都一致在发送信息。最后一个，如果设置State
synchronization
为Off，会完全停止NetworkView所有的网络同步行为。如果你的NetworkView组件没有在对物体进行监视，你可以把同步选项关闭（不过也不是必须的）。如果你不明白我们为什么需要这么一个关掉了同步选项的NetworkView组件，就这么给你说吧，因为“Remote
Procedure Calls”（远程程序调用）需要一个NetworkView组件，但是并不需要State
synchronization和observed选项。不过你还是可以把RPC和observed一起用。RPC的内容会在下面的教程2A3里讲到。基本上它就是一个你自己定义的网络信息收发机制。
2/Tutorial
2A2如果你想让方块物体沿着Y轴移动怎么办，或者你想控制unity同步的具体内容。跑一下教程2/教程2A2.这个游戏应该和之前一摸一样，但是后端的代码已经改变了。PlayerCube上的NetworkView组件现在监测的是“Tutorial2A2.js”脚本。
if(Network.isServer)
//Only the server can move the
&var moveDirection :
Vector3 = new Vector3(-1*Input.GetAxis("Vertical"),
0,Input.GetAxis("Horizontal"));
var speed : float = 5;
&transform.Translate(speed * moveDirection *
Time.deltaTime);
OnSerializeNetworkView(stream : BitStream, info :
NetworkMessageInfo)
if (stream.isWriting)
{&&&&&&&&&&&
//Executed on the owne
in this case the Server
&&&&&&&&&&&
//The server sends it's position over the
&var pos : Vector3 =
transform.&&
&&&&&&&&&&
stream.Serialize(pos);//"Encode" it, and send
&&&&&&&&&&&&
{&&&&&&&&&&&
in this case the Clients
&&&&&&&&&&&
&//The clients receive a position and set the
object to it&&
&&&&&&&&&&&
&var posReceive :
Vector3 = Vector3.
&&&&&&&&&&&stream.Serialize(posReceive);
//"Decode" it and receive it
&&&&&&&&&&&transform.position
&&&&&&&&&&&
具体就是说，这个NetworkView组件现在在检测脚本内的“OnSerializeNetworkView”函数。看一下这个函数.我们现在明确的指定了我们想要监测的内容。你可以用这个函数来同步具体你需要的内容，再说一次，当你选中Reliable
compressed的时候，只有当参数发生变化的时候才会被发送出去。OnSerializeNetworkView函数有点诡异，它虽然是用来发送和接受数据，但是unity会查看Networkview组件的使用者，然后决定你是不是能够发送数据，如果你是服务器端，就调用“stream.isWriting”部分的代码，你就可以发送数据。如果你是客户端，就调用“else”部分的代码，你就只能接收数据。
2/Tutorial 2A3
这是我最喜欢的发送信息的方法，也是最后一个方法；Remote Procedure
Calls。我之前提到过这个，你可以去看看Tutorial 2/Tutorial
2A3的例子，搞个明白到底是怎么一回事。这个Demo和之前两个实现了一样的功能。不过Networkview不再监视任何物体，同步选项也已经被关闭。秘密就在Tutorial
2A3.js这个脚本里，特别是这一行networkView.RPC("SetPosition", RPCMode.Others,
transform.position);.
Tutorial 2A3.js脚本:
private var
lastPosition : Vector3;
if(Network.isServer)
&//Only the server can move
cube!&&&&&&&&&&
var moveDirection : Vector3 = new
Vector3(-1*Input.GetAxis("Vertical"),
0,Input.GetAxis("Horizontal"));
var speed : float = 5;
transform.Translate(speed * moveDirection * Time.deltaTime);
&&&&&&&&&&
//Save so only send an
rpc when the position has moved more than
if(Vector3.Distance(transform.position,
lastPosition)&=0.05)
&&&&&&&&&&&&
&lastPosition=transform.
&&&&&&&&&&&&&&&&&
//Send the position Vector3 over to the
in this case all
clients&&&&&&&&&&&&
networkView.RPC("SetPosition", RPCMode.Others,
transform.position);
function SetPosition(newPos : Vector3)
//This RPC is in this case always called by
the server,
// but executed on all clients&
transform.position=newP&
服务器调用了RPC,这个RPC会要求客户端调用“SetPosition”函数，同时这个RPC还包含这一个新的位置信息“transform.position”，然后所有的客户端都调用”SetPosition”这个函数。下面是整个移动的过程：
1.服务器端玩家按下按键，他控制的物体移动。（代码14-18行）
2.服务器用移动的数值和上次更新的数值比较，如果差距大于设置的最小值，就发送一个RPC给出了自己的所有人，这个RPC包含了新的物体位置。（代码20-25行）
3.所有的客户端接收到RPC的设置物体位置命令，并且得到其中包括的新位置参数，然后再让它们本地执行位置移动的代码。
4.现在无论服务器还是客户端，大家的物体都处在相同的位置了~！
如果我们想要使用RPC函数，需要在脚本中这个函数的上面加上“@RPC”（C#里面是”[RPC]”）.当发送一个RPC的时候，我们可以指定下列的接收器：
&RPCMode.Server&&&
&只发送给服务器
&RPCMode.Others&
&发送给除了调用者之外的所有人
&RPCMode.OthersBuffered&
&发送给除了调用者之外的所有人，暂存的内容
&RPCMode.All
&发送给包括调用者在内的所有人
&RPCMode.AllBuffered
&发送给包括调用者在内的所有人，暂存的内容
暂存的内容，指的是无论何时新玩家连接到服务器，都将会接收到这个信息。一个包含暂存内容的RPC可以用于比如说生成玩家的时候。这个暂存的内容会被服务器记住，然后每个玩家连接到服务器的时候，都会先收到一个生成玩家的RPC，这个RPC会在这个刚连接的新玩家的客户端中，生成其他所有在他之间加入服务器的玩家。
如果你大致已经明白上面讲的所有的内容的话，你已经很牛啦！我们已经讲完了所有的基础内容，现在可以关注一下细节问题了。
Tutorial 2B: Server and client(s) play,
with instantiating.
我们现在要研究一下FPS游戏的基本细节。我们需要搞一个多人游戏，可以包括服务器端的玩家在内，并且也要可以剔除服务器端的玩家，把服务器放在后台。所以我们决定当新的客户端连接到服务器的时候，再生成玩家，而不是把玩家设置成物体，直接放在场景中。打开场景“Tutorial
2/Tutorial
2B”，服务器端还是在编辑器中，客户端在web里，都打开。移动一下方块，看看在客户端和服务器端是不是都工作正常。
PlayerCube物体已经从场景中移除了，我们新建了一个Spawnscript物体，并且给它赋予了Spawnscript.js脚本。
public var
playerPrefab : T
OnServerInitialized()
&Spawnplayer();
OnConnectedToServer()
Spawnplayer();
Spawnplayer()
& var myNewTrans : Transform =
Network.Instantiate(playerPrefab,&&&&&&&&&&&&&&&
transform.position, transform.rotation, 0);
function OnPlayerDisconnected(player:
NetworkPlayer)
Debug.Log("Clean up after player " + player);
&Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
OnDisconnectedFromServer(info :
NetworkDisconnection)
Debug.Log("Clean up a bit after server quit");
Network.RemoveRPCs(Network.player);
Network.DestroyPlayerObjects(Network.player);
&Application.LoadLevel(Application.loadedLevel);
当玩家（包括服务器和客户端）开始的时候，这个生成玩家的脚本会生成我们指定的预设物体（这里就是生成玩家-其实是方块）。生成脚本包含了位置，旋转角度和物体所在小组的信息。生成的物体会复制Spawnscripts物体本身的位置和角度信息，并且设置小组号为0（现在不用关心小组的事儿）。当我们断开连接的时候，会移除所有生成的预设物体。谁调用的Network.Instantiate谁就会自动获得这个函数本次生成的物体。这样我们就可以正确的控制不同的方块物体（服务器端和客户端就不会混在一起）。
“Tutorial_2B_Playerscript.js”脚本使用了Tutorial
2AB的代码，不同的地方是，只有物体的所有者的输入才会被监测。
Tutorial 3:
Authoritative servers
之前的服务器设置，被称之为“非权威性”服务器；服务器对所有的网络信息没有任何控制权，客户端会和服务器共享物体的位置信息，并且所有的终端都接受并且执行这些信息。在你的FPS游戏里，你肯定不想有玩家能瞬间移动，水上飞什么的。所以一般来说服务器都是“权威性”服务器。设置一个权威性服务器也不需要什么特别难的代码，不过它的确需要你设计代码框架的时候，稍微做些调整。你需要在服务器端完成所有的工作并且检查所有的通讯。
我们回头看一下上个教程B2,怎么才能把它修改成权威性服务器呢。首先，服务器需要生产玩家，玩家不能决定他们被生成的时间和地点。其次，服务器要告诉所有的客户端所有物体的位置，客户端之间无法发送和接受信息。因为只有服务器能够移动物体的位置，客户端的玩家想要移动的话，必须向服务器发送他的所需要的移动信息，然后接收服务器指令才能移动。
我们要发送所有客户端的移动输入命令到服务器端，服务器会处理这些数据，然后送回结果数据（新的位置）到客户端。看一下Tutorial3场景。功能还是和以前一样，但是内部处理机制已经不一样了。移动起来可能比以前感觉更卡一点，但是现在这个暂时不重要。
这个例子里没有新脚本，只有Playerscript脚本和spawnscript脚本的内容有改变。我们先看下
Tutorial_3_Spawnscript.js。
public var
playerPrefab : T
public var playerScripts : ArrayList = new
ArrayList();
OnServerInitialized()
//Spawn a player for the server
itself&&&&&
Spawnplayer(Network.player);
OnPlayerConnected(newPlayer: NetworkPlayer)
//A player connected to me(the
server)!&&&&
&Spawnplayer(newPlayer);
function Spawnplayer(newPlayer :
NetworkPlayer)
//Called on the server
var playerNumber : int =
parseInt(newPlayer+"");&&&&&
//Instantiate a new object for this player,
the server is therefore the
owner.&&&&&
var myNewTrans : Transform =
Network.Instantiate(playerPrefab, transform.position,
transform.rotation,
playerNumber);&
//Get the networkview of this new
transform&&&&
newObjectsNetworkview : NetworkView =
myNewTrans.networkV&
//Keep track of this new player so we can
properly destroy it when required.&&&&&
playerScripts.Add(myNewTrans.GetComponent(Tutorial_3_Playerscript));
&//Call an RPC on this new
networkview, set the player who controls this
player&&&&&&newObjectsNetworkview.RPC("SetPlayer",
RPCMode.AllBuffered, newPlayer);//Set it on the
OnPlayerDisconnected(player: NetworkPlayer)
&Debug.Log("Clean up after player " +
for(var script : Tutorial_3_Playerscript in
playerScripts)
&&&&&&&&&&&&&
if(player==script.owner)
&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&
&//We found the players
&&&&&&&&&&&&&&&&&&&
//remove the bufferd SetPlayer
call&&&&&&&&&&&&&&&&&&
&Network.RemoveRPCs(script.gameObject.networkView.viewID);
&&&&&&&&&&&&&&&&&
//Destroying the GO will destroy
everything
&&&&&&&&&&&&&&&&&Network.Destroy(script.gameObject);&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&
playerScripts.Remove(script);//Remove this player from the
list&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&//Remove the buffered RPC
call for instantiate for this
player.&&&&&&&&&
&var playerNumber :
int = parseInt(player+"");
Network.RemoveRPCs(Network.player,
playerNumber);&
&&&&&&&&&&
// The next destroys will not destroy
anything since the players never
&// instantiated anything nor buffered
RPCs&&&&&&&&&&
Network.RemoveRPCs(player);
&Network.DestroyPlayerObjects(player);
OnDisconnectedFromServer(info :
NetworkDisconnection)
&Debug.Log("Resetting the scene the easy
Application.LoadLevel(Application.loadedLevel);&
客户端在这个脚本里没有任何操作，每当客户端连接的时候服务器端才开始生成物体。服务器端还会保存一个已连接客户端的列表，列表中还包括了Playerscripts的信息，这样在一个客户端下线的时候，服务器就可以删除正确的玩家物体。这个Spawnscript脚本是一个纯粹的服务器端脚本，和客户端的“OnDisconnectedFromServer”函数没有任何关系。现在我们再看一下
Tutorial_3_Playerscript.js脚本：
public var owner :
//Last input value, we're
saving this to save network
messages/bandwidth.private var lastClientHInput : float=0;
private var lastClientVInput : float=0;
//The input values the server
will execute on this objectprivate var serverCurrentHInput : float = 0;
private var serverCurrentVInput : float = 0;
function Awake()
// We are probably not the owner of this
object: disable this script.
// RPC's and OnSerializeNetworkView will STILL get trough!
&// The server ALWAYS run this script
though&&&&
&if(Network.isClient)
&&&&&&&&&&
enabled=& // disable this script (this
enables Update());&
function SetPlayer(player : NetworkPlayer)
if(player==Network.player)
{&&&&&&&&&&&//Hey
thats us! We can control this player: enable this script (this
Update());&&&&&&&&&&
&if(owner!=null
Network.player==owner)
&&&&&&&&&&&&//Only
the client that owns this object executes this
code&&&&&&&&&&
&var HInput : float
= Input.GetAxis("Horizontal");
var VInput : float =
Input.GetAxis("Vertical");&&
&&&&&&&&&&&
//Is our input different? Do we need to
update the
server?&&&&&&&&&&&
if(lastClientHInput!=HInput ||
lastClientVInput!=VInput )
&&&&&&&&&&&
&&&&&&&&&&&&&&&&
&lastClientHInput = HI
&&&&&&&&&&&&&&&&
&lastClientVInput =
&&&&&&&&&&&&&&&&&&if(Network.isServer)
&&&&&&&&&&&&&&&&&
{&&&&&&&&&&&&&&&&&&&
&&& //Too bad a server can't send an rpc to
&&&&&&&&&&&&&&&&&&&&&&&
//using "RPCMode.Server"!...bugged :[
&&&&&&&&&&&&&&&&&&&&&&
&SendMovementInput(HInput,
&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
else if(Network.isClient)
&&&&&&&&&&&&&&&&&&
{&&&&&&&&&&&&&&&&&&&&&&&//SendMovementInput(HInput,
VInput); //Use this (and line 64) for simple
"prediction"&&&&&&&&&&&&&&&&&&&&
networkView.RPC("SendMovementInput", RPCMode.Server, HInput,
&//Server movement
code&if(Network.isServer)//Also
enable this on the client itself: "||
Network.player==owner)
&//Actually move the player
using his/her
input&&&&&
&var moveDirection :
Vector3 = new Vector3(serverCurrentHInput, 0,
serverCurrentVInput);
&&var speed : float = 5;
transform.Translate(speed * moveDirection * Time.deltaTime);
function SendMovementInput(HInput : float, VInput :
//Called on the server&&&&&&&serverCurrentHInput
serverCurrentVInput = VI
OnSerializeNetworkView(stream : BitStream, info :
NetworkMessageInfo)
if (stream.isWriting)
{&&&&&&&&&&&
&//This is executed on the
owner of the networkview
&&&&&&&&&&&
&//The owner sends it's position over the
&&&&&&&&&&&&&
&var pos : Vector3 =
transform.&&
&&&&&&&&&&
stream.Serialize(pos);//"Encode" it, and send
&&&&&&&&&}
{&&&&&&&&&&&&&&//Executed
on all non-owners
&&&&&&&&&&&&&
//This client receive a position and set the object to it
&&&&&&&&&&&&&&&
&var posReceive :
Vector3 = Vector3.
&&&&&&&&&&&&&stream.Serialize(posReceive);
//"Decode" it and receive it
&&&&&&&&&&&&
&//We've just recieved the
current servers position of this object in
'posReceive'.&&
&&&&&&&&&&&&&&
transform.position =
&&&&&&&&&&&&&&&//To
reduce laggy movement a bit you could comment the line above and
use position lerping below instead:&
&&&&&&&&&&&&&
&//transform.position =
Vector3.Lerp(transform.position, posReceive, 0.9); //"lerp" to the
posReceive by
这个脚本现在不只被Networkview所有。因为现在由服务器端来生成所有的物体，所以全部的Networkview都为服务器所有。所以现在我们使用每个终端自己的“所有者”参数来控制，哪一个网络上的玩家会控制哪一个物体。playerscript脚本的所有者会发送移动信息到服务器。服务器执行这个移动信息并且负责移动玩家物体。这样一来，我们就有了一个“权威性”的服务器！
关于卡的问题：在之前的例子里，玩家物体会在按下按键后立即移动，但是当我们使用权威性服务器，我们需要发送移动信息给服务器，然后服务器会处理它，然后再发回一个移动指令，然后我们才能移动物体。我们当然是想让服务器端有所有的控制权，但是我们不想让客户端等太长时间。其实这个问题也很简单，只要让客户端也同时计算移动信息，然后再让服务器端的信息覆盖客户端的计算结果，这样服务器端总是有控制权。很简单吧。Tutorial_3_Playerscript.js这个脚本在客户端调用了“SendMevementInput(HIput,Vinput)”函数。这里你可以发送一个移动信息RPC到服务器（第56行代码）。随后这个SendMovementInput
RPC 会调用客户端移动脚本里的Update（）函数的最后一部分代码，来更新物体的移动。同时在本地调用这一段代码：“||
Network.player == owner)”
（第64行代码）。这样就可以确保客户端的移动立刻就能执行，而且让服务器端的计算结果为最终结果。
虽然我们设置了让客户端可以“预测”物体的移动，但是还是有些卡，在代码的第100行这里有一段代码，它合并了当前的物体位置和服务器发送来的位置，并且以服务器的位置为主。你还可以把服务器发送来的位置保存为一个参数，然后用Vector3.Lerp这个命令来进行插值。这样你就可以在Update函数里进行平滑的插值，而不是只能在OnSerializeNetworkView函数里进行一次插值。
注意一下，其实你不用总是在你的多人游戏里用“权威性”服务器。比如我们公司的Crashdriver
3D游戏，就用了非权威性服务器。玩家可以恶意修改他的赛车位置；但是谁在乎呢~这种修改最多也就能让玩家得到很高的分数。之后我们再检查那些高的离谱的得分要容易得多。总而言之：想明白你究竟为什么要用权威性服务器。另外也要知道，如果你直接修改权威性服务器，也能作弊哦。
Further network subjects explained
Unity editor options related to networking
“Edit - Project settings - Network”
Sendrate（发送率）：这个选项决定了每秒钟发送多少次网络信息（Unreliable 或者 Reliable delta
compressed).注意，这个选项对RPC信息没有效果。在不影响游戏视觉效果的前提下，尽量把这个数值调低。
Debug level:改变多少debug信息会在编辑器中显示。
“Edit - Project settings - Player”
Run in background: Yes/No 当运行服务器端时，需要打开这个选项以便服务器可以在后台保持通讯。
Limiting traffic: Scoping and group
你可以通过限制数据的数量来提高通讯性能。在多人游戏里，玩家不用接受所有的信息。一定距离以外发生的事情，对玩家也就没什么意义了。这里有两种方法，可以让玩家拒收信息：“组”或者”玩家“。
首先所有的NetworkView组件，要设置一个SetScop函数：
function SetScope (player : NetworkPlayer, relevancy : bool) :
默认情况下，这个函数为true。你可以设置为false如果某个玩家已经离你足够远，然后你就不会再接收到他的信息。不过很可惜，这个函数只能用于NetworkViwe的observe属性，对RPC不起作用。
网络函数：
static function SetReceivingEnabled (player : NetworkPlayer, group
: int, enabled : bool) : void
static function SetSendingEnabled (group : int, enabled : bool) :
这两个函数可以根据网络组来限制信息的发送和接收。比如说，你可以把地图划分为32份，玩家只会发送/接收玩家周围的8个格子（还有玩家本身的一个，总共9个）。但是很遗憾在unity网络库中，你最多只能有32个组，虽然对FPS这样的游戏来说也够用了，但是对真正的MMO游戏，还是差很远。
Securing the network connection
添加AES加密，CRS，随即加密SYNCookies和RSA加密好像都挺复杂的哈。幸运的是我们可以只用一行代码就搞定这些：
function StartServer ()
Network.InitializeSecurity();//
就是这一行！&&&&&
Network.InitializeServer(32, 25000);
只是记得在初始化服务器之前调用Network.InitializeSecurity()函数一次，安全系统会让每个信息包增加15比特。
就算是有了之前的安全系统，当你设计游戏的时候，还是要考虑到最糟的情况。假设玩家对程序懂的和你一样多，并且他们可以随意修改你的网络信息包，搞出一些离谱的数值来。所以总是要在服务器端检查你接收到的数据。只要设计网络功能的时候巧妙一些，就不用为了反作弊写一大堆额外的代码。
proxy关于使用代理的事，手册上已经说的很清楚了，自己看下链接吧：
虽然我们对使用代理来改善网络链接很有兴趣，但是我们还没有仔细研究这部分功能。
Combat Lag: prediction, extrapolation and
interpolation
（战斗延迟：预测，外推法和插值）
我们已经在Tutorial
3里大致提到了这些问题：当你使用权威性服务器来做计算的时候，同时可以让客户端做预测计算来减少延迟。
以下摘至Unity手册：
“我们用来推测玩家行为的方法也可以用来推测敌人的行为。外推法就是根据服务器上一帧所收到的信息，计算一个敌人可能的方向和速度，然后假设敌人会继续朝这个方向移动。
插值是怎么回事呢，当丢包的时候，通常玩家和敌人会突然卡住不动了，然后当下一个包发过来的时候，再跳到新的位置。但是我们可以设置一个延时（通常大约100毫秒）然后把之前的位置和新的位置做一个插值，这样的话，丢包的时候，玩家的移动依然是平滑的。”
在unity的官方例子里可以找到关于插值和外推法的例子,这个教程中的FPS例子里，也有这相关内容。另外你也可以通过提高网络发送率来提高同步的精度。
Manually allocate networkview
ID's（手动分配NetworkViewID）
有时候Network.Instantiate 对权威性服务器的支持不好。如果手动分配网络设置的ID可以获得更好的控制。
代码例子：
loading对于网络工作来说，只要网络连接情况良好，无论服务器或者客户端上跑的是什么内容都无关紧要。也就是说你可以在服务器端跑一个游戏场景，而在一个刚连接的新客户端跑游戏大厅。通常都不会出什么问题，除非服务器向所有的客户端发送“缓存的实例化”游戏物体的命令。因为这个原因，你最好在载入游戏的时候暂时关闭网络通讯。你可以在客户端成功连接服务器之后，立即调用下面的代码：“Network.isMessageQueueRunning=”这样就可以关闭网络通讯。网络大厅的例子里有这个代码的应用。
告诉你一个秘密，其实一个服务器可以同时跑多个场景/关卡，只要你能巧妙地设置好网络组。只是要小心不同场景中的玩家的碰撞信息。
Example 1:
Chatscript
public var usingChat : boolean =
be used to determine if we need to stop player movement since we're
chattingvar skin :
GUIS&&&&&&//Skin
var showChat : boolean=
&&&//Show/Hide
//Private vars used by the
scriptprivate var
inputField : String= "";
private var scrollPosition :
private var width : int= 500;
private var height : int= 180;
private var playerName : S
private var lastUnfocusTime : float =0;private var window :
//Server-only
playerlistprivate var
playerList = new ArrayList();
class PlayerNode
playerName : S
networkPlayer : NetworkP
private var chatEntries = new
ArrayList();
class ChatEntry
var name : String= "";
&&& var text :
String= "";&
&& window =
Rect(Screen.width/2-width/2, Screen.height-height+5, width,
&& //We get
the name from the masterserver example, if you entered your name
playerName =
PlayerPrefs.GetString("playerName", "");
if(!playerName || playerName=="")
playerName = "RandomName"+Random.Range(1,999);
functionfunction
OnConnectedToServer()
ShowChatWindow();
networkView.RPC ("TellServerOurName", RPCMode.Server,
playerName);&&&
// //We could have also announced
ourselves:
addGameChatMessage(playerName" joined the chat");
&&& // //But
using "TellServer.." we build a list of active players which we can
use for other stuff as well.}
functionfunction
OnServerInitialized()
&ShowChatWindow();&&
//I wish Unity supported sending an RPC on
the server to the server itself :(
&& // I we could use the
same line as in
"OnConnectedToServer();"&&
var newEntry : PlayerNode = new
PlayerNode();
newEntry.playerName=playerN
newEntry.networkPlayer=Network.
&playerList.Add(newEntry);&
&addGameChatMessage(playerName+" joined the
//A handy wrapper function to get the
PlayerNode by networkplayerfunction GetPlayerNode(networkPlayer :
NetworkPlayer)
&& for(var entry : PlayerNode
in& playerList)
if(entry.networkPlayer==networkPlayer)
&Debug.LogError("GetPlayerNode: Requested a
playernode of non-existing player!");&
//Server functionfunction OnPlayerDisconnected(player:
NetworkPlayer)
&&&addGameChatMessage("Player
disconnected from: " + player.ipAddress+":" + player.port);
//Remove player from the server
list&&&&playerList.Remove(
GetPlayerNode(player) );
OnDisconnectedFromServer()
CloseChatWindow();
functionfunction
OnPlayerConnected(player: NetworkPlayer)
&& addGameChatMessage("Player
connected from: " + player.ipAddress +":" + player.port);
@RPC//Sent by
newly connected clients, recieved by
serverfunction
TellServerOurName(name : String, info :
NetworkMessageInfo)
&& var newEntry : PlayerNode =
new PlayerNode();
&newEntry.playerName=
newEntry.networkPlayer=info.
&playerList.Add(newEntry);
&& addGameChatMessage(name+"
joined the chat");
function CloseChatWindow ()
&&&showChat =
&& inputField = "";
&& chatEntries = new
ArrayList();
function ShowChatWindow ()
&& showChat =
&& inputField = "";
& &chatEntries = new
ArrayList();
function OnGUI ()
if(!showChat){
&GUI.skin =
&if (Event.current.type == EventType.keyDown
&& Event.current.character == "\n"
&& inputField.Length
if(lastUnfocusTime+0.25&Time.time)
&usingChat=
GUI.FocusWindow(5);
&GUI.FocusControl("Chat input field");
&window = GUI.Window (5, window, GlobalChatWindow,
function GlobalChatWindow (id :
GUILayout.BeginVertical();
&& GUILayout.Space(10);
GUILayout.EndVertical();&
&&& // Begin a scroll view. All rects are calculated
automatically -
&&& // it will
use up any available screen space and make sure contents flow
correctly.
&&& // This is
kept small with the last two parameters to force scrollbars to
scrollPosition =
GUILayout.BeginScrollView (scrollPosition);
&for (var entry : ChatEntry in chatEntries)
&GUILayout.BeginHorizontal();
if(entry.name=="")
message&&&&&&
&& GUILayout.Label
(entry.text);
GUILayout.Label (entry.name+": "+entry.text);
GUILayout.EndHorizontal();
GUILayout.Space(3);
&}&// End the scrollview we began
GUILayout.EndScrollView ();
(Event.current.type == EventType.keyDown
&& Event.current.character == "\n"
&& inputField.Length
&HitEnter(inputField);
GUI.SetNextControlName("Chat input field");
inputField = GUILayout.TextField(inputField);
if(Input.GetKeyDown("mouse 0"))
&if(usingChat)
&&&&&&&&&&&
usingChat=
&&&&&&&&&&&
GUI.UnfocusWindow ();//Deselect chat
&&&&&&&&&&&
lastUnfocusTime=Time.
function HitEnter(msg :
msg = msg.Replace("\n", "");
networkView.RPC("ApplyGlobalChatText", RPCMode.All, playerName,
inputField = ""; //Clear
&GUI.UnfocusWindow ();//Deselect chat&&&&
lastUnfocusTime=Time.
usingChat=
function ApplyGlobalChatText (name : String, msg : String)
&& &var entry =
new ChatEntry();
&&& entry.name =
&&& entry.text =
chatEntries.Add(entry);
//Remove old
entries&&&&
if (chatEntries.Count & 4)
chatEntries.RemoveAt(0);
&scrollPosition.y
= 1000000;&
//Add game messages
etcfunction
addGameChatMessage(str : String)
&ApplyGlobalChatText("", str);
if(Network.connections.length&0)
networkView.RPC("ApplyGlobalChatText", RPCMode.Others, "",
Example1/Example1_Chat基本是就是教程1的代码加上一个聊天脚本。在游戏里添加一个聊天功能简单的要死。你可以重复使用这个脚本只要没有其他特殊要求。只是记得要对应好玩家的名字。现在可以显示4行聊天信息。你要想修改代码让它能显示更多聊天内容的话，可以用yield或者coroutine来删除或者淡出旧的信息。服务器中保存了一个玩家的列表。在真正的游戏中你应该做一个单独的游戏玩家列表，而不是把玩家列表放在聊天脚本里。
Example2： Masterserver
打开场景“Example2/Example2_menu”.这个例子中使用到了masterserver来显示所有正在进行中的游戏。快速游戏的按钮可以让玩家随机加入第一个可以进入的游戏。下面的进阶选项中玩家可以创建一个服务器，填写IP和端口以便别的玩家可以直接连接到他，或者用masterserver的游戏列表直接手动选一个。唯一没有的功能是用密码开房间。这个功能可以简单的加在创建房间和连接的步骤之间，然后再游戏列表上你要加一个输入密码的窗口。
这个例子中的”游戏“只是展示了怎么连接服务器和客户端，你可以轻易地替换游戏内容，网络功能也一样可以正常使用。你只需要设置“Network.isMessageQueueRunning
”。我们之前把这个函数关掉了，因为在客户端还在加载的时候，我们要防止从游戏局内发出一些无法识别的网络信息。还有一个事就是在服务器开始游戏之后，记得要在masterserver注册一下游戏。
Example 3：Lobby system
“Example3/Example3_lobby”:这个例子和第一个例子很像，唯一的不同是它给每个游戏创建了一个大厅，并且有密码选项。在大厅里，只会显示给玩家masterserver的游戏列表，游戏一旦开始就会被从列表中移除。还是一样，你要想用这些功能，直接拷贝代码然后针对你的游戏做点调整就行，只是记得在游戏场景里开启信息队列。
Example4：FPS game
由于大多数想学unity网络功能的人都想做一个FPS游戏，我决定根据最后一个例子来做一个FPS的游戏。这个FPS例子是用的非权威性服务器，所以如果你愿意，可以重新设计代码，把它改成一个权威性服务器的游戏。
这个例子用了masterserver的代码来连接主菜单。游戏中的功能有：聊天，得分板，移动，射击，拾取物体。
如果你想用这个例子作为基础来写你自己的游戏，你可能用到的新功能大概有：
权威性服务器控制移动：预防作弊
角色动画：远程同步动画，或者让客户端计算何时播放正确的动画
和多人游戏不太相关的项目有：
游戏回合时间
同时打开多个unity（方便网络功能的查错）
你无法打开相同的unity项目两次，所以你要用一个脚本来开第二个unity。你可以拷贝你的项目，一个跑服务器另一个跑客户端，但是你要保存你的改动2次。
Windows上：
修改快捷方式的属性。 在后面加上个
-projectPath，例如：&& "D:\Program
Files\Unity\Editor\Unity.exe" -projectPath
这样的话运行的时候窗口底部会报一个找不到路径的错误，无所谓，clear一次就行。
把Unity.app复制一份。分开运行。
OnSerializeNetworkView bug in 2.6 (and earlier)
我一直都不想用OnSerializeNetworkView
，因为我喜欢RPC~，不过当我用OnSerializeNetworkView
的时候发现它有个缺陷。这个缺陷只发生在你要分配NetworkView ID给你自己的时候。
具体如下：
当你用OnSerializeNetworkView和NetworkView
监视功能的时候，服务器端的玩家没有问题，但是当客户端玩家连接的时候，它会报错说不知道第一个玩家（服务器端玩家）的networkview
"Received state update for view ID ******random info here about
your specific number*** but no
initial state has ever been sent. Ignoring message."
这个问题是因为新的客户端从来没有初始化过他们自己的networkview，所以新的客户端连接的时候就会出问题。
Group limit
你最多只能建32个组，你可以通过代码指定48个组，但是assigning 48 works like assigning
482=16.（完全不明白）
unity2.1有好多新功能，不过好像都不是支持RPC的，只支持OnSerializeNetworkWiew。
当你使用权威性服务器，而且服务器本身也在跑一个玩家的时候，会用到下面的代码：
networkView.RPC("SendUserInput", RPCMode.Server, horizontalInput,
verticalInput);
但是上面的代码其实不能用，用下面的：
if(Network.isServer)
SendUserInput(horizontalInput, verticalInput);
networkView.RPC("SendUserInput", RPCMode.Server,
horizontalInput,verticalInput);
Run dedicated servers（专用服务器）
现在untiy的专业服务器还不太完善，不过也凑合能用。在Mac上面跑专用服务器的话，要执行的时候添加一个批处理参数。
Win从unity2.6开始也加上了相同的功能。参见以下链接
当你用专用服务器的时候，应该用“Application.targetFrameRate”来控制帧率，否则unity可能会把帧率搞的太高，拖慢性能。
Connection issues: How to connect over the internet
（连接问题：如果通过互联网连接）
连接方面来说，本地局域网和互联网差不多，只是局域网速度肯定快一点。当你让你的游戏在局域网上跑起来之后，你会发现在互联网上跑设置起来还是有点麻烦。下面这个表可以帮助你检查哪儿出的问题：
互联网连接不工作：
确定是连接的互联网还是局域网
两台电脑都连接了互联网没？
确定两台电脑的防火墙没有关闭你用到的端口，或者暂时关闭防火墙
尝试一下直接连接，开一个服务器，然后用另一台电脑做客户端直接连接服务器端的互联网网络地址
如果还是连不上，你的路由器可能屏蔽了连接功能，作为安全措施。你有两个选择
1.用NAT穿透（见masterserver例子）然后祈祷你的路由器支持穿透功能。
2.你可以手动在路由器中打开你用到的端口，然后从这个端口转发所有的连接到你的内部局域网IP地址。这个绝对能用，但是你不能保证所有的玩家都会设置路由器端口。
Other networking options
这里是一些unity网络的资料，有一些第三方的网络支持，可以自行查看（2009.8月）
Create your own custom RakNet backend
& Smartfox
& Photon & Neutron from ExitGames
& Project DarkStar
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。