Unity3d网络总结NetWork组件使用
Unity3d网络总结(一) NetWork组件使用
学习Unity3d的过程中,经常上网查阅各位大牛的博客,受益匪浅,从今天开始写自己在学习过程中遇到的问题,总结归纳下来,方便日后复习
这两天在学习Unity的网络模块,今天先总结Unity自带的Network组件相关使用方法
1.网络管理物体
搭建网络,需要先创建一个空物体用来添加网络管理组件,首先要给空物体添加以下两个组件
注意事项: 1. OffLine Scene代表客户端连接服务器前,等待的场景(游戏大厅)
. OnLine Scene代表客户端连接服务器后的场景 (游戏场景)
2.Spawn Info 服务器卵生信息 : 把网络预设体(必须挂有网络组件) 拖入PlayerPrefab , 服务器会把游戏对象孪生到所有连接的客户端中
二.游戏对象
1.Network Identity
游戏对象(网络预设体)需要挂Network Identity组件,该组件是网络的核心,由服务器Spwan(卵生)的物体都必须具备,该组件在卵生的时候会自动分配assetID和权限
注意事项:1.ServerOnly 勾选后物体只在服务器中存在
2.Local Player Authority勾选后在客户端中存在
2.实现状态同步
游戏对象的控制脚本需要继承NetWorkBehaviour组件(依赖于NetWorkIdentity),用来实现RPC技术和状态同步属性.
1.Transform同步
这个组件负责玩家对象在客户端发出移动指令后,把该玩家的移动同步到所有客户端中
注意事项:1.Net Work Send Rate 表示同步Transform的频率
2.Transform Synv Mode 表示同步的模式,可以选择同步刚体组件,角色控制器等
然后在控制脚本编写代码
public class ControlMove : NetworkBehaviour {
void Update() {
if (!isLocalPlayer) //判断是否是本地客户端 {
return;
}
float x = Input.GetAxis("Horizontal");
float y = Input.GetAxis("Vertical");
if (x != 0 || y != 0)
{
transform.position += new Vector3(x, 0, y);
}
这里需要注意的有两点 1.所有网络控制脚本必须要继承 NetWorkBehaviour
2.在Update里需要先判断是否是本地客户端,不是的话Return~!!! 如果没有这个判断条件,在客户端发出指令,网络里所有的客户端都会执行
2.发射子弹与减血的同步
经过上边的步骤,已经可以实现物体在网络里的移动,但我们想要实现在网络里发射子弹,受到攻击后还要减血,这些指令都需要在服务器上执行,先来看一下NetWorkBehaviour的常用特性
[SyncVar] 用于标识序列化变量,实现变量同步 例: (把Hp标识,就可以实现同步减血)
[Client] 表示只能在客户端调用
[ClientCallBack] 表示客户端执行的回调
[Command] 表示客户端向服务端发送的命令,在服务端执行
[ClientPrc] 表示服务端向客户端发送的命令,在客户端执行
直接来看代码如何使用:
//将血量设置为网络同步变量 [SyncVar]
float hp = 100;
public Slider slider; //显示血量的血条
public GameObject bullet; //子弹预设体
void Start () {
ClientScene.RegisterPrefab(bullet); //在场景注册预设体 }
void Update () {
// 2.将血量的值赋给slider
slider.value = hp / 100f;
if (!isLocalPlayer)
{
return;
}
if (Input.GetKeyDown(KeyCode.Q))
{
CmdReduceHp();
}
if (Input.GetKeyDown(KeyCode.T))
{
CmdFire();
}
}
//减血的方法 标识为Command由服务器执行
//前缀必须是Cmd 开头 [Command]
public void CmdReduceHp()
{
hp -= 10;
} //发射子弹的方法 [Command]
public void CmdFire()
{
GameObject a= Instantiate(bullet, transform.position+transform.right, Quaternion.identity);
a.GetComponent<Rigidbody>().AddForce(transform.right*100); //给子弹添加向右的力
NetworkServer.Spawn(a); //由服务器卵生给连接的客户端
}
注意事项:1.网络预设体需要先在客户端场景里注册一下,才能正常产生
2.hp赋值给Slider要写在判断是否是本地客户端前,血条才会正常同步显示
3.Command修饰的方法,由客户端发起,服务端执行,方法名前必须加Cmd
4.监听键盘事件的Iput.GetKeyDown要放在Update里,不能放在Cmd方法里!!! (此时方法由服务器调用,无法监听键盘事件)
3.动画的同步
要实现游戏对象的动画同步,还需要添加一个网络组件,并给组件指定Animator,并勾选Animator里包含的动画.
动画同步需要注意一点,过度条件是Trigger时需要由客户端发起指令,在服务端执行,再分发给各个客户端执行,其他条件正常.
这里Animator的两个动画,attack01条件是bool,attack02条件是Trigger ,代码如下:
Animator ani;
void Start()
{
ani = GetComponent<Animator>();
}
void Update () {
if (Input.GetKeyDown(KeyCode.Q))
{
ani.SetBool("attack01", !ani.GetBool("attack01"));
}
if (Input.GetKeyDown(KeyCode.E))
{
CmdAttack02();
}
}
[Command] //服务器执行
void CmdAttack02()
{
RpcPlayTrigger();
}
[ClientRpc] //由服务器端调用,在客户端执行
void RpcPlayTrigger()
{
ani.SetTrigger("attack02");
}
Unity3d网络总结(二)使用NetWorking代码搭建简单的网络模块
上一篇文章(http://www.cnblogs.com/dabaimifan/p/7212615.html)介绍了通过给物体添加NetWorking相关组件实现简单的搭建一个网络,本文通过C#代码搭建一个简单的网路,详细解释会在代码里注释,供新手学习使用
首先,引入UnityEngine下的NetWorking命名空间,并初始化相关对象,提前创建好预设体并放入Resources文件夹下,这里需要注意的是在Start里调用方法让程序保持在后台运行,不然客户端会连接不上服务器(后台),
public class NetManager : MonoBehaviour {
//创建客户端 NetworkClient MyClient;
//创建预设体 网络对象 GameObject playerPre;
void Start ()
{
//保持程序后台运行
Application.runInBackground = true;
playerPre = Resources.Load("Player") as GameObject;
//初始化客户端
MyClient = new NetworkClient();
}
然后写 创建服务器的方法
//创建服务器的方法
public void InitServerAction()
{
if (!NetworkServer.active)
{
//创键并开启服务器,服务器开始监听
// 默认ip地址 为127.0.0.1
NetworkServer.Listen("127.0.0.1", 1345);
Debug.Log("服务器已经开启");
//给服务器注册回调方法(ServerAddPlayerCallback) NetworkServer.RegisterHandler(MsgType.AddPlayer, ServerAddPlayerCallback);
//将服务器也初始化 为一个客户端
MyClient = ClientScene.ConnectLocalServer();
//注册客户端连接之后的回调方法(ClientConnectServerCallback) MyClient.RegisterHandler(MsgType.Connect, ClientConnectServerCallback);
}
}
写服务器添加玩家后的回调方法(ServerAddPlayerCallback) 与客户端连接之后的回调方法(ClientConnectServerCallback):
//服务器接收客户端发送的添加游戏玩家之后执行的回调方法
void ServerAddPlayerCallback(NetworkMessage msg)
{
//创建一个游戏对象
GameObject player= Instantiate(playerPre,new Vector3(0,0,0),Quaternion.identity);
//将创建的网络对象的权限赋值给客户端
NetworkServer.AddPlayerForConnection(msg.conn, player,31);
//将该玩家的对象卵生到所有连接服务器的客户端 NetworkServer.Spawn(player);
}//客户端连接之后的回调方法
void ClientConnectServerCallback(NetworkMessage msg)
{
//告诉服务器准备完毕 ClientScene.Ready(msg.conn);
//向服务器注册预设体(预设体必须是网络对象) ClientScene.RegisterPrefab(playerPre);
//向服务器发送添加游戏对象的请求
//服务器在接收这个请求之后会自动调用 添加游戏玩家的回调方法
ClientScene.AddPlayer(31);
}
再写一个客户端连接服务器的方法:
//客户端连接服务器的事件
public void ClientConnectServerAction()
{
//连接服务器
MyClient.Connect("127.0.0.0", 1345);
//注册客户端连接之后的回调方法 MyClient.RegisterHandler(MsgType.Connect, ClientConnectServerCallback);
}
最后我们用GUI添加两个Button绑定事件
private void OnGUI()
{
if (GUI.Button(new Rect(10, 10,100, 30), "server"))
{
InitServerAction();
}
if (GUI.Button(new Rect(10, 50, 100, 30), "client"))
{
ClientConnectServerAction();
}
}
效果图
运行,点击Server创建服务器
打包程序并运行,点击Client连接服务器
Unity3d网络总结(三) 封装Socket创建简单网络
这次自己搭建一个Socket模块,比较基础,适合新手学习,详细介绍Socket的搭建过程,同样会把详细过程在代码里进行注释~
在搭建Socket过程中,需要创建以下几个常用的方法:
1.创建套接字(socket)
2.绑定Ip和端口
3.监听方法
4.接收客户端请求的方法
5.收发消息的方法
创建SocketManger管理类
把客户端与服务端代码都写在新建的SocketManger里,并把SocketManger写成单例,方便调用
using System.Net;//引入套接字协议类using System.Net.Sockets;using System;using System.Text;
public class SocketManager {
#region 单例类
private static SocketManager instance;
private SocketManager()
{
}
public static SocketManager Instance
{
get
{
if (instance == null)
{
instance = new SocketManager();
}
return instance;
}
}
#endregion
public delegate void MyCallBack(string msg); //声明一个委托类型,在服务器和客户端工作的时候,会使用这个回调方法反馈当前交互的具体情况
服务端代码
#region 服务器代码
/* 创建服务器
* 等待客户端的连接
* 接受消息
*/
Socket serverSocket; //创建服务器的套接字对象
MyCallBack serverCallBack; //定义一个服务器使用的回调委托对象
byte[] serverBuffer; //数据缓存区 文字,音频,视频,图片...
public void InitServer(MyCallBack callBack)
{
serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //参数(1.使用IP地址的类型 2.套接字类型,使用TCP的流式传输 3.使用TCP协议)
serverBuffer = new byte[1024]; //初始化缓冲区的大小
serverCallBack = callBack; //绑定初始化服务器的回调方法
IPEndPoint point = new IPEndPoint(IPAddress.Any, 34567); //参数(1.地址,代表一台电脑, 2.端口号表示一个应用)
serverSocket.Bind(point); //绑定地址节点
serverSocket.Listen(10); //开始监听, 一旦监听成功,服务器就启动,10代表最大监听数量
serverCallBack("服务器启动成功");
//服务器开始进入等待用户连接的状态
//开辟一条子线程实时监测是否有人连接
//一旦有客户端连接,立马通知主线程,通知内容会以IAsyncResult 返回,连接者的所有信息 serverSocket.BeginAccept(ServerAccept, serverSocket);
}
//服务器开始接收的方法
void ServerAccept(IAsyncResult ar)
{
serverSocket = ar.AsyncState as Socket; //拿到当前连接服务器的Socket 对象
Socket workingSocket = serverSocket.EndAccept(ar); //将当前的Socket的全部信息交给一个新的Socket处理
workingSocket.BeginReceive(serverBuffer, 0, serverBuffer.Length, SocketFlags.None,ServerReceive, workingSocket); //(数据收发缓存区,起始位置,长度,不分类型,全部接收, 接受消息之后的回调,当前Socket的状态)
serverSocket.BeginAccept(ServerAccept, serverSocket); //尾递归 }
//服务器接收消息之后的回调方法
void ServerReceive(IAsyncResult ar)
{
Socket workingSorket = ar.AsyncState as Socket;
int size=workingSorket.EndReceive(ar); //拿到接收到的数据一共有多少字节
string str = Encoding.UTF8.GetString(serverBuffer); //将接收到的byte数组转换成字符串
serverCallBack("接收到了" + size + "字节");
serverCallBack(str);
workingSorket.BeginReceive(serverBuffer, 0, serverBuffer.Length, SocketFlags.None, ServerReceive, workingSorket); //尾递归 }
#endregion
客户端代码
#region
Socket clientSocket;
MyCallBack clientCallBack;
byte[] clientBuffer;
//客户端连接服务器的方法
public void ClientConnectServer(string ip,int port,MyCallBack callBack)
{
clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
clientBuffer = new byte[1024];
clientCallBack = callBack;
clientSocket.Connect(IPAddress.Parse(ip),port); //连接服务器
clientCallBack("连接服务器成功");
clientSocket.BeginReceive(clientBuffer, 0, clientBuffer.Length, SocketFlags.None,ClientReceive, clientSocket);
}
void ClientReceive(IAsyncResult ar)
{
Socket WorkingSocket = ar.AsyncState as Socket;
int size=WorkingSocket.EndReceive(ar); //接收多少字节
string msg= Encoding.UTF8.GetString(clientBuffer);
clientCallBack("接收了"+size+"字节");
clientCallBack(msg);
clientSocket.BeginReceive(clientBuffer, size, clientBuffer.Length, SocketFlags.None, ClientReceive, WorkingSocket);
}
//客户端发送消息的方法
public void ClientSendMsg(string msg)
{
byte[] buffer= Encoding.UTF8.GetBytes(msg);
clientSocket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, SendCallBack, clientSocket);
}
void SendCallBack(IAsyncResult ar)
{
Socket workingSocket = ar.AsyncState as Socket;
workingSocket.EndSend(ar);
clientCallBack("发送完成");
}
#endregion
简单的Socket搭建完成,但是有一点小Bug,服务器进入等待用户连接状态后,会开辟子线程实时检测,没有关闭这条线程,因此在搭建服务器的脚本,可以在Start方法里写一个方法,在程序退出时关闭这条线程! 这个方法在关闭程序时自动调用
private void OnApplicationQuit()
{
serverSocket.Shutdown(SocketShutdown.Both);
serverSocket.Close();
}
简单的Socket搭建完了,当然这只是非常基础的Socket传递,在实际使用中,还要考虑很多问题,比如Socket的沾包, 闭包,需要进一步处理
http://www.cnblogs.com/dabaimifan/p/7220428.html
Unity3d数据存储 PlayerPrefs,XML,Json数据的存储与解析
Unity3d中常用的数据存储方式有Unity自带的PlayerPrefs, XML文档, Json文档,还有常用的轻量级数据库SQL, 涉及的琐碎知识非常多,在这里自己归纳总结一下,方便日后温故而知新.
PlayerPrefs存储数据
PlayerPrefs的存储方式非常简单,但可用性不强,一般只用于调试过程存储少量数据,很少大范围使用
适用设备:Mac OSX, Linux, Windows,Web Players
存储机制:Key-Value (类似于字典的键值对,通过键值索引到相应数据)
可存储变量类型: int, float, string
常用方法: SetFloat 存储float 类型的数据 GetFloat 获取float 类型的数据
SetInt 存储Int类型的数据 GetInt 获取Int 类型的数据
SetString 存储string 类型的数据 GetString 获取string 类型的数据
DeleteAll 删除所有PlayerPrefs数据 HasKey 判断是否存在该Key值的数据
简单代码示例如下,是不是很简单?
void ExamplePlayerPrefs()
{
PlayerPrefs.SetFloat("PlayerScore", 10f);
Debug.Log(PlayerPrefs.GetFloat("PlayerScore"));
}
XML的存储与解析
(1)XMl常用类及其常用属性和方法
XmlNode
InnerText 获取或设置节点及其所有子节点的值(仅元素节点拥有)
Value 获取或设置节点的值(仅属性节点拥有)
AppendChild 将指定的节点添加到该节点的子节点列表的末尾
ChildNodes 获取节点的所有子节点
FirestChild
XmlDocument
CreateXmlDeclaration 创建一个具有指定值的XmlDeclaration节点
CreateElement 创建具有指定名称的元素
CreateNode 创建具有指定的节点类型的XmlNode
AppendChild 将指定节点添加到末尾(继承自XmlNode)
Save 将Xml文档保存到指定的文件
Load 从指定的URL加载Xml文档
LoadXml 从指定的字符串加载Xml文档
XmlElement
SetAttribute 设置具有指定名称的特性的值
HasAttributes 判断该元素节点是否具有属性
GetAttribute 返回具有指定名称的属性值
(2)XML数据的生成步骤
在Unity引擎中如何生成本地XML数据?
第一步:引入C#的命名空间 System.Xml
第二步:生成XML文档(XmlDocument类)
第三步: 生成根元素(XmlElement类) 添加给文档对象
第四步:循环生成子元素添加给父元素
第五步:将生成的XML文档保存
(3)XML解析步骤
在解析时注意, 需要根据Xml文件的结构创建好对应的数据模型,去接受解析出来的数据!!!
Json的存储与解析
Json一般使用两个类库,一个System.Json(便于Json生成),一个是LitJson(便于Json解析)
Json生成
void LitCtreatJson()
{
JsonData hero = new JsonData();
hero["HeroName"] = "诺克萨斯";
hero["Hp"] = 100;
hero["attack"] = 40;
hero["Skills"] = new JsonData();
JsonData skill1 = new JsonData();
skill1["KeyCode"] = "Q";
skill1["Name"] = "大杀四方";
skill1["Mp"] = 20;
skill1["cd"] = 8;
hero["Skills"].Add(skill1);
JsonData skill2 = new JsonData();
skill2["KeyCode"] = "W";
skill2["Name"] = "致残打击";
skill2["Mp"] = 40;
skill2["cd"] = 5;
hero["Skills"].Add(skill2);
JsonData skill3 = new JsonData();
skill3["KeyCode"] = "E";
skill3["Name"] = "无情铁手";
skill3["Mp"] = 10;
skill3["cd"] = 9;
hero["Skills"].Add(skill3);
JsonData skill4 = new JsonData();
skill4["KeyCode"] = "R";
skill4["Name"] = "诺克萨斯断头台";
skill4["Mp"] = 120;
skill4["cd"] = 60;
hero["Skills"].Add(skill4);
}
Json解析
void LitParseJson()
{
FileInfo file =new FileInfo(Application.dataPath + "/LoL.json");
StreamReader sr = new StreamReader(file.OpenRead(), Encoding.UTF8);
string content = sr.ReadToEnd();
JsonData data= JsonMapper.ToObject(content);
foreach (JsonData item in data["Skills"])
{
print(item["name"]);
}
Hero hero;
hero = JsonUtility.FromJson<Hero>(content);
sr.Close();
sr.Dispose();
}
untiy3d 5x,network的服务器端和客户端通信
https://blog.****.net/wuyt2008/article/details/51281668
unity3d 5x以前，可以用NetworkView.RPC的方式进行通信。5x，之后，虽然还可以用networkview建立服务器和客户端，但是NetworkView.RPC的通信方式被取消了。
取代的是用networking下的networkserver和nerworkclient（大概吧，我猜的）
以前类似于下面这样的，应该是不能再用了。
[csharp] view plain copy
1. [RPC]
2. void SpawnBox(NetworkViewID viewID, Vector3 location) {
3. Transform clone;
4. clone = Instantiate(cubePrefab, location, Quaternion.identity) as Transform as Transform;
5. NetworkView nView;
6. nView = clone.GetComponent<NetworkView>();
7. nView.viewID = viewID;
8. }
接下来用新的方法试试：
建立新场景，加上按钮，输入框，文本显示。（不爱用OnGUI）
首先，要引用UnityEngine.Networking
[csharp] view plain copy
1. using UnityEngine.Networking;
建立服务器用NetworkServer.Listen
[csharp] view plain copy
1. NetworkServer.Listen(4444);
客户端连接的方法是NetworkClient.Connect
[csharp] view plain copy
1. NetworkClient myClient;
2. myClient = new NetworkClient ();
3. myClient.Connect("127.0.0.1", 8888);
服务器端和客户端的事件都是通过RegisterHandler方法注册的，
下面的例子就是在服务器端注册了一个OnConnected事件，事件是当有客户端连接到服务器端的时候在服务器端触发。
[csharp] view plain copy
1. void Start()
2. {
3. NetworkServer.Listen(7070);
4. NetworkServer.RegisterHandler(MsgType.Connect, OnConnected);
5. }
6.
7. void OnConnected(NetworkMessage netMsg)
8. {
9. Debug.Log ("Client connected");
10. }
客户端注册事件的方法相同。
接下来，说发送信息。
服务器端发送信息是用NetworkServer.SendToAll或NetworkServer.SendToClient，客户端发送信息用NetworkClient.Send
其中参数Networking.MessageBase msg是一个自己定义的类，但是这个类必须继承自MessageBase
[csharp] view plain copy
1. class RegisterHostMessage : MessageBase
2. {
3. public string gameName;
4. public string comment;
5. public bool passwordProtected;
6.
7. }
ok，说明完毕，上代码
这是发生信息的类
[csharp] view plain copy
1. using UnityEngine.Networking;
2.
3. public class UserMsg : MessageBase {
4. public string message;
5. }
这是主类
[csharp] view plain copy
1. using UnityEngine;
2. using UnityEngine.Networking;
3. using UnityEngine.UI;
4. using System;
5.
6. public class MyNetworkManager : MonoBehaviour
7. {
8. /// <summary>
9. /// 服务器ip地址
10. /// </summary>
11. public InputField ip;
12. /// <summary>
13. /// 服务器端口
14. /// </summary>
15. public InputField port;
16. /// <summary>
17. /// 要发送的信息
18. /// </summary>
19. public InputField send;
20. /// <summary>
21. /// 显示信息
22. /// </summary>
23. public Text info;
24. /// <summary>
25. /// 网络客户端
26. /// </summary>
27. private NetworkClient myClient;
28. /// <summary>
29. /// 用户信息分类
30. /// </summary>
31. private const short userMsg = 64;
32.
33. void Start ()
34. {
35. info.text = "Start...";
36. myClient = new NetworkClient ();
37. }
38.
39.
40. /// <summary>
41. /// 建立服务器
42. /// </summary>
43. public void SetupServer ()
44. {
45. if (!NetworkServer.active) {
46. ShowMsg ("setup server");
47. ServerRegisterHandler ();
48. NetworkServer.Listen (int.Parse (port.text));
49.
50. if (NetworkServer.active) {
51. ShowMsg ("Server setup ok.");
52. }
53. }
54. }
55.
56. /// <summary>
57. /// 建立客户端
58. /// </summary>
59. public void SetupClient ()
60. {
61. if (!myClient.isConnected) {
62. ShowMsg ("setup client");
63. ClientRegisterHandler ();
64. myClient.Connect (ip.text, int.Parse (port.text));
65. }
66. }
67.
68. /// <summary>
69. /// 停止客户端
70. /// </summary>
71. public void ShutdownClient ()
72. {
73. if (myClient.isConnected) {
74. ClientUnregisterHandler ();
75. myClient.Disconnect ();
76.
77. //NetworkClient.Shutdown()使用后，无法再次连接。
78. //This should be done when a client is no longer going to be used.
79. //myClient.Shutdown ();
80. }
81. }
82.
83. /// <summary>
84. /// 停止服务器端
85. /// </summary>
86. public void ShutdownServer ()
87. {
88. if (NetworkServer.active) {
89. ServerUnregisterHandler ();
90. NetworkServer.DisconnectAll ();
91. NetworkServer.Shutdown ();
92.
93. if (!NetworkServer.active) {
94. ShowMsg ("shut down server");
95. }
96. }
97. }
98.
99. /// <summary>
100. /// 客户端连接到服务器事件
101. /// </summary>
102. /// <param name="netMsg">Net message.</param>
103. private void OnClientConnected (NetworkMessage netMsg)
104. {
105. ShowMsg ("Client connected to server");
106. }
107.
108. /// <summary>
109. ///客户端从服务器断开事件
110. /// </summary>
111. /// <param name="netMsg">Net message.</param>
112. private void OnClientDisconnected (NetworkMessage netMsg)
113. {
114. ShowMsg ("Client disconnected from server");
115. }
116.
117. /// <summary>
118. /// 客户端错误事件
119. /// </summary>
120. /// <param name="netMsg">Net message.</param>
121. private void OnClientError (NetworkMessage netMsg)
122. {
123. ClientUnregisterHandler ();
124. ShowMsg ("Client error");
125. }
126.
127.
128.
129. /// <summary>
130. /// 服务器端有客户端连入事件
131. /// </summary>
132. /// <param name="netMsg">Net message.</param>
133. private void OnServerConnected (NetworkMessage netMsg)
134. {
135. ShowMsg ("One client connected to server");
136. }
137.
138. /// <summary>
139. /// 服务器端有客户端断开事件
140. /// </summary>
141. /// <param name="netMsg">Net message.</param>
142. private void OnServerDisconnected (NetworkMessage netMsg)
143. {
144. ShowMsg ("One client connected from server");
145. }
146.
147. /// <summary>
148. /// 服务器端错误事件
149. /// </summary>
150. /// <param name="netMsg">Net message.</param>
151. private void OnServerError (NetworkMessage netMsg)
152. {
153. ServerUnregisterHandler ();
154. ShowMsg ("Server error");
155. }
156.
157. /// <summary>
158. /// 显示信息
159. /// </summary>
160. /// <param name="Msg">Message.</param>
161. private void ShowMsg (string Msg)
162. {
163. info.text = Msg + "\n\r" + info.text;
164. //Debug.Log (Msg);
165. }
166.
167. /// <summary>
168. /// 客户端向服务器端发送信息
169. /// </summary>
170. public void ClientSend ()
171. {
172. if (myClient.isConnected) {
173. UserMsg um = new UserMsg ();
174. um.message = send.text;
175. if (myClient.Send (userMsg, um)) {
176. ShowMsg ("Client send:" + send.text);
177. }
178. }
179. }
180.
181. /// <summary>
182. /// 客户端接收到服务器端信息事件
183. /// </summary>
184. /// <param name="netMsg">Net message.</param>
185. private void ClientGet (NetworkMessage netMsg)
186. {
187. UserMsg Msg = netMsg.ReadMessage<UserMsg> ();
188. ShowMsg ("Client get:"+Msg.message);
189. }
190.
191. /// <summary>
192. /// 服务器端向所有客户端发送信息
193. /// </summary>
194. public void ServerSend ()
195. {
196. if (NetworkServer.active) {
197. UserMsg um = new UserMsg ();
198. um.message = send.text;
199. if (NetworkServer.SendToAll (userMsg, um)) {
200. ShowMsg ("Server send:" + send.text);
201. }
202. }
203. }
204.
205. /// <summary>
206. /// 服务器端收到信息事件
207. /// </summary>
208. /// <param name="netMsg">Net message.</param>
209. private void ServerGet (NetworkMessage netMsg)
210. {
211. UserMsg Msg = netMsg.ReadMessage<UserMsg> ();
212. ShowMsg ("Server get:"+Msg.message);
213. }
214.
215. /// <summary>
216. /// 服务器端注册事件
217. /// </summary>
218. private void ServerRegisterHandler(){
219. NetworkServer.RegisterHandler (MsgType.Connect, OnServerConnected);
220. NetworkServer.RegisterHandler (MsgType.Disconnect, OnServerDisconnected);
221. NetworkServer.RegisterHandler (MsgType.Error, OnServerError);
222. NetworkServer.RegisterHandler (userMsg, ServerGet);
223. }
224.
225. /// <summary>
226. /// 客户端注册事件
227. /// </summary>
228. private void ClientRegisterHandler(){
229. myClient.RegisterHandler (MsgType.Connect, OnClientConnected);
230. myClient.RegisterHandler (MsgType.Disconnect, OnClientDisconnected);
231. myClient.RegisterHandler (MsgType.Error, OnClientError);
232. myClient.RegisterHandler (userMsg, ClientGet);
233. }
234.
235. /// <summary>
236. /// 客户端注销事件
237. /// </summary>
238. private void ClientUnregisterHandler(){
239. myClient.UnregisterHandler (MsgType.Connect);
240. myClient.UnregisterHandler (MsgType.Disconnect);
241. myClient.UnregisterHandler (MsgType.Error);
242. myClient.UnregisterHandler (userMsg);
243. }
244.
245. /// <summary>
246. /// 服务器端注销事件
247. /// </summary>
248. private void ServerUnregisterHandler(){
249. NetworkServer.UnregisterHandler (MsgType.Connect);
250. NetworkServer.UnregisterHandler (MsgType.Disconnect);
251. NetworkServer.UnregisterHandler (MsgType.Error);
252. NetworkServer.UnregisterHandler (userMsg);
253. }
254. }
运行结果如下
代码下载地址：http://download.****.net/detail/wuyt2008/9506591