Unity3d网络游戏Socket通讯

小咪咪 2022-08-27 15:58 262阅读 0赞

unity3d网络游戏Socket通讯

网络游戏是一种人们娱乐休闲互交的应用软件。既然是互交，当然需要彼此间的了解通讯。要通讯那必须需要Socket：我们今天要实现的主角即套接字。Socket的英文原义是“孔”或“插座”，正如其英文原意那样，象一个多孔插座。一台电脑机器犹如布满各种插座的房间，每个插座有一个编号，有的插座提供220伏交流电， 有的提供110伏交流电，有的则提供有线电视节目。 客户软件将插头插到不同编号的插座，就可以得到不同的服务。下面我们来看看下图，游戏中玩家移动是如何通讯：

[![【转】Unity3d网络游戏Socket通讯][Unity3d_Socket]][Unity3d_Socket_Unity3d_Socket]

下面是Unity3d游戏通讯Socket实现： BaseGameSocket.cs  
@原创：dongfu.luo  
using System;  
using System.Collections.Generic;  
using System.Net.Sockets;

public abstract class BaseGameSocket  
\{  
//用来接收服务端发过来的缓冲Buff  
private byte\[\] \_data\_buffer;  
  
//缓冲二进制数组从哪里开始读  
private int \_data\_offset;  
  
//缓冲二进制数组读多少个byte  
private int \_data\_size;  
  
//游戏服务器IP地址  
private string \_ip;  
private bool \_is\_read\_head;  
  
//游戏服务器端口  
private int \_port;  
  
//要服务端发送的数据命令列表  
private List \_send\_list = new List();  
private Socket \_sock;  
private const int MAX\_SEND\_QUEUE = 0x3e8;  
  
//清空数据，一般是在断开重联时候调用

private void Clear()  
\{  
this.\_ip = null;  
this.\_port = 0;  
this.\_sock = null;  
List list = this.\_send\_list;  
lock (list)  
\{  
this.\_send\_list.Clear();  
\}  
this.\_is\_read\_head = false;  
this.\_data\_buffer = null;  
this.\_data\_offset = 0;  
this.\_data\_size = 0;  
\}  
  
//关闭客户端的Socket

public void Close()  
\{  
try  
\{  
Socket socket = this.\_sock;  
this.Clear();  
if ((socket != null) && socket.Connected)  
\{  
socket.Shutdown(SocketShutdown.Both);  
socket.Close();  
\}  
\}  
catch (Exception exception)  
\{  
UEDebug.LogError("Connect: " + exception.ToString());  
this.Error(Lang.GetString("k3432"));  
\}  
\}  
  
//连接游戏服务端

public void Connect(string ip, int port)  
\{  
try  
\{  
this.Close();  
this.\_ip = ip;  
this.\_port = port;  
this.\_sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
this.\_sock.NoDelay = true;  
this.\_sock.BeginConnect(this.\_ip, this.\_port, new AsyncCallback(this.OnConnect), this.\_sock);  
\}  
catch (Exception exception)  
\{  
UEDebug.LogError("Connect: " + exception.ToString());  
this.Error(Lang.GetString("k3432"));  
\}  
\}  
  
//如果Socket没有关闭继续等服务器信息，如果有信息则开始读

private void ContinueRead()  
\{  
try  
\{  
if (this.IsConnected)  
\{  
this.\_sock.BeginReceive(this.\_data\_buffer, this.\_data\_offset, this.\_data\_size - this.\_data\_offset, SocketFlags.None, new AsyncCallback(this.OnRead), null);  
\}  
\}  
catch (Exception exception)  
\{  
UEDebug.LogError(exception.ToString());  
this.Error(Lang.GetString("k3432"));  
\}  
\}  
  
  
//从发送队列从不断向游戏服务器发送命令

private void ContinueSend()  
\{  
PacketOut state = null;  
List list = this.\_send\_list;  
lock (list)  
\{  
if (this.\_send\_list.Count == 0)  
\{  
return;  
\}  
state = this.\_send\_list\[0\];  
if (state.start)  
\{  
return;  
\}  
state.start = true;  
\}  
Socket sock = state.sock;  
if (sock.Connected)  
\{  
sock.BeginSend(state.buff, 0, state.buff.Length, SocketFlags.None, new AsyncCallback(this.OnSend), state);  
\}  
\}  
//发送失败或错误，则关闭Socket一般是网络断了服务器关闭了

protected void Error(string msg)  
\{  
this.Close();  
this.OnError(msg);  
\}  
  
//程序猿都知道这是析构函数

~PackedSocket()  
\{  
this.Close();  
\}

public int GetSendQueueSize()  
\{  
List list = this.\_send\_list;  
lock (list)  
\{  
return this.\_send\_list.Count;  
\}  
\}  
  
//此函数由子类去处理

protected abstract void OnConnect();  
  
//如果是第一次连接上了，解析消息头  
private void OnConnect(IAsyncResult ret)  
\{  
if (ret.AsyncState == this.\_sock)  
\{  
try  
\{  
this.\_sock.EndConnect(ret);  
this.ReadHead();  
this.OnConnect();  
\}  
catch (Exception exception)  
\{

Debug.log(exception);  
\}  
\}  
\}

protected abstract void OnError(string msg);  
protected abstract void OnPack(byte\[\] data);  
  
//有服务端信息来，开始解析，现解析信息头再解析消息体  
private void OnRead(IAsyncResult ar)  
\{  
try  
\{  
if (this.IsConnected)  
\{  
int num = this.\_sock.EndReceive(ar);  
this.\_data\_offset += num;  
if (num <= 0)  
\{  
  
\}  
else if (this.\_data\_offset != this.\_data\_size)  
\{  
this.ContinueRead();  
\}  
else if (this.\_is\_read\_head)  
\{  
int num2 = BitConverter.ToInt32(this.\_data\_buffer, 0);  
this.ReadData(num2);  
\}  
else  
\{  
this.OnPack(this.\_data\_buffer);  
this.ReadHead();  
\}  
\}  
\}  
catch (Exception exception)  
\{

Debug.log(exception);  
\}  
\}  
  
//如果命令发送成功，检查发送队列是否还有需要发送的命令。如果有则继续发送

private void OnSend(IAsyncResult ar)  
\{  
PacketOut asyncState = ar.AsyncState as PacketOut;  
Socket sock = asyncState.sock;  
if (sock.Connected)  
\{  
sock.EndSend(ar);  
List list = this.\_send\_list;  
lock (list)  
\{  
if (this.\_send\_list.Contains(asyncState))  
\{  
this.\_send\_list.Remove(asyncState);  
\}  
\}  
this.ContinueSend();  
\}  
\}  
//读取消息体

private void ReadData(int pack\_len)  
\{  
this.\_is\_read\_head = false;  
this.\_data\_size = pack\_len;  
this.\_data\_offset = 4;  
this.\_data\_buffer = new byte\[this.\_data\_size\];  
this.ContinueRead();  
\}  
  
//读取消息头

private void ReadHead()  
\{  
this.\_is\_read\_head = true;  
this.\_data\_size = 4;  
this.\_data\_offset = 0;  
this.\_data\_buffer = new byte\[this.\_data\_size\];  
this.ContinueRead();  
\}  
  
//具体的发送信息，先把数据发到发送队列

public void Send(byte\[\] buff)  
\{  
if (this.IsConnected)  
\{  
PacketOut item = new PacketOut \{  
start = false,  
buff = buff,  
sock = this.\_sock  
\};  
int count = 0;  
List list = this.\_send\_list;  
lock (list)  
\{  
this.\_send\_list.Add(item);  
count = this.\_send\_list.Count;  
\}  
if (count > 0x3e8)  
\{

else  
\{  
this.ContinueSend();  
\}  
\}  
\}

public bool IsClosed  
\{  
get  
\{  
return (this.\_sock == null);  
\}  
\}

public bool IsConnected  
\{  
get  
\{  
return ((this.\_sock != null) && this.\_sock.Connected);  
\}  
\}

private class PacketOut  
\{  
public byte\[\] buff;  
public Socket sock;  
public bool start;  
\}  
\}

[Unity3d_Socket]: http://s14.sinaimg.cn/mw690/002CcMcHgy6KBr29xDLdd&690
[Unity3d_Socket_Unity3d_Socket]: /images/20220823/fa13301fa3ed40d1bfab0533d4a92a0c.png