update

Automatically handle removing the Rigidbody on non-authority instances when running in client-server mode.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/Components/Helpers/ComponentHelpers.cs

@@ -0,0 +1,60 @@
+#if UNIFIED_NETCODE
+using System.Reflection;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    internal static class ComponentHelpers
+    {
+        /// <summary>
+        /// Copies the properties and fields of a source component to a target component
+        /// </summary>
+        /// <typeparam name="T">Type of the component being copied.</typeparam>
+        /// <param name="target">The copy to target.</param>
+        /// <param name="source">The copy from source.</param>
+        /// <returns></returns>
+        internal static T Copy<T>(this Component target, T source) where T : Component
+        {
+            var targetType = target.GetType();
+            var sourceType = source.GetType();
+            if (targetType != sourceType)
+            {
+                Debug.LogError($"[ComponentHelpers][GetCopyOf<{targetType.Name}>][Mismatched target & source] Source: {sourceType.Name}!");
+                return null; 
+            }
+
+            var bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Default | BindingFlags.DeclaredOnly;
+
+            // Copy properties
+            foreach (var property in targetType.GetProperties(bindingFlags))
+            {
+                if (property.CanWrite)
+                {
+                    try { property.SetValue(target, property.GetValue(source, null), null); }
+                    catch { } // Handle exceptions for unsupported properties
+                }
+            }
+
+            // Copy fields
+            foreach (var field in targetType.GetFields(bindingFlags))
+            {
+                field.SetValue(target, field.GetValue(source));
+            }
+
+            return target as T;
+        }
+
+        /// <summary>
+        /// Add a component of Type T and copy the source somponent's properties and fields.
+        /// </summary>
+        /// <typeparam name="T">Component type to add.</typeparam>
+        /// <param name="gameObject">The target GameObject the component will be added to.</param>
+        /// <param name="sourceComponent">The source component (must be the same Type of T).</param>
+        /// <returns></returns>
+        internal static T AddAndCopy<T>(this GameObject gameObject, T sourceComponent) where T : Component
+        {
+            return gameObject.AddComponent<T>().Copy(sourceComponent);
+        }
+    }
+}
+#endif

com.unity.netcode.gameobjects/Runtime/Components/Helpers/ComponentHelpers.cs.meta

@@ -0,0 +1,100 @@
+#if UNIFIED_NETCODE
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Can be used to remove and add back a component that is being tracked.
+    /// Requires invoking <see cref="Initialize"/> before a component is marked to be tracked.
+    /// </summary>
+    [HideInInspector]
+    internal class ComponentMarker : MonoBehaviour
+    {
+        internal static Dictionary<NetworkManager, Dictionary<GameObject, HashSet<ComponentMarker>>> RegisteredMarkers = new Dictionary<NetworkManager, Dictionary<GameObject, HashSet<ComponentMarker>>>();
+
+        private static void AddInstance(NetworkManager networkManager, ComponentMarker instance)
+        {
+            if (!RegisteredMarkers.ContainsKey(networkManager))
+            {
+                RegisteredMarkers.Add(networkManager, new Dictionary<GameObject, HashSet<ComponentMarker>>());
+            }
+
+            if (!RegisteredMarkers[networkManager].ContainsKey(instance.gameObject))
+            {
+                RegisteredMarkers[networkManager].Add(instance.gameObject, new HashSet<ComponentMarker>());
+            }
+            RegisteredMarkers[networkManager][instance.gameObject].Add(instance);
+        }
+
+        private static void RemoveInstance(NetworkManager networkManager, ComponentMarker instance)
+        {
+            if (!RegisteredMarkers.ContainsKey(networkManager))
+            {
+                return;
+            }
+
+            if (!RegisteredMarkers[networkManager].ContainsKey(instance.gameObject))
+            {
+                return;
+            }
+            RegisteredMarkers[networkManager][instance.gameObject].Remove(instance);
+
+            if (RegisteredMarkers[networkManager][instance.gameObject].Count == 0)
+            {
+                RegisteredMarkers[networkManager].Remove(instance.gameObject);
+            }
+
+            if (RegisteredMarkers[networkManager].Count == 0)
+            {
+                RegisteredMarkers.Remove(networkManager);
+            }
+        }
+
+        internal NetworkManager NetworkManager { get; private set; }
+
+        internal Component PrefabInstance { get; private set; }
+        internal Component CurrentInstance { get; private set; }
+
+        internal void Add<T>() where T : Component
+        {
+            if (CurrentInstance)
+            {
+                return;
+            }
+            var instanceAsType = (T)PrefabInstance;
+            CurrentInstance = ComponentHelpers.AddAndCopy(gameObject, instanceAsType);
+        }
+
+        internal void Remove<T>() where T : Component
+        {
+            if (!CurrentInstance)
+            {
+                return;
+            }
+            Destroy(CurrentInstance);
+            CurrentInstance = null;
+        }
+
+        /// <summary>
+        /// Initializes this marker to track the current component instance paired with the prefab's instance of the component.
+        /// </summary>
+        /// <typeparam name="T">The type of component being marked.</typeparam>
+        /// <param name="networkManager">To help with integration testing (tracking which NetworkManager instance a registered marker belongs to.</param>
+        /// <param name="currentInstance">The current active comonent instance.</param>
+        /// <param name="prefabInstance">The prefab's instance of the component (used to replicate the setttings when adding back).</param>
+        internal void Initialize<T>(NetworkManager networkManager, T currentInstance, T prefabInstance) where T : Component
+        {
+            CurrentInstance = currentInstance;
+            PrefabInstance = prefabInstance;
+            NetworkManager = networkManager;
+            AddInstance(networkManager, this);
+        }
+
+        internal void OnDestroy()
+        {
+            RemoveInstance(NetworkManager, this);
+        }
+    }
+}
+#endif

com.unity.netcode.gameobjects/Runtime/Components/Helpers/ComponentMarker.cs

@@ -79,7 +79,6 @@ public override bool Initialize(string defaultWorldName)
             Instance = this;
             AutoConnectPort = Port;
             CreateDefaultClientServerWorlds();
-
             var initialized = base.Initialize(defaultWorldName);
             OnInitialized?.Invoke(initialized);
             return initialized;

com.unity.netcode.gameobjects/Runtime/Components/Helpers/ComponentMarker.cs.meta

@@ -1791,6 +1791,19 @@ internal void RegisterRigidbody(NetworkRigidbodyBase networkRigidbody)
                 m_UseRigidbodyForMotion = m_NetworkRigidbodyInternal.UseRigidBodyForMotion;
             }
         }
+
+#if UNIFIED_NETCODE
+        internal void UnregisterRigidbody()
+        {
+            if (m_NetworkRigidbodyInternal)
+            {
+                NetworkManager.NetworkTransformRegistration(NetworkObject, false, false);
+                NetworkManager.NetworkTransformRegistration(NetworkObject, true, true);
+                m_NetworkRigidbodyInternal = null;
+                m_UseRigidbodyForMotion = false;
+            }
+        }
+#endif
 #endif
 
 #if DEBUG_NETWORKTRANSFORM || UNITY_INCLUDE_TESTS
@@ -3594,6 +3607,8 @@ protected virtual void Awake()
             }
 
             CachedTransform = transform;
+
+
         }
 
         internal override void InternalOnNetworkPreSpawn(ref NetworkManager networkManager)
@@ -3606,6 +3621,12 @@ internal override void InternalOnNetworkPreSpawn(ref NetworkManager networkManag
         /// <inheritdoc/>
         public override void OnNetworkSpawn()
         {
+#if UNIFIED_NETCODE
+            if (NetworkObject.HasGhost)
+            {
+                return;
+            }
+#endif
             m_ParentedChildren.Clear();
             m_CachedNetworkManager = NetworkManager;
 
@@ -3700,6 +3721,13 @@ private void ResetInterpolatedStateToCurrentAuthoritativeState()
         /// <param name="isOwnershipChange"></param>
         private void InternalInitialization(bool isOwnershipChange = false)
         {
+
+#if UNIFIED_NETCODE
+            if (NetworkObject.HasGhost)
+            {
+                return;
+            }
+#endif
             if (!IsSpawned)
             {
                 return;
@@ -3808,7 +3836,7 @@ protected void Initialize()
         {
             InternalInitialization();
         }
-        #endregion
+#endregion
 
         #region PARENTING AND OWNERSHIP
         /// <inheritdoc/>

com.unity.netcode.gameobjects/Runtime/Components/Helpers/NetworkObjectBridge.cs

@@ -47,6 +47,11 @@ public class NetworkPrefabs
         [NonSerialized]
         private List<NetworkPrefab> m_Prefabs = new List<NetworkPrefab>();
 
+#if UNIFIED_NETCODE
+        [NonSerialized]
+        internal Dictionary<uint, NetworkPrefab> PrefabTable = new Dictionary<uint, NetworkPrefab>();
+#endif
+
         [NonSerialized]
         private List<NetworkPrefab> m_RuntimeAddedPrefabs = new List<NetworkPrefab>();
 
@@ -57,12 +62,21 @@ private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
                 // Don't add this to m_RuntimeAddedPrefabs
                 // This prefab is now in the PrefabList, so if we shutdown and initialize again, we'll pick it up from there.
                 m_Prefabs.Add(networkPrefab);
+#if UNIFIED_NETCODE
+                if (!PrefabTable.ContainsKey(networkPrefab.SourcePrefabGlobalObjectIdHash))
+                {
+                    PrefabTable.Add(networkPrefab.SourcePrefabGlobalObjectIdHash, networkPrefab);
+                }
+#endif
             }
         }
 
         private void RemoveTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
         {
             m_Prefabs.Remove(networkPrefab);
+#if UNIFIED_NETCODE
+            PrefabTable.Remove(networkPrefab.SourcePrefabGlobalObjectIdHash);
+#endif
         }
 
         /// <summary>
@@ -95,6 +109,9 @@ public void Initialize(bool warnInvalid = true)
         {
             m_Prefabs.Clear();
             NetworkPrefabsLists.RemoveAll(x => x == null);
+#if UNIFIED_NETCODE
+            PrefabTable.Clear();
+#endif
             foreach (var list in NetworkPrefabsLists)
             {
                 list.OnAdd += AddTriggeredByNetworkPrefabList;
@@ -127,10 +144,22 @@ public void Initialize(bool warnInvalid = true)
                 if (AddPrefabRegistration(networkPrefab))
                 {
                     m_Prefabs.Add(networkPrefab);
+#if UNIFIED_NETCODE
+                    if (!PrefabTable.ContainsKey(networkPrefab.SourcePrefabGlobalObjectIdHash))
+                    {
+                        PrefabTable.Add(networkPrefab.SourcePrefabGlobalObjectIdHash, networkPrefab);
+                    }
+#endif
                 }
                 else
                 {
                     removeList?.Add(networkPrefab);
+#if UNIFIED_NETCODE
+                    if (PrefabTable.ContainsKey(networkPrefab.SourcePrefabGlobalObjectIdHash))
+                    {
+                        PrefabTable.Remove(networkPrefab.SourcePrefabGlobalObjectIdHash);
+                    }
+#endif
                 }
             }
 
@@ -139,10 +168,22 @@ public void Initialize(bool warnInvalid = true)
                 if (AddPrefabRegistration(networkPrefab))
                 {
                     m_Prefabs.Add(networkPrefab);
+#if UNIFIED_NETCODE
+                    if (!PrefabTable.ContainsKey(networkPrefab.SourcePrefabGlobalObjectIdHash))
+                    {
+                        PrefabTable.Add(networkPrefab.SourcePrefabGlobalObjectIdHash, networkPrefab);
+                    }
+#endif
                 }
                 else
                 {
                     removeList?.Add(networkPrefab);
+#if UNIFIED_NETCODE
+                    if (PrefabTable.ContainsKey(networkPrefab.SourcePrefabGlobalObjectIdHash))
+                    {
+                        PrefabTable.Remove(networkPrefab.SourcePrefabGlobalObjectIdHash);
+                    }
+#endif
                 }
             }
 
@@ -175,6 +216,12 @@ public bool Add(NetworkPrefab networkPrefab)
             {
                 m_Prefabs.Add(networkPrefab);
                 m_RuntimeAddedPrefabs.Add(networkPrefab);
+#if UNIFIED_NETCODE
+                if (!PrefabTable.ContainsKey(networkPrefab.SourcePrefabGlobalObjectIdHash))
+                {
+                    PrefabTable.Add(networkPrefab.SourcePrefabGlobalObjectIdHash, networkPrefab);
+                }
+#endif
                 return true;
             }
 
@@ -202,6 +249,12 @@ public void Remove(NetworkPrefab prefab)
             m_RuntimeAddedPrefabs.Remove(prefab);
             OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash);
             NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash);
+#if UNIFIED_NETCODE
+            if (PrefabTable.ContainsKey(prefab.SourcePrefabGlobalObjectIdHash))
+            {
+                PrefabTable.Remove(prefab.SourcePrefabGlobalObjectIdHash);
+            }
+#endif
         }
 
         /// <summary>

com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs

@@ -1400,7 +1400,6 @@ public bool StartServer()
                     return false;
                 }
                 NetCodeConfig.Global.HostWorldModeSelection = NetCodeConfig.HostWorldMode.SingleWorld;
-                DefaultWorldInitialization.Initialize("Default World", false);
                 StartCoroutine(WaitForHybridPrefabRegistration(StartType.Server));
                 return true;
             }
@@ -1475,7 +1474,6 @@ public bool StartClient()
                     return false;
                 }
 
-                DefaultWorldInitialization.Initialize("Default World", false);
                 StartCoroutine(WaitForHybridPrefabRegistration(StartType.Client));
                 // TODO-UNIFIED: Need a way to signal everything completed.
                 return true;
@@ -1549,8 +1547,6 @@ public bool StartHost()
                     ShutdownInternal();
                     return false;
                 }
-
-                DefaultWorldInitialization.Initialize("Default World", false);
                 StartCoroutine(WaitForHybridPrefabRegistration(StartType.Host));
                 // TODO-UNIFIED: Need a way to signal everything completed.
                 return true;