unity的网络通信

迈不过友情╰ 2022-08-08 06:18 175阅读 0赞

（一）unity network初步

**最新消息：在11月2日的开发者大会上，我问了一下unity的人，会不会对网络层进行封装和改进，unity的人表示，最晚5.0，最快4.x版本里，就会加入新的网络通信接口，他们已经在测试阶段了。**

翻了半天unity的API，也没有发现可以处理Socket的方法。Unity自己封了个网络处理的类Network，主要用于状态同步。 似乎是要实现MMO级别的网络应用，只能用C\#自己去写了。（Unity不像AS，有直接处理数据包、字节级别的底层函数。至少现在没有。如果您要应用于实际，比如做了个网游，那么您需要用unity自带的C\#去写一套自定义通信协议来实现。这个我在后面的文章中会写一个示例。）

我们还是先了解一下Unity，看看用Unity自带的组件，如何编写通信，从最简单的开始。

1，新建项目。新建一个项目里面会有一个摄像机。

2，编写**服务器端**代码cs：

**\[csharp\]** [view plain][] [copy][view plain]

1.  **using** UnityEngine; 
2.  **using** System.Collections; 
3.  
4.  **public****class** server : MonoBehaviour \{ 
5.  
6.  **int** Port = 10000; 
7.  
8.  //OnGUI方法，所有GUI的绘制都需要在这个方法中实现
9.  **void** OnGUI()\{ 
10. //Network.peerType是端类型的状态:
11. //即disconnected, connecting, server 或 client四种
12. **switch**(Network.peerType)\{ 
13. //禁止客户端连接运行, 服务器未初始化
14. **case** NetworkPeerType.Disconnected: 
15.  StartServer(); 
16. **break**; 
17. //运行于服务器端
18. **case** NetworkPeerType.Server: 
19.  OnServer(); 
20. **break**; 
21. //运行于客户端
22. **case** NetworkPeerType.Client: 
23. **break**; 
24. //正在尝试连接到服务器
25. **case** NetworkPeerType.Connecting: 
26. **break**; 
27.  \} 
28.  \} 
29. 
30. **void** StartServer()\{ 
31. //当用户点击按钮的时候为true
32. **if** (GUILayout.Button("创建服务器")) \{ 
33. //初始化本机服务器端口，第一个参数就是本机接收多少连接
34.  NetworkConnectionError error = Network.InitializeServer(12,Port,**false**); 
35.  Debug.Log("错误日志"\+error); 
36.  \} 
37.  \} 
38. 
39. **void** OnServer()\{ 
40.  GUILayout.Label("服务端已经运行,等待客户端连接"); 
41. //Network.connections是所有连接的玩家, 数组\[\]
42. //取客户端连接数. 
43. **int** length = Network.connections.Length; 
44. //按数组下标输出每个客户端的IP,Port
45. **for** (**int** i=0; i<length; i++) 
46.  \{ 
47.  GUILayout.Label("客户端"\+i); 
48.  GUILayout.Label("客户端ip"\+Network.connections\[i\].ipAddress); 
49.  GUILayout.Label("客户端端口"\+Network.connections\[i\].port); 
50.  \} 
51. //当用户点击按钮的时候为true
52. **if** (GUILayout.Button("断开服务器"))\{ 
53.  Network.Disconnect(); 
54.  \} 
55.  \} 
56. 
57. 
58. /\* 系统提供的方法，该方法只执行一次 \*/
59. // Use this for initialization
60. **void** Start () \{ 
61. 
62.  \} 
63. 
64. // Update is called once per frame
65. **void** Update () \{ 
66. 
67.  \} 
68. \}

3，把这个代码拖拽到摄像机上。

4，运行程序 File---->Build settings---->Build And Run，选择Web Player

5，服务器端建立完毕，保持服务器端的运行状态。

6，这里可以再新建立个项目写客户端。嫌麻烦也可以像我这样，先把摄像机上的服务器脚本删掉，再把下面的客户端脚本拖拽上去。

**客户端**代码如下：

**\[csharp\]** [view plain][] [copy][view plain]

1.  **using** UnityEngine; 
2.  **using** System.Collections; 
3.  
4.  **public****class** client : MonoBehaviour \{ 
5.  //要连接的服务器地址
6.  **string** IP = "127.0.0.1"; 
7.  //要连接的端口
8.  **int** Port = 10000; 
9.  
10. **void** OnGUI()\{ 
11. //端类型的状态
12. **switch**(Network.peerType)\{ 
13. //禁止客户端连接运行, 服务器未初始化
14. **case** NetworkPeerType.Disconnected: 
15.  StartConnect(); 
16. **break**; 
17. //运行于服务器端
18. **case** NetworkPeerType.Server: 
19. **break**; 
20. //运行于客户端
21. **case** NetworkPeerType.Client: 
22. **break**; 
23. //正在尝试连接到服务器
24. **case** NetworkPeerType.Connecting: 
25. **break**; 
26.  \} 
27.  \} 
28. 
29. 
30. **void** StartConnect()\{ 
31. **if** (GUILayout.Button("连接服务器"))\{ 
32.  NetworkConnectionError error = Network.Connect(IP,Port); 
33.  Debug.Log("连接状态"\+error); 
34.  \} 
35.  \} 
36. 
37. // Use this for initialization
38. **void** Start () \{ 
39. 
40.  \} 
41. 
42. // Update is called once per frame
43. **void** Update () \{ 
44. 
45.  \} 
46. \}

7，运行程序 File---->Build settings---->Build And Run，选择Web Player

（二）unity network聊天

在上一个例子基础上，我们构建一个聊天室程序。

1，首先建立一个新项目，文件夹名为chat。

2，给接收请求的脚本所绑定的对象，添加网络视图组件（听起来有点绕口）。我们的服务器脚本是绑定在主摄像机上的，所以点击主摄像机，在菜单上选择component-->miscellaneous-->Net work View。

3，**服务器端**程序：（C\# 脚本）

**\[csharp\]** [view plain][view plain 1] [copy][view plain 1]

1.  **using** UnityEngine; 
2.  **using** System.Collections; 
3.  
4.  **public****class** server : MonoBehaviour \{ 
5.  
6.  **int** Port = 10100; 
7.  **string** Message = ""; 
8.  //声明一个二维向量 
9.   Vector2 Sc; 
10. 
11. //OnGUI方法，所有GUI的绘制都需要在这个方法中实现
12. **void** OnGUI()\{ 
13. //Network.peerType是端类型的状态:
14. //即disconnected, connecting, server 或 client四种
15. **switch**(Network.peerType)\{ 
16. //禁止客户端连接运行, 服务器未初始化
17. **case** NetworkPeerType.Disconnected: 
18.  StartServer(); 
19. **break**; 
20. //运行于服务器端
21. **case** NetworkPeerType.Server: 
22.  OnServer(); 
23. **break**; 
24. //运行于客户端
25. **case** NetworkPeerType.Client: 
26. **break**; 
27. //正在尝试连接到服务器
28. **case** NetworkPeerType.Connecting: 
29. **break**; 
30.  \} 
31.  \} 
32. 
33. **void** StartServer()\{ 
34. //当用户点击按钮的时候为true
35. **if** (GUILayout.Button("创建服务器")) \{ 
36. //初始化本机服务器端口，第一个参数就是本机接收多少连接
37.  NetworkConnectionError error = Network.InitializeServer(12,Port,**false**); 
38. //连接状态
39. **switch**(error)\{ 
40. **case** NetworkConnectionError.NoError: 
41. **break**; 
42. **default**: 
43.  Debug.Log("服务端错误"\+error); 
44. **break**; 
45.  \} 
46.  \} 
47.  \} 
48. 
49. **void** OnServer()\{ 
50.  GUILayout.Label("服务端已经运行,等待客户端连接"); 
51. //Network.connections是所有连接的玩家, 数组\[\]
52. //取客户端连接数. 
53. **int** length = Network.connections.Length; 
54. //按数组下标输出每个客户端的IP,Port
55. **for** (**int** i=0; i<length; i++) 
56.  \{ 
57.  GUILayout.Label("客户端"\+i); 
58.  GUILayout.Label("客户端ip"\+Network.connections\[i\].ipAddress); 
59.  GUILayout.Label("客户端端口"\+Network.connections\[i\].port); 
60.  GUILayout.Label("-------------------------------"); 
61.  \} 
62. //当用户点击按钮的时候为true
63. **if** (GUILayout.Button("断开服务器"))\{ 
64.  Network.Disconnect(); 
65.  \} 
66. //创建开始滚动视图
67.  Sc = GUILayout.BeginScrollView(Sc,GUILayout.Width(280),GUILayout.Height(400)); 
68. //绘制纹理, 显示内容
69.  GUILayout.Box(Message); 
70. //结束滚动视图, 注意, 与开始滚动视图成对出现
71.  GUILayout.EndScrollView(); 
72.  \} 
73. 
74. //接收请求的方法. 注意要在上面添加\[RPC\]
75.  \[RPC\] 
76. **void** ReciveMessage(**string** msg, NetworkMessageInfo info)\{ 
77. //刚从网络接收的数据的相关信息,会被保存到NetworkMessageInfo这个结构中
78.  Message = "发送端"\+info.sender +"消息"\+msg; 
79. //+"时间"+info.timestamp +"网络视图"+info.networkView
80.  \} 
81. 
82. 
83. // Use this for initialization
84. **void** Start () \{ 
85. 
86.  \} 
87. 
88. // Update is called once per frame
89. **void** Update () \{ 
90. 
91.  \} 
92. \}

4，把脚本拖拽到主摄像机上，绑定。

5，运行程序 File---->Build settings---->Build And Run，选择Web Player

6，服务器端建立完毕，保持服务器端的运行状态。

7，简单起见，我们这里不新建项目。先把摄像机上的服务器脚本删掉，再把下面的客户端脚本拖拽上去。

**客户端**代码：

**\[csharp\]** [view plain][view plain 1] [copy][view plain 1]

1.  **using** UnityEngine; 
2.  **using** System.Collections; 
3.  
4.  **public****class** client : MonoBehaviour \{ 
5.  //要连接的服务器地址
6.  **string** IP = "127.0.0.1"; 
7.  //要连接的端口
8.  **int** Port = 10100; 
9.  //聊天信息
10. **string** Message = ""; 
11. //声明一个二维向量 
12.  Vector2 Sc; 
13. 
14. **void** OnGUI()\{ 
15. //端类型的状态
16. **switch**(Network.peerType)\{ 
17. //禁止客户端连接运行, 服务器未初始化
18. **case** NetworkPeerType.Disconnected: 
19.  StartConnect(); 
20. **break**; 
21. //运行于服务器端
22. **case** NetworkPeerType.Server: 
23. **break**; 
24. //运行于客户端
25. **case** NetworkPeerType.Client: 
26.  OnClient(); 
27. **break**; 
28. //正在尝试连接到服务器
29. **case** NetworkPeerType.Connecting: 
30. **break**; 
31.  \} 
32.  \} 
33. 
34. **void** StartConnect()\{ 
35. **if** (GUILayout.Button("连接服务器"))\{ 
36.  NetworkConnectionError error = Network.Connect(IP,Port); 
37. //连接状态
38. **switch**(error)\{ 
39. **case** NetworkConnectionError.NoError: 
40. **break**; 
41. **default**: 
42.  Debug.Log("客户端错误"\+error); 
43. **break**; 
44.  \} 
45.  \} 
46.  \} 
47. 
48. **void** OnClient()\{ 
49. //创建开始滚动视图
50.  Sc = GUILayout.BeginScrollView(Sc,GUILayout.Width(280),GUILayout.Height(400)); 
51. //绘制纹理, 显示内容
52.  GUILayout.Box(Message); 
53. //文本框
54.  Message = GUILayout.TextArea(Message); 
55. **if** (GUILayout.Button("发送"))\{ 
56. //发送给接收的函数, 模式为全部, 参数为信息
57.  networkView.RPC("ReciveMessage", RPCMode.All, Message); 
58.  \} 
59. //结束滚动视图, 注意, 与开始滚动视图成对出现
60.  GUILayout.EndScrollView(); 
61. 
62.  \} 
63. 
64. //接收请求的方法. 注意要在上面添加\[RPC\]
65.  \[RPC\] 
66. **void** ReciveMessage(**string** msg, NetworkMessageInfo info)\{ 
67. //刚从网络接收的数据的相关信息,会被保存到NetworkMessageInfo这个结构中
68.  Message = "发送端"\+info.sender +"消息"\+msg; 
69.  \} 
70. 
71. // Use this for initialization
72. **void** Start () \{ 
73. 
74.  \} 
75. 
76. // Update is called once per frame
77. **void** Update () \{ 
78. 
79.  \} 
80. \}

服务端运行状态：

![1345789506_2844.jpg][]

客户端运行状态：

![1345789523_5837.jpg][]

（三）unity network物体同步

**在上两篇的基础上，这次我们要做物体同步。使两个物体在两个机器上显示同样的移动效果。这里，使用W、S、A、D四个键位实现前后左右的移动。**

**注意：如果您复制粘贴代码，千万注意文件编码！最好为ANSI，否则会报出各种各样奇怪的错误！**

**步骤：**

1，首先建立一个新工程。

2，添加两个cube，分别重命名为Cube01,和Cube02。这两个cube就是我们要同步的对象。

3，添加一个平行光源，Directional light。否则你在漆黑的场景中，真的很难找到你的cube。

4，调整摄像机、cube、Directional light 的相对位置，使他们在视野内，可以看着它们运行。

![1346205603_9891.jpg][]

5，create一个C\#脚本cube\_move，如下：

**\[csharp\]** [view plain][view plain 2] [copy][view plain 2]

1.  **using** UnityEngine; 
2.  **using** System.Collections; 
3.  
4.  **public****class** cube\_move : MonoBehaviour \{ 
5.  
6.  **string** IP = "192.168.1.6"; 
7.  **int** Port = 10100; 
8.  
9.  **int** moveSpeed = 16; 
10. 
11.  GameObject cube01 = **null**; 
12.  GameObject cube02 = **null**; 
13. 
14.  GameObject myself = **null**; 
15.  GameObject another = **null**; 
16. 
17. // Use this for initialization
18. **void** Start () \{ 
19.  cube01 = GameObject.Find("Cube01"); 
20.  cube02 = GameObject.Find("Cube02"); 
21.  \} 
22. 
23. //OnGUI方法，所有GUI的绘制都需要在这个方法中实现
24. **void** OnGUI()\{ 
25. //Network.peerType是端类型的状态:
26. //即disconnected, connecting, server 或 client四种
27. **switch**(Network.peerType)\{ 
28. //禁止客户端连接运行, 服务器未初始化
29. **case** NetworkPeerType.Disconnected: 
30.  StartServer(); 
31. **break**; 
32. //运行于服务器端
33. **case** NetworkPeerType.Server: 
34.  OnServer(); 
35. **break**; 
36. //运行于客户端
37. **case** NetworkPeerType.Client: 
38. **break**; 
39. //正在尝试连接到服务器
40. **case** NetworkPeerType.Connecting: 
41. **break**; 
42.  \} 
43.  \} 
44. 
45. **void** StartServer()\{ 
46.  GUILayout.Label("同步测试:"); 
47. //当用户点击按钮的时候为true
48. **if** (GUILayout.Button("创建服务器")) \{ 
49. //初始化本机服务器端口，第一个参数就是本机接收多少连接
50.  NetworkConnectionError error = Network.InitializeServer(12,Port,**false**); 
51. //连接状态
52. **switch**(error)\{ 
53. **case** NetworkConnectionError.NoError: 
54. **break**; 
55. **default**: 
56.  Debug.Log("服务端错误"\+error); 
57. **break**; 
58.  \} 
59.  \} 
60. **if** (GUILayout.Button("连接服务器"))\{ 
61.  NetworkConnectionError error = Network.Connect(IP,Port); 
62. //连接状态
63. **switch**(error)\{ 
64. **case** NetworkConnectionError.NoError: 
65. **break**; 
66. **default**: 
67.  Debug.Log("客户端错误"\+error); 
68. **break**; 
69.  \} 
70.  \} 
71.  \} 
72. 
73. **void** OnServer()\{ 
74.  GUILayout.Label("服务端已经运行,等待客户端连接"); 
75. //Network.connections是所有连接的玩家, 数组\[\]
76. //取客户端连接数. 
77. **int** length = Network.connections.Length; 
78. //按数组下标输出每个客户端的IP,Port
79. **for** (**int** i=0; i<length; i++) 
80.  \{ 
81.  GUILayout.Label("客户端"\+i); 
82.  GUILayout.Label("客户端ip"\+Network.connections\[i\].ipAddress); 
83.  GUILayout.Label("客户端端口"\+Network.connections\[i\].port); 
84.  GUILayout.Label("-------------------------------"); 
85.  \} 
86. //当用户点击按钮的时候为true
87. **if** (GUILayout.Button("断开服务器"))\{ 
88.  Network.Disconnect(); 
89.  \} 
90.  \} 
91. 
92. //接收请求的方法. 注意要在上面添加\[RPC\]
93.  \[RPC\] 
94. **void** ProcessMove(**string** msg, NetworkMessageInfo info)\{ 
95. //刚从网络接收的数据的相关信息,会被保存到NetworkMessageInfo这个结构中
96. **string** sender = info.sender.ToString(); 
97. //看脚本运行在什么状态下
98.  NetworkPeerType status = Network.peerType; 
99. **if** (status == NetworkPeerType.Server) 
100.  \{ 
101.  myself = cube01; //假如运行在server状态下, 那么自己就是cube1
102.  another = cube02; 
103. 
104.  \} 
105. **else**
106.  \{ 
107.  myself = cube02; //假如运行在client状态下, 那么自己就是cube2
108.  another = cube01; 
109.  \} 
110. //假如是自己发送的信息
111. **if** (sender == "-1") 
112.  \{ 
113. **if** (msg == "W") 
114.  \{ 
115.  myself.transform.Translate(Vector3.forward \* Time.deltaTime \* moveSpeed); 
116.  \} 
117. **if** (msg == "S") 
118.  \{ 
119.  myself.transform.Translate(Vector3.back \* Time.deltaTime \* moveSpeed); 
120.  \} 
121. **if** (msg == "A") 
122.  \{ 
123.  myself.transform.Translate(Vector3.left \* Time.deltaTime \* moveSpeed); 
124.  \} 
125. **if** (msg == "D") 
126.  \{ 
127.  myself.transform.Translate(Vector3.right \* Time.deltaTime \* moveSpeed); 
128.  \} 
129. 
130.  \} 
131. //假如是别人发送的信息
132. **else**
133.  \{ 
134. **if** (msg == "W") 
135.  \{ 
136.  another.transform.Translate(Vector3.forward \* Time.deltaTime \* moveSpeed); 
137.  \} 
138. **if** (msg == "S") 
139.  \{ 
140.  another.transform.Translate(Vector3.back \* Time.deltaTime \* moveSpeed); 
141.  \} 
142. **if** (msg == "A") 
143.  \{ 
144.  another.transform.Translate(Vector3.left \* Time.deltaTime \* moveSpeed); 
145.  \} 
146. **if** (msg == "D") 
147.  \{ 
148.  another.transform.Translate(Vector3.right \* Time.deltaTime \* moveSpeed); 
149.  \} 
150.  \} 
151.  \} 
152. // Update is called once per frame
153. **void** Update () 
154.  \{ 
155. //前移
156. **if** (Input.GetKeyDown(KeyCode.W)) 
157.  \{ 
158.  Debug.Log("wwwwwwwww|"); 
159.  networkView.RPC("ProcessMove", RPCMode.All, "W"); 
160.  \} 
161. **if** (Input.GetKey(KeyCode.W)) 
162.  \{ 
163.  networkView.RPC("ProcessMove", RPCMode.All, "W"); 
164.  \} 
165. //后退
166. **if** (Input.GetKeyDown(KeyCode.S)) 
167.  \{ 
168.  Debug.Log("sssssssss!"); 
169.  networkView.RPC("ProcessMove", RPCMode.All, "S"); 
170.  \} 
171. **if** (Input.GetKey(KeyCode.S)) 
172.  \{ 
173.  networkView.RPC("ProcessMove", RPCMode.All, "S"); 
174.  \} 
175. //向左移动
176. **if** (Input.GetKeyDown(KeyCode.A)) 
177.  \{ 
178.  networkView.RPC("ProcessMove", RPCMode.All, "A"); 
179.  \} 
180. **if** (Input.GetKey(KeyCode.A)) 
181.  \{ 
182.  networkView.RPC("ProcessMove", RPCMode.All, "A"); 
183.  \} 
184. //向右移动
185. **if** (Input.GetKeyDown(KeyCode.D)) 
186.  \{ 
187.  networkView.RPC("ProcessMove", RPCMode.All, "D"); 
188.  \} 
189. **if** (Input.GetKey(KeyCode.D)) 
190.  \{ 
191.  networkView.RPC("ProcessMove", RPCMode.All, "D"); 
192.  \} 
193.  \} 
194. \}

6，给接收请求的脚本所绑定的对象，添加网络视图组件（听起来有点绕口）。我们的这个脚本是绑定在主摄像机上的，所以点击主摄像机，在菜单上选择component-->miscellaneous-->Net work View。

7，绑定脚本，把脚本拖拽到摄像机上。

8，编译发布成web的：File---->Build settings---->Build And Run，选择Web Player

9，拷贝编译出来的文件夹，到另一台机器上。

10，分别在两台机器上运行服务器端和客户端。

你会看到同步的效果了。

附注：在一台机器上，不太容易看到效果。因为浏览器失焦后，似乎无法刷新画面，导致同步效果不明显。

**Ps. 这个代码只是unity自带的网络组件示例。在实际应用中，不能直接应用。需要用unity底层支持的C\#语言，重新写一套通信框架。我已经写了一套，但是没有时间发博客。改天发出来。**

[view plain]: http://blog.csdn.net/chenggong2dm/article/details/7896440#
[view plain 1]: http://blog.csdn.net/chenggong2dm/article/details/7899577#
[1345789506_2844.jpg]: https://img-my.csdn.net/uploads/201208/24/1345789506_2844.jpg
[1345789523_5837.jpg]: https://img-my.csdn.net/uploads/201208/24/1345789523_5837.jpg
[1346205603_9891.jpg]: https://img-my.csdn.net/uploads/201208/29/1346205603_9891.jpg
[view plain 2]: http://blog.csdn.net/chenggong2dm/article/details/7917125#