Exposed SpawnManager API & Added convenience collections and methods

TwoTenPvP · TwoTenPvP · commit 6f69a48a7d76 · 2018-07-10T20:42:53.000+02:00
diff --git a/MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs b/MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs
@@ -1959,7 +1959,7 @@ protected void SendToClientsTarget<T>(string messageType, string channelName, T
         /// <returns></returns>
         protected NetworkedObject GetNetworkedObject(uint networkId)
         {
-            return SpawnManager.spawnedObjects[networkId];
+            return SpawnManager.SpawnedObjects[networkId];
         }
     }
 }
diff --git a/MLAPI/MonoBehaviours/Core/NetworkingManager.cs b/MLAPI/MonoBehaviours/Core/NetworkingManager.cs
@@ -211,7 +211,8 @@ private object Init(bool server)
             MessageManager.releasedMessageHandlerCounters.Clear();
             MessageManager.reverseChannels.Clear();
             MessageManager.reverseMessageTypes.Clear();
-            SpawnManager.spawnedObjects.Clear();
+            SpawnManager.SpawnedObjects.Clear();
+            SpawnManager.SpawnedObjectsList.Clear();
             SpawnManager.releasedNetworkObjectIds.Clear();
             NetworkPoolManager.Pools.Clear();
             NetworkPoolManager.PoolNamesToIndexes.Clear();
@@ -899,27 +900,27 @@ private void HandleIncomingData(uint clientId, byte[] data, int channelId, uint
                         //Custom message, invoke all message handlers
                         if (targeted)
                         {
-                            if (!SpawnManager.spawnedObjects.ContainsKey(targetNetworkId))
+                            if (!SpawnManager.SpawnedObjects.ContainsKey(targetNetworkId))
                             {
                                 if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("No target for message found");
                                 messageReader.Dispose();
                                 return;
                             }
-                            else if (!SpawnManager.spawnedObjects[targetNetworkId].targetMessageActions.ContainsKey(networkOrderId))
+                            else if (!SpawnManager.SpawnedObjects[targetNetworkId].targetMessageActions.ContainsKey(networkOrderId))
                             {
                                 if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("No target messageType for message found");
                                 messageReader.Dispose();
                                 return;
                             }
-                            else if (!SpawnManager.spawnedObjects[targetNetworkId].targetMessageActions[networkOrderId].ContainsKey(messageType))
+                            else if (!SpawnManager.SpawnedObjects[targetNetworkId].targetMessageActions[networkOrderId].ContainsKey(messageType))
                             {
                                 if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("No target found with the given messageType");
                                 messageReader.Dispose();
                                 return;
                             }
-                            if (SpawnManager.spawnedObjects[targetNetworkId].targetMessageActions[networkOrderId].ContainsKey(messageType))
+                            if (SpawnManager.SpawnedObjects[targetNetworkId].targetMessageActions[networkOrderId].ContainsKey(messageType))
                             {
-                                SpawnManager.spawnedObjects[targetNetworkId].targetMessageActions[networkOrderId][messageType].Invoke(clientId, messageReader);
+                                SpawnManager.SpawnedObjects[targetNetworkId].targetMessageActions[networkOrderId][messageType].Invoke(clientId, messageReader);
                             }
                         }
                         else
@@ -1036,7 +1037,7 @@ internal void DisconnectClient(uint clientId)
                 diffieHellmanPublicKeys.Remove(clientId);
 #endif
 
-            foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.spawnedObjects)
+            foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.SpawnedObjects)
                 pair.Value.observers.Remove(clientId);
 
             NetworkConfig.NetworkTransport.DisconnectClient(clientId);
@@ -1064,7 +1065,7 @@ internal void OnClientDisconnectFromServer(uint clientId)
 
             if (isServer)
             {
-                foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.spawnedObjects)
+                foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.SpawnedObjects)
                     pair.Value.observers.Remove(clientId);
 
                 using (BitWriter writer = BitWriter.Get())
@@ -1138,7 +1139,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3
                     ConnectedClients[clientId].PlayerObject = netObject;
                 }
 
-                int amountOfObjectsToSend = SpawnManager.spawnedObjects.Values.Count;
+                int amountOfObjectsToSend = SpawnManager.SpawnedObjects.Values.Count;
 
                 using (BitWriter writer = BitWriter.Get())
                 {
@@ -1174,7 +1175,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3
                     {
                         writer.WriteInt(amountOfObjectsToSend);
 
-                        foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.spawnedObjects)
+                        foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.SpawnedObjects)
                         {
                             pair.Value.RebuildObservers(clientId); //Rebuilds observers for the new client
 
@@ -1640,7 +1641,7 @@ public void SendToClients<T>(string messageType, string channelName, T instance)
         /// <returns>Returns the NetworkedObject</returns>
         public NetworkedObject GetNetworkedObject(uint networkId)
         {
-            return SpawnManager.spawnedObjects[networkId];
+            return SpawnManager.SpawnedObjects[networkId];
         }
 #endregion
     }
diff --git a/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Receive.cs b/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Receive.cs
@@ -191,59 +191,59 @@ internal static void HandleSpawnPoolObject(uint clientId, BitReader reader, int
             float yRot = reader.ReadFloat();
             float zRot = reader.ReadFloat();
 
-            SpawnManager.spawnedObjects[netId].transform.position = new Vector3(xPos, yPos, zPos);
-            SpawnManager.spawnedObjects[netId].transform.rotation = Quaternion.Euler(xRot, yRot, zRot);
-            SpawnManager.spawnedObjects[netId].gameObject.SetActive(true);
+            SpawnManager.SpawnedObjects[netId].transform.position = new Vector3(xPos, yPos, zPos);
+            SpawnManager.SpawnedObjects[netId].transform.rotation = Quaternion.Euler(xRot, yRot, zRot);
+            SpawnManager.SpawnedObjects[netId].gameObject.SetActive(true);
         }
 
         internal static void HandleDestroyPoolObject(uint clientId, BitReader reader, int channelId)
         {
             uint netId = reader.ReadUInt();
-            SpawnManager.spawnedObjects[netId].gameObject.SetActive(false);
+            SpawnManager.SpawnedObjects[netId].gameObject.SetActive(false);
         }
 
         internal static void HandleChangeOwner(uint clientId, BitReader reader, int channelId)
         {
             uint netId = reader.ReadUInt();
             uint ownerClientId = reader.ReadUInt();
-            if (SpawnManager.spawnedObjects[netId].OwnerClientId == netManager.LocalClientId)
+            if (SpawnManager.SpawnedObjects[netId].OwnerClientId == netManager.LocalClientId)
             {
                 //We are current owner.
-                SpawnManager.spawnedObjects[netId].InvokeBehaviourOnLostOwnership();
+                SpawnManager.SpawnedObjects[netId].InvokeBehaviourOnLostOwnership();
             }
             if (ownerClientId == netManager.LocalClientId)
             {
                 //We are new owner.
-                SpawnManager.spawnedObjects[netId].InvokeBehaviourOnGainedOwnership();
+                SpawnManager.SpawnedObjects[netId].InvokeBehaviourOnGainedOwnership();
             }
-            SpawnManager.spawnedObjects[netId].OwnerClientId = ownerClientId;
+            SpawnManager.SpawnedObjects[netId].OwnerClientId = ownerClientId;
         }
 
         internal static void HandleSyncVarUpdate(uint clientId, BitReader reader, int channelId)
         {
             uint netId = reader.ReadUInt();
             ushort orderIndex = reader.ReadUShort();
 
-            if (!SpawnManager.spawnedObjects.ContainsKey(netId))
+            if (!SpawnManager.SpawnedObjects.ContainsKey(netId))
             {
                 if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Sync message recieved for a non existant object with id: " + netId);
                 return;
             }
-            else if (SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex) == null)
+            else if (SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex) == null)
             {
                 if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Sync message recieved for a non existant behaviour");
                 return;
             }
 
-            for (int i = 0; i < SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).syncedVarFields.Count; i++)
+            for (int i = 0; i < SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).syncedVarFields.Count; i++)
             {
                 if (!reader.ReadBool())
                     continue;
-                SyncedVarField field = SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).syncedVarFields[i];
-                SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).OnSyncVarUpdate(FieldTypeHelper.ReadFieldType(reader,
+                SyncedVarField field = SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).syncedVarFields[i];
+                SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).OnSyncVarUpdate(FieldTypeHelper.ReadFieldType(reader,
                     field.FieldInfo.FieldType, field.FieldValue), i);
             }
-            SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).OnSyncVarUpdate();
+            SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).OnSyncVarUpdate();
         }
 
         internal static void HandleAddObjects(uint clientId, BitReader reader, int channelId)
@@ -299,7 +299,7 @@ internal static void HandleCommand(uint clientId, BitReader reader, int channelI
             uint networkId = reader.ReadUInt();
             ushort orderId = reader.ReadUShort();
             ulong hash = reader.ReadULong();
-            NetworkedBehaviour behaviour = SpawnManager.spawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);
+            NetworkedBehaviour behaviour = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);
             if (clientId != behaviour.OwnerClientId)
                 return; // Not owner
             MethodInfo targetMethod = null;
@@ -321,7 +321,7 @@ internal static void HandleRpc(uint clientId, BitReader reader, int channelId)
             uint networkId = reader.ReadUInt();
             ushort orderId = reader.ReadUShort();
             ulong hash = reader.ReadULong();
-            NetworkedBehaviour behaviour = SpawnManager.spawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);
+            NetworkedBehaviour behaviour = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);
             MethodInfo targetMethod = null;
             if (behaviour.cachedMethods.ContainsKey(hash))
                 targetMethod = behaviour.cachedMethods[hash];
@@ -341,7 +341,7 @@ internal static void HandleTargetRpc(uint clientId, BitReader reader, int channe
             uint networkId = reader.ReadUInt();
             ushort orderId = reader.ReadUShort();
             ulong hash = reader.ReadULong();
-            NetworkedBehaviour behaviour = SpawnManager.spawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);
+            NetworkedBehaviour behaviour = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);
             MethodInfo targetMethod = null;
             if (behaviour.cachedMethods.ContainsKey(hash))
                 targetMethod = behaviour.cachedMethods[hash];
@@ -358,8 +358,8 @@ internal static void HandleSetVisibility(uint clientId, BitReader reader, int ch
             uint networkId = reader.ReadUInt();
             bool visibility = reader.ReadBool();
             if (visibility)
-                SpawnManager.spawnedObjects[networkId].SetFormattedSyncedVarData(reader);
-            SpawnManager.spawnedObjects[networkId].SetLocalVisibility(visibility);
+                SpawnManager.SpawnedObjects[networkId].SetFormattedSyncedVarData(reader);
+            SpawnManager.SpawnedObjects[networkId].SetLocalVisibility(visibility);
         }
     }
 }
diff --git a/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Send.cs b/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Send.cs
@@ -49,7 +49,7 @@ internal static bool Send(uint clientId, string messageType, string channelName,
                 targetClientId = netManager.NetworkConfig.NetworkTransport.ServerNetId;
             }
             //If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we return
-            if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(clientId))
+            if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(clientId))
                 return false;
 
             bool isPassthrough = (!netManager.isServer && clientId != netManager.NetworkConfig.NetworkTransport.ServerNetId && netManager.NetworkConfig.AllowPassthroughMessages);
@@ -126,7 +126,7 @@ internal static void Send(uint[] clientIds, string messageType, string channelNa
                     }
 
                     //If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we continue
-                    if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(clientIds[i]))
+                    if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(clientIds[i]))
                         continue;
 
                     writer.Finalize(ref FinalMessageBuffer);
@@ -168,7 +168,7 @@ internal static void Send(List<uint> clientIds, string messageType, string chann
                     }
 
                     //If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we continue
-                    if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(clientIds[i]))
+                    if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(clientIds[i]))
                         continue;
 
                     writer.Finalize(ref FinalMessageBuffer);
@@ -215,7 +215,7 @@ internal static ref List<uint> Send(string messageType, string channelName, BitW
                     }
 
                     //If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we continue
-                    if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(pair.Key))
+                    if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(pair.Key))
                     {
                         failedObservers.Add(pair.Key);
                         continue;
@@ -266,7 +266,7 @@ internal static ref List<uint> Send(string messageType, string channelName, BitW
                     }
 
                     //If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we continue
-                    if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(pair.Key))
+                    if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(pair.Key))
                     {
                         failedObservers.Add(pair.Key);
                         continue;
diff --git a/MLAPI/NetworkingManagerComponents/Core/NetworkSceneManager.cs b/MLAPI/NetworkingManagerComponents/Core/NetworkSceneManager.cs
@@ -95,7 +95,7 @@ internal static void OnSceneSwitch(uint sceneIndex)
         private static void OnSceneLoaded(AsyncOperation operation)
         {
             SceneManager.SetActiveScene(nextScene);
-            List<NetworkedObject> objectsToKeep = SpawnManager.spawnedObjects.Values.ToList();
+            List<NetworkedObject> objectsToKeep = SpawnManager.SpawnedObjectsList;
             //The last loaded scene
             nextScene = SceneManager.GetSceneAt(SceneManager.sceneCount - 1);
             for (int i = 0; i < objectsToKeep.Count; i++)
diff --git a/MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs b/MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs

Original file line number	Diff line number	Diff line change
`@@ -1959,7 +1959,7 @@ protected void SendToClientsTarget<T>(string messageType, string channelName, T`
`1959`	`1959`	`/// <returns></returns>`
`1960`	`1960`	`protected NetworkedObject GetNetworkedObject(uint networkId)`
`1961`	`1961`	`{`
`1962`		`- return SpawnManager.spawnedObjects[networkId];`
	`1962`	`+ return SpawnManager.SpawnedObjects[networkId];`
`1963`	`1963`	`}`
`1964`	`1964`	`}`
`1965`	`1965`	`}`
Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,8 @@ private object Init(bool server)`
`211`	`211`	`MessageManager.releasedMessageHandlerCounters.Clear();`
`212`	`212`	`MessageManager.reverseChannels.Clear();`
`213`	`213`	`MessageManager.reverseMessageTypes.Clear();`
`214`		`- SpawnManager.spawnedObjects.Clear();`
	`214`	`+ SpawnManager.SpawnedObjects.Clear();`
	`215`	`+ SpawnManager.SpawnedObjectsList.Clear();`
`215`	`216`	`SpawnManager.releasedNetworkObjectIds.Clear();`
`216`	`217`	`NetworkPoolManager.Pools.Clear();`
`217`	`218`	`NetworkPoolManager.PoolNamesToIndexes.Clear();`
`@@ -899,27 +900,27 @@ private void HandleIncomingData(uint clientId, byte[] data, int channelId, uint`
`899`	`900`	`//Custom message, invoke all message handlers`
`900`	`901`	`if (targeted)`
`901`	`902`	`{`
`902`		`- if (!SpawnManager.spawnedObjects.ContainsKey(targetNetworkId))`
	`903`	`+ if (!SpawnManager.SpawnedObjects.ContainsKey(targetNetworkId))`
`903`	`904`	`{`
`904`	`905`	`if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("No target for message found");`
`905`	`906`	`messageReader.Dispose();`
`906`	`907`	`return;`
`907`	`908`	`}`
`908`		`- else if (!SpawnManager.spawnedObjects[targetNetworkId].targetMessageActions.ContainsKey(networkOrderId))`
	`909`	`+ else if (!SpawnManager.SpawnedObjects[targetNetworkId].targetMessageActions.ContainsKey(networkOrderId))`
`909`	`910`	`{`
`910`	`911`	`if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("No target messageType for message found");`
`911`	`912`	`messageReader.Dispose();`
`912`	`913`	`return;`
`913`	`914`	`}`
`914`		`- else if (!SpawnManager.spawnedObjects[targetNetworkId].targetMessageActions[networkOrderId].ContainsKey(messageType))`
	`915`	`+ else if (!SpawnManager.SpawnedObjects[targetNetworkId].targetMessageActions[networkOrderId].ContainsKey(messageType))`
`915`	`916`	`{`
`916`	`917`	`if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("No target found with the given messageType");`
`917`	`918`	`messageReader.Dispose();`
`918`	`919`	`return;`
`919`	`920`	`}`
`920`		`- if (SpawnManager.spawnedObjects[targetNetworkId].targetMessageActions[networkOrderId].ContainsKey(messageType))`
	`921`	`+ if (SpawnManager.SpawnedObjects[targetNetworkId].targetMessageActions[networkOrderId].ContainsKey(messageType))`
`921`	`922`	`{`
`922`		`- SpawnManager.spawnedObjects[targetNetworkId].targetMessageActions[networkOrderId][messageType].Invoke(clientId, messageReader);`
	`923`	`+ SpawnManager.SpawnedObjects[targetNetworkId].targetMessageActions[networkOrderId][messageType].Invoke(clientId, messageReader);`
`923`	`924`	`}`
`924`	`925`	`}`
`925`	`926`	`else`
`@@ -1036,7 +1037,7 @@ internal void DisconnectClient(uint clientId)`
`1036`	`1037`	`diffieHellmanPublicKeys.Remove(clientId);`
`1037`	`1038`	`#endif`
`1038`	`1039`
`1039`		`- foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.spawnedObjects)`
	`1040`	`+ foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.SpawnedObjects)`
`1040`	`1041`	`pair.Value.observers.Remove(clientId);`
`1041`	`1042`
`1042`	`1043`	`NetworkConfig.NetworkTransport.DisconnectClient(clientId);`
`@@ -1064,7 +1065,7 @@ internal void OnClientDisconnectFromServer(uint clientId)`
`1064`	`1065`
`1065`	`1066`	`if (isServer)`
`1066`	`1067`	`{`
`1067`		`- foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.spawnedObjects)`
	`1068`	`+ foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.SpawnedObjects)`
`1068`	`1069`	`pair.Value.observers.Remove(clientId);`
`1069`	`1070`
`1070`	`1071`	`using (BitWriter writer = BitWriter.Get())`
`@@ -1138,7 +1139,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3`
`1138`	`1139`	`ConnectedClients[clientId].PlayerObject = netObject;`
`1139`	`1140`	`}`
`1140`	`1141`
`1141`		`- int amountOfObjectsToSend = SpawnManager.spawnedObjects.Values.Count;`
	`1142`	`+ int amountOfObjectsToSend = SpawnManager.SpawnedObjects.Values.Count;`
`1142`	`1143`
`1143`	`1144`	`using (BitWriter writer = BitWriter.Get())`
`1144`	`1145`	`{`
`@@ -1174,7 +1175,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3`
`1174`	`1175`	`{`
`1175`	`1176`	`writer.WriteInt(amountOfObjectsToSend);`
`1176`	`1177`
`1177`		`- foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.spawnedObjects)`
	`1178`	`+ foreach (KeyValuePair<uint, NetworkedObject> pair in SpawnManager.SpawnedObjects)`
`1178`	`1179`	`{`
`1179`	`1180`	`pair.Value.RebuildObservers(clientId); //Rebuilds observers for the new client`
`1180`	`1181`
`@@ -1640,7 +1641,7 @@ public void SendToClients<T>(string messageType, string channelName, T instance)`
`1640`	`1641`	`/// <returns>Returns the NetworkedObject</returns>`
`1641`	`1642`	`public NetworkedObject GetNetworkedObject(uint networkId)`
`1642`	`1643`	`{`
`1643`		`- return SpawnManager.spawnedObjects[networkId];`
	`1644`	`+ return SpawnManager.SpawnedObjects[networkId];`
`1644`	`1645`	`}`
`1645`	`1646`	`#endregion`
`1646`	`1647`	`}`
Original file line number	Diff line number	Diff line change
`@@ -191,59 +191,59 @@ internal static void HandleSpawnPoolObject(uint clientId, BitReader reader, int`
`191`	`191`	`float yRot = reader.ReadFloat();`
`192`	`192`	`float zRot = reader.ReadFloat();`
`193`	`193`
`194`		`- SpawnManager.spawnedObjects[netId].transform.position = new Vector3(xPos, yPos, zPos);`
`195`		`- SpawnManager.spawnedObjects[netId].transform.rotation = Quaternion.Euler(xRot, yRot, zRot);`
`196`		`- SpawnManager.spawnedObjects[netId].gameObject.SetActive(true);`
	`194`	`+ SpawnManager.SpawnedObjects[netId].transform.position = new Vector3(xPos, yPos, zPos);`
	`195`	`+ SpawnManager.SpawnedObjects[netId].transform.rotation = Quaternion.Euler(xRot, yRot, zRot);`
	`196`	`+ SpawnManager.SpawnedObjects[netId].gameObject.SetActive(true);`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`internal static void HandleDestroyPoolObject(uint clientId, BitReader reader, int channelId)`
`200`	`200`	`{`
`201`	`201`	`uint netId = reader.ReadUInt();`
`202`		`- SpawnManager.spawnedObjects[netId].gameObject.SetActive(false);`
	`202`	`+ SpawnManager.SpawnedObjects[netId].gameObject.SetActive(false);`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`internal static void HandleChangeOwner(uint clientId, BitReader reader, int channelId)`
`206`	`206`	`{`
`207`	`207`	`uint netId = reader.ReadUInt();`
`208`	`208`	`uint ownerClientId = reader.ReadUInt();`
`209`		`- if (SpawnManager.spawnedObjects[netId].OwnerClientId == netManager.LocalClientId)`
	`209`	`+ if (SpawnManager.SpawnedObjects[netId].OwnerClientId == netManager.LocalClientId)`
`210`	`210`	`{`
`211`	`211`	`//We are current owner.`
`212`		`- SpawnManager.spawnedObjects[netId].InvokeBehaviourOnLostOwnership();`
	`212`	`+ SpawnManager.SpawnedObjects[netId].InvokeBehaviourOnLostOwnership();`
`213`	`213`	`}`
`214`	`214`	`if (ownerClientId == netManager.LocalClientId)`
`215`	`215`	`{`
`216`	`216`	`//We are new owner.`
`217`		`- SpawnManager.spawnedObjects[netId].InvokeBehaviourOnGainedOwnership();`
	`217`	`+ SpawnManager.SpawnedObjects[netId].InvokeBehaviourOnGainedOwnership();`
`218`	`218`	`}`
`219`		`- SpawnManager.spawnedObjects[netId].OwnerClientId = ownerClientId;`
	`219`	`+ SpawnManager.SpawnedObjects[netId].OwnerClientId = ownerClientId;`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`internal static void HandleSyncVarUpdate(uint clientId, BitReader reader, int channelId)`
`223`	`223`	`{`
`224`	`224`	`uint netId = reader.ReadUInt();`
`225`	`225`	`ushort orderIndex = reader.ReadUShort();`
`226`	`226`
`227`		`- if (!SpawnManager.spawnedObjects.ContainsKey(netId))`
	`227`	`+ if (!SpawnManager.SpawnedObjects.ContainsKey(netId))`
`228`	`228`	`{`
`229`	`229`	`if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Sync message recieved for a non existant object with id: " + netId);`
`230`	`230`	`return;`
`231`	`231`	`}`
`232`		`- else if (SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex) == null)`
	`232`	`+ else if (SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex) == null)`
`233`	`233`	`{`
`234`	`234`	`if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Sync message recieved for a non existant behaviour");`
`235`	`235`	`return;`
`236`	`236`	`}`
`237`	`237`
`238`		`- for (int i = 0; i < SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).syncedVarFields.Count; i++)`
	`238`	`+ for (int i = 0; i < SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).syncedVarFields.Count; i++)`
`239`	`239`	`{`
`240`	`240`	`if (!reader.ReadBool())`
`241`	`241`	`continue;`
`242`		`- SyncedVarField field = SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).syncedVarFields[i];`
`243`		`- SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).OnSyncVarUpdate(FieldTypeHelper.ReadFieldType(reader,`
	`242`	`+ SyncedVarField field = SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).syncedVarFields[i];`
	`243`	`+ SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).OnSyncVarUpdate(FieldTypeHelper.ReadFieldType(reader,`
`244`	`244`	`field.FieldInfo.FieldType, field.FieldValue), i);`
`245`	`245`	`}`
`246`		`- SpawnManager.spawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).OnSyncVarUpdate();`
	`246`	`+ SpawnManager.SpawnedObjects[netId].GetBehaviourAtOrderIndex(orderIndex).OnSyncVarUpdate();`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`internal static void HandleAddObjects(uint clientId, BitReader reader, int channelId)`
`@@ -299,7 +299,7 @@ internal static void HandleCommand(uint clientId, BitReader reader, int channelI`
`299`	`299`	`uint networkId = reader.ReadUInt();`
`300`	`300`	`ushort orderId = reader.ReadUShort();`
`301`	`301`	`ulong hash = reader.ReadULong();`
`302`		`- NetworkedBehaviour behaviour = SpawnManager.spawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);`
	`302`	`+ NetworkedBehaviour behaviour = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);`
`303`	`303`	`if (clientId != behaviour.OwnerClientId)`
`304`	`304`	`return; // Not owner`
`305`	`305`	`MethodInfo targetMethod = null;`
`@@ -321,7 +321,7 @@ internal static void HandleRpc(uint clientId, BitReader reader, int channelId)`
`321`	`321`	`uint networkId = reader.ReadUInt();`
`322`	`322`	`ushort orderId = reader.ReadUShort();`
`323`	`323`	`ulong hash = reader.ReadULong();`
`324`		`- NetworkedBehaviour behaviour = SpawnManager.spawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);`
	`324`	`+ NetworkedBehaviour behaviour = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);`
`325`	`325`	`MethodInfo targetMethod = null;`
`326`	`326`	`if (behaviour.cachedMethods.ContainsKey(hash))`
`327`	`327`	`targetMethod = behaviour.cachedMethods[hash];`
`@@ -341,7 +341,7 @@ internal static void HandleTargetRpc(uint clientId, BitReader reader, int channe`
`341`	`341`	`uint networkId = reader.ReadUInt();`
`342`	`342`	`ushort orderId = reader.ReadUShort();`
`343`	`343`	`ulong hash = reader.ReadULong();`
`344`		`- NetworkedBehaviour behaviour = SpawnManager.spawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);`
	`344`	`+ NetworkedBehaviour behaviour = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(orderId);`
`345`	`345`	`MethodInfo targetMethod = null;`
`346`	`346`	`if (behaviour.cachedMethods.ContainsKey(hash))`
`347`	`347`	`targetMethod = behaviour.cachedMethods[hash];`
`@@ -358,8 +358,8 @@ internal static void HandleSetVisibility(uint clientId, BitReader reader, int ch`
`358`	`358`	`uint networkId = reader.ReadUInt();`
`359`	`359`	`bool visibility = reader.ReadBool();`
`360`	`360`	`if (visibility)`
`361`		`- SpawnManager.spawnedObjects[networkId].SetFormattedSyncedVarData(reader);`
`362`		`- SpawnManager.spawnedObjects[networkId].SetLocalVisibility(visibility);`
	`361`	`+ SpawnManager.SpawnedObjects[networkId].SetFormattedSyncedVarData(reader);`
	`362`	`+ SpawnManager.SpawnedObjects[networkId].SetLocalVisibility(visibility);`
`363`	`363`	`}`
`364`	`364`	`}`
`365`	`365`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ internal static bool Send(uint clientId, string messageType, string channelName,`
`49`	`49`	`targetClientId = netManager.NetworkConfig.NetworkTransport.ServerNetId;`
`50`	`50`	`}`
`51`	`51`	`//If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we return`
`52`		`- if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(clientId))`
	`52`	`+ if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(clientId))`
`53`	`53`	`return false;`
`54`	`54`
`55`	`55`	`bool isPassthrough = (!netManager.isServer && clientId != netManager.NetworkConfig.NetworkTransport.ServerNetId && netManager.NetworkConfig.AllowPassthroughMessages);`
`@@ -126,7 +126,7 @@ internal static void Send(uint[] clientIds, string messageType, string channelNa`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`//If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we continue`
`129`		`- if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(clientIds[i]))`
	`129`	`+ if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(clientIds[i]))`
`130`	`130`	`continue;`
`131`	`131`
`132`	`132`	`writer.Finalize(ref FinalMessageBuffer);`
`@@ -168,7 +168,7 @@ internal static void Send(List<uint> clientIds, string messageType, string chann`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`//If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we continue`
`171`		`- if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(clientIds[i]))`
	`171`	`+ if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(clientIds[i]))`
`172`	`172`	`continue;`
`173`	`173`
`174`	`174`	`writer.Finalize(ref FinalMessageBuffer);`
`@@ -215,7 +215,7 @@ internal static ref List<uint> Send(string messageType, string channelName, BitW`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`//If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we continue`
`218`		`- if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(pair.Key))`
	`218`	`+ if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(pair.Key))`
`219`	`219`	`{`
`220`	`220`	`failedObservers.Add(pair.Key);`
`221`	`221`	`continue;`
`@@ -266,7 +266,7 @@ internal static ref List<uint> Send(string messageType, string channelName, BitW`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`//If we respect the observers, and the message is targeted (networkId != null) and the targetedNetworkId isnt observing the receiver. Then we continue`
`269`		`- if (netManager.isServer && fromNetId != null && !SpawnManager.spawnedObjects[fromNetId.Value].observers.Contains(pair.Key))`
	`269`	`+ if (netManager.isServer && fromNetId != null && !SpawnManager.SpawnedObjects[fromNetId.Value].observers.Contains(pair.Key))`
`270`	`270`	`{`
`271`	`271`	`failedObservers.Add(pair.Key);`
`272`	`272`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ internal static void OnSceneSwitch(uint sceneIndex)`
`95`	`95`	`private static void OnSceneLoaded(AsyncOperation operation)`
`96`	`96`	`{`
`97`	`97`	`SceneManager.SetActiveScene(nextScene);`
`98`		`- List<NetworkedObject> objectsToKeep = SpawnManager.spawnedObjects.Values.ToList();`
	`98`	`+ List<NetworkedObject> objectsToKeep = SpawnManager.SpawnedObjectsList;`
`99`	`99`	`//The last loaded scene`
`100`	`100`	`nextScene = SceneManager.GetSceneAt(SceneManager.sceneCount - 1);`
`101`	`101`	`for (int i = 0; i < objectsToKeep.Count; i++)`