Changed GameObject internal usage to NetworkedObject

TwoTenPvP · TwoTenPvP · commit d67d698b9ff2 · 2018-05-24T11:49:30.000+01:00
diff --git a/MLAPI/Data/NetworkPool.cs b/MLAPI/Data/NetworkPool.cs
@@ -6,12 +6,12 @@ namespace MLAPI.Data
 {
     internal class NetworkPool
     {
-        internal GameObject[] objects;
+        internal NetworkedObject[] objects;
         internal ushort poolId;
 
         internal NetworkPool(int prefabId, uint size, ushort poolIndex)
         {
-            objects = new GameObject[size];
+            objects = new NetworkedObject[size];
             poolId = poolIndex;
             for (int i = 0; i < size; i++)
             {
@@ -24,13 +24,13 @@ internal NetworkPool(int prefabId, uint size, ushort poolIndex)
             }
         }
 
-        internal GameObject SpawnObject(Vector3 position, Quaternion rotation)
+        internal NetworkedObject SpawnObject(Vector3 position, Quaternion rotation)
         {
             for (int i = 0; i < objects.Length; i++)
             {
-                if (objects[i].activeInHierarchy)
+                if (objects[i].gameObject.activeInHierarchy)
                 {
-                    GameObject go = objects[i];
+                    GameObject go = objects[i].gameObject;
                     go.transform.position = position;
                     go.transform.rotation = rotation;
                     go.SetActive(true);
diff --git a/MLAPI/Data/NetworkedClient.cs b/MLAPI/Data/NetworkedClient.cs
@@ -1,6 +1,5 @@
 ﻿using MLAPI.MonoBehaviours.Core;
 using System.Collections.Generic;
-using UnityEngine;
 
 namespace MLAPI.Data
 {
@@ -16,7 +15,7 @@ public class NetworkedClient
         /// <summary>
         /// The PlayerObject of the Client
         /// </summary>
-        public GameObject PlayerObject;
+        public NetworkedObject PlayerObject;
         /// <summary>
         /// The NetworkedObject's owned by this Client
         /// </summary>
diff --git a/MLAPI/MonoBehaviours/Core/NetworkingManager.cs b/MLAPI/MonoBehaviours/Core/NetworkingManager.cs
@@ -1161,9 +1161,8 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3
                 {
                     uint networkId = SpawnManager.GetNetworkObjectId();
                     prefabId = prefabId == -1 ? NetworkConfig.NetworkPrefabIds[NetworkConfig.PlayerPrefabName] : prefabId;
-                    GameObject go = SpawnManager.CreateSpawnedObject(prefabId, networkId, clientId, true, position, rotation, null, false, false);
-                    netObject = go.GetComponent<NetworkedObject>();
-                    connectedClients[clientId].PlayerObject = go;
+                    netObject = SpawnManager.CreateSpawnedObject(prefabId, networkId, clientId, true, position, rotation, null, false, false);
+                    connectedClients[clientId].PlayerObject = netObject;
                 }
 
                 int amountOfObjectsToSend = SpawnManager.spawnedObjects.Values.Count;
diff --git a/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Receive.cs b/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Receive.cs
@@ -105,11 +105,11 @@ internal static void HandleConnectionApproved(uint clientId, BitReader reader, i
                     float yRot = reader.ReadFloat();
                     float zRot = reader.ReadFloat();
 
-                    GameObject go = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,
+                    NetworkedObject netObject = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,
                         new Vector3(xPos, yPos, zPos), Quaternion.Euler(xRot, yRot, zRot), reader, visible, false);
-                    go.GetComponent<NetworkedObject>().SetLocalVisibility(visible);
-                    go.GetComponent<NetworkedObject>().sceneObject = sceneObject;
-                    go.SetActive(isActive);
+                    netObject.SetLocalVisibility(visible);
+                    netObject.sceneObject = sceneObject;
+                    netObject.gameObject.SetActive(isActive);
                 }
             }
 
@@ -149,11 +149,11 @@ internal static void HandleAddObject(uint clientId, BitReader reader, int channe
                     netManager.connectedClients.Add(ownerId, new NetworkedClient() { ClientId = ownerId });
                     netManager.connectedClientsList.Add(netManager.connectedClients[ownerId]);
                 }
-                GameObject go = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,
+                NetworkedObject netObject = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,
                     new Vector3(xPos, yPos, zPos), Quaternion.Euler(xRot, yRot, zRot), reader, visible, hasPayload);
 
-                go.GetComponent<NetworkedObject>().SetLocalVisibility(visible);
-                go.GetComponent<NetworkedObject>().sceneObject = sceneObject;
+                netObject.SetLocalVisibility(visible);
+                netObject.sceneObject = sceneObject;
 
             }
             else
@@ -273,9 +273,10 @@ internal static void HandleAddObjects(uint clientId, BitReader reader, int chann
                         netManager.connectedClients.Add(ownerId, new NetworkedClient() { ClientId = ownerId });
                         netManager.connectedClientsList.Add(netManager.connectedClients[ownerId]);
                     }
-                    GameObject go = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject, new Vector3(xPos, yPos, zPos), Quaternion.Euler(xRot, yRot, zRot), reader, visible, false);
-                    go.GetComponent<NetworkedObject>().SetLocalVisibility(visible);
-                    go.GetComponent<NetworkedObject>().sceneObject = sceneObject;
+                    NetworkedObject netObject = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,
+                        new Vector3(xPos, yPos, zPos), Quaternion.Euler(xRot, yRot, zRot), reader, visible, false);
+                    netObject.SetLocalVisibility(visible);
+                    netObject.sceneObject = sceneObject;
 
                 }
             }
diff --git a/MLAPI/NetworkingManagerComponents/Core/NetworkPoolManager.cs b/MLAPI/NetworkingManagerComponents/Core/NetworkPoolManager.cs
@@ -58,17 +58,17 @@ public static void DestroyPool(string poolName)
         /// <param name="position">The position to spawn the object at</param>
         /// <param name="rotation">The rotation to spawn the object at</param>
         /// <returns></returns>
-        public static GameObject SpawnPoolObject(string poolName, Vector3 position, Quaternion rotation)
+        public static NetworkedObject SpawnPoolObject(string poolName, Vector3 position, Quaternion rotation)
         {
             if (!NetworkingManager.singleton.isServer)
             {
                 if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Object spawning can only occur on server");
                 return null;
             }
-            GameObject go = Pools[PoolNamesToIndexes[poolName]].SpawnObject(position, rotation);
+            NetworkedObject netObject = Pools[PoolNamesToIndexes[poolName]].SpawnObject(position, rotation);
             using (BitWriter writer = BitWriter.Get())
             {
-                writer.WriteUInt(go.GetComponent<NetworkedObject>().NetworkId);
+                writer.WriteUInt(netObject.NetworkId);
 
                 writer.WriteFloat(position.x);
                 writer.WriteFloat(position.y);
@@ -80,7 +80,7 @@ public static GameObject SpawnPoolObject(string poolName, Vector3 position, Quat
 
                 InternalMessageHandler.Send("MLAPI_SPAWN_POOL_OBJECT", "MLAPI_INTERNAL", writer, null);
             }
-            return go;
+            return netObject;
         }
 
         /// <summary>
diff --git a/MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs b/MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs
@@ -152,7 +152,7 @@ internal static void FlushSceneObjects()
             }
         }
 
-        internal static GameObject CreateSpawnedObject(int networkedPrefabId, uint networkId, uint owner, bool playerObject, Vector3 position, Quaternion rotation, BitReader reader, bool readSyncedVar, bool readPayload)
+        internal static NetworkedObject CreateSpawnedObject(int networkedPrefabId, uint networkId, uint owner, bool playerObject, Vector3 position, Quaternion rotation, BitReader reader, bool readSyncedVar, bool readPayload)
         {
             if (!netManager.NetworkConfig.NetworkPrefabNames.ContainsKey(networkedPrefabId))
             {
@@ -184,7 +184,7 @@ internal static GameObject CreateSpawnedObject(int networkedPrefabId, uint netwo
             netObject.transform.rotation = rotation;
             spawnedObjects.Add(netObject.NetworkId, netObject);
             netObject.InvokeBehaviourNetworkSpawn(reader);
-            return go;
+            return netObject;
         }
 
         internal static void UnSpawnObject(NetworkedObject netObject)
@@ -242,7 +242,7 @@ internal static void SpawnPlayerObject(NetworkedObject netObject, uint clientId,
             netObject._isSpawned = true;
             netObject.sceneObject = false;
             netObject._isPlayerObject = true;
-            netManager.connectedClients[clientId].PlayerObject = netObject.gameObject;
+            netManager.connectedClients[clientId].PlayerObject = netObject;
 
             if (payload == null) netObject.InvokeBehaviourNetworkSpawn(null);
             else using (BitReader payloadReader = BitReader.Get(payload.Finalize())) netObject.InvokeBehaviourNetworkSpawn(payloadReader);
@@ -353,7 +353,6 @@ internal static void OnDestroyObject(uint networkId, bool destroyGameObject)
                 //Someone owns it.
                 NetworkingManager.singleton.connectedClients[spawnedObjects[networkId].OwnerClientId].OwnedObjects.RemoveAll(x => x.NetworkId == networkId);
             }
-            GameObject go = spawnedObjects[networkId].gameObject;
             spawnedObjects[networkId]._isSpawned = false;
 
             if (netManager != null && netManager.isServer)
@@ -369,6 +368,8 @@ internal static void OnDestroyObject(uint networkId, bool destroyGameObject)
                     }
                 }
             }
+
+            GameObject go = spawnedObjects[networkId].gameObject;
             if (destroyGameObject && go != null)
                 MonoBehaviour.Destroy(go);
             spawnedObjects.Remove(networkId);

Original file line number	Diff line number	Diff line change
`@@ -6,12 +6,12 @@ namespace MLAPI.Data`
`6`	`6`	`{`
`7`	`7`	`internal class NetworkPool`
`8`	`8`	`{`
`9`		`- internal GameObject[] objects;`
	`9`	`+ internal NetworkedObject[] objects;`
`10`	`10`	`internal ushort poolId;`
`11`	`11`
`12`	`12`	`internal NetworkPool(int prefabId, uint size, ushort poolIndex)`
`13`	`13`	`{`
`14`		`- objects = new GameObject[size];`
	`14`	`+ objects = new NetworkedObject[size];`
`15`	`15`	`poolId = poolIndex;`
`16`	`16`	`for (int i = 0; i < size; i++)`
`17`	`17`	`{`
`@@ -24,13 +24,13 @@ internal NetworkPool(int prefabId, uint size, ushort poolIndex)`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
`27`		`- internal GameObject SpawnObject(Vector3 position, Quaternion rotation)`
	`27`	`+ internal NetworkedObject SpawnObject(Vector3 position, Quaternion rotation)`
`28`	`28`	`{`
`29`	`29`	`for (int i = 0; i < objects.Length; i++)`
`30`	`30`	`{`
`31`		`- if (objects[i].activeInHierarchy)`
	`31`	`+ if (objects[i].gameObject.activeInHierarchy)`
`32`	`32`	`{`
`33`		`- GameObject go = objects[i];`
	`33`	`+ GameObject go = objects[i].gameObject;`
`34`	`34`	`go.transform.position = position;`
`35`	`35`	`go.transform.rotation = rotation;`
`36`	`36`	`go.SetActive(true);`
Original file line number	Diff line number	Diff line change
`@@ -1161,9 +1161,8 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3`
`1161`	`1161`	`{`
`1162`	`1162`	`uint networkId = SpawnManager.GetNetworkObjectId();`
`1163`	`1163`	`prefabId = prefabId == -1 ? NetworkConfig.NetworkPrefabIds[NetworkConfig.PlayerPrefabName] : prefabId;`
`1164`		`- GameObject go = SpawnManager.CreateSpawnedObject(prefabId, networkId, clientId, true, position, rotation, null, false, false);`
`1165`		`- netObject = go.GetComponent<NetworkedObject>();`
`1166`		`- connectedClients[clientId].PlayerObject = go;`
	`1164`	`+ netObject = SpawnManager.CreateSpawnedObject(prefabId, networkId, clientId, true, position, rotation, null, false, false);`
	`1165`	`+ connectedClients[clientId].PlayerObject = netObject;`
`1167`	`1166`	`}`
`1168`	`1167`
`1169`	`1168`	`int amountOfObjectsToSend = SpawnManager.spawnedObjects.Values.Count;`
Original file line number	Diff line number	Diff line change
`@@ -105,11 +105,11 @@ internal static void HandleConnectionApproved(uint clientId, BitReader reader, i`
`105`	`105`	`float yRot = reader.ReadFloat();`
`106`	`106`	`float zRot = reader.ReadFloat();`
`107`	`107`
`108`		`- GameObject go = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,`
	`108`	`+ NetworkedObject netObject = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,`
`109`	`109`	`new Vector3(xPos, yPos, zPos), Quaternion.Euler(xRot, yRot, zRot), reader, visible, false);`
`110`		`- go.GetComponent<NetworkedObject>().SetLocalVisibility(visible);`
`111`		`- go.GetComponent<NetworkedObject>().sceneObject = sceneObject;`
`112`		`- go.SetActive(isActive);`
	`110`	`+ netObject.SetLocalVisibility(visible);`
	`111`	`+ netObject.sceneObject = sceneObject;`
	`112`	`+ netObject.gameObject.SetActive(isActive);`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`
`@@ -149,11 +149,11 @@ internal static void HandleAddObject(uint clientId, BitReader reader, int channe`
`149`	`149`	`netManager.connectedClients.Add(ownerId, new NetworkedClient() { ClientId = ownerId });`
`150`	`150`	`netManager.connectedClientsList.Add(netManager.connectedClients[ownerId]);`
`151`	`151`	`}`
`152`		`- GameObject go = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,`
	`152`	`+ NetworkedObject netObject = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,`
`153`	`153`	`new Vector3(xPos, yPos, zPos), Quaternion.Euler(xRot, yRot, zRot), reader, visible, hasPayload);`
`154`	`154`
`155`		`- go.GetComponent<NetworkedObject>().SetLocalVisibility(visible);`
`156`		`- go.GetComponent<NetworkedObject>().sceneObject = sceneObject;`
	`155`	`+ netObject.SetLocalVisibility(visible);`
	`156`	`+ netObject.sceneObject = sceneObject;`
`157`	`157`
`158`	`158`	`}`
`159`	`159`	`else`
`@@ -273,9 +273,10 @@ internal static void HandleAddObjects(uint clientId, BitReader reader, int chann`
`273`	`273`	`netManager.connectedClients.Add(ownerId, new NetworkedClient() { ClientId = ownerId });`
`274`	`274`	`netManager.connectedClientsList.Add(netManager.connectedClients[ownerId]);`
`275`	`275`	`}`
`276`		`- GameObject go = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject, new Vector3(xPos, yPos, zPos), Quaternion.Euler(xRot, yRot, zRot), reader, visible, false);`
`277`		`- go.GetComponent<NetworkedObject>().SetLocalVisibility(visible);`
`278`		`- go.GetComponent<NetworkedObject>().sceneObject = sceneObject;`
	`276`	`+ NetworkedObject netObject = SpawnManager.CreateSpawnedObject(prefabId, networkId, ownerId, isPlayerObject,`
	`277`	`+ new Vector3(xPos, yPos, zPos), Quaternion.Euler(xRot, yRot, zRot), reader, visible, false);`
	`278`	`+ netObject.SetLocalVisibility(visible);`
	`279`	`+ netObject.sceneObject = sceneObject;`
`279`	`280`
`280`	`281`	`}`
`281`	`282`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,17 +58,17 @@ public static void DestroyPool(string poolName)`
`58`	`58`	`/// <param name="position">The position to spawn the object at</param>`
`59`	`59`	`/// <param name="rotation">The rotation to spawn the object at</param>`
`60`	`60`	`/// <returns></returns>`
`61`		`- public static GameObject SpawnPoolObject(string poolName, Vector3 position, Quaternion rotation)`
	`61`	`+ public static NetworkedObject SpawnPoolObject(string poolName, Vector3 position, Quaternion rotation)`
`62`	`62`	`{`
`63`	`63`	`if (!NetworkingManager.singleton.isServer)`
`64`	`64`	`{`
`65`	`65`	`if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Object spawning can only occur on server");`
`66`	`66`	`return null;`
`67`	`67`	`}`
`68`		`- GameObject go = Pools[PoolNamesToIndexes[poolName]].SpawnObject(position, rotation);`
	`68`	`+ NetworkedObject netObject = Pools[PoolNamesToIndexes[poolName]].SpawnObject(position, rotation);`
`69`	`69`	`using (BitWriter writer = BitWriter.Get())`
`70`	`70`	`{`
`71`		`- writer.WriteUInt(go.GetComponent<NetworkedObject>().NetworkId);`
	`71`	`+ writer.WriteUInt(netObject.NetworkId);`
`72`	`72`
`73`	`73`	`writer.WriteFloat(position.x);`
`74`	`74`	`writer.WriteFloat(position.y);`
`@@ -80,7 +80,7 @@ public static GameObject SpawnPoolObject(string poolName, Vector3 position, Quat`
`80`	`80`
`81`	`81`	`InternalMessageHandler.Send("MLAPI_SPAWN_POOL_OBJECT", "MLAPI_INTERNAL", writer, null);`
`82`	`82`	`}`
`83`		`- return go;`
	`83`	`+ return netObject;`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ internal static void FlushSceneObjects()`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
`155`		`- internal static GameObject CreateSpawnedObject(int networkedPrefabId, uint networkId, uint owner, bool playerObject, Vector3 position, Quaternion rotation, BitReader reader, bool readSyncedVar, bool readPayload)`
	`155`	`+ internal static NetworkedObject CreateSpawnedObject(int networkedPrefabId, uint networkId, uint owner, bool playerObject, Vector3 position, Quaternion rotation, BitReader reader, bool readSyncedVar, bool readPayload)`
`156`	`156`	`{`
`157`	`157`	`if (!netManager.NetworkConfig.NetworkPrefabNames.ContainsKey(networkedPrefabId))`
`158`	`158`	`{`
`@@ -184,7 +184,7 @@ internal static GameObject CreateSpawnedObject(int networkedPrefabId, uint netwo`
`184`	`184`	`netObject.transform.rotation = rotation;`
`185`	`185`	`spawnedObjects.Add(netObject.NetworkId, netObject);`
`186`	`186`	`netObject.InvokeBehaviourNetworkSpawn(reader);`
`187`		`- return go;`
	`187`	`+ return netObject;`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`internal static void UnSpawnObject(NetworkedObject netObject)`
`@@ -242,7 +242,7 @@ internal static void SpawnPlayerObject(NetworkedObject netObject, uint clientId,`
`242`	`242`	`netObject._isSpawned = true;`
`243`	`243`	`netObject.sceneObject = false;`
`244`	`244`	`netObject._isPlayerObject = true;`
`245`		`- netManager.connectedClients[clientId].PlayerObject = netObject.gameObject;`
	`245`	`+ netManager.connectedClients[clientId].PlayerObject = netObject;`
`246`	`246`
`247`	`247`	`if (payload == null) netObject.InvokeBehaviourNetworkSpawn(null);`
`248`	`248`	`else using (BitReader payloadReader = BitReader.Get(payload.Finalize())) netObject.InvokeBehaviourNetworkSpawn(payloadReader);`
`@@ -353,7 +353,6 @@ internal static void OnDestroyObject(uint networkId, bool destroyGameObject)`
`353`	`353`	`//Someone owns it.`
`354`	`354`	`NetworkingManager.singleton.connectedClients[spawnedObjects[networkId].OwnerClientId].OwnedObjects.RemoveAll(x => x.NetworkId == networkId);`
`355`	`355`	`}`
`356`		`- GameObject go = spawnedObjects[networkId].gameObject;`
`357`	`356`	`spawnedObjects[networkId]._isSpawned = false;`
`358`	`357`
`359`	`358`	`if (netManager != null && netManager.isServer)`
`@@ -369,6 +368,8 @@ internal static void OnDestroyObject(uint networkId, bool destroyGameObject)`
`369`	`368`	`}`
`370`	`369`	`}`
`371`	`370`	`}`
	`371`	`+`
	`372`	`+ GameObject go = spawnedObjects[networkId].gameObject;`
`372`	`373`	`if (destroyGameObject && go != null)`
`373`	`374`	`MonoBehaviour.Destroy(go);`
`374`	`375`	`spawnedObjects.Remove(networkId);`