Untiy 网络通信。。三合一。。。。

最新推荐文章于 2025-04-09 09:14:43 发布
最新推荐文章于 2025-04-09 09:14:43 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： U3D网络 文章标签： 网络 服务器 vector 脚本 server string

 

 

 

Unity 网络通信（一）Unity Network 初步

 

翻了半天unity的API，也没有发现可以处理Socket的方法。Unity自己封了个网络处理的类Network，主要用于状态同步。 似乎是要实现MMO级别的网络应用，只能用C#自己去写了。（Unity不像AS，有直接处理数据包、字节级别的底层函数。至少现在没有。）

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


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

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

[csharp] view plain copy print ?
  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. }  
using UnityEngine;
using System.Collections;

public class server : MonoBehaviour {
	
	int Port = 10000;
	
	//OnGUI方法，所有GUI的绘制都需要在这个方法中实现
	void OnGUI(){
		//Network.peerType是端类型的状态:
		//即disconnected, connecting, server 或 client四种
		switch(Network.peerType){
			//禁止客户端连接运行, 服务器未初始化
			case NetworkPeerType.Disconnected:
				StartServer();
			    break;
			//运行于服务器端
			case NetworkPeerType.Server:
				OnServer();
			    break;
			//运行于客户端
			case NetworkPeerType.Client:
			    break;
			//正在尝试连接到服务器
			case NetworkPeerType.Connecting:
				break;
		}
	}
	
	void StartServer(){
		//当用户点击按钮的时候为true
		if (GUILayout.Button("创建服务器")) {
			//初始化本机服务器端口，第一个参数就是本机接收多少连接
			NetworkConnectionError error = Network.InitializeServer(12,Port,false);
			Debug.Log("错误日志"+error);
		}
	}
	
	void OnServer(){
		GUILayout.Label("服务端已经运行,等待客户端连接");
		//Network.connections是所有连接的玩家, 数组[]
		//取客户端连接数. 
		int length = Network.connections.Length;
		//按数组下标输出每个客户端的IP,Port
		for (int i=0; i<length; i++)
		{
			GUILayout.Label("客户端"+i);
			GUILayout.Label("客户端ip"+Network.connections[i].ipAddress);
			GUILayout.Label("客户端端口"+Network.connections[i].port);
		}
		//当用户点击按钮的时候为true
		if (GUILayout.Button("断开服务器")){
			Network.Disconnect();
		}
	}
	
	
	/* 系统提供的方法，该方法只执行一次 */
	// Use this for initialization
	void Start () {
	
	}
	
	// Update is called once per frame
	void Update () {
	
	}
}

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

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

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

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

客户端代码如下：

[csharp] view plain copy print ?
  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. }  
using UnityEngine;
using System.Collections;

public class client : MonoBehaviour {
	//要连接的服务器地址
	string IP = "127.0.0.1";
	//要连接的端口
	int Port = 10000;
		
	void OnGUI(){
		//端类型的状态
		switch(Network.peerType){
			//禁止客户端连接运行, 服务器未初始化
			case NetworkPeerType.Disconnected:
				StartConnect();
			    break;
			//运行于服务器端
			case NetworkPeerType.Server:
			    break;
			//运行于客户端
			case NetworkPeerType.Client:
			    break;
			//正在尝试连接到服务器
			case NetworkPeerType.Connecting:
				break;
		}
	}
		
		
	void StartConnect(){
		if (GUILayout.Button("连接服务器")){
			NetworkConnectionError error = Network.Connect(IP,Port);
			Debug.Log("连接状态"+error);
		}
	}
		
	// Use this for initialization
	void Start () {
	
	}
	
	// Update is called once per frame
	void Update () {
	
	}
}

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

8，结果如下，可以通信。



附注： 本文大部分代码出自《Unity 3D 游戏开发》，作者宣雨松。


 

Unity网络通信（二）Unity Network 聊天

 

 

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

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

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

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

[csharp] view plain copy print ?
  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. }  
using UnityEngine;
using System.Collections;

public class server : MonoBehaviour {
	
	int Port = 10100;
	string Message = "";
	//声明一个二维向量 
	Vector2 Sc; 
	
	//OnGUI方法，所有GUI的绘制都需要在这个方法中实现
	void OnGUI(){
		//Network.peerType是端类型的状态:
		//即disconnected, connecting, server 或 client四种
		switch(Network.peerType){
			//禁止客户端连接运行, 服务器未初始化
			case NetworkPeerType.Disconnected:
				StartServer();
			    break;
			//运行于服务器端
			case NetworkPeerType.Server:
				OnServer();
			    break;
			//运行于客户端
			case NetworkPeerType.Client:
			    break;
			//正在尝试连接到服务器
			case NetworkPeerType.Connecting:
				break;
		}
	}
	
	void StartServer(){
		//当用户点击按钮的时候为true
		if (GUILayout.Button("创建服务器")) {
			//初始化本机服务器端口，第一个参数就是本机接收多少连接
			NetworkConnectionError error = Network.InitializeServer(12,Port,false);
			//连接状态
			switch(error){
				case NetworkConnectionError.NoError:
				    break;
			    default:
			        Debug.Log("服务端错误"+error);
				    break;
			}
		}
	}
	
	void OnServer(){
		GUILayout.Label("服务端已经运行,等待客户端连接");
		//Network.connections是所有连接的玩家, 数组[]
		//取客户端连接数. 
		int length = Network.connections.Length;
		//按数组下标输出每个客户端的IP,Port
		for (int i=0; i<length; i++)
		{
			GUILayout.Label("客户端"+i);
			GUILayout.Label("客户端ip"+Network.connections[i].ipAddress);
			GUILayout.Label("客户端端口"+Network.connections[i].port);
			GUILayout.Label("-------------------------------");
		}
		//当用户点击按钮的时候为true
		if (GUILayout.Button("断开服务器")){
			Network.Disconnect();
		}
		//创建开始滚动视图
		Sc = GUILayout.BeginScrollView(Sc,GUILayout.Width(280),GUILayout.Height(400));
		//绘制纹理, 显示内容
		GUILayout.Box(Message);
		//结束滚动视图, 注意, 与开始滚动视图成对出现
		GUILayout.EndScrollView();	
	}
	
	//接收请求的方法. 注意要在上面添加[RPC]
	[RPC]
	void ReciveMessage(string msg, NetworkMessageInfo info){
		//刚从网络接收的数据的相关信息,会被保存到NetworkMessageInfo这个结构中
		Message = "发送端"+info.sender  +"消息"+msg;
		//+"时间"+info.timestamp +"网络视图"+info.networkView
	}
	
	
	// Use this for initialization
	void Start () {
	
	}
	
	// Update is called once per frame
	void Update () {
	
	}
}

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

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

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

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

客户端代码：

[csharp] view plain copy print ?
  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. }  
using UnityEngine;
using System.Collections;

public class client : MonoBehaviour {
	//要连接的服务器地址
	string IP = "127.0.0.1";
	//要连接的端口
	int Port = 10100;
	//聊天信息
	string Message = "";
	//声明一个二维向量 
	Vector2 Sc; 
		
	void OnGUI(){
		//端类型的状态
		switch(Network.peerType){
			//禁止客户端连接运行, 服务器未初始化
			case NetworkPeerType.Disconnected:
				StartConnect();
			    break;
			//运行于服务器端
			case NetworkPeerType.Server:
			    break;
			//运行于客户端
			case NetworkPeerType.Client:
			    OnClient();
			    break;
			//正在尝试连接到服务器
			case NetworkPeerType.Connecting:
				break;
		}
	}
		
	void StartConnect(){
		if (GUILayout.Button("连接服务器")){
			NetworkConnectionError error = Network.Connect(IP,Port);
			//连接状态
			switch(error){
				case NetworkConnectionError.NoError:
				    break;
			    default:
			        Debug.Log("客户端错误"+error);
				    break;
			}
		}
	}
	
	void OnClient(){
		//创建开始滚动视图
		Sc = GUILayout.BeginScrollView(Sc,GUILayout.Width(280),GUILayout.Height(400));
		//绘制纹理, 显示内容
		GUILayout.Box(Message);
		//文本框
		Message = GUILayout.TextArea(Message);
		if (GUILayout.Button("发送")){
			//发送给接收的函数, 模式为全部, 参数为信息
			networkView.RPC("ReciveMessage", RPCMode.All, Message);
		}
		//结束滚动视图, 注意, 与开始滚动视图成对出现
		GUILayout.EndScrollView();
		
	}
	
    //接收请求的方法. 注意要在上面添加[RPC]
	[RPC]
	void ReciveMessage(string msg, NetworkMessageInfo info){
		//刚从网络接收的数据的相关信息,会被保存到NetworkMessageInfo这个结构中
		Message = "发送端"+info.sender  +"消息"+msg;
	}
		
	// Use this for initialization
	void Start () {
	
	}
	
	// Update is called once per frame
	void Update () {
	
	}
}

服务端运行状态：



客户端运行状态：


附注： 本文大部分代码出自《Unity 3D 游戏开发》，作者宣雨松。

 

 

 

 

Unity网络通信（三）同步物体

 

在上两篇的基础上，这次我们要做物体同步。使两个物体在两个机器上显示同样的移动效果。当然，换成角色的话，就是角色同步了。这里，使用W、S、A、D四个键位实现前后左右的移动，像《魔兽世界》那样。

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

 

步骤：

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

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

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

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

5，create一个C#脚本cube_move，如下：

[csharp] view plain copy print ?
  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. }  
using UnityEngine;
using System.Collections;

public class cube_move : MonoBehaviour {
	
	string IP = "192.168.1.6";
   	int Port = 10100;
	
	int moveSpeed = 16;
	
	GameObject cube01 = null;
	GameObject cube02 = null;
	
	GameObject myself = null;
	GameObject another = null;
	
	// Use this for initialization
	void Start () {
		cube01 = GameObject.Find("Cube01");
		cube02 = GameObject.Find("Cube02");
	}
	
	//OnGUI方法，所有GUI的绘制都需要在这个方法中实现
	void OnGUI(){
		//Network.peerType是端类型的状态:
		//即disconnected, connecting, server 或 client四种
		switch(Network.peerType){
			//禁止客户端连接运行, 服务器未初始化
			case NetworkPeerType.Disconnected:
				StartServer();
			    break;
			//运行于服务器端
			case NetworkPeerType.Server:
				OnServer();
			    break;
			//运行于客户端
			case NetworkPeerType.Client:
			    break;
			//正在尝试连接到服务器
			case NetworkPeerType.Connecting:
				break;
		}
	}
	
	void StartServer(){
		GUILayout.Label("同步测试:");
		//当用户点击按钮的时候为true
		if (GUILayout.Button("创建服务器")) {
			//初始化本机服务器端口，第一个参数就是本机接收多少连接
			NetworkConnectionError error = Network.InitializeServer(12,Port,false);
			//连接状态
			switch(error){
				case NetworkConnectionError.NoError:
				    break;
			    default:
			        Debug.Log("服务端错误"+error);
				    break;
			}
		}
		if (GUILayout.Button("连接服务器")){
			NetworkConnectionError error = Network.Connect(IP,Port);
			//连接状态
			switch(error){
				case NetworkConnectionError.NoError:
				    break;
			    default:
			        Debug.Log("客户端错误"+error);
				    break;
			}
		}
	}
	
	void OnServer(){
		GUILayout.Label("服务端已经运行,等待客户端连接");
		//Network.connections是所有连接的玩家, 数组[]
		//取客户端连接数. 
		int length = Network.connections.Length;
		//按数组下标输出每个客户端的IP,Port
		for (int i=0; i<length; i++)
		{
			GUILayout.Label("客户端"+i);
			GUILayout.Label("客户端ip"+Network.connections[i].ipAddress);
			GUILayout.Label("客户端端口"+Network.connections[i].port);
			GUILayout.Label("-------------------------------");
		}
		//当用户点击按钮的时候为true
		if (GUILayout.Button("断开服务器")){
			Network.Disconnect();
		}
	}
	
	//接收请求的方法. 注意要在上面添加[RPC]
	[RPC]
	void ProcessMove(string msg, NetworkMessageInfo info){
		//刚从网络接收的数据的相关信息,会被保存到NetworkMessageInfo这个结构中
		string sender = info.sender.ToString();
		//看脚本运行在什么状态下
		NetworkPeerType status = Network.peerType;
		if (status == NetworkPeerType.Server) 
		{
			myself = cube01;  //假如运行在server状态下, 那么自己就是cube1
			another = cube02;
			
		}
		else
		{
			myself = cube02;  //假如运行在client状态下, 那么自己就是cube2
			another = cube01;
		}
		//假如是自己发送的信息
		if (sender == "-1")
		{
			if (msg == "W")
			{
				myself.transform.Translate(Vector3.forward * Time.deltaTime * moveSpeed);
			}
			if (msg == "S")
			{
				myself.transform.Translate(Vector3.back * Time.deltaTime * moveSpeed);
			}
			if (msg == "A")
			{
				myself.transform.Translate(Vector3.left * Time.deltaTime * moveSpeed);
			}
			if (msg == "D")
			{
				myself.transform.Translate(Vector3.right * Time.deltaTime * moveSpeed);
			}
			
		}
		//假如是别人发送的信息
	    else
		{
			if (msg == "W")
			{
				another.transform.Translate(Vector3.forward * Time.deltaTime * moveSpeed);
			}
			if (msg == "S")
			{
				another.transform.Translate(Vector3.back * Time.deltaTime * moveSpeed);
			}
			if (msg == "A")
			{
				another.transform.Translate(Vector3.left * Time.deltaTime * moveSpeed);
			}
			if (msg == "D")
			{
				another.transform.Translate(Vector3.right * Time.deltaTime * moveSpeed);
			}
		}
	}
	// Update is called once per frame
	void Update () 
	{
		//前移
		if (Input.GetKeyDown(KeyCode.W))
		{
			Debug.Log("wwwwwwwww|");
			networkView.RPC("ProcessMove", RPCMode.All, "W");
		}
		if (Input.GetKey(KeyCode.W))
		{
			networkView.RPC("ProcessMove", RPCMode.All, "W");
		}
		//后退
	    if (Input.GetKeyDown(KeyCode.S))
		{
			Debug.Log("sssssssss!");
			networkView.RPC("ProcessMove", RPCMode.All, "S");
		}
		if (Input.GetKey(KeyCode.S))
		{
			networkView.RPC("ProcessMove", RPCMode.All, "S");
		}
		//向左移动
		if (Input.GetKeyDown(KeyCode.A))
		{
			networkView.RPC("ProcessMove", RPCMode.All, "A");
		}
		if (Input.GetKey(KeyCode.A))
		{
			networkView.RPC("ProcessMove", RPCMode.All, "A");
		}
		//向右移动
		if (Input.GetKeyDown(KeyCode.D))
		{
			networkView.RPC("ProcessMove", RPCMode.All, "D");
		}
		if (Input.GetKey(KeyCode.D))
		{
			networkView.RPC("ProcessMove", RPCMode.All, "D");
		}
	}
}

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

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

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

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

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

 

你会看到同步的效果了。

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

 


原址：http://blog.youkuaiyun.com/chenggong2dm/article/details/7896440

12 Python学习总结：网络通信知识点总结
数据知道的博客
07-30 3万+
Python 提供了丰富的库和工具，用于实现网络通信。无论是构建客户端-服务器应用，还是进行网络数据抓取，Python 都能轻松应对。以下是 Python 网络通信的详细总结。
【网络进阶】网络问题排查实例集锦（实战经验分享）
热门推荐
dvlinker的技术专栏
05-08 3万+
本文详细讲述了实际项目中遇到的多个网络问题的排查过程，以供参考！
【Unity3D技巧】在Unity中使用事件/委托机制（event/delegate）进行GameObject之间的通信...
weixin_30544657的博客
06-13 649
作者：王选易，出处：http://www.cnblogs.com/neverdie/ 欢迎转载，也请保留这段声明。如果你喜欢这篇文章，请点【推荐】。谢谢！ 引子 在前面两篇文章： 【Unity3D基础教程】给初学者看的Unity教程（四）：通过制作Flappy Bird了解Native 2D中的RigidBody2D和Collider2D 【Unity3D基础教程】给初学者看的Un...
Unity 游戏框架搭建 2019 (五十) 消息机制小结
凉鞋的笔记
05-29 1225
我们花了 5 篇文章学习了消息机制的方方面面。并且完成了一个简易消息机制，之后集成到了我们的 MonoBehaviourSimplify 里。 现在 MonoBehaviourSimplify 有一点框架的感觉了。因为 MonoBehaviourSimplify 在提供消息功能的同时，决定了项目脚本中的交互方式。而目前的这套结构，足够用它来完成一个比较小的项目了。 消息机制是笔者在接触单例之后，第二次被震撼到的设计模式（观察者模式/发布者订阅者模式）。而笔者在初学的时候，还不太敢去设计 MonoBehavi
Unity——网络游戏通信方案
m0_51743362的博客
05-22 3094
目录 弱联网和强联网游戏 弱联网游戏 强联网游戏 弱联网游戏代表 强联网游戏代表 长连接和短连接游戏 短连接游戏 通信特点 通信方式 长连接游戏 通信特点 通信方式 Socket、HTTP、FTP Socket Http/Ht...
用 Unity 做个游戏（八） - 客户端逻辑结构和网络同步机制
weixin_33700350的博客
04-12 460
本文首发自inspoy的杂七杂八 | 菜鸡inspoy的学习记录 前言 距离上一篇又差不多一周多了，果然写代码要比写博客轻松多了orz经过了漫长的无聊的准备，这次终于开始正式写游戏逻辑相关的内容了，当然，到目前为止的代码可以直接拿来做任意一个游戏，这也算是个好处吧233断断续续写了一周的代码，到目前为止已经基本实现了：登陆，加入战斗，同步移动。其中同步移动是重点，之前的坑里就是因为这一点导致爆炸，...
Unity 游戏框架搭建 (五) 简易消息机制
m0_37680204的博客
05-31 654
什么是消息机制? 23333333，让我先笑一会。 为什么用消息机制?   三个字,解!!!!耦!!!!合!!!!。 我的框架中的消息机制用例: 1.接收者 using UnityEngine; using System.Collections; using QFramework; /// /// 1.接收者需要实现IMsgReceiver接口。 /// 2.使用
【小沐学C++】C++实现socket网络通信
爱看书的小沐
11-15 1万+
C++实现socket通信1、简介2、TCP方式2.1 服务端2.2 客户端后续 1、简介 socket顾名思义就是套接字的意思，用于描述地址和端口，是一个通信链的句柄。应用程序通过socket向网络发出请求或者回应。 socket编程有三种，流式套接字（SOCK_STREAM）,数据报套接字(SOCK_DGRAM),原始套接字(SOCK_RAW),前两者较常用。基于TCP的socket编程是流式套接字。 2、TCP方式 Server Initialize Winsock. Create a sock
华为 Python网络自动化
艺博东的博客
02-08 1万+
光棍二十年，不知道情人节是什么鬼东西。还是好好学技术吧！努力、奋斗吧！为了早日走向人生巅峰，迎娶白富美！拼了 文章目录1、安装环境并导入相关模块2、创建VLAN并配置IP地址和路由协议2.1 拓扑2.2 简单配置与测试2.3 python脚本3、telnet 远程登录管理设备3.1 拓扑3.2 简单配置与测试3.3 python脚本 1、安装环境并导入相关模块 首先是安装好Python3环境，接着安装Param
【小沐学Python】Python实现socket网络通信
爱看书的小沐
11-16 3147
Python 提供了两个级别访问的网络服务： - 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统 Socket 接口的全部方法。 - 高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。
出现 This failure was cached in the local repository and resolution is not reattempted until 解决方法（万能）
码农研究僧的博客
04-28 4830
cn.iocoder.boot:yudao-dependencies:pom:2.0.1-jdk8-snapshot was not found in https://maven.aliyun.com/repository/public during a previous attempt. This failure was cached in the local repository and resolution is not reattempted until the update interval of
Linux C/C++编程之（十七）进程间通信
种树最好的时间是10年前，其次是现在！！！
07-07 8826
文章目录一、概述 一、概述
无涯教程-Lua - repeat...until 语句函数
无涯教程
08-02 1376
与 for 和 while 循环(它们在循环顶部测试循环条件)不同，Lua编程中的循环语言在循环的底部检查其条件。循环与while循环相似，不同之处在于，保证循环至少执行一次。
Unity 网络游戏同步方式
起个名字好难啊
12-06 1359
对于联网游戏来讲，同步的方式主要分为两种，状态同步、帧同步。 1、状态同步：顾名思义，是指的将其他玩家的状态行为同步的方式，一般情况下AI逻辑，技能逻辑，战斗计算都由服务器运算，只是将运算的结果同步给客户端，客户端只需要接受服务器传过来的状态变化，然后更新自己本地的动作状态、Buff状态，位置等就可以了，但是为了给玩家好的体验，减少同步的数据量，客户端也会做很多的本地运算，减少服务器同步的频率以...
禁用 WebSocket 项目中的进度条显示并更新 pip 安装方式
最新发布
Mr数据杨
04-09 104
在使用 WebSocket 时，由于进度条展示对funasr项目的兼容性差，修改成本高，因此需要直接禁用进度条。同时，为确保模型依赖项安装使用的是当前虚拟环境的 pip，也需要调整相关安装方法。
无需libpacp库，BPF指令高效捕获指定数据包
Lucky小小吴的小屋
04-08 718
无需libpacp库，BPF指令高效捕获指定数据包
[ 计算机网络 ] | HTTP协议(一)
2501_90686778的博客
04-05 818
问号之前是我们要请求的资源，后面的是我们传递给的参数，key=value的格式，如果是若个参数，使用&符号将他们级联起来。我们使用IP地址来定位全网中的唯一一台机器(网络)，使用路径在这台机器中定位唯一一个资源(系统)，因为我们使用的Google浏览器只要知道了我们访问时候使用的协议，会为我们做缺省端口的填写。-> 上网的所有行为都是在做IO。http的响应与请求格式基本一致，在响应行中多了个状态码和状态描述，这一部分比如就是。URL中的 / 不一定是根目录，他其实叫做web根目录，两者不一定是同一个。
202年充电计划——自学手册 网络安全（黑客技术）
2401_85027424的博客
04-02 2208
网络安全可以基于攻击和防御视角来分类，我们经常听到的 “红队”、“渗透测试” 等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。走安全行业的工程方向的，技术上面其实有很大的重叠性，抛开甲乙方、岗位名称、岗位职责等因素来看，作为学技术的，也根据以往我们给学员推荐就业和入职情况来看，只要好好掌握以下几种技术（网络协议与安全设备、Linux操作系统、Web服务部署/开发、主流渗透测试/安全工具、一门及以上的编程语言）中的2到3个，都可以较好的胜任工作需求。
网络层IP协议
小何代码咖啡馆
04-05 719
所谓的IP分片就是在网络层将有效载荷进行切分，而切分的依据就是数据链路层的MTU（Maximum Transmission Unit），在Linux中，这个值一般是1500字节。发送方的网络层需要根据MTU进行分片，那么对应的接收方就需要对分片的数据进行组装但是如果出现分片，那么就会增加丢包的概率，假如，一个包丢包的概率为0.01，那么对应的接收方正常收到数据的概率就是0.99，如果需要分片为10个数据，此时丢包的概率就变成了1−0.99101−0.9910。
阻塞模式实现网络通信c代码
10-16
阻塞模式在网络通信中通常指的是客户端在发送数据到服务器后，会等待服务器的响应，直到接收到确认信息才会继续执行后续操作。在C语言中，可以使用socket API来实现这种模式，下面是一个简单的TCP客户端和服务器的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值