Addressable scene loader

com.unity.netcode.gameobjects/Runtime/Configuration/NetworkConfig.cs

@@ -342,8 +342,8 @@ public ulong GetConfig(bool cache = true)
                 {
                     var sortedDictionary = Prefabs.NetworkPrefabOverrideLinks.OrderBy(x => x.Key);
                     foreach (var sortedEntry in sortedDictionary)
-
                     {
+                        Debug.Log($"[NetworkConfig] - GetConfig - [{sortedEntry.Key}={sortedEntry.Value.Prefab}]");
                         writer.WriteValueSafe(sortedEntry.Key);
                     }
                 }

com.unity.netcode.gameobjects/Runtime/Configuration/NetworkPrefabs.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using TrollKing.Core;
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -13,6 +14,8 @@ namespace Unity.Netcode
     [Serializable]
     public class NetworkPrefabs
     {
+        private static readonly NetworkLogScope k_Log = new NetworkLogScope(nameof(NetworkPrefabs));
+
         /// <summary>
         /// Edit-time scripted object containing a list of NetworkPrefabs.
         /// </summary>
@@ -52,6 +55,7 @@ public class NetworkPrefabs
 
         private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
         {
+            k_Log.Debug(() => $"NetworkPrefabs AddTriggeredByNetworkPrefabList [networkPrefab={networkPrefab}]");
             if (AddPrefabRegistration(networkPrefab))
             {
                 // Don't add this to m_RuntimeAddedPrefabs
@@ -62,6 +66,7 @@ private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
 
         private void RemoveTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
         {
+            k_Log.Debug(() => $"NetworkPrefabs RemoveTriggeredByNetworkPrefabList [networkPrefab={networkPrefab}]");
             m_Prefabs.Remove(networkPrefab);
         }
 
@@ -93,6 +98,7 @@ internal void Shutdown()
         /// <param name="warnInvalid">When true, logs warnings about invalid prefabs that are removed during initialization</param>
         public void Initialize(bool warnInvalid = true)
         {
+            k_Log.Debug(() => $"NetworkPrefabs Initialize [warnInvalid={warnInvalid}]");
             m_Prefabs.Clear();
             foreach (var list in NetworkPrefabsLists)
             {
@@ -111,6 +117,8 @@ public void Initialize(bool warnInvalid = true)
                 {
                     foreach (var networkPrefab in list.PrefabList)
                     {
+                        var netObj = networkPrefab.Prefab.GetComponent<NetworkObject>();
+                        k_Log.Debug(() => $"NetworkPrefabs Add networkPrefab [networkPrefab={networkPrefab}] [prefab={networkPrefab.Prefab}] [prefabHash={netObj.PrefabIdHash}] [globalHash={netObj.GlobalObjectIdHash}]");
                         prefabs.Add(networkPrefab);
                     }
                 }
@@ -288,9 +296,19 @@ private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
             {
                 return false;
             }
+
+            var netObj = networkPrefab.Prefab.GetComponent<NetworkObject>();
+            if (netObj)
+            {
+                k_Log.Debug(() => $"NetworkPrefabs AddPrefabRegistration [prefab={networkPrefab.Prefab.name}] [networkPrefab={networkPrefab}] [hash={netObj.PrefabIdHash}] [global={netObj.GlobalObjectIdHash}]");
+            }
+
+
+
             // Safeguard validation check since this method is called from outside of NetworkConfig and we can't control what's passed in.
             if (!networkPrefab.Validate())
             {
+                Debug.LogError($"NetworkPrefabs AddPrefabRegistration INVALID [networkPrefab={networkPrefab}]");
                 return false;
             }
 
@@ -303,14 +321,15 @@ private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
                 var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
 
                 // This should never happen, but in the case it somehow does log an error and remove the duplicate entry
-                Debug.LogError($"{nameof(NetworkPrefab)} ({networkObject.name}) has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} source entry value of: {source}!");
+                Debug.LogError($"NetworkPrefabs {nameof(NetworkPrefab)} ({networkObject.name}) has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} source entry value of: {source}!");
                 return false;
             }
 
             // If we don't have an override configured, registration is simple!
             if (networkPrefab.Override == NetworkPrefabOverride.None)
             {
                 NetworkPrefabOverrideLinks.Add(source, networkPrefab);
+                k_Log.Debug(() => $"NetworkPrefabs AddPrefabRegistration NetworkPrefabOverrideLinks [prefab={networkPrefab.Prefab.name}] [source={source}] [networkPrefab={networkPrefab}]");
                 return true;
             }
 

com.unity.netcode.gameobjects/Runtime/Core/NetworkLogScope.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace TrollKing.Core
+{
+    public enum NetworkLoggingLevel
+    {
+        Debug,
+        Info,
+        Warn,
+        Error,
+        Exception,
+        None
+    }
+
+    public class NetworkLogScope
+    {
+        private readonly string m_LoggerName;
+        private readonly NetworkLoggingLevel m_Level = NetworkLoggingLevel.Info;
+
+        public NetworkLogScope(string logName, NetworkLoggingLevel logLevel = NetworkLoggingLevel.Info)
+        {
+            m_LoggerName = logName;
+            m_Level = logLevel;
+        }
+
+        public NetworkLoggingLevel GetLevel()
+        {
+            return m_Level;
+        }
+
+        public void Log(Func<string> stringProvider, NetworkLoggingLevel logLevel = NetworkLoggingLevel.Info)
+        {
+            if (logLevel >= m_Level)
+            {
+                string logString = stringProvider.Invoke();
+                DateTime time = DateTime.Now;
+                var shortTime = time.ToString("T");
+
+                switch (logLevel)
+                {
+                    case NetworkLoggingLevel.Debug:
+                        UnityEngine.Debug.Log($"[{shortTime}][DEBUG][{m_LoggerName}] {logString}");
+                        break;
+                    case NetworkLoggingLevel.Info:
+                        UnityEngine.Debug.Log($"[{shortTime}][INFO][{m_LoggerName}] {logString}");
+                        break;
+                    case NetworkLoggingLevel.Warn:
+                        UnityEngine.Debug.LogWarning($"[{shortTime}][WARN][{m_LoggerName}] {logString}");
+                        break;
+                    case NetworkLoggingLevel.Error:
+                        UnityEngine.Debug.LogError($"[{shortTime}][ERROR][{m_LoggerName}] {logString}");
+                        break;
+                    case NetworkLoggingLevel.Exception:
+                        UnityEngine.Debug.LogError($"[{shortTime}][EXCEPTION][{m_LoggerName}] {logString}");
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(logLevel), logLevel, null);
+                }
+            }
+        }
+
+        public void Debug(Func<string> logString)
+        {
+            Log(logString, NetworkLoggingLevel.Debug);
+        }
+
+        public void Info(Func<string> logString)
+        {
+            Log(logString, NetworkLoggingLevel.Info);
+        }
+
+        public void Warning(Func<string> logString)
+        {
+            Log(logString, NetworkLoggingLevel.Warn);
+        }
+
+        public void LogWarning(Func<string> logString)
+        {
+            Log(logString, NetworkLoggingLevel.Warn);
+        }
+
+        public void Error(Func<string> logString)
+        {
+            Log(logString, NetworkLoggingLevel.Error);
+        }
+
+        public void LogError(Func<string> logString)
+        {
+            Log(logString, NetworkLoggingLevel.Error);
+        }
+
+        public void LogException(Exception e)
+        {
+            UnityEngine.Debug.LogException(e);
+        }
+
+        public void LogError(Exception e)
+        {
+            UnityEngine.Debug.LogError($"[{m_LoggerName}] {e}");
+            UnityEngine.Debug.LogException(e);
+        }
+    }
+
+    public static class NetworkGameObjectUtility
+    {
+        private static readonly NetworkLogScope Log = new NetworkLogScope(nameof(NetworkGameObjectUtility));
+
+        private static string NetworkGetScenePathRecursive(Transform go, string path)
+        {
+            if (go.parent == null)
+            {
+                return $"{go.gameObject.scene.name}:{go.name}:{path}";
+            }
+
+            return NetworkGetScenePathRecursive(go.parent, $"{go.name}:{path}");
+        }
+
+        // Depth first, we are going all the way down each leg
+        public static void NetworkGetAllHierarchyChildrenRecursive(this GameObject source, ref Queue<GameObject> queue)
+        {
+            if (source == null)
+            {
+                return;
+            }
+
+            int children = source.transform.childCount;
+            for (int i = 0; i < children; i++)
+            {
+                var child = source.transform.GetChild(i);
+                var go = child.gameObject;
+                Log.Debug(() => $"AddingHierarchyChild {go}");
+                queue.Enqueue(go);
+                NetworkGetAllHierarchyChildrenRecursive(go, ref queue);
+            }
+        }
+
+        public static Queue<GameObject> NetworkGetAllHierarchyChildren(this GameObject root)
+        {
+            var retVal = new Queue<GameObject>();
+            if (root == null)
+            {
+                return retVal;
+            }
+            Log.Debug(() => $"AddingHierarchyParent {root}");
+            retVal.Enqueue(root);
+            root.NetworkGetAllHierarchyChildrenRecursive(ref retVal);
+            return retVal;
+        }
+
+        public static string NetworkGetScenePath(this GameObject go)
+        {
+            return NetworkGetScenePath(go.transform);
+        }
+
+        public static string NetworkGetScenePath(this Transform go)
+        {
+            return NetworkGetScenePathRecursive(go, "");
+        }
+
+        public static string NetworkGetSceneName(this GameObject go)
+        {
+            return go.scene.name;
+        }
+
+        public static bool NetworkTryGetComponentInParent<T>(this GameObject go, out T comp)
+        {
+            var parent = go.transform;
+            while (parent != null && parent.parent != parent)
+            {
+                if (parent.TryGetComponent(out comp))
+                {
+                    return true;
+                }
+                parent = parent.parent;
+            }
+
+            comp = default;
+            return false;
+        }
+    }
+}

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -1090,7 +1090,7 @@ public int MaximumFragmentedMessageSize
             get => MessageManager.FragmentedMessageMaxSize;
         }
 
-        internal void Initialize(bool server)
+        public virtual void Initialize(bool server)
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             if (!DisableNotOptimizedSerializedType)

com.unity.netcode.gameobjects/Runtime/Core/NetworkUpdateLoop.cs

@@ -61,6 +61,7 @@ public enum NetworkUpdateStage : byte
         PostScriptLateUpdate = 8,
         /// <summary>
         /// Updated after the Monobehaviour.LateUpdate for all components is invoked
+        /// and all rendering is complete
         /// </summary>
         PostLateUpdate = 7
     }
@@ -74,12 +75,24 @@ public static class NetworkUpdateLoop
         private static Dictionary<NetworkUpdateStage, INetworkUpdateSystem[]> s_UpdateSystem_Arrays;
         private const int k_UpdateSystem_InitialArrayCapacity = 1024;
 
+        private static NetworkUpdateStage[] _CACHED_ENUM = null;
+
+        public static NetworkUpdateStage[] GetNetworkUpdateStageEnumValues()
+        {
+            if (_CACHED_ENUM == null)
+            {
+                _CACHED_ENUM = (NetworkUpdateStage[])Enum.GetValues(typeof(NetworkUpdateStage));
+            }
+
+            return _CACHED_ENUM;
+        }
+
         static NetworkUpdateLoop()
         {
             s_UpdateSystem_Sets = new Dictionary<NetworkUpdateStage, HashSet<INetworkUpdateSystem>>();
             s_UpdateSystem_Arrays = new Dictionary<NetworkUpdateStage, INetworkUpdateSystem[]>();
 
-            foreach (NetworkUpdateStage updateStage in Enum.GetValues(typeof(NetworkUpdateStage)))
+            foreach (NetworkUpdateStage updateStage in GetNetworkUpdateStageEnumValues())
             {
                 s_UpdateSystem_Sets.Add(updateStage, new HashSet<INetworkUpdateSystem>());
                 s_UpdateSystem_Arrays.Add(updateStage, new INetworkUpdateSystem[k_UpdateSystem_InitialArrayCapacity]);
@@ -92,7 +105,7 @@ static NetworkUpdateLoop()
         /// <param name="updateSystem">The <see cref="INetworkUpdateSystem"/> implementation to register for all network updates</param>
         public static void RegisterAllNetworkUpdates(this INetworkUpdateSystem updateSystem)
         {
-            foreach (NetworkUpdateStage updateStage in Enum.GetValues(typeof(NetworkUpdateStage)))
+            foreach (NetworkUpdateStage updateStage in GetNetworkUpdateStageEnumValues())
             {
                 RegisterNetworkUpdate(updateSystem, updateStage);
             }
@@ -136,7 +149,7 @@ public static void RegisterNetworkUpdate(this INetworkUpdateSystem updateSystem,
         /// <param name="updateSystem">The <see cref="INetworkUpdateSystem"/> implementation to deregister from all network updates</param>
         public static void UnregisterAllNetworkUpdates(this INetworkUpdateSystem updateSystem)
         {
-            foreach (NetworkUpdateStage updateStage in Enum.GetValues(typeof(NetworkUpdateStage)))
+            foreach (NetworkUpdateStage updateStage in GetNetworkUpdateStageEnumValues())
             {
                 UnregisterNetworkUpdate(updateSystem, updateStage);
             }

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/ConnectionRequestMessage.cs

@@ -143,7 +143,7 @@ public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                     {
-                        NetworkLog.LogWarning($"{nameof(NetworkConfig)} mismatch. The configuration between the server and client does not match");
+                        NetworkLog.LogWarning($"{nameof(NetworkConfig)} mismatch. IncomingHash=[{ConfigHash}] OurHash=[{networkManager.NetworkConfig.GetConfig()}] The configuration between the server and client does not match");
                     }
 
                     networkManager.DisconnectClient(context.SenderId);

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -188,6 +188,7 @@ public void Serialize(FastBufferWriter writer, int targetVersion)
 
                 var startingSize = writer.Length;
                 var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
+
                 var shouldWrite = networkVariable.IsDirty() &&
                     networkVariable.CanClientRead(TargetClientId) &&
                     (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId)) &&

com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs

@@ -580,7 +580,8 @@ public void RemoveAt(int index)
             // check write permissions
             if (!CanClientWrite(m_NetworkManager.LocalClientId))
             {
-                throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
+                LogWritePermissionError();
+                return;
             }
 
             var value = m_List[index];