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);
}
}
}
}
internal static string GetCmdHashRpcName(int cmdHash)
{
return(NetworkBehaviour.GetCmdHashPrefixName(cmdHash, "InvokeRpc"));
}
internal static string GetCmdHashListName(int cmdHash)
{
return(NetworkBehaviour.GetCmdHashPrefixName(cmdHash, "InvokeSyncList"));
}
internal void HandleRPC(int cmdHash, NetworkReader reader)
{
if (base.gameObject == null)
{
if (LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[] { "ClientRpc [", NetworkBehaviour.GetCmdHashHandlerName(cmdHash), "] received for deleted object ", this.netId }));
}
}
else if (this.m_NetworkBehaviours.Length == 0)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("No receiver found for ClientRpc [" + NetworkBehaviour.GetCmdHashHandlerName(cmdHash) + "]. Does the script with the function inherit NetworkBehaviour?");
}
}
else
{
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour behaviour = this.m_NetworkBehaviours[i];
if (behaviour.InvokeRPC(cmdHash, reader))
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, 2, NetworkBehaviour.GetCmdHashRpcName(cmdHash), 1);
return;
}
}
string invoker = NetworkBehaviour.GetInvoker(cmdHash);
if (invoker == null)
{
invoker = "[unknown:" + cmdHash + "]";
}
if (LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[] { "Failed to invoke RPC ", invoker, "(", cmdHash, ") on netID ", this.netId }));
}
NetworkBehaviour.DumpInvokers();
}
}
internal static bool GetInvokerForHashSyncEvent(int cmdHash, out System.Type invokeClass, out NetworkBehaviour.CmdDelegate invokeFunction)
{
return(NetworkBehaviour.GetInvokerForHash(cmdHash, NetworkBehaviour.UNetInvokeType.SyncEvent, out invokeClass, out invokeFunction));
}
// invoked by unity runtime immediately after the regular "Update()" function.
internal void UNetUpdate()
{
// check if any behaviours are ready to send
uint dirtyChannelBits = 0;
for (int i = 0; i < m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour comp = m_NetworkBehaviours[i];
int channelId = comp.GetDirtyChannel();
if (channelId != -1)
{
dirtyChannelBits |= (uint)(1 << channelId);
}
}
if (dirtyChannelBits == 0)
{
return;
}
for (int channelId = 0; channelId < NetworkServer.numChannels; channelId++)
{
if ((dirtyChannelBits & (uint)(1 << channelId)) != 0)
{
s_UpdateWriter.StartMessage(MsgType.UpdateVars);
s_UpdateWriter.Write(netId);
bool wroteData = false;
short oldPos;
for (int i = 0; i < m_NetworkBehaviours.Length; i++)
{
oldPos = s_UpdateWriter.Position;
NetworkBehaviour comp = m_NetworkBehaviours[i];
if (comp.GetDirtyChannel() != channelId)
{
// component could write more than one dirty-bits, so call the serialize func
comp.OnSerialize(s_UpdateWriter, false);
continue;
}
if (comp.OnSerialize(s_UpdateWriter, false))
{
comp.ClearAllDirtyBits();
#if UNITY_EDITOR
UnityEditor.NetworkDetailStats.IncrementStat(
UnityEditor.NetworkDetailStats.NetworkDirection.Outgoing,
MsgType.UpdateVars, comp.GetType().Name, 1);
#endif
wroteData = true;
}
if (s_UpdateWriter.Position - oldPos > NetworkServer.maxPacketSize)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("Large state update of " + (s_UpdateWriter.Position - oldPos) + " bytes for netId:" + netId + " from script:" + comp);
}
}
}
if (!wroteData)
{
// nothing to send.. this could be a script with no OnSerialize function setting dirty bits
continue;
}
s_UpdateWriter.FinishMessage();
NetworkServer.SendWriterToReady(gameObject, s_UpdateWriter, channelId);
}
}
}
public void RebuildObservers(bool initialize)
{
if (m_Observers == null)
{
return;
}
bool flag = false;
bool flag2 = false;
HashSet <NetworkConnection> hashSet = new HashSet <NetworkConnection>();
HashSet <NetworkConnection> hashSet2 = new HashSet <NetworkConnection>(m_Observers);
for (int i = 0; i < m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour networkBehaviour = m_NetworkBehaviours[i];
flag2 |= networkBehaviour.OnRebuildObservers(hashSet, initialize);
}
if (!flag2)
{
if (!initialize)
{
return;
}
for (int j = 0; j < NetworkServer.connections.Count; j++)
{
NetworkConnection networkConnection = NetworkServer.connections[j];
if (networkConnection != null && networkConnection.isReady)
{
AddObserver(networkConnection);
}
}
for (int k = 0; k < NetworkServer.localConnections.Count; k++)
{
NetworkConnection networkConnection2 = NetworkServer.localConnections[k];
if (networkConnection2 != null && networkConnection2.isReady)
{
AddObserver(networkConnection2);
}
}
return;
}
foreach (NetworkConnection item in hashSet)
{
if (item != null)
{
if (!item.isReady)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("Observer is not ready for " + base.gameObject + " " + item);
}
}
else if (initialize || !hashSet2.Contains(item))
{
item.AddToVisList(this);
if (LogFilter.logDebug)
{
Debug.Log("New Observer for " + base.gameObject + " " + item);
}
flag = true;
}
}
}
foreach (NetworkConnection item2 in hashSet2)
{
if (!hashSet.Contains(item2))
{
item2.RemoveFromVisList(this, isDestroyed: false);
if (LogFilter.logDebug)
{
Debug.Log("Removed Observer for " + base.gameObject + " " + item2);
}
flag = true;
}
}
if (initialize)
{
for (int l = 0; l < NetworkServer.localConnections.Count; l++)
{
if (!hashSet.Contains(NetworkServer.localConnections[l]))
{
OnSetLocalVisibility(vis: false);
}
}
}
if (flag)
{
m_Observers = new List <NetworkConnection>(hashSet);
m_ObserverConnections.Clear();
for (int m = 0; m < m_Observers.Count; m++)
{
m_ObserverConnections.Add(m_Observers[m].connectionId);
}
}
}
internal void OnStartServer()
{
if (this.m_IsServer)
{
return;
}
this.m_IsServer = true;
if (this.m_LocalPlayerAuthority)
{
this.m_HasAuthority = false;
}
else
{
this.m_HasAuthority = true;
}
this.m_Observers = new List <NetworkConnection>();
this.m_ObserverConnections = new HashSet <int>();
this.CacheBehaviours();
if (this.netId.IsEmpty())
{
this.m_NetId = NetworkIdentity.GetNextNetworkId();
if (LogFilter.logDev)
{
Debug.Log(string.Concat(new object[]
{
"OnStartServer ",
base.gameObject,
" GUID:",
this.netId
}));
}
NetworkServer.instance.SetLocalObjectOnServer(this.netId, base.gameObject);
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
try
{
networkBehaviour.OnStartServer();
}
catch (Exception ex)
{
Debug.LogError("Exception in OnStartServer:" + ex.Message + " " + ex.StackTrace);
}
}
if (NetworkClient.active && NetworkServer.localClientActive)
{
ClientScene.SetLocalObject(this.netId, base.gameObject);
this.OnStartClient();
}
if (this.m_HasAuthority)
{
this.OnStartAuthority();
}
return;
}
if (LogFilter.logError)
{
Debug.LogError(string.Concat(new object[]
{
"Object has non-zero netId ",
this.netId,
" for ",
base.gameObject,
" !!1"
}));
}
}
internal void UNetUpdate()
{
uint num = 0u;
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
int dirtyChannel = networkBehaviour.GetDirtyChannel();
if (dirtyChannel != -1)
{
num |= 1u << dirtyChannel;
}
}
if (num == 0u)
{
return;
}
for (int j = 0; j < NetworkServer.numChannels; j++)
{
if ((num & 1u << j) != 0u)
{
NetworkIdentity.s_UpdateWriter.StartMessage(8);
NetworkIdentity.s_UpdateWriter.Write(this.netId);
bool flag = false;
for (int k = 0; k < this.m_NetworkBehaviours.Length; k++)
{
short position = NetworkIdentity.s_UpdateWriter.Position;
NetworkBehaviour networkBehaviour2 = this.m_NetworkBehaviours[k];
if (networkBehaviour2.GetDirtyChannel() != j)
{
networkBehaviour2.OnSerialize(NetworkIdentity.s_UpdateWriter, false);
}
else
{
if (networkBehaviour2.OnSerialize(NetworkIdentity.s_UpdateWriter, false))
{
networkBehaviour2.ClearAllDirtyBits();
flag = true;
}
if (NetworkIdentity.s_UpdateWriter.Position - position > (short)NetworkServer.maxPacketSize)
{
Debug.LogWarning(string.Concat(new object[]
{
"Large state update of ",
(int)(NetworkIdentity.s_UpdateWriter.Position - position),
" bytes (max is ",
NetworkServer.maxPacketSize,
" for netId:",
this.netId,
" from script:",
networkBehaviour2
}));
}
}
}
if (flag)
{
NetworkIdentity.s_UpdateWriter.FinishMessage();
NetworkServer.SendWriterToReady(base.gameObject, NetworkIdentity.s_UpdateWriter, j);
}
}
}
}
/// <summary>
/// <para>This causes the set of players that can see this object to be rebuild. The OnRebuildObservers callback function will be invoked on each NetworkBehaviour.</para>
/// </summary>
/// <param name="initialize">True if this is the first time.</param>
public void RebuildObservers(bool initialize)
{
if (this.m_Observers == null)
{
return;
}
bool flag1 = false;
bool flag2 = false;
HashSet <NetworkConnection> observers = new HashSet <NetworkConnection>();
HashSet <NetworkConnection> networkConnectionSet = new HashSet <NetworkConnection>((IEnumerable <NetworkConnection>) this.m_Observers);
for (int index = 0; index < this.m_NetworkBehaviours.Length; ++index)
{
NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[index];
flag2 |= networkBehaviour.OnRebuildObservers(observers, initialize);
}
if (!flag2)
{
if (!initialize)
{
return;
}
foreach (NetworkConnection connection in NetworkServer.connections)
{
if (connection != null && connection.isReady)
{
this.AddObserver(connection);
}
}
using (List <NetworkConnection> .Enumerator enumerator = NetworkServer.localConnections.GetEnumerator())
{
while (enumerator.MoveNext())
{
NetworkConnection current = enumerator.Current;
if (current != null && current.isReady)
{
this.AddObserver(current);
}
}
}
}
else
{
using (HashSet <NetworkConnection> .Enumerator enumerator = observers.GetEnumerator())
{
while (enumerator.MoveNext())
{
NetworkConnection current = enumerator.Current;
if (current != null)
{
if (!current.isReady)
{
if (LogFilter.logWarn)
{
Debug.LogWarning((object)("Observer is not ready for " + (object)this.gameObject + " " + (object)current));
}
}
else if (initialize || !networkConnectionSet.Contains(current))
{
current.AddToVisList(this);
if (LogFilter.logDebug)
{
Debug.Log((object)("New Observer for " + (object)this.gameObject + " " + (object)current));
}
flag1 = true;
}
}
}
}
using (HashSet <NetworkConnection> .Enumerator enumerator = networkConnectionSet.GetEnumerator())
{
while (enumerator.MoveNext())
{
NetworkConnection current = enumerator.Current;
if (!observers.Contains(current))
{
current.RemoveFromVisList(this, false);
if (LogFilter.logDebug)
{
Debug.Log((object)("Removed Observer for " + (object)this.gameObject + " " + (object)current));
}
flag1 = true;
}
}
}
if (initialize)
{
using (List <NetworkConnection> .Enumerator enumerator = NetworkServer.localConnections.GetEnumerator())
{
while (enumerator.MoveNext())
{
NetworkConnection current = enumerator.Current;
if (!observers.Contains(current))
{
this.OnSetLocalVisibility(false);
}
}
}
}
if (!flag1)
{
return;
}
this.m_Observers = new List <NetworkConnection>((IEnumerable <NetworkConnection>)observers);
this.m_ObserverConnections.Clear();
using (List <NetworkConnection> .Enumerator enumerator = this.m_Observers.GetEnumerator())
{
while (enumerator.MoveNext())
{
this.m_ObserverConnections.Add(enumerator.Current.connectionId);
}
}
}
}
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 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 OnSyncEventMessage(NetworkMessage netMsg)
{
int cmdHash = (int)netMsg.reader.ReadPackedUInt32();
NetworkInstanceId netId = netMsg.reader.ReadNetworkId();
if (LogFilter.logDebug)
{
Debug.Log((object)("ClientScene::OnSyncEventMessage " + (object)netId));
}
NetworkIdentity uv;
if (ClientScene.s_NetworkScene.GetNetworkIdentity(netId, out uv))
{
uv.HandleSyncEvent(cmdHash, netMsg.reader);
}
else if (LogFilter.logWarn)
{
Debug.LogWarning((object)("Did not find target for SyncEvent message for " + (object)netId));
}
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Outgoing, (short)7, NetworkBehaviour.GetCmdHashHandlerName(cmdHash), 1);
}
internal void HandleSyncList(int cmdHash, NetworkReader reader)
{
if (base.gameObject == null)
{
if (LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[] { "SyncList [", NetworkBehaviour.GetCmdHashHandlerName(cmdHash), "] received for deleted object ", this.netId }));
}
}
else
{
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour behaviour = this.m_NetworkBehaviours[i];
if (behaviour.InvokeSyncList(cmdHash, reader))
{
NetworkDetailStats.IncrementStat(NetworkDetailStats.NetworkDirection.Incoming, 9, NetworkBehaviour.GetCmdHashListName(cmdHash), 1);
break;
}
}
}
}
/// <summary>
/// <para>This causes the set of players that can see this object to be rebuild. The OnRebuildObservers callback function will be invoked on each NetworkBehaviour.</para>
/// </summary>
/// <param name="initialize">True if this is the first time.</param>
public void RebuildObservers(bool initialize)
{
if (this.m_Observers != null)
{
bool flag = false;
bool flag2 = false;
HashSet <NetworkConnection> observers = new HashSet <NetworkConnection>();
HashSet <NetworkConnection> set2 = new HashSet <NetworkConnection>(this.m_Observers);
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour behaviour = this.m_NetworkBehaviours[i];
flag2 |= behaviour.OnRebuildObservers(observers, initialize);
}
if (!flag2)
{
if (initialize)
{
for (int j = 0; j < NetworkServer.connections.Count; j++)
{
NetworkConnection conn = NetworkServer.connections[j];
if ((conn != null) && conn.isReady)
{
this.AddObserver(conn);
}
}
for (int k = 0; k < NetworkServer.localConnections.Count; k++)
{
NetworkConnection connection2 = NetworkServer.localConnections[k];
if ((connection2 != null) && connection2.isReady)
{
this.AddObserver(connection2);
}
}
}
}
else
{
foreach (NetworkConnection connection3 in observers)
{
if (connection3 != null)
{
if (!connection3.isReady)
{
if (LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[] { "Observer is not ready for ", base.gameObject, " ", connection3 }));
}
}
else if (initialize || !set2.Contains(connection3))
{
connection3.AddToVisList(this);
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[] { "New Observer for ", base.gameObject, " ", connection3 }));
}
flag = true;
}
}
}
foreach (NetworkConnection connection4 in set2)
{
if (!observers.Contains(connection4))
{
connection4.RemoveFromVisList(this, false);
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[] { "Removed Observer for ", base.gameObject, " ", connection4 }));
}
flag = true;
}
}
if (initialize)
{
for (int m = 0; m < NetworkServer.localConnections.Count; m++)
{
if (!observers.Contains(NetworkServer.localConnections[m]))
{
this.OnSetLocalVisibility(false);
}
}
}
if (flag)
{
this.m_Observers = new List <NetworkConnection>(observers);
this.m_ObserverConnections.Clear();
for (int n = 0; n < this.m_Observers.Count; n++)
{
this.m_ObserverConnections.Add(this.m_Observers[n].connectionId);
}
}
}
}
}
public void RebuildObservers(bool initialize)
{
if (this.m_Observers == null)
{
return;
}
bool flag = false;
bool flag2 = false;
HashSet <NetworkConnection> hashSet = new HashSet <NetworkConnection>();
HashSet <NetworkConnection> hashSet2 = new HashSet <NetworkConnection>(this.m_Observers);
for (int i = 0; i < this.m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour networkBehaviour = this.m_NetworkBehaviours[i];
flag2 |= networkBehaviour.OnRebuildObservers(hashSet, initialize);
}
if (!flag2)
{
if (initialize)
{
foreach (NetworkConnection current in NetworkServer.connections)
{
if (current != null)
{
if (current.isReady)
{
this.AddObserver(current);
}
}
}
foreach (NetworkConnection current2 in NetworkServer.localConnections)
{
if (current2 != null)
{
if (current2.isReady)
{
this.AddObserver(current2);
}
}
}
}
return;
}
foreach (NetworkConnection current3 in hashSet)
{
if (current3 != null)
{
if (!current3.isReady)
{
if (LogFilter.logWarn)
{
Debug.LogWarning(string.Concat(new object[]
{
"Observer is not ready for ",
base.gameObject,
" ",
current3
}));
}
}
else if (initialize || !hashSet2.Contains(current3))
{
current3.AddToVisList(this);
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[]
{
"New Observer for ",
base.gameObject,
" ",
current3
}));
}
flag = true;
}
}
}
foreach (NetworkConnection current4 in hashSet2)
{
if (!hashSet.Contains(current4))
{
current4.RemoveFromVisList(this, false);
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[]
{
"Removed Observer for ",
base.gameObject,
" ",
current4
}));
}
flag = true;
}
}
if (initialize)
{
foreach (NetworkConnection current5 in NetworkServer.localConnections)
{
if (!hashSet.Contains(current5))
{
this.OnSetLocalVisibility(false);
}
}
}
if (!flag)
{
return;
}
this.m_Observers = new List <NetworkConnection>(hashSet);
this.m_ObserverConnections.Clear();
foreach (NetworkConnection current6 in this.m_Observers)
{
this.m_ObserverConnections.Add(current6.connectionId);
}
}
internal void OnStartServer(bool allowNonZeroNetId)
{
if (m_IsServer)
{
return;
}
m_IsServer = true;
if (m_LocalPlayerAuthority)
{
// local player on server has NO authority
m_HasAuthority = false;
}
else
{
// enemy on server has authority
m_HasAuthority = true;
}
m_Observers = new List <NetworkConnection>();
m_ObserverConnections = new HashSet <int>();
CacheBehaviours();
// If the instance/net ID is invalid here then this is an object instantiated from a prefab and the server should assign a valid ID
if (netId.IsEmpty())
{
m_NetId = GetNextNetworkId();
}
else
{
if (allowNonZeroNetId)
{
//allowed
}
else
{
if (LogFilter.logError)
{
Debug.LogError("Object has non-zero netId " + netId + " for " + gameObject);
}
return;
}
}
if (LogFilter.logDev)
{
Debug.Log("OnStartServer " + gameObject + " GUID:" + netId);
}
NetworkServer.instance.SetLocalObjectOnServer(netId, gameObject);
for (int i = 0; i < m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour comp = m_NetworkBehaviours[i];
try
{
comp.OnStartServer();
}
catch (Exception e)
{
Debug.LogError("Exception in OnStartServer:" + e.Message + " " + e.StackTrace);
}
}
if (NetworkClient.active && NetworkServer.localClientActive)
{
// there will be no spawn message, so start the client here too
ClientScene.SetLocalObject(netId, gameObject);
OnStartClient();
}
if (m_HasAuthority)
{
OnStartAuthority();
}
}
internal static bool GetInvokerForHashClientRpc(int cmdHash, out Type invokeClass, out NetworkBehaviour.CmdDelegate invokeFunction)
{
return(NetworkBehaviour.GetInvokerForHash(cmdHash, NetworkBehaviour.UNetInvokeType.ClientRpc, out invokeClass, out invokeFunction));
}
public void RebuildObservers(bool initialize)
{
if (m_Observers == null)
{
return;
}
bool changed = false;
bool result = false;
HashSet <NetworkConnection> newObservers = new HashSet <NetworkConnection>();
HashSet <NetworkConnection> oldObservers = new HashSet <NetworkConnection>(m_Observers);
for (int i = 0; i < m_NetworkBehaviours.Length; i++)
{
NetworkBehaviour comp = m_NetworkBehaviours[i];
result |= comp.OnRebuildObservers(newObservers, initialize);
}
if (!result)
{
// none of the behaviours rebuilt our observers, use built-in rebuild method
if (initialize)
{
for (int i = 0; i < NetworkServer.connections.Count; i++)
{
var conn = NetworkServer.connections[i];
if (conn == null)
{
continue;
}
if (conn.isReady)
{
AddObserver(conn);
}
}
for (int i = 0; i < NetworkServer.localConnections.Count; i++)
{
var conn = NetworkServer.localConnections[i];
if (conn == null)
{
continue;
}
if (conn.isReady)
{
AddObserver(conn);
}
}
}
return;
}
// apply changes from rebuild
foreach (var conn in newObservers)
{
if (conn == null)
{
continue;
}
if (!conn.isReady)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("Observer is not ready for " + gameObject + " " + conn);
}
continue;
}
if (initialize || !oldObservers.Contains(conn))
{
// new observer
conn.AddToVisList(this);
if (LogFilter.logDebug)
{
Debug.Log("New Observer for " + gameObject + " " + conn);
}
changed = true;
}
}
foreach (var conn in oldObservers)
{
if (!newObservers.Contains(conn))
{
// removed observer
conn.RemoveFromVisList(this, false);
if (LogFilter.logDebug)
{
Debug.Log("Removed Observer for " + gameObject + " " + conn);
}
changed = true;
}
}
// special case for local client.
if (initialize)
{
for (int i = 0; i < NetworkServer.localConnections.Count; i++)
{
if (!newObservers.Contains(NetworkServer.localConnections[i]))
{
OnSetLocalVisibility(false);
}
}
}
if (!changed)
{
return;
}
m_Observers = new List <NetworkConnection>(newObservers);
// rebuild hashset once we have the final set of new observers
m_ObserverConnections.Clear();
for (int i = 0; i < m_Observers.Count; i++)
{
m_ObserverConnections.Add(m_Observers[i].connectionId);
}
}
public static string DumpParams(this UnityEngine.Networking.NetworkBehaviour behaviour)
{
return(string.Format("isClient: {0}\nisServer: {1}\nhasAuthority: {2}",
behaviour.isClient, behaviour.isServer, behaviour.hasAuthority));
}
public void InitializeBehaviour(NetworkBehaviour beh, int cmdHash)
{
m_Behaviour = beh;
m_CmdHash = cmdHash;
}
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);
}
}
