update

Several improvements on the attach and detach processing.
Added the ability to tie ComponentControllers to AttachableBehaviours in order to auto-notify when something is attaching and detaching.
Several adjustments to fix the issue with ungraceful disconnects and re-synchronizing attachables.
Added forced change based on flags applied, things like when an AttachableNode is despawning, changing ownership, or being destroyed then local instances, whether authority or not, will all force the attach or detach  state.
Added an internal virtual destroy method on NetworkBehaviour to allow for helper components to assure on destroy script is invoked.

Author: NoelStephensUnity

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

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
@@ -25,6 +27,49 @@ namespace Unity.Netcode.Components
     /// </remarks>
     public class AttachableBehaviour : NetworkBehaviour
     {
+        [Serializable]
+        internal class ComponentControllerEntry
+        {
+            // Ignoring the naming convention in order to auto-assign element names
+#pragma warning disable IDE1006
+            /// <summary>
+            /// Used for naming each element entry.
+            /// </summary>
+            [HideInInspector]
+            public string name;
+#pragma warning restore IDE1006
+
+
+#if UNITY_EDITOR
+
+            internal void OnValidate()
+            {
+                if (!HasInitialized)
+                {
+                    AutoTrigger = TriggerTypes.OnAttach | TriggerTypes.OnDetach;
+                    HasInitialized = true;
+                }
+                name = ComponentController != null ? ComponentController.GetComponentNameFormatted(ComponentController) : "Component Controller";
+            }
+#endif
+
+            [Flags]
+            public enum TriggerTypes : byte
+            {
+                Nothing,
+                OnAttach,
+                OnDetach,
+            }
+
+            public TriggerTypes AutoTrigger;
+            public bool EnableOnAttach = true;
+            public ComponentController ComponentController;
+
+            [HideInInspector]
+            [SerializeField]
+            internal bool HasInitialized;
+        }
+
 #if UNITY_EDITOR
         /// <inheritdoc/>
         /// <remarks>
@@ -45,6 +90,15 @@ protected virtual void OnValidate()
                 // Wait for the next editor update to create a nested child and add the AttachableBehaviour
                 EditorApplication.update += CreatedNestedChild;
             }
+
+            foreach (var componentController in ComponentControllers)
+            {
+                if (componentController == null)
+                {
+                    continue;
+                }
+                componentController.OnValidate();
+            }
         }
 
         private void CreatedNestedChild()
@@ -57,6 +111,34 @@ private void CreatedNestedChild()
             DestroyImmediate(this);
         }
 #endif
+        /// <summary>
+        /// Flags to determine if the <see cref="AttachableBehaviour"/> will automatically detatch.
+        /// </summary>
+        [Flags]
+        public enum AutoDetatchTypes
+        {
+            None,
+            /// <summary>
+            /// Detatch on ownership change.
+            /// </summary>
+            OnOwnershipChange,
+            /// <summary>
+            /// Detatch on despawn.
+            /// </summary>
+            OnDespawn,
+            /// <summary>
+            /// Detatch on destroy.
+            /// </summary>
+            OnAttachNodeDestroy,
+        }
+
+        /// <summary>
+        /// Determines if this <see cref="AttachableBehaviour"/> will automatically detatch on all instances if it has one of the <see cref="AutoDetatchTypes"/> flags.
+        /// </summary>
+        public AutoDetatchTypes AutoDetach = AutoDetatchTypes.OnDespawn | AutoDetatchTypes.OnOwnershipChange | AutoDetatchTypes.OnAttachNodeDestroy;
+
+        [SerializeField]
+        internal List<ComponentControllerEntry> ComponentControllers;
 
         /// <summary>
         /// Invoked when the <see cref="AttachState"/> of this instance has changed.
@@ -115,6 +197,7 @@ public enum AttachState
         /// If attached, attaching, or detaching this will be the <see cref="AttachableNode"/> this <see cref="AttachableBehaviour"/> instance is attached to.
         /// </summary>
         protected AttachableNode m_AttachableNode { get; private set; }
+        internal AttachableNode AttachableNode => m_AttachableNode;
 
         private NetworkBehaviourReference m_AttachedNodeReference = new NetworkBehaviourReference(null);
         private Vector3 m_OriginalLocalPosition;
@@ -125,17 +208,20 @@ protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
         {
             // Example of how to synchronize late joining clients when using an RPC to update
             // a local property's state.
-            if (serializer.IsWriter)
-            {
-                serializer.SerializeValue(ref m_AttachedNodeReference);
-            }
-            else
-            {
-                serializer.SerializeValue(ref m_AttachedNodeReference);
-            }
+            serializer.SerializeValue(ref m_AttachedNodeReference);
             base.OnSynchronize(ref serializer);
         }
 
+        /// <summary>
+        /// Override this method in place of Awake. This method is invoked during Awake.
+        /// </summary>
+        /// <remarks>
+        /// The <see cref="AttachableBehaviour"/>'s Awake method is protected to assure it initializes itself at this point in time.
+        /// </remarks>
+        protected virtual void OnAwake()
+        {
+        }
+
         /// <summary>
         /// If you create a custom <see cref="AttachableBehaviour"/> and override this method, you must invoke
         /// this base instance of <see cref="Awake"/>.
@@ -147,6 +233,7 @@ protected virtual void Awake()
             m_OriginalLocalRotation = transform.localRotation;
             m_AttachState = AttachState.Detached;
             m_AttachableNode = null;
+            OnAwake();
         }
 
         /// <inheritdoc/>
@@ -162,28 +249,52 @@ protected override void OnNetworkSessionSynchronized()
             base.OnNetworkSessionSynchronized();
         }
 
-        /// <inheritdoc/>
-        public override void OnNetworkDespawn()
+        internal void ForceDetatch()
         {
+            if (m_AttachState == AttachState.Detached || m_AttachState == AttachState.Detaching)
+            {
+                return;
+            }
+
+            ForceComponentChange(false, true);
             InternalDetach();
             if (NetworkManager && !NetworkManager.ShutdownInProgress)
             {
                 // Notify of the changed attached state
                 UpdateAttachState(m_AttachState, m_AttachableNode);
             }
             m_AttachedNodeReference = new NetworkBehaviourReference(null);
+        }
+
+        /// <inheritdoc/>
+        public override void OnNetworkPreDespawn()
+        {
+            if (AutoDetach.HasFlag(AutoDetatchTypes.OnDespawn))
+            {
+                ForceDetatch();
+            }
             base.OnNetworkDespawn();
         }
 
         private void UpdateAttachedState()
         {
             var attachableNode = (AttachableNode)null;
-            var shouldParent = m_AttachedNodeReference.TryGet(out attachableNode, NetworkManager);
-            var preState = shouldParent ? AttachState.Attaching : AttachState.Detaching;
-            var preNode = shouldParent ? attachableNode : m_AttachableNode;
-            shouldParent = shouldParent && attachableNode != null;
+            var isAttaching = m_AttachedNodeReference.TryGet(out attachableNode, NetworkManager);
+            var preState = isAttaching ? AttachState.Attaching : AttachState.Detaching;
+
+            // Exit early if we are already in the correct attached state and the incoming
+            // AttachableNode reference is the same as the local AttachableNode property.
+            if (attachableNode == m_AttachableNode &&
+                ((isAttaching && m_AttachState == AttachState.Attached) ||
+                (!isAttaching && m_AttachState == AttachState.Detached)))
+            {
+                return;
+            }
+
+            var preNode = isAttaching ? attachableNode : m_AttachableNode;
+            isAttaching = isAttaching && attachableNode != null;
 
-            if (shouldParent && m_AttachableNode != null && m_AttachState == AttachState.Attached)
+            if (isAttaching && m_AttachableNode != null && m_AttachState == AttachState.Attached)
             {
                 // If we are attached to some other AttachableNode, then detach from that before attaching to a new one.
                 if (m_AttachableNode != attachableNode)
@@ -201,7 +312,8 @@ private void UpdateAttachedState()
             // Change the state to attaching or detaching
             UpdateAttachState(preState, preNode);
 
-            if (shouldParent)
+            ForceComponentChange(isAttaching, false);
+            if (isAttaching)
             {
                 InternalAttach(attachableNode);
             }
@@ -215,7 +327,7 @@ private void UpdateAttachedState()
 
             // When detaching, we want to make our final action
             // the invocation of the AttachableNode's Detach method.
-            if (!shouldParent && m_AttachableNode)
+            if (!isAttaching && m_AttachableNode)
             {
                 m_AttachableNode.Detach(this);
                 m_AttachableNode = null;
@@ -257,6 +369,29 @@ private void UpdateAttachState(AttachState attachState, AttachableNode attachabl
             }
         }
 
+        /// <inheritdoc/>
+        protected override void OnOwnershipChanged(ulong previous, ulong current)
+        {
+            if (AutoDetach.HasFlag(AutoDetatchTypes.OnOwnershipChange))
+            {
+                ForceDetatch();
+            }
+            base.OnOwnershipChanged(previous, current);
+        }
+
+        internal void ForceComponentChange(bool isAttaching, bool forcedChange)
+        {
+            var triggerType = isAttaching ? ComponentControllerEntry.TriggerTypes.OnAttach : ComponentControllerEntry.TriggerTypes.OnDetach;
+
+            foreach (var componentControllerEntry in ComponentControllers)
+            {
+                if (componentControllerEntry.AutoTrigger.HasFlag(triggerType))
+                {
+                    componentControllerEntry.ComponentController.ForceChangeEnabled(componentControllerEntry.EnableOnAttach ? isAttaching : !isAttaching, forcedChange);
+                }
+            }
+        }
+
         /// <summary>
         /// Internal attach method that just handles changing state, parenting, and sending the <see cref="AttachableNode"/> a
         /// notification that an <see cref="AttachableBehaviour"/> has attached.
@@ -349,23 +484,23 @@ public void Detach()
                 return;
             }
 
-            if (m_AttachState != AttachState.Attached || m_AttachableNode == null)
+            if (m_AttachState == AttachState.Detached || m_AttachState == AttachState.Detaching || m_AttachableNode == null)
             {
                 // Check for the unlikely scenario that an instance has mismatch between the state and assigned attachable node.
-                if (!m_AttachableNode && m_AttachState == AttachState.Attached)
+                if (!m_AttachableNode)
                 {
                     NetworkLog.LogError($"[{name}][Detach] Invalid state detected! {name}'s state is still {m_AttachState} but has no {nameof(AttachableNode)} assigned!");
                 }
 
                 // Developer only notification for the most likely scenario where this method is invoked but the instance is not attached to anything.
-                if (NetworkManager && NetworkManager.LogLevel <= LogLevel.Developer)
+                if (!m_AttachableNode && NetworkManager && NetworkManager.LogLevel <= LogLevel.Developer)
                 {
                     NetworkLog.LogWarning($"[{name}][Detach] Cannot detach! {name} is not attached to anything!");
                 }
 
                 // If we have the attachable node set and we are not in the middle of detaching, then log an error and note
                 // this could potentially occur if inoked more than once for the same instance in the same frame.
-                if (m_AttachableNode && m_AttachState != AttachState.Detaching)
+                if (m_AttachableNode)
                 {
                     NetworkLog.LogError($"[{name}][Detach] Invalid state detected! {name} is still referencing {nameof(AttachableNode)} {m_AttachableNode.name}! Could {nameof(Detach)} be getting invoked more than once for the same instance?");
                 }
@@ -407,5 +542,18 @@ private void UpdateAttachStateRpc(NetworkBehaviourReference attachedNodeReferenc
         {
             ChangeReference(attachedNodeReference);
         }
+
+        /// <summary>
+        /// Notification that the <see cref="AttachableNode"/> is being destroyed
+        /// </summary>
+        internal void OnAttachNodeDestroy()
+        {
+            // If this instance should force a detatch on destroy
+            if (AutoDetach.HasFlag(AutoDetatchTypes.OnAttachNodeDestroy))
+            {
+                // Force a detatch
+                ForceDetatch();
+            }
+        }
     }
 }

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

@@ -29,6 +29,35 @@ public class AttachableNode : NetworkBehaviour
     /// </summary>
     protected readonly List<AttachableBehaviour> m_AttachedBehaviours = new List<AttachableBehaviour>();
 
+    /// <inheritdoc/>
+    protected override void OnNetworkPreSpawn(ref NetworkManager networkManager)
+    {
+        m_AttachedBehaviours.Clear();
+        base.OnNetworkPreSpawn(ref networkManager);
+    }
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// When the ownership of an <see cref="AttachableNode"/> changes, it will find all currently attached <see cref="AttachableBehaviour"/> components
+    /// that are registered as being attached to this instance.
+    /// </remarks>
+    protected override void OnOwnershipChanged(ulong previous, ulong current)
+    {
+        if (current == NetworkManager.LocalClientId)
+        {
+            m_AttachedBehaviours.Clear();
+            var attachables = NetworkObject.transform.GetComponentsInChildren<AttachableBehaviour>();
+            foreach (var attachable in attachables)
+            {
+                if (attachable.AttachableNode == this)
+                {
+                    m_AttachedBehaviours.Add(attachable);
+                }
+            }
+        }
+        base.OnOwnershipChanged(previous, current);
+    }
+
     /// <inheritdoc/>
     /// <remarks>
     /// If the <see cref="NetworkObject"/> this <see cref="AttachableNode"/> belongs to is despawned,
@@ -46,11 +75,15 @@ public override void OnNetworkPreDespawn()
         base.OnNetworkPreDespawn();
     }
 
-    /// <inheritdoc/>
-    public override void OnNetworkDespawn()
+    internal override void InternalOnDestroy()
     {
+        // Notify any attached behaviours that this node is being destroyed.
+        for (int i = m_AttachedBehaviours.Count - 1; i >= 0; i--)
+        {
+            m_AttachedBehaviours[i]?.OnAttachNodeDestroy();
+        }
         m_AttachedBehaviours.Clear();
-        base.OnNetworkDespawn();
+        base.InternalOnDestroy();
     }
 
     /// <summary>
@@ -69,7 +102,6 @@ internal void Attach(AttachableBehaviour attachableBehaviour)
             NetworkLog.LogError($"[{nameof(AttachableNode)}][{name}][Attach] {nameof(AttachableBehaviour)} {attachableBehaviour.name} is already attached!");
             return;
         }
-
         m_AttachedBehaviours.Add(attachableBehaviour);
         OnAttached(attachableBehaviour);
     }
@@ -90,7 +122,6 @@ internal void Detach(AttachableBehaviour attachableBehaviour)
             NetworkLog.LogError($"[{nameof(AttachableNode)}][{name}][Detach] {nameof(AttachableBehaviour)} {attachableBehaviour.name} is not attached!");
             return;
         }
-
         m_AttachedBehaviours.Remove(attachableBehaviour);
         OnDetached(attachableBehaviour);
     }