update

Work in progress adjustments for usability under various scenarios.

Author: NoelStephensUnity

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

@@ -18,7 +18,10 @@ namespace Unity.Netcode.Components
     /// The term "attach" is used in place of parenting in order to distinguish between <see cref="NetworkObject"/> parenting and
     /// <see cref="AttachableBehaviour"/> parenting ("attaching" and "detaching").<br />
     /// This component can be used along with one or more <see cref="ComponentController"/> in order to enable or disable different components depending
-    /// upon the <see cref="AttachableBehaviour"/> instance's current state.
+    /// upon the <see cref="AttachableBehaviour"/> instance's current state.<br />
+    /// <see cref="AttachableNode"/> invocation order:
+    /// - When attaching, the <see cref="AttachableNode"/>'s <see cref="AttachableNode.OnAttached(AttachableBehaviour)"/> is invoked just before the <see cref="OnAttachStateChanged"/> is invoked with the <see cref="AttachState.Attached"/> state.<br />
+    /// - When detaching, the <see cref="AttachableNode"/>'s <see cref="AttachableNode.OnDetached(AttachableBehaviour)"/> is invoked right after the <see cref="OnAttachStateChanged"/> is invoked with the <see cref="AttachState.Detached"/> notification.<br />
     /// </remarks>
     public class AttachableBehaviour : NetworkBehaviour
     {
@@ -191,9 +194,11 @@ private void UpdateAttachedState()
                 {
                     // Run through the same process without being triggerd by a NetVar update.
                     UpdateAttachState(AttachState.Detaching, m_AttachableNode);
+                    InternalDetach();
+                    UpdateAttachState(AttachState.Detached, m_AttachableNode);
+
                     m_AttachableNode.Detach(this);
-                    transform.parent = null;
-                    UpdateAttachState(AttachState.Detached, null);
+                    m_AttachableNode = null;
                 }
             }
 
@@ -211,6 +216,14 @@ private void UpdateAttachedState()
 
             // Notify of the changed attached state
             UpdateAttachState(m_AttachState, m_AttachableNode);
+
+            // When detatching, we want to make our final action
+            // the invocation of the AttachableNode's Detatch method.
+            if (!shouldParent && m_AttachableNode)
+            {
+                m_AttachableNode.Detach(this);
+                m_AttachableNode = null;
+            }
         }
 
         /// <summary>
@@ -309,8 +322,6 @@ internal void InternalDetach()
         {
             if (m_AttachableNode)
             {
-                m_AttachableNode.Detach(this);
-                m_AttachableNode = null;
                 if (m_DefaultParent)
                 {
                     // Set the original parent and origianl local position and rotation

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

@@ -14,6 +14,11 @@
 /// </remarks>
 public class AttachableNode : NetworkBehaviour
 {
+    /// <summary>
+    /// Returns true if the <see cref="AttachableNode"/> instance has one or more attached <see cref="AttachableBehaviour"/> components.
+    /// </summary>
+    public bool HasAttachments => m_AttachedBehaviours.Count > 0;
+
     /// <summary>
     /// A <see cref="List{T}"/> of the currently attached <see cref="AttachableBehaviour"/>s.
     /// </summary>

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

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
 using UnityEngine;
@@ -16,8 +17,19 @@ public class ComponentControllerEntry
         /// When true, this component's enabled state will be the inverse of
         /// the value passed into <see cref="ComponentController.SetEnabled(bool)"/>.
         /// </summary>
+        [Tooltip("When enabled, this component will inversely mirror the currently applied enable or disable state.")]
         public bool InvertEnabled;
 
+        /// <summary>
+        /// The amount of time to delay enabling this component when the <see cref="ComponentController"/> has just transitioned from a disabled to enabled state.
+        /// </summary>
+        public float EnableDelay;
+
+        /// <summary>
+        /// The amount of time to delay disabling this component when the <see cref="ComponentController"/> has just transitioned from an enabled to disabled state.
+        /// </summary>
+        public float DisableDelay;
+
         /// <summary>
         /// The component to control.
         /// </summary>
@@ -27,8 +39,63 @@ public class ComponentControllerEntry
         /// and <see cref="InvertEnabled"/> properties will be applied to all components found on the <see cref="GameObject"/>.
         /// </remarks>
         public Object Component;
-
         internal PropertyInfo PropertyInfo;
+
+
+        internal bool TimeDeltaDelayInProgress;
+        internal bool PendingState;
+        internal float EnableDelayTimeDelta;
+        internal float DisableDelayTimeDelta;
+
+        private bool GetRelativeEnabled(bool enabled)
+        {
+            return InvertEnabled ? !enabled : enabled;
+        }
+
+        internal bool HasDelay(bool enabled)
+        {
+            return GetRelativeEnabled(enabled) ? EnableDelay > 0.0f : DisableDelay > 0.0f;
+        }
+
+        internal void StartTimeDeltaTracking(bool isEnabled)
+        {
+            if (GetRelativeEnabled(isEnabled))
+            {
+                EnableDelayTimeDelta = Time.realtimeSinceStartup + EnableDelay;
+            }
+            else
+            {
+                DisableDelayTimeDelta = Time.realtimeSinceStartup + DisableDelay;
+            }
+            TimeDeltaDelayInProgress = true;
+            PendingState = isEnabled;
+        }
+
+
+        internal void SetValue(bool isEnabled)
+        {
+            // If invert enabled is true, then use the inverted value passed in.
+            // Otherwise, directly apply the value passed in.
+            PropertyInfo.SetValue(Component, GetRelativeEnabled(isEnabled));
+        }
+
+        internal bool CheckTimeDeltaDelay()
+        {
+            if (!TimeDeltaDelayInProgress)
+            {
+                return false;
+            }
+
+            var isDeltaDelayInProgress = ((EnableDelayTimeDelta > Time.realtimeSinceStartup)
+                || (DisableDelayTimeDelta > Time.realtimeSinceStartup));
+
+            if (!isDeltaDelayInProgress)
+            {
+                SetValue(PendingState);
+            }
+            TimeDeltaDelayInProgress = isDeltaDelayInProgress;
+            return TimeDeltaDelayInProgress;
+        }
     }
 
     /// <summary>
@@ -52,6 +119,17 @@ public class ComponentController : NetworkBehaviour
         [Tooltip("The initial state of the component controllers enabled status when instnatiated.")]
         public bool StartEnabled = true;
 
+        /// <summary>
+        /// The coroutine yield time used to check on any pending delayed <see cref="ComponentControllerEntry"/> state transitions.
+        /// </summary>
+        /// <remarks>
+        /// If there are any <see cref="ComponentControllerEntry"/> delays (enable, disable, or both), then upon changing the state of a <see cref="ComponentController"/> a coroutine will be started
+        /// (if not already started) that will monitor any pending delayed transitions (<see cref="EnableDelay"/> or <see cref="DisableDelay"/>) and will
+        /// handle changing each delayed <see cref="ComponentControllerEntry"/> until all instances have transitioned their value to the pending state change.
+        /// When there are no more pending delayed <see cref="ComponentControllerEntry"/>s, the coroutine will stop.
+        /// </remarks>
+        public float PendingDelayYieldTime = 0.032f;
+
         /// <summary>
         /// The list of <see cref="Components"/>s to be enabled and disabled.
         /// </summary>
@@ -214,6 +292,17 @@ public override void OnNetworkDespawn()
             base.OnNetworkDespawn();
         }
 
+        /// <inheritdoc/>
+        public override void OnDestroy()
+        {
+            if (m_CoroutineObject.IsRunning)
+            {
+                StopCoroutine(m_CoroutineObject.Coroutine);
+                m_CoroutineObject.IsRunning = false;
+            }
+            base.OnDestroy();
+        }
+
         private void OnEnabledChanged(bool previous, bool current)
         {
             ApplyEnabled(current);
@@ -239,13 +328,54 @@ private void InitializeComponents()
         /// <param name="enabled">the state update to apply</param>
         private void ApplyEnabled(bool enabled)
         {
+
             foreach (var entry in ValidComponents)
             {
-                // If invert enabled is true, then use the inverted value passed in.
-                // Otherwise, directly apply the value passed in.
-                var isEnabled = entry.InvertEnabled ? !enabled : enabled;
-                entry.PropertyInfo.SetValue(entry.Component, isEnabled);
+                if (entry.HasDelay(enabled))
+                {
+                    if (!m_CoroutineObject.IsRunning)
+                    {
+                        m_CoroutineObject.Coroutine = StartCoroutine(PendingAppliedState());
+                        m_CoroutineObject.IsRunning = true;
+                    }
+                    entry.StartTimeDeltaTracking(enabled);
+                }
+                else
+                {
+                    entry.SetValue(enabled);
+                }
+            }
+        }
+
+        private class CoroutineObject
+        {
+            public Coroutine Coroutine;
+            public bool IsRunning;
+        }
+
+        private CoroutineObject m_CoroutineObject = new CoroutineObject();
+
+
+        private IEnumerator PendingAppliedState()
+        {
+            var checkPendingDeltaDelays = true;
+            var waitTime = new WaitForSeconds(PendingDelayYieldTime);
+
+            while (checkPendingDeltaDelays)
+            {
+                yield return waitTime;
+                checkPendingDeltaDelays = false;
+                foreach (var entry in ValidComponents)
+                {
+                    if (!entry.CheckTimeDeltaDelay())
+                    {
+                        continue;
+                    }
+                    checkPendingDeltaDelays = true;
+                }
             }
+            m_CoroutineObject.IsRunning = false;
+            yield break;
         }
 
         /// <summary>