Merge branch 'develop-2.0.0' into develop-2.0.0

xmanning · web-flow · commit edfd01bffefa · 2025-10-07T14:46:36.000-04:00
diff --git a/com.unity.netcode.gameobjects/CHANGELOG.md b/com.unity.netcode.gameobjects/CHANGELOG.md
@@ -15,6 +15,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Changed
 
+- Improved performance of the NetworkVariable. (#3683)
 - Improved performance around the NetworkBehaviour component. (#3687)
 
 ### Deprecated
diff --git a/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs b/com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/AnticipatedNetworkVariable.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/AnticipatedNetworkVariable.cs
@@ -217,7 +217,7 @@ public void Anticipate(T value)
             m_LastAnticipationCounter = m_NetworkBehaviour.NetworkManager.AnticipationSystem.AnticipationCounter;
             m_AnticipatedValue = value;
             NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
-            if (CanWrite)
+            if (CanWrite())
             {
                 AuthoritativeValue = value;
             }
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs
@@ -429,7 +429,7 @@ public IEnumerator<T> GetEnumerator()
         public void Add(T item)
         {
             // check write permissions
-            if (CannotWrite)
+            if (CannotWrite())
             {
                 LogWritePermissionError();
                 return;
@@ -456,7 +456,7 @@ public void Add(T item)
         public void Clear()
         {
             // check write permissions
-            if (CannotWrite)
+            if (CannotWrite())
             {
                 LogWritePermissionError();
                 return;
@@ -494,7 +494,7 @@ public bool Contains(T item)
         public bool Remove(T item)
         {
             // check write permissions
-            if (CannotWrite)
+            if (CannotWrite())
             {
                 LogWritePermissionError();
                 return false;
@@ -543,7 +543,7 @@ public int IndexOf(T item)
         public void Insert(int index, T item)
         {
             // check write permissions
-            if (CannotWrite)
+            if (CannotWrite())
             {
                 LogWritePermissionError();
                 return;
@@ -579,7 +579,7 @@ public void Insert(int index, T item)
         public void RemoveAt(int index)
         {
             // check write permissions
-            if (CannotWrite)
+            if (CannotWrite())
             {
                 throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
             }
@@ -613,7 +613,7 @@ public void RemoveAt(int index)
         public void Set(int index, T value, bool forceUpdate = false)
         {
             // check write permissions
-            if (CannotWrite)
+            if (CannotWrite())
             {
                 LogWritePermissionError();
                 return;
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariable.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariable.cs
@@ -89,7 +89,7 @@ public NetworkVariable(T value = default,
         /// <param name="value">the value to reset the NetworkVariable to (if none specified it resets to the default)</param>
         public void Reset(T value = default)
         {
-            if (m_NetworkBehaviour == null || m_NetworkBehaviour != null && !m_NetworkBehaviour.NetworkObject.IsSpawned)
+            if (m_NetworkBehaviour == null || m_NetworkObject == null || !m_NetworkObject.IsSpawned)
             {
                 m_InternalValue = value;
                 NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_LastInternalValue);
@@ -148,7 +148,7 @@ public virtual T Value
             get => m_InternalValue;
             set
             {
-                if (CannotWrite)
+                if (CannotWrite())
                 {
                     LogWritePermissionError();
                     return;
@@ -182,7 +182,7 @@ public bool CheckDirtyState(bool forceCheck = false)
             var isDirty = base.IsDirty();
 
             // A client without permissions invoking this method should only check to assure the current value is equal to the last known current value
-            if (CannotWrite)
+            if (CannotWrite())
             {
                 // If modifications are detected, then revert back to the last known current value
                 if (!NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_LastInternalValue))
@@ -266,7 +266,7 @@ public override bool IsDirty()
         {
             // If the client does not have write permissions but the internal value is determined to be locally modified and we are applying updates, then we should revert
             // to the original collection value prior to applying updates (primarily for collections).
-            if (!NetworkUpdaterCheck && CannotWrite && !NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_LastInternalValue))
+            if (!NetworkUpdaterCheck && CannotWrite() && !NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_LastInternalValue))
             {
                 NetworkVariableSerialization<T>.Duplicate(m_LastInternalValue, ref m_InternalValue);
                 return true;
@@ -328,7 +328,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
         {
             // If the client does not have write permissions but the internal value is determined to be locally modified and we are applying updates, then we should revert
             // to the original collection value prior to applying updates (primarily for collections).
-            if (CannotWrite && !NetworkVariableSerialization<T>.AreEqual(ref m_LastInternalValue, ref m_InternalValue))
+            if (CannotWrite() && !NetworkVariableSerialization<T>.AreEqual(ref m_LastInternalValue, ref m_InternalValue))
             {
                 NetworkVariableSerialization<T>.Duplicate(m_LastInternalValue, ref m_InternalValue);
             }
@@ -370,7 +370,7 @@ public override void ReadField(FastBufferReader reader)
         {
             // If the client does not have write permissions but the internal value is determined to be locally modified and we are applying updates, then we should revert
             // to the original collection value prior to applying updates (primarily for collections).
-            if (CannotWrite && !NetworkVariableSerialization<T>.AreEqual(ref m_LastInternalValue, ref m_InternalValue))
+            if (CannotWrite() && !NetworkVariableSerialization<T>.AreEqual(ref m_LastInternalValue, ref m_InternalValue))
             {
                 NetworkVariableSerialization<T>.Duplicate(m_LastInternalValue, ref m_InternalValue);
             }
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariableBase.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariableBase.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.CompilerServices;
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -42,7 +43,11 @@ public abstract class NetworkVariableBase : IDisposable
         /// </summary>
         private protected NetworkBehaviour m_NetworkBehaviour;
 
-        private NetworkManager m_InternalNetworkManager;
+        private protected NetworkManager m_NetworkManager;
+
+        private protected NetworkObject m_NetworkObject;
+
+        private bool m_UseServerTime;
 
         // Determines if this NetworkVariable has been "initialized" to prevent initializing more than once which can happen when first
         // instantiated and spawned. If this NetworkVariable instance is on an in-scene placed NetworkObject =or= a pooled NetworkObject
@@ -60,8 +65,6 @@ internal void LogWritePermissionError()
             Debug.LogError(GetWritePermissionError());
         }
 
-        private protected NetworkManager m_NetworkManager => m_InternalNetworkManager;
-
         /// <summary>
         /// Gets the NetworkBehaviour instance associated with this network variable
         /// </summary>
@@ -108,31 +111,35 @@ public void Initialize(NetworkBehaviour networkBehaviour)
                 return;
             }
 
-            if (!m_NetworkBehaviour.NetworkObject.NetworkManagerOwner)
+            m_NetworkObject = m_NetworkBehaviour.NetworkObject;
+
+            if (!m_NetworkObject.NetworkManagerOwner)
             {
                 // Exit early if there has yet to be a NetworkManagerOwner assigned
                 // to the NetworkObject. This is ok because Initialize is invoked
                 // multiple times until it is considered "initialized".
                 return;
             }
-            m_InternalNetworkManager = m_NetworkBehaviour.NetworkObject.NetworkManagerOwner;
+            m_NetworkManager = m_NetworkObject.NetworkManagerOwner;
+
+            m_UseServerTime = m_NetworkManager.CMBServiceConnection || !m_NetworkManager.IsServer;
 
             // When in distributed authority mode, there is no such thing as server write permissions
-            InternalWritePerm = m_InternalNetworkManager.DistributedAuthorityMode ? NetworkVariableWritePermission.Owner : InternalWritePerm;
+            InternalWritePerm = m_NetworkManager.DistributedAuthorityMode ? NetworkVariableWritePermission.Owner : InternalWritePerm;
 
             OnInitialize();
 
             // Some unit tests don't operate with a running NetworkManager.
             // Only update the last time if there is a NetworkTimeSystem.
-            if (m_InternalNetworkManager.NetworkTimeSystem != null)
+            if (m_NetworkManager.NetworkTimeSystem != null)
             {
                 // Update our last sent time relative to when this was initialized
                 UpdateLastSentTime();
 
                 // At this point, this instance is considered initialized
                 HasBeenInitialized = true;
             }
-            else if (m_InternalNetworkManager.LogLevel == LogLevel.Developer)
+            else if (m_NetworkManager.LogLevel == LogLevel.Developer)
             {
                 Debug.LogWarning($"[{m_NetworkBehaviour.name}][{m_NetworkBehaviour.GetType().Name}][{GetType().Name}][Initialize] {nameof(NetworkManager)} has no {nameof(NetworkTimeSystem)} assigned!");
             }
@@ -251,7 +258,7 @@ public virtual void SetDirty(bool isDirty)
         internal bool CanSend()
         {
             // When connected to a service or not the server, always use the synchronized server time as opposed to the local time
-            var time = m_InternalNetworkManager.CMBServiceConnection || !m_InternalNetworkManager.IsServer ? m_NetworkBehaviour.NetworkManager.ServerTime.Time : m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;
+            var time = m_UseServerTime ? m_NetworkManager.ServerTime.Time : m_NetworkManager.NetworkTimeSystem.LocalTime;
             var timeSinceLastUpdate = time - LastUpdateSent;
             return
                 (
@@ -267,7 +274,7 @@ internal bool CanSend()
         internal void UpdateLastSentTime()
         {
             // When connected to a service or not the server, always use the synchronized server time as opposed to the local time
-            LastUpdateSent = m_InternalNetworkManager.CMBServiceConnection || !m_InternalNetworkManager.IsServer ? m_NetworkBehaviour.NetworkManager.ServerTime.Time : m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;
+            LastUpdateSent = m_UseServerTime ? m_NetworkManager.ServerTime.Time : m_NetworkManager.NetworkTimeSystem.LocalTime;
         }
 
         internal static bool IgnoreInitializeWarning;
@@ -286,27 +293,27 @@ protected void MarkNetworkBehaviourDirty()
                 }
                 return;
             }
-            if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress)
+            if (m_NetworkManager.ShutdownInProgress)
             {
-                if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)
+                if (m_NetworkManager.LogLevel <= LogLevel.Developer)
                 {
                     Debug.LogWarning($"NetworkVariable is written to during the NetworkManager shutdown! " +
                  "Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");
                 }
                 return;
             }
 
-            if (!m_NetworkBehaviour.NetworkManager.IsListening)
+            if (!m_NetworkManager.IsListening)
             {
-                if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)
+                if (m_NetworkManager.LogLevel <= LogLevel.Developer)
                 {
                     Debug.LogWarning($"NetworkVariable is written to after the NetworkManager has already shutdown! " +
                      "Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");
                 }
                 return;
             }
 
-            m_NetworkBehaviour.NetworkManager.BehaviourUpdater?.AddForUpdate(m_NetworkBehaviour.NetworkObject);
+            m_NetworkManager.BehaviourUpdater?.AddForUpdate(m_NetworkObject);
         }
 
         /// <summary>
@@ -345,7 +352,7 @@ public bool CanClientRead(ulong clientId)
             }
 
             // When in distributed authority mode, everyone can read (but only the owner can write)
-            if (m_NetworkManager != null && m_NetworkManager.DistributedAuthorityMode)
+            if (m_NetworkManager.DistributedAuthorityMode)
             {
                 return true;
             }
@@ -355,7 +362,7 @@ public bool CanClientRead(ulong clientId)
                 case NetworkVariableReadPermission.Everyone:
                     return true;
                 case NetworkVariableReadPermission.Owner:
-                    return clientId == m_NetworkBehaviour.NetworkObject.OwnerClientId || NetworkManager.ServerClientId == clientId;
+                    return clientId == m_NetworkObject.OwnerClientId || NetworkManager.ServerClientId == clientId;
             }
         }
 
@@ -377,26 +384,26 @@ public bool CanClientWrite(ulong clientId)
                 case NetworkVariableWritePermission.Server:
                     return clientId == NetworkManager.ServerClientId;
                 case NetworkVariableWritePermission.Owner:
-                    return clientId == m_NetworkBehaviour.NetworkObject.OwnerClientId;
+                    return clientId == m_NetworkObject.OwnerClientId;
             }
         }
 
         /// <summary>
         /// Returns true if the current <see cref="NetworkManager.LocalClientId"/> can write to this variable; otherwise false.
         /// </summary>
-        internal bool CanWrite => m_NetworkManager && CanClientWrite(m_NetworkManager.LocalClientId);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal bool CanWrite()
+        {
+            return m_NetworkManager && CanClientWrite(m_NetworkManager.LocalClientId);
+        }
 
         /// <summary>
         /// Returns false if the current <see cref="NetworkManager.LocalClientId"/> can write to this variable; otherwise true.
         /// </summary>
-        internal bool CannotWrite => m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId);
-
-        /// <summary>
-        /// Returns the ClientId of the owning client
-        /// </summary>
-        internal ulong OwnerClientId()
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal bool CannotWrite()
         {
-            return m_NetworkBehaviour.NetworkObject.OwnerClientId;
+            return m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId);
         }
 
         /// <summary>
@@ -467,7 +474,10 @@ internal virtual void WriteFieldSynchronization(FastBufferWriter writer)
         /// </summary>
         public virtual void Dispose()
         {
-            m_InternalNetworkManager = null;
+            HasBeenInitialized = false;
+            m_NetworkBehaviour = null;
+            m_NetworkObject = null;
+            m_NetworkManager = null;
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ public void Anticipate(T value)`
`217`	`217`	`m_LastAnticipationCounter = m_NetworkBehaviour.NetworkManager.AnticipationSystem.AnticipationCounter;`
`218`	`218`	`m_AnticipatedValue = value;`
`219`	`219`	`NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);`
`220`		`- if (CanWrite)`
	`220`	`+ if (CanWrite())`
`221`	`221`	`{`
`222`	`222`	`AuthoritativeValue = value;`
`223`	`223`	`}`
Original file line number	Diff line number	Diff line change
`@@ -429,7 +429,7 @@ public IEnumerator<T> GetEnumerator()`
`429`	`429`	`public void Add(T item)`
`430`	`430`	`{`
`431`	`431`	`// check write permissions`
`432`		`- if (CannotWrite)`
	`432`	`+ if (CannotWrite())`
`433`	`433`	`{`
`434`	`434`	`LogWritePermissionError();`
`435`	`435`	`return;`
`@@ -456,7 +456,7 @@ public void Add(T item)`
`456`	`456`	`public void Clear()`
`457`	`457`	`{`
`458`	`458`	`// check write permissions`
`459`		`- if (CannotWrite)`
	`459`	`+ if (CannotWrite())`
`460`	`460`	`{`
`461`	`461`	`LogWritePermissionError();`
`462`	`462`	`return;`
`@@ -494,7 +494,7 @@ public bool Contains(T item)`
`494`	`494`	`public bool Remove(T item)`
`495`	`495`	`{`
`496`	`496`	`// check write permissions`
`497`		`- if (CannotWrite)`
	`497`	`+ if (CannotWrite())`
`498`	`498`	`{`
`499`	`499`	`LogWritePermissionError();`
`500`	`500`	`return false;`
`@@ -543,7 +543,7 @@ public int IndexOf(T item)`
`543`	`543`	`public void Insert(int index, T item)`
`544`	`544`	`{`
`545`	`545`	`// check write permissions`
`546`		`- if (CannotWrite)`
	`546`	`+ if (CannotWrite())`
`547`	`547`	`{`
`548`	`548`	`LogWritePermissionError();`
`549`	`549`	`return;`
`@@ -579,7 +579,7 @@ public void Insert(int index, T item)`
`579`	`579`	`public void RemoveAt(int index)`
`580`	`580`	`{`
`581`	`581`	`// check write permissions`
`582`		`- if (CannotWrite)`
	`582`	`+ if (CannotWrite())`
`583`	`583`	`{`
`584`	`584`	`throw new InvalidOperationException("Client is not allowed to write to this NetworkList");`
`585`	`585`	`}`
`@@ -613,7 +613,7 @@ public void RemoveAt(int index)`
`613`	`613`	`public void Set(int index, T value, bool forceUpdate = false)`
`614`	`614`	`{`
`615`	`615`	`// check write permissions`
`616`		`- if (CannotWrite)`
	`616`	`+ if (CannotWrite())`
`617`	`617`	`{`
`618`	`618`	`LogWritePermissionError();`
`619`	`619`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public NetworkVariable(T value = default,`
`89`	`89`	`/// <param name="value">the value to reset the NetworkVariable to (if none specified it resets to the default)</param>`
`90`	`90`	`public void Reset(T value = default)`
`91`	`91`	`{`
`92`		`- if (m_NetworkBehaviour == null \|\| m_NetworkBehaviour != null && !m_NetworkBehaviour.NetworkObject.IsSpawned)`
	`92`	`+ if (m_NetworkBehaviour == null \|\| m_NetworkObject == null \|\| !m_NetworkObject.IsSpawned)`
`93`	`93`	`{`
`94`	`94`	`m_InternalValue = value;`
`95`	`95`	`NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_LastInternalValue);`
`@@ -148,7 +148,7 @@ public virtual T Value`
`148`	`148`	`get => m_InternalValue;`
`149`	`149`	`set`
`150`	`150`	`{`
`151`		`- if (CannotWrite)`
	`151`	`+ if (CannotWrite())`
`152`	`152`	`{`
`153`	`153`	`LogWritePermissionError();`
`154`	`154`	`return;`
`@@ -182,7 +182,7 @@ public bool CheckDirtyState(bool forceCheck = false)`
`182`	`182`	`var isDirty = base.IsDirty();`
`183`	`183`
`184`	`184`	`// A client without permissions invoking this method should only check to assure the current value is equal to the last known current value`
`185`		`- if (CannotWrite)`
	`185`	`+ if (CannotWrite())`
`186`	`186`	`{`
`187`	`187`	`// If modifications are detected, then revert back to the last known current value`
`188`	`188`	`if (!NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_LastInternalValue))`
`@@ -266,7 +266,7 @@ public override bool IsDirty()`
`266`	`266`	`{`
`267`	`267`	`// If the client does not have write permissions but the internal value is determined to be locally modified and we are applying updates, then we should revert`
`268`	`268`	`// to the original collection value prior to applying updates (primarily for collections).`
`269`		`- if (!NetworkUpdaterCheck && CannotWrite && !NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_LastInternalValue))`
	`269`	`+ if (!NetworkUpdaterCheck && CannotWrite() && !NetworkVariableSerialization<T>.AreEqual(ref m_InternalValue, ref m_LastInternalValue))`
`270`	`270`	`{`
`271`	`271`	`NetworkVariableSerialization<T>.Duplicate(m_LastInternalValue, ref m_InternalValue);`
`272`	`272`	`return true;`
`@@ -328,7 +328,7 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)`
`328`	`328`	`{`
`329`	`329`	`// If the client does not have write permissions but the internal value is determined to be locally modified and we are applying updates, then we should revert`
`330`	`330`	`// to the original collection value prior to applying updates (primarily for collections).`
`331`		`- if (CannotWrite && !NetworkVariableSerialization<T>.AreEqual(ref m_LastInternalValue, ref m_InternalValue))`
	`331`	`+ if (CannotWrite() && !NetworkVariableSerialization<T>.AreEqual(ref m_LastInternalValue, ref m_InternalValue))`
`332`	`332`	`{`
`333`	`333`	`NetworkVariableSerialization<T>.Duplicate(m_LastInternalValue, ref m_InternalValue);`
`334`	`334`	`}`
`@@ -370,7 +370,7 @@ public override void ReadField(FastBufferReader reader)`
`370`	`370`	`{`
`371`	`371`	`// If the client does not have write permissions but the internal value is determined to be locally modified and we are applying updates, then we should revert`
`372`	`372`	`// to the original collection value prior to applying updates (primarily for collections).`
`373`		`- if (CannotWrite && !NetworkVariableSerialization<T>.AreEqual(ref m_LastInternalValue, ref m_InternalValue))`
	`373`	`+ if (CannotWrite() && !NetworkVariableSerialization<T>.AreEqual(ref m_LastInternalValue, ref m_InternalValue))`
`374`	`374`	`{`
`375`	`375`	`NetworkVariableSerialization<T>.Duplicate(m_LastInternalValue, ref m_InternalValue);`
`376`	`376`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Runtime.CompilerServices;`
`2`	`3`	`using UnityEngine;`
`3`	`4`
`4`	`5`	`namespace Unity.Netcode`
`@@ -42,7 +43,11 @@ public abstract class NetworkVariableBase : IDisposable`
`42`	`43`	`/// </summary>`
`43`	`44`	`private protected NetworkBehaviour m_NetworkBehaviour;`
`44`	`45`
`45`		`- private NetworkManager m_InternalNetworkManager;`
	`46`	`+ private protected NetworkManager m_NetworkManager;`
	`47`	`+`
	`48`	`+ private protected NetworkObject m_NetworkObject;`
	`49`	`+`
	`50`	`+ private bool m_UseServerTime;`
`46`	`51`
`47`	`52`	`// Determines if this NetworkVariable has been "initialized" to prevent initializing more than once which can happen when first`
`48`	`53`	`// instantiated and spawned. If this NetworkVariable instance is on an in-scene placed NetworkObject =or= a pooled NetworkObject`
`@@ -60,8 +65,6 @@ internal void LogWritePermissionError()`
`60`	`65`	`Debug.LogError(GetWritePermissionError());`
`61`	`66`	`}`
`62`	`67`
`63`		`- private protected NetworkManager m_NetworkManager => m_InternalNetworkManager;`
`64`		`-`
`65`	`68`	`/// <summary>`
`66`	`69`	`/// Gets the NetworkBehaviour instance associated with this network variable`
`67`	`70`	`/// </summary>`
`@@ -108,31 +111,35 @@ public void Initialize(NetworkBehaviour networkBehaviour)`
`108`	`111`	`return;`
`109`	`112`	`}`
`110`	`113`
`111`		`- if (!m_NetworkBehaviour.NetworkObject.NetworkManagerOwner)`
	`114`	`+ m_NetworkObject = m_NetworkBehaviour.NetworkObject;`
	`115`	`+`
	`116`	`+ if (!m_NetworkObject.NetworkManagerOwner)`
`112`	`117`	`{`
`113`	`118`	`// Exit early if there has yet to be a NetworkManagerOwner assigned`
`114`	`119`	`// to the NetworkObject. This is ok because Initialize is invoked`
`115`	`120`	`// multiple times until it is considered "initialized".`
`116`	`121`	`return;`
`117`	`122`	`}`
`118`		`- m_InternalNetworkManager = m_NetworkBehaviour.NetworkObject.NetworkManagerOwner;`
	`123`	`+ m_NetworkManager = m_NetworkObject.NetworkManagerOwner;`
	`124`	`+`
	`125`	`+ m_UseServerTime = m_NetworkManager.CMBServiceConnection \|\| !m_NetworkManager.IsServer;`
`119`	`126`
`120`	`127`	`// When in distributed authority mode, there is no such thing as server write permissions`
`121`		`- InternalWritePerm = m_InternalNetworkManager.DistributedAuthorityMode ? NetworkVariableWritePermission.Owner : InternalWritePerm;`
	`128`	`+ InternalWritePerm = m_NetworkManager.DistributedAuthorityMode ? NetworkVariableWritePermission.Owner : InternalWritePerm;`
`122`	`129`
`123`	`130`	`OnInitialize();`
`124`	`131`
`125`	`132`	`// Some unit tests don't operate with a running NetworkManager.`
`126`	`133`	`// Only update the last time if there is a NetworkTimeSystem.`
`127`		`- if (m_InternalNetworkManager.NetworkTimeSystem != null)`
	`134`	`+ if (m_NetworkManager.NetworkTimeSystem != null)`
`128`	`135`	`{`
`129`	`136`	`// Update our last sent time relative to when this was initialized`
`130`	`137`	`UpdateLastSentTime();`
`131`	`138`
`132`	`139`	`// At this point, this instance is considered initialized`
`133`	`140`	`HasBeenInitialized = true;`
`134`	`141`	`}`
`135`		`- else if (m_InternalNetworkManager.LogLevel == LogLevel.Developer)`
	`142`	`+ else if (m_NetworkManager.LogLevel == LogLevel.Developer)`
`136`	`143`	`{`
`137`	`144`	`Debug.LogWarning($"[{m_NetworkBehaviour.name}][{m_NetworkBehaviour.GetType().Name}][{GetType().Name}][Initialize] {nameof(NetworkManager)} has no {nameof(NetworkTimeSystem)} assigned!");`
`138`	`145`	`}`
`@@ -251,7 +258,7 @@ public virtual void SetDirty(bool isDirty)`
`251`	`258`	`internal bool CanSend()`
`252`	`259`	`{`
`253`	`260`	`// When connected to a service or not the server, always use the synchronized server time as opposed to the local time`
`254`		`- var time = m_InternalNetworkManager.CMBServiceConnection \|\| !m_InternalNetworkManager.IsServer ? m_NetworkBehaviour.NetworkManager.ServerTime.Time : m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;`
	`261`	`+ var time = m_UseServerTime ? m_NetworkManager.ServerTime.Time : m_NetworkManager.NetworkTimeSystem.LocalTime;`
`255`	`262`	`var timeSinceLastUpdate = time - LastUpdateSent;`
`256`	`263`	`return`
`257`	`264`	`(`
`@@ -267,7 +274,7 @@ internal bool CanSend()`
`267`	`274`	`internal void UpdateLastSentTime()`
`268`	`275`	`{`
`269`	`276`	`// When connected to a service or not the server, always use the synchronized server time as opposed to the local time`
`270`		`- LastUpdateSent = m_InternalNetworkManager.CMBServiceConnection \|\| !m_InternalNetworkManager.IsServer ? m_NetworkBehaviour.NetworkManager.ServerTime.Time : m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;`
	`277`	`+ LastUpdateSent = m_UseServerTime ? m_NetworkManager.ServerTime.Time : m_NetworkManager.NetworkTimeSystem.LocalTime;`
`271`	`278`	`}`
`272`	`279`
`273`	`280`	`internal static bool IgnoreInitializeWarning;`
`@@ -286,27 +293,27 @@ protected void MarkNetworkBehaviourDirty()`
`286`	`293`	`}`
`287`	`294`	`return;`
`288`	`295`	`}`
`289`		`- if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress)`
	`296`	`+ if (m_NetworkManager.ShutdownInProgress)`
`290`	`297`	`{`
`291`		`- if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)`
	`298`	`+ if (m_NetworkManager.LogLevel <= LogLevel.Developer)`
`292`	`299`	`{`
`293`	`300`	`Debug.LogWarning($"NetworkVariable is written to during the NetworkManager shutdown! " +`
`294`	`301`	`"Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");`
`295`	`302`	`}`
`296`	`303`	`return;`
`297`	`304`	`}`
`298`	`305`
`299`		`- if (!m_NetworkBehaviour.NetworkManager.IsListening)`
	`306`	`+ if (!m_NetworkManager.IsListening)`
`300`	`307`	`{`
`301`		`- if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)`
	`308`	`+ if (m_NetworkManager.LogLevel <= LogLevel.Developer)`
`302`	`309`	`{`
`303`	`310`	`Debug.LogWarning($"NetworkVariable is written to after the NetworkManager has already shutdown! " +`
`304`	`311`	`"Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");`
`305`	`312`	`}`
`306`	`313`	`return;`
`307`	`314`	`}`
`308`	`315`
`309`		`- m_NetworkBehaviour.NetworkManager.BehaviourUpdater?.AddForUpdate(m_NetworkBehaviour.NetworkObject);`
	`316`	`+ m_NetworkManager.BehaviourUpdater?.AddForUpdate(m_NetworkObject);`
`310`	`317`	`}`
`311`	`318`
`312`	`319`	`/// <summary>`
`@@ -345,7 +352,7 @@ public bool CanClientRead(ulong clientId)`
`345`	`352`	`}`
`346`	`353`
`347`	`354`	`// When in distributed authority mode, everyone can read (but only the owner can write)`
`348`		`- if (m_NetworkManager != null && m_NetworkManager.DistributedAuthorityMode)`
	`355`	`+ if (m_NetworkManager.DistributedAuthorityMode)`
`349`	`356`	`{`
`350`	`357`	`return true;`
`351`	`358`	`}`
`@@ -355,7 +362,7 @@ public bool CanClientRead(ulong clientId)`
`355`	`362`	`case NetworkVariableReadPermission.Everyone:`
`356`	`363`	`return true;`
`357`	`364`	`case NetworkVariableReadPermission.Owner:`
`358`		`- return clientId == m_NetworkBehaviour.NetworkObject.OwnerClientId \|\| NetworkManager.ServerClientId == clientId;`
	`365`	`+ return clientId == m_NetworkObject.OwnerClientId \|\| NetworkManager.ServerClientId == clientId;`
`359`	`366`	`}`
`360`	`367`	`}`
`361`	`368`
`@@ -377,26 +384,26 @@ public bool CanClientWrite(ulong clientId)`
`377`	`384`	`case NetworkVariableWritePermission.Server:`
`378`	`385`	`return clientId == NetworkManager.ServerClientId;`
`379`	`386`	`case NetworkVariableWritePermission.Owner:`
`380`		`- return clientId == m_NetworkBehaviour.NetworkObject.OwnerClientId;`
	`387`	`+ return clientId == m_NetworkObject.OwnerClientId;`
`381`	`388`	`}`
`382`	`389`	`}`
`383`	`390`
`384`	`391`	`/// <summary>`
`385`	`392`	`/// Returns true if the current <see cref="NetworkManager.LocalClientId"/> can write to this variable; otherwise false.`
`386`	`393`	`/// </summary>`
`387`		`- internal bool CanWrite => m_NetworkManager && CanClientWrite(m_NetworkManager.LocalClientId);`
	`394`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`395`	`+ internal bool CanWrite()`
	`396`	`+ {`
	`397`	`+ return m_NetworkManager && CanClientWrite(m_NetworkManager.LocalClientId);`
	`398`	`+ }`
`388`	`399`
`389`	`400`	`/// <summary>`
`390`	`401`	`/// Returns false if the current <see cref="NetworkManager.LocalClientId"/> can write to this variable; otherwise true.`
`391`	`402`	`/// </summary>`
`392`		`- internal bool CannotWrite => m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId);`
`393`		`-`
`394`		`- /// <summary>`
`395`		`- /// Returns the ClientId of the owning client`
`396`		`- /// </summary>`
`397`		`- internal ulong OwnerClientId()`
	`403`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`404`	`+ internal bool CannotWrite()`
`398`	`405`	`{`
`399`		`- return m_NetworkBehaviour.NetworkObject.OwnerClientId;`
	`406`	`+ return m_NetworkManager && !CanClientWrite(m_NetworkManager.LocalClientId);`
`400`	`407`	`}`
`401`	`408`
`402`	`409`	`/// <summary>`
`@@ -467,7 +474,10 @@ internal virtual void WriteFieldSynchronization(FastBufferWriter writer)`
`467`	`474`	`/// </summary>`
`468`	`475`	`public virtual void Dispose()`
`469`	`476`	`{`
`470`		`- m_InternalNetworkManager = null;`
	`477`	`+ HasBeenInitialized = false;`
	`478`	`+ m_NetworkBehaviour = null;`
	`479`	`+ m_NetworkObject = null;`
	`480`	`+ m_NetworkManager = null;`
`471`	`481`	`}`
`472`	`482`	`}`
`473`	`483`	`}`