feat!: Network Prefab Overrides, Inspector View, and the default Player Prefab

com.unity.multiplayer.mlapi/Runtime/Configuration/NetworkConfig.cs

@@ -42,22 +42,23 @@ public class NetworkConfig
         public bool AllowRuntimeSceneChanges = false;
 
         /// <summary>
-        /// A list of spawnable prefabs
+        /// The default player prefab
         /// </summary>
-        [Tooltip("The prefabs that can be spawned across the network")]
-        public List<NetworkPrefab> NetworkPrefabs = new List<NetworkPrefab>();
+        [Tooltip("When set, NetworkManager will automatically create and spawn the assigned player prefab. This can be overridden by adding it to the NetworkPrefabs list and selecting override.")]
+        public GameObject PlayerPrefab;
 
         /// <summary>
-        /// The default player prefab
+        /// A list of spawnable prefabs
         /// </summary>
-        [SerializeReference]
-        internal uint PlayerPrefabHash;
+        [SerializeField]
+        [Tooltip("The prefabs that can be spawned across the network")]
+        internal List<NetworkPrefab> NetworkPrefabs = new List<NetworkPrefab>();
 
         /// <summary>
-        /// Whether or not a player object should be created by default. This value can be overridden on a case by case basis with ConnectionApproval.
+        /// This dictionary provides a quick way to check and see if a NetworkPrefab has a NetworkPrefab override.
+        /// Generated at runtime and OnValidate
         /// </summary>
-        [Tooltip("Whether or not a player object should be created by default. This value can be overridden on a case by case basis with ConnectionApproval.")]
-        public bool CreatePlayerPrefab = true;
+        internal Dictionary<uint, NetworkPrefab> NetworkPrefabOverrideLinks = new Dictionary<uint, NetworkPrefab>();
 
         /// <summary>
         /// Amount of times per second the receive queue is emptied and all messages inside are processed.
@@ -300,10 +301,10 @@ public ulong GetConfig(bool cache = true)
 
                 if (ForceSamePrefabs)
                 {
-                    var sortedPrefabList = NetworkPrefabs.OrderBy(x => x.Hash).ToList();
-                    for (int i = 0; i < sortedPrefabList.Count; i++)
+                    var sortedDictionary = NetworkPrefabOverrideLinks.OrderBy(x => x.Key);
+                    foreach (var sortedEntry in sortedDictionary)
                     {
-                        writer.WriteUInt32Packed(sortedPrefabList[i].Hash);
+                        writer.WriteUInt32Packed(sortedEntry.Key);
                     }
                 }
 

com.unity.multiplayer.mlapi/Runtime/Configuration/NetworkPrefab.cs

@@ -4,49 +4,43 @@
 
 namespace MLAPI.Configuration
 {
+    internal enum NetworkPrefabOverride
+    {
+        None,
+        Prefab,
+        Hash
+    }
+
     /// <summary>
     /// Class that represents a NetworkPrefab
     /// </summary>
     [Serializable]
-    public class NetworkPrefab
+    internal class NetworkPrefab
     {
+        /// <summary>
+        /// The override setttings for this NetworkPrefab
+        /// </summary>
+        public NetworkPrefabOverride Override;
+
         /// <summary>
         /// Asset reference of the network prefab
         /// </summary>
         public GameObject Prefab;
 
         /// <summary>
-        /// Whether or not this is a player prefab
+        /// Used when prefab is selected for the source prefab to override value (i.e. direct reference, the prefab is within the same project)
+        /// We keep a separate value as the user might want to have something different than the default Prefab for the SourcePrefabToOverride
         /// </summary>
-        public bool IsPlayer;
-
-        internal uint Hash
-        {
-            get
-            {
-                if (Prefab == null)
-                {
-                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                    {
-                        NetworkLog.LogWarning($"{nameof(NetworkPrefab)} does not have a prefab assigned");
-                    }
+        public GameObject SourcePrefabToOverride;
 
-                    return 0;
-                }
-
-                var networkObject = Prefab.GetComponent<NetworkObject>();
-                if (networkObject == null)
-                {
-                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                    {
-                        NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {Prefab.name} does not have a {nameof(NetworkObject)} component");
-                    }
-
-                    return 0;
-                }
+        /// <summary>
+        /// Used when hash is selected for the source prefab to override value (i.e. a direct reference is not possible such as in a multi-project pattern)
+        /// </summary>
+        public uint SourceHashToOverride;
 
-                return networkObject.GlobalObjectIdHash;
-            }
-        }
+        /// <summary>
+        /// The prefab to replace (override) the source prefab with
+        /// </summary>
+        public GameObject OverridingTargetPrefab;
     }
 }

com.unity.multiplayer.mlapi/Runtime/Core/NetworkManager.cs

@@ -4,7 +4,6 @@
 using System.ComponentModel;
 using System.Diagnostics;
 using UnityEngine;
-using System.Linq;
 using MLAPI.Logging;
 using MLAPI.Configuration;
 using MLAPI.Internal;
@@ -216,7 +215,7 @@ private void OnValidate()
         {
             if (NetworkConfig == null)
             {
-                return; //May occur when the component is added
+                return; // May occur when the component is added
             }
 
             if (GetComponentInChildren<NetworkObject>() != null)
@@ -247,39 +246,58 @@ private void OnValidate()
                 };
             }
 
+            // During OnValidate we will always clear out NetworkPrefabOverrideLinks and rebuild it
+            NetworkConfig.NetworkPrefabOverrideLinks.Clear();
+
+            // Check network prefabs and assign to dictionary for quick look up
             for (int i = 0; i < NetworkConfig.NetworkPrefabs.Count; i++)
             {
                 if (NetworkConfig.NetworkPrefabs[i] != null && NetworkConfig.NetworkPrefabs[i].Prefab != null)
                 {
-                    if (NetworkConfig.NetworkPrefabs[i].Prefab.GetComponent<NetworkObject>() == null)
+                    var networkObject = NetworkConfig.NetworkPrefabs[i].Prefab.GetComponent<NetworkObject>();
+                    if (networkObject == null)
                     {
                         if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                         {
                             NetworkLog.LogWarning($"{nameof(NetworkPrefab)} [{i}] does not have a {nameof(NetworkObject)} component");
                         }
                     }
-                }
-            }
+                    else
+                    {
+                        // Default to the standard NetworkPrefab.Prefab's NetworkObject first
+                        var globalObjectIdHash = networkObject.GlobalObjectIdHash;
 
-            int playerPrefabCount = NetworkConfig.NetworkPrefabs.Count(x => x.IsPlayer);
+                        // Now check to see if it has an override
+                        switch (NetworkConfig.NetworkPrefabs[i].Override)
+                        {
+                            case NetworkPrefabOverride.Prefab:
+                                {
+                                    if (NetworkConfig.NetworkPrefabs[i].SourcePrefabToOverride == null && NetworkConfig.NetworkPrefabs[i].Prefab != null)
+                                    {
+                                        NetworkConfig.NetworkPrefabs[i].SourcePrefabToOverride = NetworkConfig.NetworkPrefabs[i].Prefab;
+                                    }
+                                    globalObjectIdHash = NetworkConfig.NetworkPrefabs[i].SourcePrefabToOverride.GetComponent<NetworkObject>().GlobalObjectIdHash;
+                                }
+                                break;
+                            case NetworkPrefabOverride.Hash:
+                                globalObjectIdHash = NetworkConfig.NetworkPrefabs[i].SourceHashToOverride;
+                                break;
+                        }
 
-            if (playerPrefabCount == 0 && !NetworkConfig.ConnectionApproval && NetworkConfig.CreatePlayerPrefab)
-            {
-                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                {
-                    NetworkLog.LogWarning($"There is no {nameof(NetworkPrefab)} marked as a {nameof(NetworkPrefab.IsPlayer)}");
-                }
-            }
-            else if (playerPrefabCount > 1)
-            {
-                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                {
-                    NetworkLog.LogWarning($"Only one {nameof(NetworkPrefab)} can be marked as a {nameof(NetworkPrefab.IsPlayer)}");
+                        // Add to the NetworkPrefabOverrideLinks or handle a new (blank) entries
+                        if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash))
+                        {
+                            NetworkConfig.NetworkPrefabOverrideLinks.Add(globalObjectIdHash, NetworkConfig.NetworkPrefabs[i]);
+                        }
+                        else
+                        {
+                            // Duplicate entries can happen when adding a new entry into a list of existing entries
+                            // Either this is user error or a new entry, either case we replace it with a new, blank, NetworkPrefab under this condition
+                            NetworkConfig.NetworkPrefabs[i] = new NetworkPrefab();
+                        }
+                    }
                 }
             }
-
-            var networkPrefab = NetworkConfig.NetworkPrefabs.FirstOrDefault(x => x.IsPlayer);
-            NetworkConfig.PlayerPrefabHash = networkPrefab?.Hash ?? (uint)0;
         }
 #endif
 
@@ -326,7 +344,7 @@ private void Init(bool server)
                 return;
             }
 
-            //This 'if' should never enter
+            // This 'if' should never enter
             if (NetworkTickSystem != null)
             {
                 NetworkTickSystem.Dispose();
@@ -335,16 +353,16 @@ private void Init(bool server)
 
             NetworkTickSystem = new NetworkTickSystem(NetworkConfig.NetworkTickIntervalSec);
 
-            //This should never happen, but in the event that it does there should be (at a minimum) a unity error logged.
+            // This should never happen, but in the event that it does there should be (at a minimum) a unity error logged.
             if (RpcQueueContainer != null)
             {
                 UnityEngine.Debug.LogError("Init was invoked, but rpcQueueContainer was already initialized! (destroying previous instance)");
                 RpcQueueContainer.Dispose();
                 RpcQueueContainer = null;
             }
 
-            //The RpcQueueContainer must be initialized within the Init method ONLY
-            //It should ONLY be shutdown and destroyed in the Shutdown method (other than just above)
+            // The RpcQueueContainer must be initialized within the Init method ONLY
+            // It should ONLY be shutdown and destroyed in the Shutdown method (other than just above)
             RpcQueueContainer = new RpcQueueContainer(this);
 
             // Register INetworkUpdateSystem (always register this after rpcQueueContainer has been instantiated)
@@ -365,23 +383,98 @@ private void Init(bool server)
                 SceneManager.SetCurrentSceneIndex();
             }
 
+            // This is used to remove entries not needed or invalid 
+            var removeEmptyPrefabs = new List<int>();
+
+            // Always clear our prefab override links before building
+            NetworkConfig.NetworkPrefabOverrideLinks.Clear();
+
+            // Build the NetworkPrefabOverrideLinks dictionary
             for (int i = 0; i < NetworkConfig.NetworkPrefabs.Count; i++)
             {
                 if (NetworkConfig.NetworkPrefabs[i] == null || NetworkConfig.NetworkPrefabs[i].Prefab == null)
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                     {
-                        NetworkLog.LogError($"{nameof(NetworkPrefab)} cannot be null ({nameof(NetworkPrefab)} at index: {i})");
+                        NetworkLog.LogWarning($"{nameof(NetworkPrefab)} cannot be null ({nameof(NetworkPrefab)} at index: {i})");
                     }
+
+                    // Provide the name of the prefab with issues so the user can more easily find the prefab and fix it
+                    UnityEngine.Debug.LogWarning($"{nameof(NetworkPrefab)} (\"{NetworkConfig.NetworkPrefabs[i].Prefab.name}\") will be removed and ignored.");
+                    removeEmptyPrefabs.Add(i);
+
+                    continue;
                 }
                 else if (NetworkConfig.NetworkPrefabs[i].Prefab.GetComponent<NetworkObject>() == null)
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                     {
-                        NetworkLog.LogError($"{nameof(NetworkPrefab)} (\"{NetworkConfig.NetworkPrefabs[i].Prefab.name}\") is missing a {nameof(NetworkObject)} component");
+                        NetworkLog.LogWarning($"{nameof(NetworkPrefab)} (\"{NetworkConfig.NetworkPrefabs[i].Prefab.name}\") is missing a {nameof(NetworkObject)} component");
+                    }
+
+                    // Provide the name of the prefab with issues so the user can more easily find the prefab and fix it
+                    UnityEngine.Debug.LogWarning($"{nameof(NetworkPrefab)} (\"{NetworkConfig.NetworkPrefabs[i].Prefab.name}\") will be removed and ignored.");
+                    removeEmptyPrefabs.Add(i);
+
+                    continue;
+                }
+
+                var networkObject = NetworkConfig.NetworkPrefabs[i].Prefab.GetComponent<NetworkObject>();
+
+                // Assign the appropriate GlobalObjectIdHash to the appropriate NetworkPrefab
+                if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(networkObject.GlobalObjectIdHash))
+                {
+                    switch (NetworkConfig.NetworkPrefabs[i].Override)
+                    {
+                        default:
+                        case NetworkPrefabOverride.None:
+                            NetworkConfig.NetworkPrefabOverrideLinks.Add(networkObject.GlobalObjectIdHash, NetworkConfig.NetworkPrefabs[i]);
+                            break;
+                        case NetworkPrefabOverride.Prefab:
+                            NetworkConfig.NetworkPrefabOverrideLinks.Add(NetworkConfig.NetworkPrefabs[i].SourcePrefabToOverride.GetComponent<NetworkObject>().GlobalObjectIdHash, NetworkConfig.NetworkPrefabs[i]);
+                            break;
+                        case NetworkPrefabOverride.Hash:
+                            NetworkConfig.NetworkPrefabOverrideLinks.Add(NetworkConfig.NetworkPrefabs[i].SourceHashToOverride, NetworkConfig.NetworkPrefabs[i]);
+                            break;
+                    }
+                }
+                else
+                {
+                    // This should never happen, but in the case it somehow does log an error and remove the duplicate entry
+                    UnityEngine.Debug.LogError($"{nameof(NetworkPrefab)} (\"{NetworkConfig.NetworkPrefabs[i].Prefab.name}\") has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} {networkObject.GlobalObjectIdHash} entry! Removing entry from list!");
+                    removeEmptyPrefabs.Add(i);
+                }
+            }
+
+            // If we have a player prefab, then we need to verify it is in the list of NetworkPrefabOverrideLinks for client side spawning.
+            if (NetworkConfig.PlayerPrefab != null)
+            {
+                var playerPrefabNetworkObject = NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>();
+                if (playerPrefabNetworkObject != null)
+                {
+                    //In the event there is no NetworkPrefab entry (i.e. no override for default player prefab)
+                    if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(playerPrefabNetworkObject.GlobalObjectIdHash))
+                    {
+                        //Then add a new entry for the player prefab
+                        var playerNetworkPrefab = new NetworkPrefab();
+                        playerNetworkPrefab.Prefab = NetworkConfig.PlayerPrefab;                        
+                        NetworkConfig.NetworkPrefabs.Insert(0, playerNetworkPrefab);
+                        NetworkConfig.NetworkPrefabOverrideLinks.Add(playerPrefabNetworkObject.GlobalObjectIdHash, playerNetworkPrefab);
                     }
                 }
+                else
+                {
+                    // Provide the name of the prefab with issues so the user can more easily find the prefab and fix it
+                    UnityEngine.Debug.LogError($"{nameof(NetworkConfig.PlayerPrefab)} (\"{NetworkConfig.PlayerPrefab.name}\") has no NetworkObject assigned to it!.");
+                }
+            }
+
+            // Clear out anything that is invalid or not used (for invalid entries we already logged warnings to the user earlier)
+            foreach (var networkPrefabIndexToRemove in removeEmptyPrefabs)
+            {
+                NetworkConfig.NetworkPrefabs.RemoveAt(networkPrefabIndexToRemove);
             }
+            removeEmptyPrefabs.Clear();
 
             NetworkConfig.NetworkTransport.OnTransportEvent += HandleRawTransportPoll;
 
@@ -604,7 +697,7 @@ public SocketTasks StartHost()
             }
             else
             {
-                HandleApproval(ServerClientId, NetworkConfig.CreatePlayerPrefab, null, true, null, null);
+                HandleApproval(ServerClientId, NetworkConfig.PlayerPrefab != null, null, true, null, null);
             }
 
             SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
@@ -1477,7 +1570,7 @@ internal void HandleApproval(ulong ownerClientId, bool createPlayerObject, uint?
 
                 if (createPlayerObject)
                 {
-                    var networkObject = SpawnManager.CreateLocalNetworkObject(false, playerPrefabHash ?? NetworkConfig.PlayerPrefabHash, ownerClientId, null, position, rotation);
+                    var networkObject = SpawnManager.CreateLocalNetworkObject(false, playerPrefabHash ?? NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash, ownerClientId, null, position, rotation);
                     SpawnManager.SpawnNetworkObjectLocally(networkObject, SpawnManager.GetNetworkObjectId(), false, true, ownerClientId, null, false, 0, false, false);
 
                     ConnectedClients[ownerClientId].PlayerObject = networkObject;
@@ -1566,7 +1659,7 @@ internal void HandleApproval(ulong ownerClientId, bool createPlayerObject, uint?
 
                 OnClientConnectedCallback?.Invoke(ownerClientId);
 
-                if (!createPlayerObject || (playerPrefabHash == null && NetworkConfig.PlayerPrefabHash == 0))
+                if (!createPlayerObject || (playerPrefabHash == null && NetworkConfig.PlayerPrefab == null))
                 {
                     return;
                 }
@@ -1594,7 +1687,7 @@ internal void HandleApproval(ulong ownerClientId, bool createPlayerObject, uint?
                         // This is not a scene object
                         writer.WriteBool(false);
 
-                        writer.WriteUInt32Packed(playerPrefabHash ?? NetworkConfig.PlayerPrefabHash);
+                        writer.WriteUInt32Packed(playerPrefabHash ?? NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash);
 
                         if (ConnectedClients[ownerClientId].PlayerObject.IncludeTransformWhenSpawning == null || ConnectedClients[ownerClientId].PlayerObject.IncludeTransformWhenSpawning(ownerClientId))
                         {

com.unity.multiplayer.mlapi/Runtime/Messaging/InternalMessageHandler.cs

@@ -81,7 +81,7 @@ public void HandleConnectionRequest(ulong clientId, Stream stream)
                 }
                 else
                 {
-                    NetworkManager.HandleApproval(clientId, NetworkManager.NetworkConfig.CreatePlayerPrefab, null, true, null, null);
+                    NetworkManager.HandleApproval(clientId, NetworkManager.NetworkConfig.PlayerPrefab != null, null, true, null, null);
                 }
             }
 #if DEVELOPMENT_BUILD || UNITY_EDITOR