| private ReceiveFromHost ( int hostId, int &connectionId, int &channelId, byte buffer, int bufferSize, int &receivedSize, byte &error ) : NetworkEventType | ||
| hostId | int | |
| connectionId | int | |
| channelId | int | |
| buffer | byte | |
| bufferSize | int | |
| receivedSize | int | |
| error | byte | |
| return | NetworkEventType | |
private void Update()
{
if (this.m_HostId == -1 || this.m_IsServer)
{
return;
}
NetworkEventType fromHost;
do
{
int connectionId;
int channelId;
int receivedSize;
byte error;
fromHost = NetworkTransport.ReceiveFromHost(this.m_HostId, out connectionId, out channelId, this.m_MsgInBuffer, 1024, out receivedSize, out error);
if (fromHost == NetworkEventType.BroadcastEvent)
{
NetworkTransport.GetBroadcastConnectionMessage(this.m_HostId, this.m_MsgInBuffer, 1024, out receivedSize, out error);
string address;
int port;
NetworkTransport.GetBroadcastConnectionInfo(this.m_HostId, out address, out port, out error);
NetworkBroadcastResult networkBroadcastResult = new NetworkBroadcastResult();
networkBroadcastResult.serverAddress = address;
networkBroadcastResult.broadcastData = new byte[receivedSize];
Buffer.BlockCopy((Array)this.m_MsgInBuffer, 0, (Array)networkBroadcastResult.broadcastData, 0, receivedSize);
this.m_BroadcastsReceived[address] = networkBroadcastResult;
this.OnReceivedBroadcast(address, NetworkDiscovery.BytesToString(this.m_MsgInBuffer));
}
}while (fromHost != NetworkEventType.Nothing);
}
/// <summary>
/// <para>This function pumps the server causing incoming network data to be processed, and pending outgoing data to be sent.</para>
/// </summary>
public void Update()
{
if (this.m_ServerHostId != -1)
{
byte num4;
NetworkEventType dataEvent = NetworkEventType.DataEvent;
if (this.m_RelaySlotId != -1)
{
dataEvent = NetworkTransport.ReceiveRelayEventFromHost(this.m_ServerHostId, out num4);
if ((dataEvent != NetworkEventType.Nothing) && LogFilter.logDebug)
{
Debug.Log("NetGroup event:" + dataEvent);
}
if ((dataEvent == NetworkEventType.ConnectEvent) && LogFilter.logDebug)
{
Debug.Log("NetGroup server connected");
}
if ((dataEvent == NetworkEventType.DisconnectEvent) && LogFilter.logDebug)
{
Debug.Log("NetGroup server disconnected");
}
}
do
{
int num;
int num2;
int num3;
dataEvent = NetworkTransport.ReceiveFromHost(this.m_ServerHostId, out num, out num2, this.m_MsgBuffer, this.m_MsgBuffer.Length, out num3, out num4);
if ((dataEvent != NetworkEventType.Nothing) && LogFilter.logDev)
{
Debug.Log(string.Concat(new object[] { "Server event: host=", this.m_ServerHostId, " event=", dataEvent, " error=", num4 }));
}
switch (dataEvent)
{
case NetworkEventType.DataEvent:
this.HandleData(num, num2, num3, num4);
break;
case NetworkEventType.ConnectEvent:
this.HandleConnect(num, num4);
break;
case NetworkEventType.DisconnectEvent:
this.HandleDisconnect(num, num4);
break;
case NetworkEventType.Nothing:
break;
default:
if (LogFilter.logError)
{
Debug.LogError("Unknown network message type received: " + dataEvent);
}
break;
}
}while (dataEvent != NetworkEventType.Nothing);
this.UpdateConnections();
}
}
private void Update()
{
if (this.m_HostId == -1)
{
return;
}
if (this.m_IsServer)
{
return;
}
NetworkEventType networkEventType;
do
{
int num;
int num2;
int num3;
byte b;
networkEventType = NetworkTransport.ReceiveFromHost(this.m_HostId, out num, out num2, this.m_MsgInBuffer, 1024, out num3, out b);
if (networkEventType == NetworkEventType.BroadcastEvent)
{
NetworkTransport.GetBroadcastConnectionMessage(this.m_HostId, this.m_MsgInBuffer, 1024, out num3, out b);
string text;
int num4;
NetworkTransport.GetBroadcastConnectionInfo(this.m_HostId, out text, out num4, out b);
NetworkBroadcastResult value = default(NetworkBroadcastResult);
value.serverAddress = text;
value.broadcastData = new byte[num3];
Buffer.BlockCopy(this.m_MsgInBuffer, 0, value.broadcastData, 0, num3);
this.m_BroadcastsReceived[text] = value;
this.OnReceivedBroadcast(text, NetworkDiscovery.BytesToString(this.m_MsgInBuffer));
}
}while (networkEventType != NetworkEventType.Nothing);
}
private void Update()
{
if ((this.m_HostId != -1) && !this.m_IsServer)
{
NetworkEventType type;
do
{
int num;
int num2;
int num3;
byte num4;
type = NetworkTransport.ReceiveFromHost(this.m_HostId, out num, out num2, this.m_MsgInBuffer, 0x400, out num3, out num4);
if (type == NetworkEventType.BroadcastEvent)
{
string str;
int num5;
NetworkTransport.GetBroadcastConnectionMessage(this.m_HostId, this.m_MsgInBuffer, 0x400, out num3, out num4);
NetworkTransport.GetBroadcastConnectionInfo(this.m_HostId, out str, out num5, out num4);
NetworkBroadcastResult result = new NetworkBroadcastResult {
serverAddress = str,
broadcastData = new byte[num3]
};
Buffer.BlockCopy(this.m_MsgInBuffer, 0, result.broadcastData, 0, num3);
this.m_BroadcastsReceived[str] = result;
this.OnReceivedBroadcast(str, BytesToString(this.m_MsgInBuffer));
}
}while (type != NetworkEventType.Nothing);
}
}
public void Update()
{
if (m_ServerHostId == -1)
{
return;
}
NetworkEventType networkEventType = NetworkEventType.DataEvent;
byte error;
if (m_RelaySlotId != -1)
{
networkEventType = NetworkTransport.ReceiveRelayEventFromHost(m_ServerHostId, out error);
if (networkEventType != NetworkEventType.Nothing && LogFilter.logDebug)
{
Debug.Log("NetGroup event:" + networkEventType);
}
if (networkEventType == NetworkEventType.ConnectEvent && LogFilter.logDebug)
{
Debug.Log("NetGroup server connected");
}
if (networkEventType == NetworkEventType.DisconnectEvent && LogFilter.logDebug)
{
Debug.Log("NetGroup server disconnected");
}
}
do
{
networkEventType = NetworkTransport.ReceiveFromHost(m_ServerHostId, out int connectionId, out int channelId, m_MsgBuffer, m_MsgBuffer.Length, out int receivedSize, out error);
if (networkEventType != NetworkEventType.Nothing && LogFilter.logDev)
{
Debug.Log("Server event: host=" + m_ServerHostId + " event=" + networkEventType + " error=" + error);
}
switch (networkEventType)
{
case NetworkEventType.ConnectEvent:
HandleConnect(connectionId, error);
continue;
case NetworkEventType.DataEvent:
HandleData(connectionId, channelId, receivedSize, error);
continue;
case NetworkEventType.DisconnectEvent:
HandleDisconnect(connectionId, error);
continue;
case NetworkEventType.Nothing:
continue;
}
if (LogFilter.logError)
{
Debug.LogError("Unknown network message type received: " + networkEventType);
}
}while (networkEventType != NetworkEventType.Nothing);
UpdateConnections();
}
void Update()
{
if (m_HostId == -1)
{
return;
}
if (m_IsServer)
{
return;
}
NetworkEventType networkEvent;
do
{
int connectionId;
int channelId;
int receivedSize;
byte error;
networkEvent = NetworkTransport.ReceiveFromHost(m_HostId, out connectionId, out channelId, m_MsgInBuffer, k_MaxBroadcastMsgSize, out receivedSize, out error);
if (networkEvent == NetworkEventType.BroadcastEvent)
{
//ブロードキャストのメッセージを取得
NetworkTransport.GetBroadcastConnectionMessage(m_HostId, m_MsgInBuffer, k_MaxBroadcastMsgSize, out receivedSize, out error);
string senderAddr;
int senderPort;
//接続情報を取得
NetworkTransport.GetBroadcastConnectionInfo(m_HostId, out senderAddr, out senderPort, out error);
//NetworkBroadcastResult変数にアドレスとメッセージを代入
var recv = new NetworkBroadcastResult();
recv.serverAddress = senderAddr;
recv.broadcastData = new byte[receivedSize];
Buffer.BlockCopy(m_MsgInBuffer, 0, recv.broadcastData, 0, receivedSize);
//見つかった部屋を登録
m_BroadcastsReceived[senderAddr] = recv;
if (RoomList.roomListAddress.Contains(senderAddr) == false)
{
OnReceivedBroadcast(senderAddr, BytesToString(m_MsgInBuffer));
}
}
}while (networkEvent != NetworkEventType.Nothing);
}
void Update()
{
if (m_HostId == -1)
{
return;
}
if (m_IsServer)
{
return;
}
NetworkEventType networkEvent;
do
{
int connectionId;
int channelId;
int receivedSize;
byte error;
networkEvent = NetworkTransport.ReceiveFromHost(m_HostId, out connectionId, out channelId, m_MsgInBuffer, k_MaxBroadcastMsgSize, out receivedSize, out error);
if (networkEvent == NetworkEventType.BroadcastEvent)
{
NetworkTransport.GetBroadcastConnectionMessage(m_HostId, m_MsgInBuffer, k_MaxBroadcastMsgSize, out receivedSize, out error);
string senderAddr;
int senderPort;
NetworkTransport.GetBroadcastConnectionInfo(m_HostId, out senderAddr, out senderPort, out error);
var recv = new NetworkBroadcastResult();
recv.serverAddress = senderAddr;
recv.broadcastData = new byte[receivedSize];
Buffer.BlockCopy(m_MsgInBuffer, 0, recv.broadcastData, 0, receivedSize);
m_BroadcastsReceived[senderAddr] = recv;
OnReceivedBroadcast(senderAddr, BytesToString(m_MsgInBuffer));
}
}while (networkEvent != NetworkEventType.Nothing);
}
private void Update()
{
if (m_HostId == -1 || m_IsServer)
{
return;
}
NetworkEventType networkEventType;
do
{
networkEventType = NetworkTransport.ReceiveFromHost(m_HostId, out int _, out int _, m_MsgInBuffer, 1024, out int receivedSize, out byte error);
if (networkEventType == NetworkEventType.BroadcastEvent)
{
NetworkTransport.GetBroadcastConnectionMessage(m_HostId, m_MsgInBuffer, 1024, out receivedSize, out error);
NetworkTransport.GetBroadcastConnectionInfo(m_HostId, out string address, out int _, out error);
NetworkBroadcastResult value = default(NetworkBroadcastResult);
value.serverAddress = address;
value.broadcastData = new byte[receivedSize];
Buffer.BlockCopy(m_MsgInBuffer, 0, value.broadcastData, 0, receivedSize);
m_BroadcastsReceived[address] = value;
OnReceivedBroadcast(address, BytesToString(m_MsgInBuffer));
}
}while (networkEventType != NetworkEventType.Nothing);
}
internal virtual void Update()
{
if (this.m_ClientId != -1)
{
switch (this.m_AsyncConnect)
{
case NetworkClient.ConnectState.None:
case NetworkClient.ConnectState.Resolving:
case NetworkClient.ConnectState.Disconnected:
return;
case NetworkClient.ConnectState.Resolved:
this.m_AsyncConnect = NetworkClient.ConnectState.Connecting;
this.ContinueConnect();
return;
case NetworkClient.ConnectState.Failed:
this.GenerateConnectError(11);
this.m_AsyncConnect = NetworkClient.ConnectState.Disconnected;
return;
}
if (this.m_Connection != null)
{
if ((int)Time.time != this.m_StatResetTime)
{
this.m_Connection.ResetStats();
this.m_StatResetTime = (int)Time.time;
}
}
int num = 0;
byte b;
for (;;)
{
int num2;
int channelId;
int numBytes;
NetworkEventType networkEventType = NetworkTransport.ReceiveFromHost(this.m_ClientId, out num2, out channelId, this.m_MsgBuffer, (int)((ushort)this.m_MsgBuffer.Length), out numBytes, out b);
if (this.m_Connection != null)
{
this.m_Connection.lastError = (NetworkError)b;
}
if (networkEventType != NetworkEventType.Nothing)
{
if (LogFilter.logDev)
{
Debug.Log(string.Concat(new object[]
{
"Client event: host=",
this.m_ClientId,
" event=",
networkEventType,
" error=",
b
}));
}
}
switch (networkEventType)
{
case NetworkEventType.DataEvent:
if (b != 0)
{
goto Block_11;
}
this.m_MsgReader.SeekZero();
this.m_Connection.TransportReceive(this.m_MsgBuffer, numBytes, channelId);
break;
case NetworkEventType.ConnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client connected");
}
if (b != 0)
{
goto Block_10;
}
this.m_AsyncConnect = NetworkClient.ConnectState.Connected;
this.m_Connection.InvokeHandlerNoData(32);
break;
case NetworkEventType.DisconnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client disconnected");
}
this.m_AsyncConnect = NetworkClient.ConnectState.Disconnected;
if (b != 0)
{
if (b != 6)
{
this.GenerateDisconnectError((int)b);
}
}
ClientScene.HandleClientDisconnect(this.m_Connection);
if (this.m_Connection != null)
{
this.m_Connection.InvokeHandlerNoData(33);
}
break;
case NetworkEventType.Nothing:
break;
default:
if (LogFilter.logError)
{
Debug.LogError("Unknown network message type received: " + networkEventType);
}
break;
}
if (++num >= 500)
{
goto Block_17;
}
if (this.m_ClientId == -1)
{
goto Block_19;
}
if (networkEventType == NetworkEventType.Nothing)
{
goto IL_2C6;
}
}
Block_10:
this.GenerateConnectError((int)b);
return;
Block_11:
this.GenerateDataError((int)b);
return;
Block_17:
if (LogFilter.logDebug)
{
Debug.Log("MaxEventsPerFrame hit (" + 500 + ")");
}
Block_19:
IL_2C6:
if (this.m_Connection != null && this.m_AsyncConnect == NetworkClient.ConnectState.Connected)
{
this.m_Connection.FlushChannels();
}
}
}
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 connectionId;
int channelId;
int receivedSize;
networkEventType = NetworkTransport.ReceiveFromHost(this.m_ServerHostId, out connectionId, out channelId, this.m_MsgBuffer, this.m_MsgBuffer.Length, out receivedSize, 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(connectionId, channelId, receivedSize, b);
break;
case NetworkEventType.ConnectEvent:
this.HandleConnect(connectionId, b);
break;
case NetworkEventType.DisconnectEvent:
this.HandleDisconnect(connectionId, 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();
}
}
internal virtual void Update()
{
if (m_ClientId == -1)
{
return;
}
switch (m_AsyncConnect)
{
case ConnectState.None:
case ConnectState.Resolving:
case ConnectState.Disconnected:
return;
case ConnectState.Failed:
GenerateConnectError((int)NetworkError.DNSFailure);
m_AsyncConnect = ConnectState.Disconnected;
return;
case ConnectState.Resolved:
m_AsyncConnect = ConnectState.Connecting;
ContinueConnect();
return;
case ConnectState.Connecting:
case ConnectState.Connected:
{
break;
}
}
if (m_Connection != null)
{
if ((int)Time.time != m_StatResetTime)
{
m_Connection.ResetStats();
m_StatResetTime = (int)Time.time;
}
}
NetworkEventType networkEvent;
do
{
int connectionId;
int channelId;
int receivedSize;
byte error;
int numEvents = 0;
networkEvent = NetworkTransport.ReceiveFromHost(m_ClientId, out connectionId, out channelId, m_MsgBuffer, (ushort)m_MsgBuffer.Length, out receivedSize, out error);
if (networkEvent != NetworkEventType.Nothing)
{
if (LogFilter.logDev)
{
Debug.Log("Client event: host=" + m_ClientId + " event=" + networkEvent + " error=" + error);
}
}
switch (networkEvent)
{
case NetworkEventType.ConnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client connected");
}
if (error != 0)
{
GenerateConnectError(error);
return;
}
m_AsyncConnect = ConnectState.Connected;
m_Connection.InvokeHandlerNoData(MsgType.Connect);
break;
case NetworkEventType.DataEvent:
if (error != 0)
{
GenerateDataError(error);
return;
}
#if UNITY_EDITOR
UnityEditor.NetworkDetailStats.IncrementStat(
UnityEditor.NetworkDetailStats.NetworkDirection.Incoming,
MsgType.LLAPIMsg, "msg", 1);
#endif
m_MsgReader.SeekZero();
m_Connection.TransportRecieve(m_MsgBuffer, receivedSize, channelId);
break;
case NetworkEventType.DisconnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client disconnected");
}
m_AsyncConnect = ConnectState.Disconnected;
if (error != 0)
{
if ((NetworkError)error != NetworkError.Timeout)
{
GenerateDisconnectError(error);
}
}
ClientScene.HandleClientDisconnect(m_Connection);
if (m_Connection != null)
{
m_Connection.InvokeHandlerNoData(MsgType.Disconnect);
}
break;
case NetworkEventType.Nothing:
break;
default:
if (LogFilter.logError)
{
Debug.LogError("Unknown network message type received: " + networkEvent);
}
break;
}
if (++numEvents >= k_MaxEventsPerFrame)
{
if (LogFilter.logDebug)
{
Debug.Log("MaxEventsPerFrame hit (" + k_MaxEventsPerFrame + ")");
}
break;
}
if (m_ClientId == -1)
{
break;
}
}while (networkEvent != NetworkEventType.Nothing);
if (m_Connection != null && m_AsyncConnect == ConnectState.Connected)
{
m_Connection.FlushChannels();
}
}
internal virtual void Update()
{
int num;
int num2;
int num3;
byte num4;
int num5;
if (this.m_ClientId == -1)
{
return;
}
switch (this.m_AsyncConnect)
{
case ConnectState.None:
case ConnectState.Resolving:
case ConnectState.Disconnected:
return;
case ConnectState.Resolved:
this.m_AsyncConnect = ConnectState.Connecting;
this.ContinueConnect();
return;
case ConnectState.Failed:
this.GenerateConnectError(11);
this.m_AsyncConnect = ConnectState.Disconnected;
return;
default:
if ((this.m_Connection != null) && (((int)Time.time) != this.m_StatResetTime))
{
this.m_Connection.ResetStats();
this.m_StatResetTime = (int)Time.time;
}
break;
}
Label_0094:
num5 = 0;
NetworkEventType type = NetworkTransport.ReceiveFromHost(this.m_ClientId, out num, out num2, this.m_MsgBuffer, (ushort)this.m_MsgBuffer.Length, out num3, out num4);
if ((type != NetworkEventType.Nothing) && LogFilter.logDev)
{
Debug.Log(string.Concat(new object[] { "Client event: host=", this.m_ClientId, " event=", type, " error=", num4 }));
}
switch (type)
{
case NetworkEventType.DataEvent:
if (num4 == 0)
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, 0x1d, "msg", 1);
this.m_MsgReader.SeekZero();
this.m_Connection.TransportRecieve(this.m_MsgBuffer, num3, num2);
break;
}
this.GenerateDataError(num4);
return;
case NetworkEventType.ConnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client connected");
}
if (num4 != 0)
{
this.GenerateConnectError(num4);
return;
}
this.m_AsyncConnect = ConnectState.Connected;
this.m_Connection.InvokeHandlerNoData(0x20);
break;
case NetworkEventType.DisconnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client disconnected");
}
this.m_AsyncConnect = ConnectState.Disconnected;
if (num4 != 0)
{
this.GenerateDisconnectError(num4);
}
ClientScene.HandleClientDisconnect(this.m_Connection);
this.m_Connection.InvokeHandlerNoData(0x21);
break;
case NetworkEventType.Nothing:
break;
default:
if (LogFilter.logError)
{
Debug.LogError("Unknown network message type received: " + type);
}
break;
}
if (++num5 >= 500)
{
if (LogFilter.logDebug)
{
Debug.Log("MaxEventsPerFrame hit (" + 500 + ")");
}
}
else if ((this.m_ClientId != -1) && (type != NetworkEventType.Nothing))
{
goto Label_0094;
}
if ((this.m_Connection != null) && (this.m_AsyncConnect == ConnectState.Connected))
{
this.m_Connection.FlushChannels();
}
}
public static NetworkEventType ReceiveFromHost(int hostId, out int connectionId, out int channelId, byte[] buffer, int bufferSize, out int receivedSize, out byte error)
{
NetworkEventType @event = NetworkTransport.ReceiveFromHost(hostId, out connectionId, out channelId, buffer, bufferSize, out receivedSize, out error);
return(BaseReceive(@event, hostId, ref connectionId, ref channelId, buffer, bufferSize, ref receivedSize, ref error));
}
/// <summary>
/// <para>This function pumps the server causing incoming network data to be processed, and pending outgoing data to be sent.</para>
/// </summary>
public void Update()
{
if (this.m_ServerHostId == -1)
{
return;
}
byte error;
if (this.m_RelaySlotId != -1)
{
NetworkEventType relayEventFromHost = NetworkTransport.ReceiveRelayEventFromHost(this.m_ServerHostId, out error);
if (relayEventFromHost != NetworkEventType.Nothing && LogFilter.logDebug)
{
Debug.Log((object)("NetGroup event:" + (object)relayEventFromHost));
}
if (relayEventFromHost == NetworkEventType.ConnectEvent && LogFilter.logDebug)
{
Debug.Log((object)"NetGroup server connected");
}
if (relayEventFromHost == NetworkEventType.DisconnectEvent && LogFilter.logDebug)
{
Debug.Log((object)"NetGroup server disconnected");
}
}
NetworkEventType fromHost;
do
{
int connectionId;
int channelId;
int receivedSize;
fromHost = NetworkTransport.ReceiveFromHost(this.m_ServerHostId, out connectionId, out channelId, this.m_MsgBuffer, this.m_MsgBuffer.Length, out receivedSize, out error);
if (fromHost == NetworkEventType.Nothing)
{
;
}
switch (fromHost)
{
case NetworkEventType.DataEvent:
this.HandleData(connectionId, channelId, receivedSize, error);
goto case NetworkEventType.Nothing;
case NetworkEventType.ConnectEvent:
this.HandleConnect(connectionId, error);
goto case NetworkEventType.Nothing;
case NetworkEventType.DisconnectEvent:
this.HandleDisconnect(connectionId, error);
goto case NetworkEventType.Nothing;
case NetworkEventType.Nothing:
continue;
default:
if (LogFilter.logError)
{
Debug.LogError((object)("Unknown network message type received: " + (object)fromHost));
goto case NetworkEventType.Nothing;
}
else
{
goto case NetworkEventType.Nothing;
}
}
}while (fromHost != NetworkEventType.Nothing);
this.UpdateConnections();
}
internal virtual void Update()
{
if (this.m_ClientId == -1)
{
return;
}
switch (this.m_AsyncConnect)
{
case NetworkClient.ConnectState.None:
break;
case NetworkClient.ConnectState.Resolving:
break;
case NetworkClient.ConnectState.Resolved:
this.m_AsyncConnect = NetworkClient.ConnectState.Connecting;
this.ContinueConnect();
break;
case NetworkClient.ConnectState.Disconnected:
break;
case NetworkClient.ConnectState.Failed:
this.GenerateConnectError(11);
this.m_AsyncConnect = NetworkClient.ConnectState.Disconnected;
break;
default:
if (this.m_Connection != null && (int)Time.time != this.m_StatResetTime)
{
this.m_Connection.ResetStats();
this.m_StatResetTime = (int)Time.time;
}
NetworkEventType fromHost;
do
{
int num1 = 0;
int connectionId;
int channelId;
int receivedSize;
byte error;
fromHost = NetworkTransport.ReceiveFromHost(this.m_ClientId, out connectionId, out channelId, this.m_MsgBuffer, (int)(ushort)this.m_MsgBuffer.Length, out receivedSize, out error);
if (fromHost != NetworkEventType.Nothing && LogFilter.logDev)
{
Debug.Log((object)("Client event: host=" + (object)this.m_ClientId + " event=" + (object)fromHost + " error=" + (object)error));
}
switch (fromHost)
{
case NetworkEventType.DataEvent:
if ((int)error != 0)
{
this.GenerateDataError((int)error);
return;
}
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, (short)29, "msg", 1);
this.m_MsgReader.SeekZero();
this.m_Connection.TransportRecieve(this.m_MsgBuffer, receivedSize, channelId);
goto case NetworkEventType.Nothing;
case NetworkEventType.ConnectEvent:
if (LogFilter.logDebug)
{
Debug.Log((object)"Client connected");
}
if ((int)error != 0)
{
this.GenerateConnectError((int)error);
return;
}
this.m_AsyncConnect = NetworkClient.ConnectState.Connected;
this.m_Connection.InvokeHandlerNoData((short)32);
goto case NetworkEventType.Nothing;
case NetworkEventType.DisconnectEvent:
if (LogFilter.logDebug)
{
Debug.Log((object)"Client disconnected");
}
this.m_AsyncConnect = NetworkClient.ConnectState.Disconnected;
if ((int)error != 0 && (int)error != 6)
{
this.GenerateDisconnectError((int)error);
}
ClientScene.HandleClientDisconnect(this.m_Connection);
if (this.m_Connection != null)
{
this.m_Connection.InvokeHandlerNoData((short)33);
goto case NetworkEventType.Nothing;
}
else
{
goto case NetworkEventType.Nothing;
}
case NetworkEventType.Nothing:
int num2;
if ((num2 = num1 + 1) >= 500)
{
if (LogFilter.logDebug)
{
Debug.Log((object)("MaxEventsPerFrame hit (" + (object)500 + ")"));
goto label_34;
}
else
{
goto label_34;
}
}
else
{
continue;
}
default:
if (LogFilter.logError)
{
Debug.LogError((object)("Unknown network message type received: " + (object)fromHost));
goto case NetworkEventType.Nothing;
}
else
{
goto case NetworkEventType.Nothing;
}
}
}while (this.m_ClientId != -1 && fromHost != NetworkEventType.Nothing);
label_34:
if (this.m_Connection == null || this.m_AsyncConnect != NetworkClient.ConnectState.Connected)
{
break;
}
this.m_Connection.FlushChannels();
break;
}
}
public NetworkEventType ReceiveFromHost(int hostId, out int connectionId, out int channelId, byte[] buffer, int bufferSize, out int receivedSize, out byte error)
{
return(NetworkTransport.ReceiveFromHost(hostId, out connectionId, out channelId, buffer, bufferSize, out receivedSize, out error));
}
public void Update()
{
if (m_ServerHostId == -1)
{
return;
}
int connectionId;
int channelId;
int receivedSize;
byte error;
var networkEvent = NetworkEventType.DataEvent;
if (m_RelaySlotId != -1)
{
networkEvent = NetworkTransport.ReceiveRelayEventFromHost(m_ServerHostId, out error);
if (NetworkEventType.Nothing != networkEvent)
{
if (LogFilter.logDebug)
{
Debug.Log("NetGroup event:" + networkEvent);
}
}
if (networkEvent == NetworkEventType.ConnectEvent)
{
if (LogFilter.logDebug)
{
Debug.Log("NetGroup server connected");
}
}
if (networkEvent == NetworkEventType.DisconnectEvent)
{
if (LogFilter.logDebug)
{
Debug.Log("NetGroup server disconnected");
}
}
}
do
{
networkEvent = NetworkTransport.ReceiveFromHost(m_ServerHostId, out connectionId, out channelId, m_MsgBuffer, (int)m_MsgBuffer.Length, out receivedSize, out error);
if (networkEvent != NetworkEventType.Nothing)
{
if (LogFilter.logDev)
{
Debug.Log("Server event: host=" + m_ServerHostId + " event=" + networkEvent + " error=" + error);
}
}
switch (networkEvent)
{
case NetworkEventType.ConnectEvent:
{
HandleConnect(connectionId, error);
break;
}
case NetworkEventType.DataEvent:
{
HandleData(connectionId, channelId, receivedSize, error);
break;
}
case NetworkEventType.DisconnectEvent:
{
HandleDisconnect(connectionId, error);
break;
}
case NetworkEventType.Nothing:
break;
default:
if (LogFilter.logError)
{
Debug.LogError("Unknown network message type received: " + networkEvent);
}
break;
}
}while (networkEvent != NetworkEventType.Nothing);
UpdateConnections();
}
internal virtual void Update()
{
if (m_ClientId == -1)
{
return;
}
switch (m_AsyncConnect)
{
case ConnectState.None:
case ConnectState.Resolving:
case ConnectState.Disconnected:
return;
case ConnectState.Failed:
GenerateConnectError(11);
m_AsyncConnect = ConnectState.Disconnected;
return;
case ConnectState.Resolved:
m_AsyncConnect = ConnectState.Connecting;
ContinueConnect();
return;
}
if (m_Connection != null && (int)Time.time != m_StatResetTime)
{
m_Connection.ResetStats();
m_StatResetTime = (int)Time.time;
}
NetworkEventType networkEventType;
do
{
int num = 0;
networkEventType = NetworkTransport.ReceiveFromHost(m_ClientId, out int _, out int channelId, m_MsgBuffer, (ushort)m_MsgBuffer.Length, out int receivedSize, out byte error);
if (networkEventType != NetworkEventType.Nothing && LogFilter.logDev)
{
Debug.Log("Client event: host=" + m_ClientId + " event=" + networkEventType + " error=" + error);
}
switch (networkEventType)
{
case NetworkEventType.ConnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client connected");
}
if (error != 0)
{
GenerateConnectError(error);
return;
}
m_AsyncConnect = ConnectState.Connected;
m_Connection.InvokeHandlerNoData(32);
break;
case NetworkEventType.DataEvent:
if (error != 0)
{
GenerateDataError(error);
return;
}
m_MsgReader.SeekZero();
m_Connection.TransportRecieve(m_MsgBuffer, receivedSize, channelId);
break;
case NetworkEventType.DisconnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client disconnected");
}
m_AsyncConnect = ConnectState.Disconnected;
if (error != 0)
{
GenerateDisconnectError(error);
}
ClientScene.HandleClientDisconnect(m_Connection);
m_Connection.InvokeHandlerNoData(33);
break;
default:
if (LogFilter.logError)
{
Debug.LogError("Unknown network message type received: " + networkEventType);
}
break;
case NetworkEventType.Nothing:
break;
}
if (num + 1 >= 500)
{
if (LogFilter.logDebug)
{
Debug.Log("MaxEventsPerFrame hit (" + 500 + ")");
}
break;
}
}while (m_ClientId != -1 && networkEventType != NetworkEventType.Nothing);
if (m_Connection != null && m_AsyncConnect == ConnectState.Connected)
{
m_Connection.FlushChannels();
}
}
internal virtual void Update()
{
if (m_ClientId == -1)
{
return;
}
switch (m_AsyncConnect)
{
case ConnectState.None:
case ConnectState.Resolving:
case ConnectState.Disconnected:
return;
case ConnectState.Failed:
GenerateConnectError((int)NetworkError.DNSFailure);
m_AsyncConnect = ConnectState.Disconnected;
return;
case ConnectState.Resolved:
m_AsyncConnect = ConnectState.Connecting;
ContinueConnect();
return;
case ConnectState.Connecting:
case ConnectState.Connected:
{
break;
}
}
int numEvents = 0;
NetworkEventType networkEvent;
do
{
int connectionId;
int channelId;
int receivedSize;
byte error;
networkEvent = NetworkTransport.ReceiveFromHost(m_ClientId, out connectionId, out channelId, m_MsgBuffer, (ushort)m_MsgBuffer.Length, out receivedSize, out error);
if (m_Connection != null)
{
m_Connection.lastError = (NetworkError)error;
}
if (networkEvent != NetworkEventType.Nothing)
{
if (LogFilter.logDev)
{
Debug.Log("Client event: host=" + m_ClientId + " event=" + networkEvent + " error=" + error);
}
}
switch (networkEvent)
{
case NetworkEventType.ConnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client connected");
}
if (error != 0)
{
GenerateConnectError(error);
return;
}
m_AsyncConnect = ConnectState.Connected;
m_Connection.InvokeHandlerNoData((short)MsgType.Connect);
break;
case NetworkEventType.DataEvent:
if (error != 0)
{
GenerateDataError(error);
return;
}
#if UNITY_EDITOR
UnityEditor.NetworkDetailStats.IncrementStat(
UnityEditor.NetworkDetailStats.NetworkDirection.Incoming,
(short)MsgType.LLAPIMsg, "msg", 1);
#endif
// create a buffer with exactly 'receivedSize' size for the handlers so we don't need to read
// a size header (saves bandwidth)
byte[] data = new byte[receivedSize];
Array.Copy(m_MsgBuffer, data, receivedSize);
m_Connection.TransportReceive(data, channelId);
break;
case NetworkEventType.DisconnectEvent:
if (LogFilter.logDebug)
{
Debug.Log("Client disconnected");
}
m_AsyncConnect = ConnectState.Disconnected;
if (error != 0)
{
if ((NetworkError)error != NetworkError.Timeout)
{
GenerateDisconnectError(error);
}
}
ClientScene.HandleClientDisconnect(m_Connection);
if (m_Connection != null)
{
m_Connection.InvokeHandlerNoData((short)MsgType.Disconnect);
}
break;
case NetworkEventType.Nothing:
break;
default:
if (LogFilter.logError)
{
Debug.LogError("Unknown network message type received: " + networkEvent);
}
break;
}
if (++numEvents >= k_MaxEventsPerFrame)
{
if (LogFilter.logDebug)
{
Debug.Log("MaxEventsPerFrame hit (" + k_MaxEventsPerFrame + ")");
}
break;
}
if (m_ClientId == -1)
{
break;
}
}while (networkEvent != NetworkEventType.Nothing);
}
