u3d局域網游戲網絡（c# socket select 模型），
之前寫了一篇。
發完之後第二天實際應用到游戲之後還是發現了一些小毛病。
比如網絡模塊有重復使用（多對象）的情況。所以將靜態類該成了普通類。
比如安卓下會有些異常出現導致游戲邏輯不正常。所以網絡相關的函數有些加了try塊。
然後發現寫入固定ip的方式根本不適合局域網。於是加了udp做的廣播系統，用以服務器和客戶端查找ip。
udp廣播部分和tcp不一樣。因為沒有連接，所以socket不需要shutdown。我在這裡吃了一虧才知道。
別的沒什麼修改。貼上修正和擴展之後的代碼。
有緣之人自取。唯一要求，如果你發現代碼有錯，或者有可以提升性能的地方請留言告知。
另：因為這是為局域網設計的，所以網絡部分框架以及鎖的應用寫得很隨意，如果需要擴展至千人萬人級的承載，請自行修改。
基礎類（base）
ClientMsgUnPack.cs 服務器tcp部分用以解包的對象
![]()
1 using UnityEngine;
2 /*
3 * 通信協議
4 * 消息頭前2字節保存當前消息長度
5 * 後面跟4字節表示消息ID
6 * 再後面是消息實質內容
7 */
8
9 namespace LanSocket
10 {
11 class ClientMsgUnPack : MsgUnPack
12 {
13 long m_UserID;
14 public ClientMsgUnPack()
15 {
16 m_UserID = -1;
17 }
18
19 public ClientMsgUnPack(byte[] mBuff, ushort len, int userID)
20 {
21 m_UserID = userID;
22 UnPack(mBuff, len);
23 }
24
25 public ClientMsgUnPack(byte[] mBuff, ushort offset, ushort len, int userID)
26 {
27 m_UserID = userID;
28 UnPack(mBuff, offset, len);
29 }
30
31 public long GetUserID()
32 {
33 return m_UserID;
34 }
35
36 public void SetUserID(long userID)
37 {
38 m_UserID = userID;
39 }
40 }
41 }
ClientMsgUnPack.cs
EventDispath.cs 事件分發，有兩個類，分別對應服務器和客戶端，主要就是參數不同
![]()
1 using UnityEngine;
2 using System.Collections;
3 using System.Collections.Generic;
4
5 delegate void ServerEventDelagate(LanSocket.ClientMsgUnPack msg);
6
7 class EventNode
8 {
9 public int m_EventID;
10 public LanSocket.ClientMsgUnPack msg;
11 }
12
13 class EventDispathBase
14 {
15 public static int g_MaxEventNum = 300;
16 }
17
18 class ServerEventDispath : EventDispathBase
19 {
20 List<ServerEventDelagate>[] m_Event;
21 Queue<EventNode> m_EventQueue;
22 public ServerEventDispath()
23 {
24 m_Event = new List<ServerEventDelagate>[g_MaxEventNum];
25 m_EventQueue = new Queue<EventNode>();
26 }
27
28 public void RegistEvent(int eventID, ServerEventDelagate func)
29 {
30 if(null == m_Event[eventID])
31 {
32 m_Event[eventID] = new List<ServerEventDelagate>();
33 }
34 m_Event[eventID].Add(func);
35 }
36
37 public void AddEvent(EventNode eventNode)
38 {
39 m_EventQueue.Enqueue(eventNode);
40 }
41
42 public void Proccess()
43 {
44 if (0 != m_EventQueue.Count)
45 {
46 EventNode mCur = m_EventQueue.Dequeue();
47 if (null == m_Event[mCur.m_EventID])
48 {
49 MonoBehaviour.print("event ID: "+ mCur.m_EventID+" is null");
50 }
51 else
52 {
53 List<ServerEventDelagate> curEventDelagate = m_Event[mCur.m_EventID];
54 for(int i = 0 ; i < curEventDelagate.Count ; ++i)
55 {
56 curEventDelagate[i](mCur.msg);
57 }
58 }
59 }
60 }
61 }
62
63
64 delegate void ClientEventDelagate(LanSocket.MsgUnPack msg);
65 class ClientEventDispath : EventDispathBase
66 {
67 List<ClientEventDelagate>[] m_Event;
68 Queue<EventNode> m_EventQueue;
69 public ClientEventDispath()
70 {
71 m_Event = new List<ClientEventDelagate>[g_MaxEventNum];
72 m_EventQueue = new Queue<EventNode>();
73 }
74
75 public void RegistEvent(int eventID, ClientEventDelagate func)
76 {
77 if (null == m_Event[eventID])
78 {
79 m_Event[eventID] = new List<ClientEventDelagate>();
80 }
81 m_Event[eventID].Add(func);
82 }
83
84 public void AddEvent(EventNode eventNode)
85 {
86 m_EventQueue.Enqueue(eventNode);
87 }
88
89 public void Proccess()
90 {
91 if (0 != m_EventQueue.Count)
92 {
93 EventNode mCur = m_EventQueue.Dequeue();
94 if (null == m_Event[mCur.m_EventID])
95 {
96 MonoBehaviour.print("event ID: " + mCur.m_EventID + " is null");
97 }
98 else
99 {
100 List<ClientEventDelagate> curEventDelagate = m_Event[mCur.m_EventID];
101 for (int i = 0; i < curEventDelagate.Count; ++i)
102 {
103 curEventDelagate[i](mCur.msg);
104 }
105 }
106 }
107 }
108 }
EventDispath.cs
LanSocketBase.cs 沒什麼實際意義，主要就是定義一些大家都會使用到的變量等
![]()
1 using System.Threading;
2 using UnityEngine;
3
4 /*
5 *輕量級局域網服務器。
6 * 協議如下
7 * 消息頭前2字節保存當前消息長度
8 * 後面跟4字節表示消息ID
9 * 再後面是消息實質內容
10 */
11
12 namespace LanSocket
13 {
14 public class LanSocketBase
15 {
16 public static int m_MaxOnePackBuff = 1024 * 3;
17 public static int m_MaxAllBuff = 1024 * 50;
18 public static int m_HeadSize = 6;
19 protected bool m_HasInit = false;
20 protected byte[] m_OnePack;
21 protected int m_OnePackIndex;
22 private Mutex m_Mutex;
23
24 public void BaseInit()
25 {
26 m_HasInit = true;
27 m_Mutex = new Mutex();
28 m_OnePack = new byte[m_MaxOnePackBuff+1];
29 m_OnePackIndex = 0;
30 }
31
32 public void BaseRelease()
33 {
34 m_Mutex.Close();
35 }
36
37 protected void Lock()
38 {
39 m_Mutex.WaitOne();
40 //MonoBehaviour.print("Lock:" + Thread.CurrentThread.ManagedThreadId.ToString());
41 }
42
43 protected void UnLock()
44 {
45 m_Mutex.ReleaseMutex();
46 //MonoBehaviour.print("Unlock:" + Thread.CurrentThread.ManagedThreadId.ToString());
47 }
48 }
49 }
LanSocketBase.cs
MsgPack.cs 打包類，參數類型不夠自行擴展
![]()
1 using UnityEngine;
2 /*
3 * 通信協議
4 * 消息頭前2字節保存當前消息長度
5 * 後面跟4字節表示消息ID
6 * 再後面是消息實質內容
7 */
8
9 namespace LanSocket
10 {
11 public class MsgPack : PackBase
12 {
13 public MsgPack()
14 {
15 m_OnePackIndex = LanSocketBase.m_HeadSize;
16 }
17
18 public void SetHead(int ID)
19 {
20 byte[] mBuff = System.BitConverter.GetBytes(ID);
21 System.Buffer.BlockCopy(mBuff, 0, m_OnePack, 2, 4);
22 }
23
24 public void PackEnd()
25 {
26 byte[] mBuff = System.BitConverter.GetBytes(m_OnePackIndex);
27 System.Buffer.BlockCopy(mBuff, 0, m_OnePack, 0, 2);
28 }
29
30 public void Packbool(bool data)
31 {
32 ushort curDatalen = 1;
33 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
34 {
35 MonoBehaviour.print("Packbool() longer lager than Max buff len");
36 return;
37 }
38 byte[] mBuff = System.BitConverter.GetBytes(data);
39 Pack(mBuff, curDatalen);
40 }
41
42 public void Pack16bit(short data)
43 {
44 ushort curDatalen = 2;
45 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
46 {
47 MonoBehaviour.print("Pack16bit(short) longer lager than Max buff len");
48 return;
49 }
50 byte[] mBuff = System.BitConverter.GetBytes(data);
51 Pack(mBuff, curDatalen);
52 }
53 public void Pack16bit(ushort data)
54 {
55 ushort curDatalen = 2;
56 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
57 {
58 MonoBehaviour.print("Pack16bit(ushort) longer lager than Max buff len");
59 return;
60 }
61 byte[] mBuff = System.BitConverter.GetBytes(data);
62 Pack(mBuff, curDatalen);
63 }
64 public void Pack32bit(int data)
65 {
66 ushort curDatalen = 4;
67 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
68 {
69 MonoBehaviour.print("Pack32bit(int) longer lager than Max buff len");
70 return;
71 }
72 byte[] mBuff = System.BitConverter.GetBytes(data);
73 Pack(mBuff, curDatalen);
74 }
75 public void Pack32bit(uint data)
76 {
77 ushort curDatalen = 4;
78 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
79 {
80 MonoBehaviour.print("Pack32bit(uint) longer lager than Max buff len");
81 return;
82 }
83 byte[] mBuff = System.BitConverter.GetBytes(data);
84 Pack(mBuff, curDatalen);
85 }
86 public void Pack32bit(float data)
87 {
88 ushort curDatalen = 4;
89 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
90 {
91 MonoBehaviour.print("Pack32bit(float) longer lager than Max buff len");
92 return;
93 }
94 byte[] mBuff = System.BitConverter.GetBytes(data);
95 Pack(mBuff, curDatalen);
96 }
97 public void Pack64bit(double data)
98 {
99 ushort curDatalen = 8;
100 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
101 {
102 MonoBehaviour.print("Pack64bit(double) longer lager than Max buff len");
103 return;
104 }
105 byte[] mBuff = System.BitConverter.GetBytes(data);
106 Pack(mBuff, curDatalen);
107 }
108 public void Pack64bit(long data)
109 {
110 ushort curDatalen = 8;
111 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
112 {
113 MonoBehaviour.print("Pack64bit(long) longer lager than Max buff len");
114 return;
115 }
116 byte[] mBuff = System.BitConverter.GetBytes(data);
117 Pack(mBuff, curDatalen);
118 }
119
120 public void PackString(string data, ushort len)
121 {
122 ushort curDatalen = len;
123 if (m_OnePackIndex + curDatalen > m_MaxOnePackBuff)
124 {
125 MonoBehaviour.print("PackString() longer lager than Max buff len");
126 return;
127 }
128 byte[] mBuff = System.Text.Encoding.UTF8.GetBytes(data);
129 Pack(mBuff, curDatalen);
130 }
131
132 void Pack(byte[] data, ushort len)
133 {
134 System.Buffer.BlockCopy(data, 0, m_OnePack, m_OnePackIndex, len);
135 m_OnePackIndex += len;
136 }
137
138 public byte[] GetByte()
139 {
140 return m_OnePack;
141 }
142
143 public int GetByteLen()
144 {
145 return m_OnePackIndex;
146 }
147 }
148 }
MsgPack.cs
MsgUnPack.cs 解包類，返回類型不夠自己擴展
![]()
1 using UnityEngine;
2 /*
3 * 通信協議
4 * 消息頭前2字節保存當前消息長度
5 * 後面跟4字節表示消息ID
6 * 再後面是消息實質內容
7 */
8
9 namespace LanSocket
10 {
11 class MsgUnPack : PackBase
12 {
13 ushort m_PackLen;
14 int m_MsgID;
15 public MsgUnPack()
16 {
17 }
18
19 void GetHead()
20 {
21 m_PackLen = System.BitConverter.ToUInt16(m_OnePack, 0);
22 m_MsgID = System.BitConverter.ToUInt16(m_OnePack, 2);
23 m_OnePackIndex = 6;
24 }
25
26 public MsgUnPack(byte[] mBuff, ushort len)
27 {
28 UnPack(mBuff, len);
29 }
30
31 public MsgUnPack(byte[] mBuff, ushort offset, ushort len)
32 {
33 UnPack(mBuff, offset, len);
34 }
35
36 public void UnPack(byte[] mBuff, ushort len)
37 {
38 System.Buffer.BlockCopy(mBuff, 0, m_OnePack, 0, len);
39 GetHead();
40 }
41
42 public void UnPack(byte[] mBuff, ushort offset, ushort len)
43 {
44 System.Buffer.BlockCopy(mBuff, offset, m_OnePack, 0, len);
45 GetHead();
46 }
47
48 public bool Readbool()
49 {
50 if (m_OnePackIndex + 1 > m_PackLen)
51 {
52 MonoBehaviour.print("Readbool() longer lager than Max buff len");
53 return false;
54 }
55 bool data = System.BitConverter.ToBoolean(m_OnePack, m_OnePackIndex);
56 ++m_OnePackIndex;
57 return data;
58 }
59
60 public short ReadShort()
61 {
62 if (m_OnePackIndex + 2 > m_PackLen)
63 {
64 MonoBehaviour.print("ReadShort() longer lager than Max buff len");
65 return 0;
66 }
67 short data = System.BitConverter.ToInt16(m_OnePack, m_OnePackIndex);
68 m_OnePackIndex += 2;
69 return data;
70 }
71
72 public ushort ReadUShort()
73 {
74 if (m_OnePackIndex + 2 > m_PackLen)
75 {
76 MonoBehaviour.print("ReadUShortbit() longer lager than Max buff len");
77 return 0;
78 }
79 ushort data = System.BitConverter.ToUInt16(m_OnePack, m_OnePackIndex);
80 m_OnePackIndex += 2;
81 return data;
82 }
83
84 public int ReadInt()
85 {
86 if (m_OnePackIndex + 4 > m_PackLen)
87 {
88 MonoBehaviour.print("ReadInt() longer lager than Max buff len");
89 return 0;
90 }
91 int data = System.BitConverter.ToInt32(m_OnePack, m_OnePackIndex);
92 m_OnePackIndex += 4;
93 return data;
94 }
95
96 public uint ReadUInt()
97 {
98 if (m_OnePackIndex + 4 > m_PackLen)
99 {
100 MonoBehaviour.print("ReadUInt() longer lager than Max buff len");
101 return 0;
102 }
103 uint data = System.BitConverter.ToUInt32(m_OnePack, m_OnePackIndex);
104 m_OnePackIndex += 4;
105 return data;
106 }
107
108 public float ReadFloat()
109 {
110 if (m_OnePackIndex + 4 > m_PackLen)
111 {
112 MonoBehaviour.print("ReadFloat() longer lager than Max buff len");
113 return 0.0f;
114 }
115 float data = System.BitConverter.ToSingle(m_OnePack, m_OnePackIndex);
116 m_OnePackIndex += 4;
117 return data;
118 }
119
120 public double ReadDouble()
121 {
122 if (m_OnePackIndex + 8 > m_PackLen)
123 {
124 MonoBehaviour.print("ReadDouble() longer lager than Max buff len");
125 return 0.0f;
126 }
127 double data = System.BitConverter.ToDouble(m_OnePack, m_OnePackIndex);
128 m_OnePackIndex += 8;
129 return data;
130 }
131
132 public long ReadLong()
133 {
134 if (m_OnePackIndex + 8 > m_PackLen)
135 {
136 MonoBehaviour.print("ReadLong() longer lager than Max buff len");
137 return 0;
138 }
139 long data = System.BitConverter.ToInt64(m_OnePack, m_OnePackIndex);
140 m_OnePackIndex += 8;
141 return data;
142 }
143
144 public ulong ReadULong()
145 {
146 if (m_OnePackIndex + 8 > m_PackLen)
147 {
148 MonoBehaviour.print("ReadULong() longer lager than Max buff len");
149 return 0;
150 }
151 ulong data = System.BitConverter.ToUInt64(m_OnePack, m_OnePackIndex);
152 m_OnePackIndex += 8;
153 return data;
154 }
155
156 public string ReadString(ushort len)
157 {
158 if (m_OnePackIndex + len > m_PackLen)
159 {
160 MonoBehaviour.print("ReadString() longer lager than Max buff len");
161 return "";
162 }
163 string data = System.Text.Encoding.UTF8.GetString(m_OnePack, m_OnePackIndex, len);
164 m_OnePackIndex += len;
165 return data;
166 }
167
168 public int GetMsgID()
169 {
170 return m_MsgID;
171 }
172 }
173 }
MsgUnPack.cs
PackBase.cs 沒什麼實際意義，主要就是打包和解包類都會使用到的一些數據
![]()
1 using System.Threading;
2
3 /*
4 *輕量級局域網服務器。
5 * 協議如下
6 * 消息頭前2字節保存當前消息長度
7 * 後面跟4字節表示消息ID
8 * 再後面是消息實質內容
9 */
10
11 namespace LanSocket
12 {
13 public class PackBase
14 {
15 protected int m_MaxOnePackBuff;
16 protected byte[] m_OnePack;
17 protected int m_OnePackIndex;
18
19 public PackBase()
20 {
21 m_MaxOnePackBuff = LanSocketBase.m_MaxOnePackBuff;
22 m_OnePack = new byte[m_MaxOnePackBuff];
23 m_OnePackIndex = 0;
24 }
25 }
26 }
PackBase.cs
SocketBase.cs 同上
![]()
1 using System.Net.Sockets;
2 using System.Threading;
3 using System.Net;
4
5 public class SocketBase
6 {
7 protected bool m_HasInit = false;
8 protected Socket m_Socket;
9 protected Thread m_LinstenThread;
10 protected IPEndPoint m_IP;
11 protected Mutex m_Mutex;
12 }
SocketBase.cs
新增的廣播類（broadcast）
特別說下，udp沒有握手，所以socket對象在shutdown的時候會出異常，具體知識我也不知道，我是試出來的，有知道的還望不吝賜教。
ReciveBroadcast.cs 廣播接收器。服務器段需要長期保持打開，因為只要有新用戶加入，服務器就需要下發數據。而客戶端不需要，因為客戶端一但連上，就不需要廣播系統了。所以服務器長期保留，客戶端用完銷毀
![]()
1 using UnityEngine;
2 using System.Net.Sockets;
3 using System.Net;
4 using System.Threading;
5 using System.Collections.Generic;
6
7 class ReciveBroadcast : SocketBase
8 {
9 public Queue<string> m_ServerIP;
10 public void Start(int port)
11 {
12 if (m_HasInit)
13 {
14 return;
15 }
16 try
17 {
18 m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
19 m_IP = new IPEndPoint(IPAddress.Any, port);
20 m_Socket.Bind(m_IP);
21 MonoBehaviour.print("廣播網絡啟動監聽" + m_Socket.LocalEndPoint.ToString());
22 m_LinstenThread = new Thread(ListenClientConnect);
23 m_LinstenThread.Start();
24 m_ServerIP = new Queue<string>();
25 m_Mutex = new Mutex();
26 m_HasInit = true;
27 }
28 catch (System.Exception ex)
29 {
30 MonoBehaviour.print("Broadcast reciver Start catch:" + ex.Message);
31 }
32 }
33
34 void ListenClientConnect()
35 {
36 EndPoint ep = (EndPoint)m_IP;
37 try
38 {
39 while (true)
40 {
41 Thread.Sleep(1);
42 byte[] data = new byte[64];
43 int recv = m_Socket.ReceiveFrom(data, ref ep);
44 string stringData = System.Text.Encoding.UTF8.GetString(data, 0, recv);
45 m_Mutex.WaitOne();
46 m_ServerIP.Enqueue(stringData);
47 m_Mutex.ReleaseMutex();
48 MonoBehaviour.print("received: " + stringData + " from: " + ep.ToString());
49 }
50 }
51 catch (System.Exception ex)
52 {
53 MonoBehaviour.print("Broadcast reciver ListenClientConnect out:" + ex.Message);
54 }
55 }
56
57 public void Destroy()
58 {
59 if (!m_HasInit)
60 {
61 return;
62 }
63 m_Socket.Close();
64 m_LinstenThread.Abort();
65 }
66
67 public string GetIP()
68 {
69 if (!m_HasInit)
70 {
71 return "";
72 }
73
74 try
75 {
76 m_Mutex.WaitOne();
77 if (0 != m_ServerIP.Count)
78 {
79 m_Mutex.ReleaseMutex();
80 return m_ServerIP.Dequeue();
81 }
82 m_Mutex.ReleaseMutex();
83 }
84 catch (System.Exception ex)
85 {
86 MonoBehaviour.print("Broadcast GetIP catch:" + ex.Message);
87 return "";
88 }
89 return "";
90 }
91 }
ReciveBroadcast.cs
SendBroadcast.cs 廣播發射器。同上
![]()
1 using UnityEngine;
2 using System.Net.Sockets;
3 using System.Net;
4
5 class SendBroadcast : SocketBase
6 {
7 byte[] m_MyIP;
8 public void Start(int port)
9 {
10 if (m_HasInit)
11 {
12 return;
13 }
14 try
15 {
16 m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
17 m_IP = new IPEndPoint(IPAddress.Broadcast, port);//255.255.255.255
18 //m_IP = new IPEndPoint(IPAddress.Parse("192.168.255.255"), 9050);
19
20 string mLocalIP = "";
21 string hostname = Dns.GetHostName();
22 IPHostEntry localHost = Dns.GetHostEntry(hostname);
23 for (int i = 0; i < localHost.AddressList.Length; ++i)
24 {
25 if (localHost.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
26 {
27 //MonoBehaviour.print(localHost.AddressList[i].ToString());
28 mLocalIP = localHost.AddressList[i].ToString();
29 break;
30 }
31 }
32
33 if ("".Equals(m_MyIP))
34 {
35 MonoBehaviour.print("網絡檢測異常。請檢查網絡設置或接入網絡");
36 m_Socket.Close();
37 m_Socket = null;
38 return;
39 }
40 m_MyIP = System.Text.Encoding.UTF8.GetBytes(mLocalIP);
41 m_Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
42 m_HasInit = true;
43 }
44 catch (System.Exception ex)
45 {
46 MonoBehaviour.print("Broadcast sender Start catch:" + ex.Message);
47 }
48 }
49
50 public void Send()
51 {
52 if(null != m_Socket)
53 {
54 MonoBehaviour.print("send a broadcast");
55 m_Socket.SendTo(m_MyIP, m_IP);
56 }
57 }
58
59 public void Destroy()
60 {
61 if (!m_HasInit)
62 {
63 return;
64 }
65 m_Socket.Close();
66 }
67 }
SendBroadcast.cs
說明：網絡模塊也是根據網絡上的代碼加以修正和自己的經驗修改完成。對於c# socket函數不熟，如果有什麼地方可以優化或者用錯或者傳錯參數，請指出賜教。
客戶端網絡（client）
SocketClient.cs 客戶端網絡模塊。包含連接服務器、接受范圍、處理返回數據等。
![]()
1 using System.Net.Sockets;
2 using System.Net;
3 using System.Threading;
4 using UnityEngine;
5 using System.Collections.Generic;
6
7 /*
8 *輕量級局域網服務器。
9 * 協議如下
10 * 消息頭前2字節保存當前消息長度
11 * 後面跟4字節表示消息ID
12 * 再後面是消息實質內容
13 */
14
15 namespace LanSocket
16 {
17 class Client : LanSocketBase
18 {
19 Thread m_ReciveThread;
20 Socket m_Connect;
21 byte[] m_AllData;
22 int m_AllDataHead;
23 int m_AllDataEnd;
24 int m_MsgNum;
25
26 public void Start(string strIP, int port)
27 {
28 if (m_HasInit)
29 {
30 return;
31 }
32 //設定服務器IP地址
33 IPAddress ip = IPAddress.Parse(strIP);
34 Socket temp = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
35 try
36 {
37 temp.Connect(new IPEndPoint(ip, port)); //配置服務器IP與端口
38 MonoBehaviour.print("連接服務器成功");
39
40 BaseInit();
41 m_Connect = temp;
42 m_ReciveThread = new Thread(ReceiveMessage);
43 m_ReciveThread.Start();
44 m_AllData = new byte[LanSocketBase.m_MaxAllBuff + 1];
45 m_AllDataHead = 0;
46 m_AllDataEnd = 0;
47 m_MsgNum = 0;
48 }
49 catch (System.Exception ex)
50 {
51 MonoBehaviour.print("連接服務器失敗: " + ex.Message);
52 return;
53 }
54 }
55
56 private void PutDataToBuff(byte[] mClientSendBuff, int mReceiveNumber)
57 {
58 if (m_AllDataEnd + mReceiveNumber >= LanSocketBase.m_MaxAllBuff)
59 {
60 byte[] mCurAllData = new byte[m_AllDataEnd - m_AllDataHead];
61 System.Buffer.BlockCopy(m_AllData, m_AllDataHead, mCurAllData, 0, m_AllDataEnd - m_AllDataHead);
62 System.Buffer.BlockCopy(mCurAllData, 0, m_AllData, 0, m_AllDataEnd - m_AllDataHead);
63 m_AllDataEnd -= m_AllDataHead;
64 m_AllDataHead = 0;
65 }
66 int mOnePackStartPos = 0;
67 while (mReceiveNumber > 0)
68 {
69 if (0 == m_OnePackIndex)
70 {
71 ushort datalen = System.BitConverter.ToUInt16(mClientSendBuff, mOnePackStartPos);
72 if (datalen <= mReceiveNumber)
73 {
74 System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_AllData, m_AllDataEnd, datalen);
75 m_AllDataEnd += datalen;
76
77 mOnePackStartPos += datalen;
78
79 mReceiveNumber -= datalen;
80 ++m_MsgNum;
81 }
82 else
83 {
84 System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mReceiveNumber);
85 m_OnePackIndex += mReceiveNumber;
86 mOnePackStartPos += mReceiveNumber;
87
88 mReceiveNumber -= mReceiveNumber;
89 }
90 }
91 else
92 {
93 ushort datalen = System.BitConverter.ToUInt16(m_OnePack, 0);
94 if (m_OnePackIndex + mReceiveNumber >= datalen)
95 {
96 int mNeedNum = datalen - m_OnePackIndex;
97 System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mNeedNum);
98 mOnePackStartPos += mNeedNum;
99
100 System.Buffer.BlockCopy(m_OnePack, 0, m_AllData, m_AllDataEnd, datalen);
101 m_OnePackIndex = 0;
102
103 mReceiveNumber -= mNeedNum;
104 }
105 else
106 {
107 System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mReceiveNumber);
108 m_OnePackIndex += mReceiveNumber;
109 mOnePackStartPos += mReceiveNumber;
110
111 mReceiveNumber -= mReceiveNumber;
112 }
113 }
114 }
115 }
116
117 public void Destroy()
118 {
119 if (!m_HasInit)
120 {
121 return;
122 }
123 BaseRelease();
124 ShutDownConnect();
125 m_MsgNum = 0;
126 }
127
128 public void GetMsg(ref MsgUnPack msg)
129 {
130 if (!m_HasInit)
131 {
132 return;
133 }
134 try
135 {
136 Lock();
137 if (0 != m_MsgNum)
138 {
139 ushort datalen = System.BitConverter.ToUInt16(m_AllData, m_AllDataHead);
140 msg = new MsgUnPack(m_AllData, (ushort)m_AllDataHead, (ushort)datalen);
141 m_AllDataHead += datalen;
142 --m_MsgNum;
143 }
144 }
145 finally
146 {
147 UnLock();
148 }
149 }
150
151 /// <summary>
152 /// 接收消息
153 /// </summary>
154 public void ReceiveMessage()
155 {
156 while (true)
157 {
158 Thread.Sleep(1);
159 try
160 {
161 //通過clientSocket接收數據
162 byte[] mClientSendBuff = new byte[m_MaxOnePackBuff + 1];
163 int mReceiveNumber = m_Connect.Receive(mClientSendBuff);
164 if (0 == mReceiveNumber)
165 {
166 MonoBehaviour.print("disconnect");
167 ShutDownConnect();
168 }
169 else if (mReceiveNumber > 0)
170 {
171 try
172 {
173 Lock();
174 PutDataToBuff(mClientSendBuff, mReceiveNumber);
175 }
176 catch (System.Exception ex)
177 {
178 MonoBehaviour.print("PutDataToBuff catch: " + ex.Message);
179 }
180 finally
181 {
182 UnLock();
183 }
184 }
185 else
186 {
187 MonoBehaviour.print("one connect recive a error num: " + mReceiveNumber.ToString());
188 }
189 }
190 catch (System.Exception ex)
191 {
192 MonoBehaviour.print("ReceiveMessage catch: " + ex.Message);
193 ShutDownConnect();
194 }
195 }
196 }
197
198 public void Send(ref MsgPack msg)
199 {
200 try
201 {
202 Lock();
203 m_Connect.Send(msg.GetByte(), msg.GetByteLen(), SocketFlags.None);
204 }
205 finally
206 {
207 UnLock();
208 }
209 }
210
211 public void ShutDownConnect()
212 {
213 m_ReciveThread.Abort();
214 if (m_Connect.Connected)
215 {
216 m_Connect.Shutdown(SocketShutdown.Both);
217 }
218 m_Connect.Close();
219 }
220 }
221 }
SocketClient.cs
服務器網絡（server）
SocketServer.cs 服務器網絡模塊。同上，額外有玩家池。
![]()
1 using System.Net.Sockets;
2 using System.Net;
3 using System.Threading;
4 using UnityEngine;
5 using System.Collections.Generic;
6 /*
7 *輕量級局域網服務器。
8 * 協議如下
9 * 消息頭前2字節保存當前消息長度
10 * 後面跟4字節表示消息ID
11 * 再後面是消息實質內容
12 */
13
14 namespace LanSocket
15 {
16 class ClientConnect
17 {
18 public byte[] m_AllData;
19 public int m_AllDataHead;
20 public int m_AllDataEnd;
21 public int m_MsgCount;
22 public byte[] m_OnePack;
23 public int m_OnePackIndex;
24 public Socket m_Connect;
25 public long m_UserID;
26
27 public ClientConnect()
28 {
29 m_AllData = new byte[LanSocketBase.m_MaxAllBuff];
30 m_AllDataHead = 0;
31 m_AllDataEnd = 0;
32 m_MsgCount = 0;
33 m_OnePack = new byte[LanSocketBase.m_MaxOnePackBuff];
34 m_OnePackIndex = 0;
35 m_Connect = null;
36 m_UserID = 0;
37 }
38
39 public void Reset()
40 {
41 m_AllDataHead = 0;
42 m_AllDataEnd = 0;
43 m_MsgCount = 0;
44 m_OnePackIndex = 0;
45 m_Connect = null;
46 m_UserID = 0;
47 }
48 }
49 class Server : LanSocketBase
50 {
51 Queue<int> m_MsgOrder;
52
53 Socket m_ServerSocket;
54 Thread m_LinstenThread;
55 Thread m_ReciveThread;
56 System.Collections.ArrayList m_ServerSocketList;
57 System.Collections.ArrayList m_listenSocketList;
58 System.Collections.ArrayList m_DeleteSocketList;
59 int m_MaxClientConnect = 10;
60 ClientConnect[] m_ConnectPool;
61 Queue<int> m_EmptyConnect;
62 public void Start(int port)
63 {
64 if (m_HasInit)
65 {
66 return;
67 }
68 string mLocalIP = "";
69
70 string mHostName = Dns.GetHostName();
71 IPHostEntry localHost = Dns.GetHostEntry(mHostName);
72 for (int i = 0; i < localHost.AddressList.Length; ++i)
73 {
74 if (localHost.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
75 {
76 //MonoBehaviour.print(localHost.AddressList[i].ToString());
77 mLocalIP = localHost.AddressList[i].ToString();
78 break;
79 }
80 }
81
82 if ("".Equals(mLocalIP))
83 {
84 MonoBehaviour.print("網絡檢測異常。請檢查網絡設置或接入網絡");
85 return;
86 }
87 BaseInit();
88 m_MsgOrder = new Queue<int>();
89
90 //服務器IP地址
91 IPAddress ip = IPAddress.Parse(mLocalIP);
92 m_ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
93 m_ServerSocket.Bind(new IPEndPoint(ip, port)); //綁定IP地址：端口
94 m_ServerSocket.Listen(10); //設定最多10個排隊連接請求
95 MonoBehaviour.print("游戲網絡啟動監聽" + m_ServerSocket.LocalEndPoint.ToString());
96
97 m_ServerSocketList = new System.Collections.ArrayList();
98 m_listenSocketList = new System.Collections.ArrayList();
99 m_DeleteSocketList = new System.Collections.ArrayList();
100
101 m_ConnectPool = new ClientConnect[m_MaxClientConnect];
102 m_EmptyConnect = new Queue<int>();
103 for (int i = 0; i < m_MaxClientConnect; ++i)
104 {
105 m_ConnectPool[i] = new ClientConnect();
106 m_EmptyConnect.Enqueue(i);
107 }
108 //通過Clientsoket發送數據
109 m_ReciveThread = new Thread(ReceiveMessage);
110 m_ReciveThread.Start();
111 m_LinstenThread = new Thread(ListenClientConnect);
112 m_LinstenThread.Start();
113 }
114
115 /// <summary>
116 /// 監聽客戶端連接
117 /// </summary>
118 public void ListenClientConnect()
119 {
120 while (true)
121 {
122 Thread.Sleep(500);
123 m_ServerSocketList.Add(m_ServerSocket);
124 Socket.Select(m_ServerSocketList, null, null, 1000);
125 for (int i = 0; i < m_ServerSocketList.Count; ++i)
126 {
127 Socket clientSocket = ((Socket)m_ServerSocketList[i]).Accept();
128 if (null != clientSocket)
129 {
130 try
131 {
132 Lock();
133 if (0 == m_EmptyConnect.Count)
134 {
135 MonoBehaviour.print("鏈接已經達到最大上線，丟棄當前連接");
136 clientSocket.Shutdown(SocketShutdown.Both);
137 clientSocket.Close();
138 }
139 else
140 {
141 //m_listenSocketList.Add(clientSocket);
142 int mSlot = m_EmptyConnect.Dequeue();
143 m_ConnectPool[mSlot].m_Connect = clientSocket;
144 m_ConnectPool[mSlot].m_UserID = System.DateTime.Now.ToFileTime();
145 MonoBehaviour.print("成功連接一個客戶端，編號:" + mSlot.ToString());
146 }
147 }
148 finally
149 {
150 UnLock();
151 }
152 }
153 }
154 m_ServerSocketList.Clear();
155 }
156 }
157
158 private bool PutDataToBuff(byte[] mClientSendBuff, int mReceiveNumber, Socket client)
159 {
160 ClientConnect curPlayer = null;
161 int mSlot = -1;
162 for (int i = 0; i < m_MaxClientConnect; ++i)
163 {
164 if (client == m_ConnectPool[i].m_Connect)
165 {
166 curPlayer = m_ConnectPool[i];
167 mSlot = i;
168 break;
169 }
170 }
171 if (null == curPlayer)
172 {
173 return false;
174 }
175 if (curPlayer.m_AllDataEnd + mReceiveNumber >= LanSocketBase.m_MaxAllBuff)
176 {
177 byte[] mCurAllData = new byte[curPlayer.m_AllDataEnd - curPlayer.m_AllDataHead];
178 System.Buffer.BlockCopy(curPlayer.m_AllData, curPlayer.m_AllDataHead, mCurAllData, 0, curPlayer.m_AllDataEnd - curPlayer.m_AllDataHead);
179 System.Buffer.BlockCopy(mCurAllData, 0, curPlayer.m_AllData, 0, curPlayer.m_AllDataEnd - curPlayer.m_AllDataHead);
180 curPlayer.m_AllDataEnd -= curPlayer.m_AllDataHead;
181 curPlayer.m_AllDataHead = 0;
182 }
183 int mOnePackStartPos = 0;
184 while (mReceiveNumber > 0)
185 {
186 if (0 == m_OnePackIndex)
187 {
188 ushort datalen = System.BitConverter.ToUInt16(mClientSendBuff, mOnePackStartPos);
189 if (datalen > LanSocketBase.m_MaxOnePackBuff || datalen < LanSocketBase.m_HeadSize)
190 {
191 return false;
192 }
193 if (datalen <= mReceiveNumber)
194 {
195 System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, curPlayer.m_AllData, curPlayer.m_AllDataEnd, datalen);
196 curPlayer.m_AllDataEnd += datalen;
197 mOnePackStartPos += datalen;
198
199 mReceiveNumber -= datalen;
200
201 m_MsgOrder.Enqueue(mSlot);
202 }
203 else
204 {
205 System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mReceiveNumber);
206 m_OnePackIndex += mReceiveNumber;
207 mOnePackStartPos += mReceiveNumber;
208
209 mReceiveNumber -= mReceiveNumber;
210 }
211 }
212 else
213 {
214 ushort datalen = System.BitConverter.ToUInt16(m_OnePack, 0);
215 if (datalen > LanSocketBase.m_MaxOnePackBuff || datalen < LanSocketBase.m_HeadSize)
216 {
217 return false;
218 }
219 if (m_OnePackIndex + mReceiveNumber >= datalen)
220 {
221 int mNeedNum = datalen - m_OnePackIndex;
222 System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mNeedNum);
223 mOnePackStartPos += mNeedNum;
224
225 System.Buffer.BlockCopy(m_OnePack, 0, curPlayer.m_AllData, curPlayer.m_AllDataEnd, datalen);
226 m_OnePackIndex = 0;
227
228 mReceiveNumber -= mNeedNum;
229
230 m_MsgOrder.Enqueue(mSlot);
231 }
232 else
233 {
234 System.Buffer.BlockCopy(mClientSendBuff, mOnePackStartPos, m_OnePack, m_OnePackIndex, mReceiveNumber);
235 m_OnePackIndex += mReceiveNumber;
236 mOnePackStartPos += mReceiveNumber;
237
238 mReceiveNumber -= mReceiveNumber;
239 }
240 }
241 }
242
243 return true;
244 }
245
246 /// <summary>
247 /// 接收消息
248 /// </summary>
249 public void ReceiveMessage()
250 {
251 try
252 {
253 while (true)
254 {
255 Thread.Sleep(1);
256 for (int i = 0; i < m_MaxClientConnect; ++i)
257 {
258 if (null != m_ConnectPool[i].m_Connect)
259 {
260 m_listenSocketList.Add(m_ConnectPool[i].m_Connect);
261 }
262 }
263 if (0 == m_listenSocketList.Count)
264 {
265 continue;
266 }
267 Socket.Select(m_listenSocketList, null, null, 1000);
268 for (int i = 0; i < m_listenSocketList.Count; ++i)
269 {
270 Socket mClient = (Socket)m_listenSocketList[i];
271 //try
272 //{
273 //通過clientSocket接收數據
274 byte[] mClientSendBuff = new byte[m_MaxOnePackBuff];
275 int mReceiveNumber = mClient.Receive(mClientSendBuff);
276 if (0 == mReceiveNumber)
277 {
278 m_DeleteSocketList.Add(mClient);
279 }
280 else if (mReceiveNumber > 0)
281 {
282 try
283 {
284 Lock();
285 bool rt = PutDataToBuff(mClientSendBuff, mReceiveNumber, mClient);
286 if (!rt)
287 {
288 m_DeleteSocketList.Add(mClient);
289 }
290 }
291 catch (System.Exception ex)
292 {
293 MonoBehaviour.print("PutDataToBuff catch: " + ex.Message);
294 }
295 finally
296 {
297 UnLock();
298 }
299 }
300 else
301 {
302 MonoBehaviour.print("one connect recive a error num: " + mReceiveNumber.ToString());
303 }
304 //}
305 //catch (System.Exception ex)
306 //{
307 // MonoBehaviour.print("ReceiveMessage catch: " + ex.Message);
308 // m_DeleteSocketList.Add(mClient);
309 //}
310 }
311 m_listenSocketList.Clear();
312 if (0 != m_DeleteSocketList.Count)
313 {
314 ShutDownConnect();
315 }
316 }
317
318 }
319 catch (System.Exception ex)
320 {
321 MonoBehaviour.print("ReceiveMessage out:" + ex.Message);
322 }
323
324 }
325
326 /// <summary>
327 /// 程序退出銷毀
328 /// </summary>
329 public void Destroy()
330 {
331 if (!m_HasInit)
332 {
333 return;
334 }
335 m_LinstenThread.Abort();
336 m_ReciveThread.Abort();
337 m_listenSocketList.Clear();
338
339 for (int i = 0; i < m_ServerSocketList.Count; ++i)
340 {
341 Socket mServer = (Socket)m_ServerSocketList[i];
342 if (mServer.Connected)
343 {
344 mServer.Shutdown(SocketShutdown.Both);
345 }
346 mServer.Close();
347 }
348 m_ServerSocketList.Clear();
349
350 for (int i = 0; i < m_MaxClientConnect; ++i)
351 {
352 if (null != m_ConnectPool[i].m_Connect)
353 {
354 if (m_ConnectPool[i].m_Connect.Connected)
355 {
356 m_ConnectPool[i].m_Connect.Shutdown(SocketShutdown.Both);
357 }
358 m_ConnectPool[i].m_Connect.Close();
359 m_ConnectPool[i].m_Connect = null;
360 }
361 }
362 m_EmptyConnect.Clear();
363 BaseRelease();
364 }
365
366 /// <summary>
367 /// 銷毀一個連接
368 /// </summary>
369 void ShutDownConnect()
370 {
371 try
372 {
373 Lock();
374 for (int j = 0; j < m_DeleteSocketList.Count; ++j)
375 {
376 Socket connect = (Socket)m_DeleteSocketList[j];
377 for (int i = 0; i < m_MaxClientConnect; ++i)
378 {
379 if (connect == m_ConnectPool[i].m_Connect)
380 {
381 connect.Shutdown(SocketShutdown.Both);
382 connect.Close();
383 m_ConnectPool[i].Reset();
384 m_EmptyConnect.Enqueue(i);
385 MonoBehaviour.print("關閉一個連接，編號:" + i.ToString());
386 break;
387 }
388 }
389 }
390 }
391 catch (System.Exception ex)
392 {
393 MonoBehaviour.print("ShutDownConnect catch: " + ex.Message);
394 }
395 finally
396 {
397 m_DeleteSocketList.Clear();
398 UnLock();
399 }
400 }
401
402 /// <summary>
403 /// 獲取一個數據
404 /// </summary>
405 public void GetMsg(ref ClientMsgUnPack msg)
406 {
407 if(!m_HasInit)
408 {
409 return;
410 }
411 try
412 {
413 Lock();
414 if (0 != m_MsgOrder.Count)
415 {
416 int mSlot = m_MsgOrder.Dequeue();
417 ClientConnect curPlayer = m_ConnectPool[mSlot];
418 ushort mOnePackLen = System.BitConverter.ToUInt16(curPlayer.m_AllData, curPlayer.m_AllDataHead);
419 msg = new ClientMsgUnPack(curPlayer.m_AllData, (ushort)curPlayer.m_AllDataHead, (ushort)mOnePackLen, mSlot);
420 msg.SetUserID(curPlayer.m_UserID);
421 curPlayer.m_AllDataHead += mOnePackLen;
422 }
423 }
424 finally
425 {
426 UnLock();
427 }
428 }
429
430 public void SendTo(ref MsgPack msg, long userID)
431 {
432 try
433 {
434 Lock();
435 for(int i = 0 ; i < m_MaxClientConnect ; ++i)
436 {
437 ClientConnect curPlayer = m_ConnectPool[i];
438 if (null != curPlayer.m_Connect && curPlayer.m_UserID == userID)
439 {
440 curPlayer.m_Connect.Send(msg.GetByte(), msg.GetByteLen(), SocketFlags.None);
441 break;
442 }
443 }
444 }
445 finally
446 {
447 UnLock();
448 }
449 }
450
451 public void SendToAll(ref MsgPack msg)
452 {
453 try
454 {
455 Lock();
456 for (int i = 0; i < m_MaxClientConnect; ++i)
457 {
458 ClientConnect curPlayer = m_ConnectPool[i];
459 if (null != curPlayer.m_Connect)
460 {
461 curPlayer.m_Connect.Send(msg.GetByte(), msg.GetByteLen(), SocketFlags.None);
462 break;
463 }
464 }
465 }
466 finally
467 {
468 UnLock();
469 }
470 }
471 }
472 }
SocketServer.cs
外部配套模塊
ClientMain.cs u3d下的一個啟動客戶端網絡模塊的控件
![]()
1 using UnityEngine;
2 using System.Collections;
3
4 public class ClientMain : MonoBehaviour {
5
6 // Use this for initialization
7 ClientEventDispath m_Msg;
8 SendBroadcast m_Sender;
9 ReciveBroadcast m_Reciver;
10 LanSocket.Client m_GameNet;
11 string m_GameServerIP;
12 bool m_bReady;
13 float m_BroadTime;
14
15 void Start ()
16 {
17 m_Sender = new SendBroadcast();
18 m_Sender.Start(6666);
19 m_Reciver = new ReciveBroadcast();
20 m_Reciver.Start(6688);
21
22 m_GameNet = new LanSocket.Client();
23
24 m_GameServerIP = "";
25
26 m_bReady = false;
27 m_BroadTime = 0.0f;
28
29 EventDispathBase.g_MaxEventNum = (int)NetMsgID.NET_MSG_END;
30 m_Msg = new ClientEventDispath();
31 m_Msg.RegistEvent((int)NetMsgID.S2C_SEND_ANIMAL_DATA, Action_S2C_SEND_ANIMAL_DATA);
32 }
33
34 // Update is called once per frame
35 void Update ()
36 {
37 if (m_bReady)
38 {
39 LanSocket.MsgUnPack msg = null;
40 m_GameNet.GetMsg(ref msg);
41 if (null != msg)
42 {
43 print("here have one msg on client");
44 }
45
46 if (Input.GetKeyUp(KeyCode.Space))
47 {
48 LanSocket.MsgPack sendMsg = new LanSocket.MsgPack();
49 sendMsg.SetHead((int)NetMsgID.C2S_SELECT_ANIMAL);
50 sendMsg.Pack16bit(1);
51 sendMsg.PackEnd();
52 m_GameNet.Send(ref sendMsg);
53 print("send 1");
54 }
55 }
56 else
57 {
58 m_GameServerIP = m_Reciver.GetIP();
59 if ("".Equals(m_GameServerIP))
60 {
61 m_BroadTime -= Time.deltaTime;
62 if(m_BroadTime - Time.deltaTime < 0.0f)
63 {
64 m_BroadTime = 5.0f;
65 m_Sender.Send();
66 }
67 }
68 else
69 {
70 print("get broadcast ip:" + m_GameServerIP);
71 GameStart();
72 }
73 }
74 }
75 void OnDestroy()
76 {
77 m_GameNet.Destroy();
78 if(null != m_Reciver)
79 {
80 m_Reciver.Destroy();
81 }
82 if (null != m_Sender)
83 {
84 m_Sender.Destroy();
85 }
86 }
87
88 void GameStart()
89 {
90 m_bReady = true;
91 m_GameNet.Start(m_GameServerIP, 8888);
92 try
93 {
94 m_Reciver.Destroy();
95 m_Sender.Destroy();
96 }
97 catch (System.Exception ex)
98 {
99 MonoBehaviour.print("GameStart catch:" + ex.Message);
100 }
101 m_Reciver = null;
102 m_Reciver = null;
103 }
104
105 void Action_S2C_SEND_ANIMAL_DATA(LanSocket.MsgUnPack msg)
106 {
107 }
108 }
ClientMain.cs
Common.cs 定義的網絡通信的消息ID
![]()
1 using UnityEngine;
2 using System.Collections;
3
4 enum NetMsgID
5 {
6 NET_MSG_START = 100,
7 S2C_SEND_ANIMAL_DATA,
8 C2S_SELECT_ANIMAL,
9
10 NET_MSG_END,
11 }
Common.cs
ServerMain.cs u3d下的一個啟動服務器網絡模塊的控件
![]()
1 using UnityEngine;
2 using System.Collections;
3
4 public class ServerMain : MonoBehaviour
5 {
6 bool m_Destroy;
7 ServerEventDispath m_ClientMsg;
8 ReciveBroadcast m_Reciver;
9 SendBroadcast m_Sender;
10 LanSocket.Server m_GameNet;
11 void Start ()
12 {
13 m_Destroy = false;
14 //廣播
15 m_Reciver = new ReciveBroadcast();
16 m_Reciver.Start(6666);
17 m_Sender = new SendBroadcast();
18 m_Sender.Start(6688);
19
20 //游戲網絡
21 m_GameNet = new LanSocket.Server();
22 m_GameNet.Start(8888);
23
24 m_ClientMsg = new ServerEventDispath();
25 m_ClientMsg.RegistEvent(123, Action_123);
26 }
27
28 // Update is called once per frame
29 void Update ()
30 {
31 if(!m_Destroy)
32 {
33 LanSocket.ClientMsgUnPack clientMsg = null;
34 m_GameNet.GetMsg(ref clientMsg);
35 if (null != clientMsg)
36 {
37 print("Msg:" + clientMsg.GetMsgID() + " from: " + clientMsg.GetUserID());
38
39 EventNode mNode = new EventNode();
40 mNode.m_EventID = clientMsg.GetMsgID(); ;
41 mNode.msg = clientMsg;
42 m_ClientMsg.AddEvent(mNode);
43 }
44
45 if(!"".Equals(m_Reciver.GetIP()))
46 {
47 m_Sender.Send();
48 }
49
50 m_ClientMsg.Proccess();
51 }
52 }
53
54 void OnDestroy()
55 {
56 m_Destroy = true;
57 m_GameNet.Destroy();
58 m_Reciver.Destroy();
59 m_Sender.Destroy();
60 }
61
62 void Action_123(LanSocket.ClientMsgUnPack msg)
63 {
64 long userID = msg.GetUserID();
65 ushort accountLen = msg.ReadUShort();
66 string account = msg.ReadString(accountLen);
67 ushort passLen = msg.ReadUShort();
68 string pass = msg.ReadString(passLen);
69
70 print("Action_123 account: " + account + " pass word: " + pass+" from user: " + userID);
71
72 LanSocket.MsgPack sendMsg = new LanSocket.MsgPack();
73 sendMsg.SetHead(123);
74 string strAccount = "test account";
75 sendMsg.Pack16bit((ushort)strAccount.Length);
76 sendMsg.PackString(strAccount, (ushort)strAccount.Length);
77 string strPass = "test pass word";
78 sendMsg.Pack16bit((ushort)strPass.Length);
79 sendMsg.PackString(strPass, (ushort)strPass.Length);
80 sendMsg.PackEnd();
81 m_GameNet.SendTo(ref sendMsg, msg.GetUserID());
82 }
83 }
ServerMain.cs
伙計們，有代碼分享出來。利人利己。
你問為什麼會利己？
等你換了工作找不到原本的代碼的時候你就知道傳到網上是一件幸福的事。
Android學習指南之二十七：如何使用Handler
Android 中關於Fragment嵌套Fragment的問題，androidfragment
MSM8909+Android5.1.1鍵盤驅動---sn7326介紹
手機影音10--音樂列表，影音10--列表
