niko
637 lines
17 KiB
C#
637 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using UnityEngine.Networking.Types;
|
|
|
|
namespace UnityEngine.Networking
|
|
{
|
|
// Token: 0x0200005A RID: 90
|
|
public class NetworkServerSimple
|
|
{
|
|
// Token: 0x0600043E RID: 1086 RVA: 0x0001897C File Offset: 0x00016B7C
|
|
public NetworkServerSimple()
|
|
{
|
|
this.m_ConnectionsReadOnly = new ReadOnlyCollection<NetworkConnection>(this.m_Connections);
|
|
}
|
|
|
|
// Token: 0x170000AF RID: 175
|
|
// (get) Token: 0x0600043F RID: 1087 RVA: 0x000189EC File Offset: 0x00016BEC
|
|
// (set) Token: 0x06000440 RID: 1088 RVA: 0x00018A07 File Offset: 0x00016C07
|
|
public int listenPort
|
|
{
|
|
get
|
|
{
|
|
return this.m_ListenPort;
|
|
}
|
|
set
|
|
{
|
|
this.m_ListenPort = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B0 RID: 176
|
|
// (get) Token: 0x06000441 RID: 1089 RVA: 0x00018A14 File Offset: 0x00016C14
|
|
// (set) Token: 0x06000442 RID: 1090 RVA: 0x00018A2F File Offset: 0x00016C2F
|
|
public int serverHostId
|
|
{
|
|
get
|
|
{
|
|
return this.m_ServerHostId;
|
|
}
|
|
set
|
|
{
|
|
this.m_ServerHostId = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B1 RID: 177
|
|
// (get) Token: 0x06000443 RID: 1091 RVA: 0x00018A3C File Offset: 0x00016C3C
|
|
public HostTopology hostTopology
|
|
{
|
|
get
|
|
{
|
|
return this.m_HostTopology;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B2 RID: 178
|
|
// (get) Token: 0x06000444 RID: 1092 RVA: 0x00018A58 File Offset: 0x00016C58
|
|
// (set) Token: 0x06000445 RID: 1093 RVA: 0x00018A73 File Offset: 0x00016C73
|
|
public bool useWebSockets
|
|
{
|
|
get
|
|
{
|
|
return this.m_UseWebSockets;
|
|
}
|
|
set
|
|
{
|
|
this.m_UseWebSockets = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B3 RID: 179
|
|
// (get) Token: 0x06000446 RID: 1094 RVA: 0x00018A80 File Offset: 0x00016C80
|
|
public ReadOnlyCollection<NetworkConnection> connections
|
|
{
|
|
get
|
|
{
|
|
return this.m_ConnectionsReadOnly;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B4 RID: 180
|
|
// (get) Token: 0x06000447 RID: 1095 RVA: 0x00018A9C File Offset: 0x00016C9C
|
|
public Dictionary<short, NetworkMessageDelegate> handlers
|
|
{
|
|
get
|
|
{
|
|
return this.m_MessageHandlers.GetHandlers();
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B5 RID: 181
|
|
// (get) Token: 0x06000448 RID: 1096 RVA: 0x00018ABC File Offset: 0x00016CBC
|
|
public byte[] messageBuffer
|
|
{
|
|
get
|
|
{
|
|
return this.m_MsgBuffer;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B6 RID: 182
|
|
// (get) Token: 0x06000449 RID: 1097 RVA: 0x00018AD8 File Offset: 0x00016CD8
|
|
public NetworkReader messageReader
|
|
{
|
|
get
|
|
{
|
|
return this.m_MsgReader;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B7 RID: 183
|
|
// (get) Token: 0x0600044A RID: 1098 RVA: 0x00018AF4 File Offset: 0x00016CF4
|
|
public Type networkConnectionClass
|
|
{
|
|
get
|
|
{
|
|
return this.m_NetworkConnectionClass;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600044B RID: 1099 RVA: 0x00018B0F File Offset: 0x00016D0F
|
|
public void SetNetworkConnectionClass<T>() where T : NetworkConnection
|
|
{
|
|
this.m_NetworkConnectionClass = typeof(T);
|
|
}
|
|
|
|
// Token: 0x0600044C RID: 1100 RVA: 0x00018B24 File Offset: 0x00016D24
|
|
public virtual void Initialize()
|
|
{
|
|
if (!this.m_Initialized)
|
|
{
|
|
this.m_Initialized = true;
|
|
NetworkTransport.Init();
|
|
this.m_MsgBuffer = new byte[65535];
|
|
this.m_MsgReader = new NetworkReader(this.m_MsgBuffer);
|
|
if (this.m_HostTopology == null)
|
|
{
|
|
ConnectionConfig connectionConfig = new ConnectionConfig();
|
|
connectionConfig.AddChannel(QosType.ReliableSequenced);
|
|
connectionConfig.AddChannel(QosType.Unreliable);
|
|
this.m_HostTopology = new HostTopology(connectionConfig, 8);
|
|
}
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkServerSimple initialize.");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600044D RID: 1101 RVA: 0x00018BB8 File Offset: 0x00016DB8
|
|
public bool Configure(ConnectionConfig config, int maxConnections)
|
|
{
|
|
HostTopology hostTopology = new HostTopology(config, maxConnections);
|
|
return this.Configure(hostTopology);
|
|
}
|
|
|
|
// Token: 0x0600044E RID: 1102 RVA: 0x00018BDC File Offset: 0x00016DDC
|
|
public bool Configure(HostTopology topology)
|
|
{
|
|
this.m_HostTopology = topology;
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x0600044F RID: 1103 RVA: 0x00018BFC File Offset: 0x00016DFC
|
|
public bool Listen(string ipAddress, int serverListenPort)
|
|
{
|
|
this.Initialize();
|
|
this.m_ListenPort = serverListenPort;
|
|
if (this.m_UseWebSockets)
|
|
{
|
|
this.m_ServerHostId = NetworkTransport.AddWebsocketHost(this.m_HostTopology, serverListenPort, ipAddress);
|
|
}
|
|
else
|
|
{
|
|
this.m_ServerHostId = NetworkTransport.AddHost(this.m_HostTopology, serverListenPort, ipAddress);
|
|
}
|
|
bool flag;
|
|
if (this.m_ServerHostId == -1)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log(string.Concat(new object[] { "NetworkServerSimple listen: ", ipAddress, ":", this.m_ListenPort }));
|
|
}
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000450 RID: 1104 RVA: 0x00018CAC File Offset: 0x00016EAC
|
|
public bool Listen(int serverListenPort)
|
|
{
|
|
return this.Listen(serverListenPort, this.m_HostTopology);
|
|
}
|
|
|
|
// Token: 0x06000451 RID: 1105 RVA: 0x00018CD0 File Offset: 0x00016ED0
|
|
public bool Listen(int serverListenPort, HostTopology topology)
|
|
{
|
|
this.m_HostTopology = topology;
|
|
this.Initialize();
|
|
this.m_ListenPort = serverListenPort;
|
|
if (this.m_UseWebSockets)
|
|
{
|
|
this.m_ServerHostId = NetworkTransport.AddWebsocketHost(this.m_HostTopology, serverListenPort);
|
|
}
|
|
else
|
|
{
|
|
this.m_ServerHostId = NetworkTransport.AddHost(this.m_HostTopology, serverListenPort);
|
|
}
|
|
bool flag;
|
|
if (this.m_ServerHostId == -1)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkServerSimple listen " + this.m_ListenPort);
|
|
}
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000452 RID: 1106 RVA: 0x00018D6C File Offset: 0x00016F6C
|
|
public void ListenRelay(string relayIp, int relayPort, NetworkID netGuid, SourceID sourceId, NodeID nodeId)
|
|
{
|
|
this.Initialize();
|
|
this.m_ServerHostId = NetworkTransport.AddHost(this.m_HostTopology, this.listenPort);
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Server Host Slot Id: " + this.m_ServerHostId);
|
|
}
|
|
this.Update();
|
|
byte b;
|
|
NetworkTransport.ConnectAsNetworkHost(this.m_ServerHostId, relayIp, relayPort, netGuid, sourceId, nodeId, out b);
|
|
this.m_RelaySlotId = 0;
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Relay Slot Id: " + this.m_RelaySlotId);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000453 RID: 1107 RVA: 0x00018E04 File Offset: 0x00017004
|
|
public void Stop()
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkServerSimple stop ");
|
|
}
|
|
NetworkTransport.RemoveHost(this.m_ServerHostId);
|
|
this.m_ServerHostId = -1;
|
|
}
|
|
|
|
// Token: 0x06000454 RID: 1108 RVA: 0x00018E30 File Offset: 0x00017030
|
|
internal void RegisterHandlerSafe(short msgType, NetworkMessageDelegate handler)
|
|
{
|
|
this.m_MessageHandlers.RegisterHandlerSafe(msgType, handler);
|
|
}
|
|
|
|
// Token: 0x06000455 RID: 1109 RVA: 0x00018E40 File Offset: 0x00017040
|
|
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
|
|
{
|
|
this.m_MessageHandlers.RegisterHandler(msgType, handler);
|
|
}
|
|
|
|
// Token: 0x06000456 RID: 1110 RVA: 0x00018E50 File Offset: 0x00017050
|
|
public void UnregisterHandler(short msgType)
|
|
{
|
|
this.m_MessageHandlers.UnregisterHandler(msgType);
|
|
}
|
|
|
|
// Token: 0x06000457 RID: 1111 RVA: 0x00018E5F File Offset: 0x0001705F
|
|
public void ClearHandlers()
|
|
{
|
|
this.m_MessageHandlers.ClearMessageHandlers();
|
|
}
|
|
|
|
// Token: 0x06000458 RID: 1112 RVA: 0x00018E70 File Offset: 0x00017070
|
|
public void UpdateConnections()
|
|
{
|
|
for (int i = 0; i < this.m_Connections.Count; i++)
|
|
{
|
|
NetworkConnection networkConnection = this.m_Connections[i];
|
|
if (networkConnection != null)
|
|
{
|
|
networkConnection.FlushChannels();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000459 RID: 1113 RVA: 0x00018EB8 File Offset: 0x000170B8
|
|
public void Update()
|
|
{
|
|
if (this.m_ServerHostId != -1)
|
|
{
|
|
NetworkEventType networkEventType;
|
|
if (this.m_RelaySlotId != -1)
|
|
{
|
|
byte b;
|
|
networkEventType = NetworkTransport.ReceiveRelayEventFromHost(this.m_ServerHostId, out b);
|
|
if (networkEventType != NetworkEventType.Nothing)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetGroup event:" + networkEventType);
|
|
}
|
|
}
|
|
if (networkEventType == NetworkEventType.ConnectEvent)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetGroup server connected");
|
|
}
|
|
}
|
|
if (networkEventType == NetworkEventType.DisconnectEvent)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetGroup server disconnected");
|
|
}
|
|
}
|
|
}
|
|
do
|
|
{
|
|
byte b;
|
|
int num;
|
|
int num2;
|
|
int num3;
|
|
networkEventType = NetworkTransport.ReceiveFromHost(this.m_ServerHostId, out num, out num2, this.m_MsgBuffer, this.m_MsgBuffer.Length, out num3, out b);
|
|
if (networkEventType != NetworkEventType.Nothing)
|
|
{
|
|
if (LogFilter.logDev)
|
|
{
|
|
Debug.Log(string.Concat(new object[] { "Server event: host=", this.m_ServerHostId, " event=", networkEventType, " error=", b }));
|
|
}
|
|
}
|
|
switch (networkEventType)
|
|
{
|
|
case NetworkEventType.DataEvent:
|
|
this.HandleData(num, num2, num3, b);
|
|
break;
|
|
case NetworkEventType.ConnectEvent:
|
|
this.HandleConnect(num, b);
|
|
break;
|
|
case NetworkEventType.DisconnectEvent:
|
|
this.HandleDisconnect(num, b);
|
|
break;
|
|
case NetworkEventType.Nothing:
|
|
break;
|
|
default:
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Unknown network message type received: " + networkEventType);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
while (networkEventType != NetworkEventType.Nothing);
|
|
this.UpdateConnections();
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600045A RID: 1114 RVA: 0x0001906C File Offset: 0x0001726C
|
|
public NetworkConnection FindConnection(int connectionId)
|
|
{
|
|
NetworkConnection networkConnection;
|
|
if (connectionId < 0 || connectionId >= this.m_Connections.Count)
|
|
{
|
|
networkConnection = null;
|
|
}
|
|
else
|
|
{
|
|
networkConnection = this.m_Connections[connectionId];
|
|
}
|
|
return networkConnection;
|
|
}
|
|
|
|
// Token: 0x0600045B RID: 1115 RVA: 0x000190AC File Offset: 0x000172AC
|
|
public bool SetConnectionAtIndex(NetworkConnection conn)
|
|
{
|
|
while (this.m_Connections.Count <= conn.connectionId)
|
|
{
|
|
this.m_Connections.Add(null);
|
|
}
|
|
bool flag;
|
|
if (this.m_Connections[conn.connectionId] != null)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
this.m_Connections[conn.connectionId] = conn;
|
|
conn.SetHandlers(this.m_MessageHandlers);
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x0600045C RID: 1116 RVA: 0x00019128 File Offset: 0x00017328
|
|
public bool RemoveConnectionAtIndex(int connectionId)
|
|
{
|
|
bool flag;
|
|
if (connectionId < 0 || connectionId >= this.m_Connections.Count)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
this.m_Connections[connectionId] = null;
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x0600045D RID: 1117 RVA: 0x0001916C File Offset: 0x0001736C
|
|
private void HandleConnect(int connectionId, byte error)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkServerSimple accepted client:" + connectionId);
|
|
}
|
|
if (error != 0)
|
|
{
|
|
this.OnConnectError(connectionId, error);
|
|
}
|
|
else
|
|
{
|
|
string text;
|
|
int num;
|
|
NetworkID networkID;
|
|
NodeID nodeID;
|
|
byte b;
|
|
NetworkTransport.GetConnectionInfo(this.m_ServerHostId, connectionId, out text, out num, out networkID, out nodeID, out b);
|
|
NetworkConnection networkConnection = (NetworkConnection)Activator.CreateInstance(this.m_NetworkConnectionClass);
|
|
networkConnection.SetHandlers(this.m_MessageHandlers);
|
|
networkConnection.Initialize(text, this.m_ServerHostId, connectionId, this.m_HostTopology);
|
|
networkConnection.lastError = (NetworkError)b;
|
|
while (this.m_Connections.Count <= connectionId)
|
|
{
|
|
this.m_Connections.Add(null);
|
|
}
|
|
this.m_Connections[connectionId] = networkConnection;
|
|
this.OnConnected(networkConnection);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600045E RID: 1118 RVA: 0x0001923C File Offset: 0x0001743C
|
|
private void HandleDisconnect(int connectionId, byte error)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkServerSimple disconnect client:" + connectionId);
|
|
}
|
|
NetworkConnection networkConnection = this.FindConnection(connectionId);
|
|
if (networkConnection != null)
|
|
{
|
|
networkConnection.lastError = (NetworkError)error;
|
|
if (error != 0)
|
|
{
|
|
if (error != 6)
|
|
{
|
|
this.m_Connections[connectionId] = null;
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError(string.Concat(new object[]
|
|
{
|
|
"Server client disconnect error, connectionId: ",
|
|
connectionId,
|
|
" error: ",
|
|
(NetworkError)error
|
|
}));
|
|
}
|
|
this.OnDisconnectError(networkConnection, error);
|
|
return;
|
|
}
|
|
}
|
|
networkConnection.Disconnect();
|
|
this.m_Connections[connectionId] = null;
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("Server lost client:" + connectionId);
|
|
}
|
|
this.OnDisconnected(networkConnection);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600045F RID: 1119 RVA: 0x0001932C File Offset: 0x0001752C
|
|
private void HandleData(int connectionId, int channelId, int receivedSize, byte error)
|
|
{
|
|
NetworkConnection networkConnection = this.FindConnection(connectionId);
|
|
if (networkConnection == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("HandleData Unknown connectionId:" + connectionId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
networkConnection.lastError = (NetworkError)error;
|
|
if (error != 0)
|
|
{
|
|
this.OnDataError(networkConnection, error);
|
|
}
|
|
else
|
|
{
|
|
this.m_MsgReader.SeekZero();
|
|
this.OnData(networkConnection, receivedSize, channelId);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000460 RID: 1120 RVA: 0x000193A4 File Offset: 0x000175A4
|
|
public void SendBytesTo(int connectionId, byte[] bytes, int numBytes, int channelId)
|
|
{
|
|
NetworkConnection networkConnection = this.FindConnection(connectionId);
|
|
if (networkConnection != null)
|
|
{
|
|
networkConnection.SendBytes(bytes, numBytes, channelId);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000461 RID: 1121 RVA: 0x000193D4 File Offset: 0x000175D4
|
|
public void SendWriterTo(int connectionId, NetworkWriter writer, int channelId)
|
|
{
|
|
NetworkConnection networkConnection = this.FindConnection(connectionId);
|
|
if (networkConnection != null)
|
|
{
|
|
networkConnection.SendWriter(writer, channelId);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000462 RID: 1122 RVA: 0x00019400 File Offset: 0x00017600
|
|
public void Disconnect(int connectionId)
|
|
{
|
|
NetworkConnection networkConnection = this.FindConnection(connectionId);
|
|
if (networkConnection != null)
|
|
{
|
|
networkConnection.Disconnect();
|
|
this.m_Connections[connectionId] = null;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000463 RID: 1123 RVA: 0x00019438 File Offset: 0x00017638
|
|
public void DisconnectAllConnections()
|
|
{
|
|
for (int i = 0; i < this.m_Connections.Count; i++)
|
|
{
|
|
NetworkConnection networkConnection = this.m_Connections[i];
|
|
if (networkConnection != null)
|
|
{
|
|
networkConnection.Disconnect();
|
|
networkConnection.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000464 RID: 1124 RVA: 0x00019485 File Offset: 0x00017685
|
|
public virtual void OnConnectError(int connectionId, byte error)
|
|
{
|
|
Debug.LogError("OnConnectError error:" + error);
|
|
}
|
|
|
|
// Token: 0x06000465 RID: 1125 RVA: 0x0001949D File Offset: 0x0001769D
|
|
public virtual void OnDataError(NetworkConnection conn, byte error)
|
|
{
|
|
Debug.LogError("OnDataError error:" + error);
|
|
}
|
|
|
|
// Token: 0x06000466 RID: 1126 RVA: 0x000194B5 File Offset: 0x000176B5
|
|
public virtual void OnDisconnectError(NetworkConnection conn, byte error)
|
|
{
|
|
Debug.LogError("OnDisconnectError error:" + error);
|
|
}
|
|
|
|
// Token: 0x06000467 RID: 1127 RVA: 0x000194CD File Offset: 0x000176CD
|
|
public virtual void OnConnected(NetworkConnection conn)
|
|
{
|
|
conn.InvokeHandlerNoData(32);
|
|
}
|
|
|
|
// Token: 0x06000468 RID: 1128 RVA: 0x000194D9 File Offset: 0x000176D9
|
|
public virtual void OnDisconnected(NetworkConnection conn)
|
|
{
|
|
conn.InvokeHandlerNoData(33);
|
|
}
|
|
|
|
// Token: 0x06000469 RID: 1129 RVA: 0x000194E5 File Offset: 0x000176E5
|
|
public virtual void OnData(NetworkConnection conn, int receivedSize, int channelId)
|
|
{
|
|
conn.TransportReceive(this.m_MsgBuffer, receivedSize, channelId);
|
|
}
|
|
|
|
// Token: 0x040001D2 RID: 466
|
|
private bool m_Initialized = false;
|
|
|
|
// Token: 0x040001D3 RID: 467
|
|
private int m_ListenPort;
|
|
|
|
// Token: 0x040001D4 RID: 468
|
|
private int m_ServerHostId = -1;
|
|
|
|
// Token: 0x040001D5 RID: 469
|
|
private int m_RelaySlotId = -1;
|
|
|
|
// Token: 0x040001D6 RID: 470
|
|
private bool m_UseWebSockets;
|
|
|
|
// Token: 0x040001D7 RID: 471
|
|
private byte[] m_MsgBuffer = null;
|
|
|
|
// Token: 0x040001D8 RID: 472
|
|
private NetworkReader m_MsgReader = null;
|
|
|
|
// Token: 0x040001D9 RID: 473
|
|
private Type m_NetworkConnectionClass = typeof(NetworkConnection);
|
|
|
|
// Token: 0x040001DA RID: 474
|
|
private HostTopology m_HostTopology;
|
|
|
|
// Token: 0x040001DB RID: 475
|
|
private List<NetworkConnection> m_Connections = new List<NetworkConnection>();
|
|
|
|
// Token: 0x040001DC RID: 476
|
|
private ReadOnlyCollection<NetworkConnection> m_ConnectionsReadOnly;
|
|
|
|
// Token: 0x040001DD RID: 477
|
|
private NetworkMessageHandlers m_MessageHandlers = new NetworkMessageHandlers();
|
|
}
|
|
}
|