public bool SendInternalBuffer()
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, (short)29, "msg", 1);
if (!this.m_IsReliable || this.m_PendingPackets.Count <= 0)
{
return(this.m_CurrentPacket.SendToTransport(this.m_Connection, (int)this.m_ChannelId));
}
while (this.m_PendingPackets.Count > 0)
{
ChannelPacket packet = this.m_PendingPackets.Dequeue();
if (!packet.SendToTransport(this.m_Connection, (int)this.m_ChannelId))
{
this.m_PendingPackets.Enqueue(packet);
break;
}
--ChannelBuffer.pendingPacketCount;
ChannelBuffer.FreePacket(packet);
if (this.m_IsBroken && this.m_PendingPackets.Count < this.m_MaxPendingPacketCount / 2)
{
if (LogFilter.logWarn)
{
Debug.LogWarning((object)"ChannelBuffer recovered from overflow but data was lost.");
}
this.m_IsBroken = false;
}
}
return(true);
}
private static void OnObjectDestroy(NetworkMessage netMsg)
{
NetworkIdentity identity;
netMsg.ReadMessage <ObjectDestroyMessage>(s_ObjectDestroyMessage);
if (LogFilter.logDebug)
{
Debug.Log("ClientScene::OnObjDestroy netId:" + s_ObjectDestroyMessage.netId);
}
if (s_NetworkScene.GetNetworkIdentity(s_ObjectDestroyMessage.netId, out identity))
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, 1, GetStringForAssetId(identity.assetId), 1);
identity.OnNetworkDestroy();
if (!NetworkScene.InvokeUnSpawnHandler(identity.assetId, identity.gameObject))
{
if (identity.sceneId.IsEmpty())
{
UnityEngine.Object.Destroy(identity.gameObject);
}
else
{
identity.gameObject.SetActive(false);
s_SpawnableObjects[identity.sceneId] = identity;
}
}
s_NetworkScene.RemoveLocalObject(s_ObjectDestroyMessage.netId);
identity.MarkForReset();
}
else if (LogFilter.logDebug)
{
Debug.LogWarning("Did not find target for destroy message for " + s_ObjectDestroyMessage.netId);
}
}
private static void OnObjectSpawnScene(NetworkMessage netMsg)
{
NetworkIdentity identity;
netMsg.ReadMessage <ObjectSpawnSceneMessage>(s_ObjectSpawnSceneMessage);
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[] { "Client spawn scene handler instantiating [netId:", s_ObjectSpawnSceneMessage.netId, " sceneId:", s_ObjectSpawnSceneMessage.sceneId, " pos:", s_ObjectSpawnSceneMessage.position }));
}
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, 10, "sceneId", 1);
if (s_NetworkScene.GetNetworkIdentity(s_ObjectSpawnSceneMessage.netId, out identity))
{
ApplySpawnPayload(identity, s_ObjectSpawnSceneMessage.position, s_ObjectSpawnSceneMessage.payload, s_ObjectSpawnSceneMessage.netId, identity.gameObject);
}
else
{
NetworkIdentity uv = SpawnSceneObject(s_ObjectSpawnSceneMessage.sceneId);
if (uv == null)
{
if (LogFilter.logError)
{
Debug.LogError("Spawn scene object not found for " + s_ObjectSpawnSceneMessage.sceneId);
}
}
else
{
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[] { "Client spawn for [netId:", s_ObjectSpawnSceneMessage.netId, "] [sceneId:", s_ObjectSpawnSceneMessage.sceneId, "] obj:", uv.gameObject.name }));
}
ApplySpawnPayload(uv, s_ObjectSpawnSceneMessage.position, s_ObjectSpawnSceneMessage.payload, s_ObjectSpawnSceneMessage.netId, uv.gameObject);
}
}
}
internal void HandleCommand(int cmdHash, NetworkReader reader)
{
if (base.gameObject == null)
{
string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
if (LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[] { "Command [", cmdHashHandlerName, "] received for deleted object [netId=", this.netId, "]" }));
}
}
else
{
bool flag = false;
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour behaviour = this.m_NetworkBehaviours[i];
if (behaviour.InvokeCommand(cmdHash, reader))
{
flag = true;
break;
}
}
if (!flag)
{
string str2 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
if (LogFilter.logError)
{
Debug.LogError(string.Concat(new object[] { "Found no receiver for incoming command [", str2, "] on ", base.gameObject, ", the server and client should have the same NetworkBehaviour instances [netId=", this.netId, "]." }));
}
}
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, 5, NetworkBehaviour.GetCmdHashCmdName(cmdHash), 1);
}
}
private static void OnObjectSpawnScene(NetworkMessage netMsg)
{
netMsg.ReadMessage <ObjectSpawnSceneMessage>(ClientScene.s_ObjectSpawnSceneMessage);
if (LogFilter.logDebug)
{
Debug.Log((object)("Client spawn scene handler instantiating [netId:" + (object)ClientScene.s_ObjectSpawnSceneMessage.netId + " sceneId:" + (object)ClientScene.s_ObjectSpawnSceneMessage.sceneId + " pos:" + (object)ClientScene.s_ObjectSpawnSceneMessage.position));
}
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, (short)10, "sceneId", 1);
NetworkIdentity uv1;
if (ClientScene.s_NetworkScene.GetNetworkIdentity(ClientScene.s_ObjectSpawnSceneMessage.netId, out uv1))
{
ClientScene.ApplySpawnPayload(uv1, ClientScene.s_ObjectSpawnSceneMessage.position, ClientScene.s_ObjectSpawnSceneMessage.payload, ClientScene.s_ObjectSpawnSceneMessage.netId, uv1.gameObject);
}
else
{
NetworkIdentity uv2 = ClientScene.SpawnSceneObject(ClientScene.s_ObjectSpawnSceneMessage.sceneId);
if ((Object)uv2 == (Object)null)
{
if (!LogFilter.logError)
{
return;
}
Debug.LogError((object)("Spawn scene object not found for " + (object)ClientScene.s_ObjectSpawnSceneMessage.sceneId));
}
else
{
if (LogFilter.logDebug)
{
Debug.Log((object)("Client spawn for [netId:" + (object)ClientScene.s_ObjectSpawnSceneMessage.netId + "] [sceneId:" + (object)ClientScene.s_ObjectSpawnSceneMessage.sceneId + "] obj:" + uv2.gameObject.name));
}
ClientScene.ApplySpawnPayload(uv2, ClientScene.s_ObjectSpawnSceneMessage.position, ClientScene.s_ObjectSpawnSceneMessage.payload, ClientScene.s_ObjectSpawnSceneMessage.netId, uv2.gameObject);
}
}
}
internal static void UNetStaticUpdate()
{
NetworkServer.Update();
NetworkClient.UpdateClients();
NetworkManager.UpdateScene();
NetworkDetailStats.NewProfilerTick(Time.time);
}
public bool SendToTransport(NetworkConnection conn, int channelId)
{
byte num;
bool flag = true;
if (!conn.TransportSend(this.m_Buffer, (ushort)this.m_Position, channelId, out num) && (!this.m_IsReliable || (num != 4)))
{
if (LogFilter.logError)
{
Debug.LogError(string.Concat(new object[] { "Failed to send internal buffer channel:", channelId, " bytesToSend:", this.m_Position }));
}
flag = false;
}
if (num != 0)
{
if (this.m_IsReliable && (num == 4))
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 30, "msg", 1);
return(false);
}
if (LogFilter.logError)
{
Debug.LogError(string.Concat(new object[] { "Send Error: ", (NetworkError)num, " channel:", channelId, " bytesToSend:", this.m_Position }));
}
flag = false;
}
this.m_Position = 0;
return(flag);
}
public bool SendInternalBuffer()
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 0x1d, "msg", 1);
if (!this.m_IsReliable || (this.m_PendingPackets.Count <= 0))
{
return(this.m_CurrentPacket.SendToTransport(this.m_Connection, this.m_ChannelId));
}
while (this.m_PendingPackets.Count > 0)
{
ChannelPacket packet = this.m_PendingPackets[0];
if (!packet.SendToTransport(this.m_Connection, this.m_ChannelId))
{
break;
}
pendingPacketCount--;
this.m_PendingPackets.RemoveAt(0);
FreePacket(packet);
if (this.m_IsBroken && (this.m_PendingPackets.Count < (this.m_MaxPendingPacketCount / 2)))
{
if (LogFilter.logWarn)
{
Debug.LogWarning("ChannelBuffer recovered from overflow but data was lost.");
}
this.m_IsBroken = false;
}
}
return(true);
}
protected void SendCommandInternal(NetworkWriter writer, int channelId, string cmdName)
{
if (!this.isLocalPlayer && !this.hasAuthority)
{
if (!LogFilter.logWarn)
{
return;
}
Debug.LogWarning((object)"Trying to send command for object without authority.");
}
else if (ClientScene.readyConnection == null)
{
if (!LogFilter.logError)
{
return;
}
Debug.LogError((object)("Send command attempted with no client running [client=" + (object)this.connectionToServer + "]."));
}
else
{
writer.FinishMessage();
ClientScene.readyConnection.SendWriter(writer, channelId);
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, (short)5, cmdName, 1);
}
}
public bool SendToTransport(NetworkConnection conn, int channelId)
{
bool flag = true;
byte error;
if (!conn.TransportSend(this.m_Buffer, (int)(ushort)this.m_Position, channelId, out error) && (!this.m_IsReliable || (int)error != 4))
{
if (LogFilter.logError)
{
Debug.LogError((object)("Failed to send internal buffer channel:" + (object)channelId + " bytesToSend:" + (object)this.m_Position));
}
flag = false;
}
if ((int)error != 0)
{
if (this.m_IsReliable && (int)error == 4)
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, (short)30, "msg", 1);
return(false);
}
if (LogFilter.logError)
{
Debug.LogError((object)("Send Error: " + (object)error + " channel:" + (object)channelId + " bytesToSend:" + (object)this.m_Position));
}
flag = false;
}
this.m_Position = 0;
return(flag);
}
private static void FreePacket(ChannelPacket packet)
{
NetworkDetailStats.SetStat(NetworkDetailStats.NetworkDirection.Outgoing, 0x1f, "msg", pendingPacketCount);
if (s_FreePackets.Count < 0x200)
{
s_FreePackets.Add(packet);
}
}
private static void FreePacket(ChannelPacket packet)
{
NetworkDetailStats.SetStat(NetworkDetailStats.NetworkDirection.Outgoing, (short)31, "msg", ChannelBuffer.pendingPacketCount);
if (ChannelBuffer.s_FreePackets.Count >= 512)
{
return;
}
ChannelBuffer.s_FreePackets.Add(packet);
}
// this is invoked by the UnityEngine
static internal void UNetStaticUpdate()
{
NetworkServer.Update();
NetworkClient.UpdateClients();
NetworkManager.UpdateScene();
#if UNITY_EDITOR
NetworkDetailStats.NewProfilerTick(Time.time);
#endif
}
public static void ShutdownAll()
{
while (s_Clients.Count != 0)
{
s_Clients[0].Shutdown();
}
s_Clients = new List <NetworkClient>();
s_IsActive = false;
ClientScene.Shutdown();
NetworkDetailStats.ResetAll();
}
internal void UNetUpdate()
{
uint num = 0;
for (int index = 0; index < this.m_NetworkBehaviours.Length; ++index)
{
int dirtyChannel = this.m_NetworkBehaviours[index].GetDirtyChannel();
if (dirtyChannel != -1)
{
num |= (uint)(1 << dirtyChannel);
}
}
if ((int)num == 0)
{
return;
}
for (int channelId = 0; channelId < NetworkServer.numChannels; ++channelId)
{
if (((int)num & 1 << channelId) != 0)
{
NetworkIdentity.s_UpdateWriter.StartMessage((short)8);
NetworkIdentity.s_UpdateWriter.Write(this.netId);
bool flag = false;
for (int index = 0; index < this.m_NetworkBehaviours.Length; ++index)
{
short position = NetworkIdentity.s_UpdateWriter.Position;
NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[index];
if (networkBehaviour.GetDirtyChannel() != channelId)
{
networkBehaviour.OnSerialize(NetworkIdentity.s_UpdateWriter, false);
}
else
{
if (networkBehaviour.OnSerialize(NetworkIdentity.s_UpdateWriter, false))
{
networkBehaviour.ClearAllDirtyBits();
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, (short)8, networkBehaviour.GetType().Name, 1);
flag = true;
}
if ((int)NetworkIdentity.s_UpdateWriter.Position - (int)position > (int)NetworkServer.maxPacketSize && LogFilter.logWarn)
{
Debug.LogWarning((object)("Large state update of " + (object)((int)NetworkIdentity.s_UpdateWriter.Position - (int)position) + " bytes for netId:" + (object)this.netId + " from script:" + (object)networkBehaviour));
}
}
}
if (flag)
{
NetworkIdentity.s_UpdateWriter.FinishMessage();
NetworkServer.SendWriterToReady(this.gameObject, NetworkIdentity.s_UpdateWriter, channelId);
}
}
}
}
internal void UNetUpdate()
{
uint num = 0;
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
int dirtyChannel = this.m_NetworkBehaviours[i].GetDirtyChannel();
if (dirtyChannel != -1)
{
num |= ((uint)1) << dirtyChannel;
}
}
if (num != 0)
{
for (int j = 0; j < NetworkServer.numChannels; j++)
{
if ((num & (((int)1) << j)) != 0)
{
s_UpdateWriter.StartMessage(8);
s_UpdateWriter.Write(this.netId);
bool flag = false;
for (int k = 0; k < this.m_NetworkBehaviours.Length; k++)
{
short position = s_UpdateWriter.Position;
NetworkBehaviour behaviour2 = this.m_NetworkBehaviours[k];
if (behaviour2.GetDirtyChannel() != j)
{
behaviour2.OnSerialize(s_UpdateWriter, false);
}
else
{
if (behaviour2.OnSerialize(s_UpdateWriter, false))
{
behaviour2.ClearAllDirtyBits();
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 8, behaviour2.GetType().Name, 1);
flag = true;
}
if (((s_UpdateWriter.Position - position) > NetworkServer.maxPacketSize) && LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[] { "Large state update of ", s_UpdateWriter.Position - position, " bytes for netId:", this.netId, " from script:", behaviour2 }));
}
}
}
if (flag)
{
s_UpdateWriter.FinishMessage();
NetworkServer.SendWriterToReady(base.gameObject, s_UpdateWriter, j);
}
}
}
}
}
private ChannelPacket AllocPacket()
{
NetworkDetailStats.SetStat(NetworkDetailStats.NetworkDirection.Outgoing, 0x1f, "msg", pendingPacketCount);
if (s_FreePackets.Count == 0)
{
return(new ChannelPacket(this.m_MaxPacketSize, this.m_IsReliable));
}
ChannelPacket packet = s_FreePackets[0];
s_FreePackets.RemoveAt(0);
packet.Reset();
return(packet);
}
private ChannelPacket AllocPacket()
{
NetworkDetailStats.SetStat(NetworkDetailStats.NetworkDirection.Outgoing, (short)31, "msg", ChannelBuffer.pendingPacketCount);
if (ChannelBuffer.s_FreePackets.Count == 0)
{
return(new ChannelPacket(this.m_MaxPacketSize, this.m_IsReliable));
}
ChannelPacket freePacket = ChannelBuffer.s_FreePackets[ChannelBuffer.s_FreePackets.Count - 1];
ChannelBuffer.s_FreePackets.RemoveAt(ChannelBuffer.s_FreePackets.Count - 1);
freePacket.Reset();
return(freePacket);
}
private void SendTransform()
{
if (this.HasMoved() && (ClientScene.readyConnection != null))
{
this.m_LocalTransformWriter.StartMessage(0x10);
this.m_LocalTransformWriter.Write(base.netId);
this.m_LocalTransformWriter.WritePackedUInt32(this.m_ChildIndex);
this.SerializeModeTransform(this.m_LocalTransformWriter);
this.m_PrevPosition = this.m_Target.localPosition;
this.m_PrevRotation = this.m_Target.localRotation;
this.m_LocalTransformWriter.FinishMessage();
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 0x10, "16:LocalChildTransform", 1);
ClientScene.readyConnection.SendWriter(this.m_LocalTransformWriter, this.GetNetworkChannel());
}
}
protected void SendTargetRPCInternal(NetworkConnection conn, NetworkWriter writer, int channelId, string rpcName)
{
if (!this.isServer)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("TargetRpc call on un-spawned object");
}
}
else
{
writer.FinishMessage();
conn.SendWriter(writer, channelId);
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 2, rpcName, 1);
}
}
protected void SendEventInternal(NetworkWriter writer, int channelId, string eventName)
{
if (!NetworkServer.active)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("SendEvent no server?");
}
}
else
{
writer.FinishMessage();
NetworkServer.SendWriterToReady(base.gameObject, writer, channelId);
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 7, eventName, 1);
}
}
protected void SendRPCInternal(NetworkWriter writer, int channelId, string rpcName)
{
if (!this.isServer)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("ClientRpc call on un-spawned object");
}
}
else
{
writer.FinishMessage();
NetworkServer.SendWriterToReady(base.gameObject, writer, channelId);
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 2, rpcName, 1);
}
}
internal void OnUpdateVars(NetworkReader reader, bool initialState)
{
if (initialState && this.m_NetworkBehaviours == null)
{
this.m_NetworkBehaviours = this.GetComponents <NetworkBehaviour>();
}
for (int index = 0; index < this.m_NetworkBehaviours.Length; ++index)
{
NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[index];
uint position = reader.Position;
networkBehaviour.OnDeserialize(reader, initialState);
if (reader.Position - position > 1U)
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, (short)8, networkBehaviour.GetType().Name, 1);
}
}
}
internal void OnUpdateVars(NetworkReader reader, bool initialState)
{
if (initialState && (this.m_NetworkBehaviours == null))
{
this.m_NetworkBehaviours = base.GetComponents <NetworkBehaviour>();
}
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour behaviour = this.m_NetworkBehaviours[i];
uint position = reader.Position;
behaviour.OnDeserialize(reader, initialState);
if ((reader.Position - position) > 1)
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, 8, behaviour.GetType().Name, 1);
}
}
}
private void SendMsg(SyncList <T> .Operation op, int itemIndex, T item)
{
if ((Object)this.m_Behaviour == (Object)null)
{
if (!LogFilter.logError)
{
return;
}
Debug.LogError((object)"SyncList not initialized");
}
else
{
NetworkIdentity component = this.m_Behaviour.GetComponent <NetworkIdentity>();
if ((Object)component == (Object)null)
{
if (!LogFilter.logError)
{
return;
}
Debug.LogError((object)"SyncList no NetworkIdentity");
}
else
{
if (!component.isServer)
{
return;
}
NetworkWriter writer = new NetworkWriter();
writer.StartMessage((short)9);
writer.Write(component.netId);
writer.WritePackedUInt32((uint)this.m_CmdHash);
writer.Write((byte)op);
writer.WritePackedUInt32((uint)itemIndex);
this.SerializeItem(writer, item);
writer.FinishMessage();
NetworkServer.SendWriterToReady(component.gameObject, writer, this.m_Behaviour.GetNetworkChannel());
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, (short)9, op.ToString(), 1);
if (!this.m_Behaviour.isServer || !this.m_Behaviour.isClient || this.m_Callback == null)
{
return;
}
this.m_Callback(op, itemIndex);
}
}
}
internal void UNetUpdate()
{
uint num = 0;
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
int dirtyChannel = this.m_NetworkBehaviours[i].GetDirtyChannel();
if (dirtyChannel != -1)
{
num |= ((uint)1) << dirtyChannel;
}
}
if (num != 0)
{
for (int j = 0; j < NetworkServer.numChannels; j++)
{
if ((num & (((int)1) << j)) != 0)
{
s_UpdateWriter.StartMessage(8);
s_UpdateWriter.Write(this.netId);
bool flag = false;
for (int k = 0; k < this.m_NetworkBehaviours.Length; k++)
{
NetworkBehaviour behaviour2 = this.m_NetworkBehaviours[k];
if (behaviour2.GetDirtyChannel() != j)
{
behaviour2.OnSerialize(s_UpdateWriter, false);
}
else if (behaviour2.OnSerialize(s_UpdateWriter, false))
{
behaviour2.ClearAllDirtyBits();
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 8, behaviour2.GetType().Name, 1);
flag = true;
}
}
if (flag)
{
s_UpdateWriter.FinishMessage();
NetworkServer.SendWriterToReady(base.gameObject, s_UpdateWriter, j);
}
}
}
}
}
internal void HandleRPC(int cmdHash, NetworkReader reader)
{
if ((UnityEngine.Object) this.gameObject == (UnityEngine.Object)null)
{
string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
if (!LogFilter.logWarn)
{
return;
}
Debug.LogWarning((object)("ClientRpc [" + cmdHashHandlerName + "] received for deleted object [netId=" + (object)this.netId + "]"));
}
else
{
System.Type invokeClass;
NetworkBehaviour.CmdDelegate invokeFunction;
if (!NetworkBehaviour.GetInvokerForHashClientRpc(cmdHash, out invokeClass, out invokeFunction))
{
string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
if (!LogFilter.logError)
{
return;
}
Debug.LogError((object)("Found no receiver for incoming [" + cmdHashHandlerName + "] on " + (object)this.gameObject + ", the server and client should have the same NetworkBehaviour instances [netId=" + (object)this.netId + "]."));
}
else
{
NetworkBehaviour invokeComponent;
if (!this.GetInvokeComponent(cmdHash, invokeClass, out invokeComponent))
{
string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
if (!LogFilter.logWarn)
{
return;
}
Debug.LogWarning((object)("ClientRpc [" + cmdHashHandlerName + "] handler not found [netId=" + (object)this.netId + "]"));
}
else
{
invokeFunction(invokeComponent, reader);
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, (short)2, NetworkBehaviour.GetCmdHashRpcName(cmdHash), 1);
}
}
}
}
private static void OnSyncListMessage(NetworkMessage netMsg)
{
NetworkIdentity identity;
NetworkInstanceId netId = netMsg.reader.ReadNetworkId();
int cmdHash = (int)netMsg.reader.ReadPackedUInt32();
if (LogFilter.logDebug)
{
Debug.Log("ClientScene::OnSyncListMessage " + netId);
}
if (s_NetworkScene.GetNetworkIdentity(netId, out identity))
{
identity.HandleSyncList(cmdHash, netMsg.reader);
}
else if (LogFilter.logWarn)
{
Debug.LogWarning("Did not find target for SyncList message for " + netId);
}
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 9, NetworkBehaviour.GetCmdHashHandlerName(cmdHash), 1);
}
internal void HandleSyncList(int cmdHash, NetworkReader reader)
{
if (base.gameObject == null)
{
string cmdHashHandlerName = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
if (LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[] { "SyncList [", cmdHashHandlerName, "] received for deleted object [netId=", this.netId, "]" }));
}
}
else
{
NetworkBehaviour.CmdDelegate delegate2;
System.Type type;
if (!NetworkBehaviour.GetInvokerForHashSyncList(cmdHash, out type, out delegate2))
{
string str2 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
if (LogFilter.logError)
{
Debug.LogError(string.Concat(new object[] { "Found no receiver for incoming [", str2, "] on ", base.gameObject, ", the server and client should have the same NetworkBehaviour instances [netId=", this.netId, "]." }));
}
}
else
{
NetworkBehaviour behaviour;
if (!this.GetInvokeComponent(cmdHash, type, out behaviour))
{
string str3 = NetworkBehaviour.GetCmdHashHandlerName(cmdHash);
if (LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[] { "SyncList [", str3, "] handler not found [netId=", this.netId, "]" }));
}
}
else
{
delegate2(behaviour, reader);
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, 9, NetworkBehaviour.GetCmdHashListName(cmdHash), 1);
}
}
}
}
public bool SendUnreliable(short msgType, MessageBase msg)
{
if (this.m_Connection != null)
{
if (this.m_AsyncConnect != ConnectState.Connected)
{
if (LogFilter.logError)
{
Debug.LogError("NetworkClient SendUnreliable when not connected to a server");
}
return(false);
}
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, 0, msgType.ToString() + ":" + msg.GetType().Name, 1);
return(this.m_Connection.SendUnreliable(msgType, msg));
}
if (LogFilter.logError)
{
Debug.LogError("NetworkClient SendUnreliable with no connection");
}
return(false);
}
