AnticipatedNetworkVariable corrected

michalChrobot · michalChrobot · commit 69590ad2d91d · 2025-04-07T14:54:39.000+02:00
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/AnticipatedNetworkVariable.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/AnticipatedNetworkVariable.cs
@@ -4,10 +4,21 @@
 
 namespace Unity.Netcode
 {
-
+    /// <summary>
+    /// Defines how anticipated network variables handle authoritative updates that are older than the current anticipated state
+    /// </summary>
     public enum StaleDataHandling
     {
+        /// <summary>
+        /// Ignores authoritative updates that are older than the current anticipated state.
+        /// The anticipated value will not be replaced until a newer authoritative update is received.
+        /// </summary>
         Ignore,
+
+        /// <summary>
+        /// Applies authoritative updates even if they are older than the current anticipated state.
+        /// This triggers reanticipation to calculate a new anticipated value based on the authoritative state.
+        /// </summary>
         Reanticipate
     }
 
@@ -85,6 +96,12 @@ public class AnticipatedNetworkVariable<T> : NetworkVariableBase
 #pragma warning restore IDE0001
         public StaleDataHandling StaleDataHandling;
 
+        /// <summary>
+        /// Delegate for handling changes in the authoritative value
+        /// </summary>
+        /// <param name="variable">The network variable that changed</param>
+        /// <param name="previousValue">The previous value before the change</param>
+        /// <param name="newValue">The new value after the change</param>
         public delegate void OnAuthoritativeValueChangedDelegate(AnticipatedNetworkVariable<T> variable, in T previousValue, in T newValue);
 
         /// <summary>
@@ -121,6 +138,9 @@ public void ResetAnticipation()
 
         private AnticipatedObject m_AnticipatedObject;
 
+        /// <summary>
+        /// Initializes the network variable, setting up initial values and registering with the anticipation system
+        /// </summary>
         public override void OnInitialize()
         {
             m_AuthoritativeValue.Initialize(m_NetworkBehaviour);
@@ -133,6 +153,10 @@ public override void OnInitialize()
             }
         }
 
+        /// <summary>
+        /// Checks if the current value has changed enough from its last synchronized value to warrant a new network update
+        /// </summary>
+        /// <returns>True if the value should be synchronized, false otherwise</returns>
         public override bool ExceedsDirtinessThreshold()
         {
             return m_AuthoritativeValue.ExceedsDirtinessThreshold();
@@ -227,6 +251,10 @@ public T AuthoritativeValue
         /// See <see cref="Mathf.Lerp"/>, <see cref="Vector3.Lerp"/>, <see cref="Vector3.Slerp"/>, and so on
         /// for examples.
         /// </summary>
+        /// <param name="authoritativeValue">The authoritative value to interpolate from</param>
+        /// <param name="anticipatedValue">The anticipated value to interpolate to</param>
+        /// <param name="amount">The interpolation factor between 0 and 1</param>
+        /// <returns>The interpolated value</returns>
         public delegate T SmoothDelegate(T authoritativeValue, T anticipatedValue, float amount);
 
         private SmoothDelegate m_SmoothDelegate = null;
@@ -242,6 +270,9 @@ public AnticipatedNetworkVariable(T value = default,
             };
         }
 
+        /// <summary>
+        /// Updates the smooth interpolation state if active
+        /// </summary>
         public void Update()
         {
             if (m_CurrentSmoothTime < m_SmoothDuration)
@@ -253,6 +284,9 @@ public void Update()
             }
         }
 
+        /// <summary>
+        /// Releases all resources used by this network variable
+        /// </summary>
         public override void Dispose()
         {
             if (m_IsDisposed)
@@ -357,33 +391,57 @@ public void Smooth(in T from, in T to, float durationSeconds, SmoothDelegate how
             m_HasSmoothValues = true;
         }
 
+        /// <summary>
+        /// Checks if the variable has been modified since the last network synchronization
+        /// </summary>
+        /// <returns>True if the variable needs to be synchronized, false otherwise</returns>
         public override bool IsDirty()
         {
             return m_AuthoritativeValue.IsDirty();
         }
 
+        /// <summary>
+        /// Resets the dirty state after network synchronization
+        /// </summary>
         public override void ResetDirty()
         {
             m_AuthoritativeValue.ResetDirty();
         }
 
+        /// <summary>
+        /// Writes only the changes in the variable's value to the network stream
+        /// </summary>
+        /// <param name="writer">Buffer to write the delta to</param>
         public override void WriteDelta(FastBufferWriter writer)
         {
             m_AuthoritativeValue.WriteDelta(writer);
         }
 
+        /// <summary>
+        /// Writes the complete state of the variable to the network stream
+        /// </summary>
+        /// <param name="writer">Buffer to write the field to</param>
         public override void WriteField(FastBufferWriter writer)
         {
             m_AuthoritativeValue.WriteField(writer);
         }
 
+        /// <summary>
+        /// Reads the complete state of the variable from the network stream
+        /// </summary>
+        /// <param name="reader">Buffer to read the field from</param>
         public override void ReadField(FastBufferReader reader)
         {
             m_AuthoritativeValue.ReadField(reader);
             NetworkVariableSerialization<T>.Duplicate(m_AuthoritativeValue.Value, ref m_AnticipatedValue);
             NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
         }
 
+        /// <summary>
+        /// Reads changes in the variable's value from the network stream
+        /// </summary>
+        /// <param name="reader">Buffer to read the delta from</param>
+        /// <param name="keepDirtyDelta">Whether to maintain the dirty state after reading</param>
         public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
         {
             m_AuthoritativeValue.ReadDelta(reader, keepDirtyDelta);
diff --git a/pvpExceptions.json b/pvpExceptions.json
@@ -45,26 +45,7 @@
           "Unity.Netcode.CustomMessagingManager.HandleNamedMessageDelegate: missing <param name=\"messagePayload\">",
           "Unity.Netcode.GenerateSerializationForGenericParameterAttribute: .ctor(int): undocumented",
           "Unity.Netcode.GenerateSerializationForTypeAttribute: .ctor(Type): undocumented",
-          "Unity.Netcode.StaleDataHandling: undocumented",
-          "Unity.Netcode.StaleDataHandling: Ignore: undocumented",
-          "Unity.Netcode.StaleDataHandling: Reanticipate: undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void OnInitialize(): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: bool ExceedsDirtinessThreshold(): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: .ctor(T, StaleDataHandling): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void Update(): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void Dispose(): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void Finalize(): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: bool IsDirty(): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void ResetDirty(): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void WriteDelta(FastBufferWriter): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void WriteField(FastBufferWriter): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void ReadField(FastBufferReader): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>: void ReadDelta(FastBufferReader, bool): undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>.OnAuthoritativeValueChangedDelegate: undocumented",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>.SmoothDelegate: missing <param name=\"authoritativeValue\">",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>.SmoothDelegate: missing <param name=\"anticipatedValue\">",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>.SmoothDelegate: missing <param name=\"amount\">",
-          "Unity.Netcode.AnticipatedNetworkVariable<T>.SmoothDelegate: missing <returns>",
+          
           "Unity.Netcode.NetworkList<T>: void Finalize(): undocumented",
           "Unity.Netcode.NetworkVariable<T>: CheckExceedsDirtinessThreshold: undocumented",
           "Unity.Netcode.NetworkVariable<T>: bool ExceedsDirtinessThreshold(): undocumented",

Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,21 @@`
`4`	`4`
`5`	`5`	`namespace Unity.Netcode`
`6`	`6`	`{`
`7`		`-`
	`7`	`+ /// <summary>`
	`8`	`+ /// Defines how anticipated network variables handle authoritative updates that are older than the current anticipated state`
	`9`	`+ /// </summary>`
`8`	`10`	`public enum StaleDataHandling`
`9`	`11`	`{`
	`12`	`+ /// <summary>`
	`13`	`+ /// Ignores authoritative updates that are older than the current anticipated state.`
	`14`	`+ /// The anticipated value will not be replaced until a newer authoritative update is received.`
	`15`	`+ /// </summary>`
`10`	`16`	`Ignore,`
	`17`	`+`
	`18`	`+ /// <summary>`
	`19`	`+ /// Applies authoritative updates even if they are older than the current anticipated state.`
	`20`	`+ /// This triggers reanticipation to calculate a new anticipated value based on the authoritative state.`
	`21`	`+ /// </summary>`
`11`	`22`	`Reanticipate`
`12`	`23`	`}`
`13`	`24`
`@@ -85,6 +96,12 @@ public class AnticipatedNetworkVariable<T> : NetworkVariableBase`
`85`	`96`	`#pragma warning restore IDE0001`
`86`	`97`	`public StaleDataHandling StaleDataHandling;`
`87`	`98`
	`99`	`+ /// <summary>`
	`100`	`+ /// Delegate for handling changes in the authoritative value`
	`101`	`+ /// </summary>`
	`102`	`+ /// <param name="variable">The network variable that changed</param>`
	`103`	`+ /// <param name="previousValue">The previous value before the change</param>`
	`104`	`+ /// <param name="newValue">The new value after the change</param>`
`88`	`105`	`public delegate void OnAuthoritativeValueChangedDelegate(AnticipatedNetworkVariable<T> variable, in T previousValue, in T newValue);`
`89`	`106`
`90`	`107`	`/// <summary>`
`@@ -121,6 +138,9 @@ public void ResetAnticipation()`
`121`	`138`
`122`	`139`	`private AnticipatedObject m_AnticipatedObject;`
`123`	`140`
	`141`	`+ /// <summary>`
	`142`	`+ /// Initializes the network variable, setting up initial values and registering with the anticipation system`
	`143`	`+ /// </summary>`
`124`	`144`	`public override void OnInitialize()`
`125`	`145`	`{`
`126`	`146`	`m_AuthoritativeValue.Initialize(m_NetworkBehaviour);`
`@@ -133,6 +153,10 @@ public override void OnInitialize()`
`133`	`153`	`}`
`134`	`154`	`}`
`135`	`155`
	`156`	`+ /// <summary>`
	`157`	`+ /// Checks if the current value has changed enough from its last synchronized value to warrant a new network update`
	`158`	`+ /// </summary>`
	`159`	`+ /// <returns>True if the value should be synchronized, false otherwise</returns>`
`136`	`160`	`public override bool ExceedsDirtinessThreshold()`
`137`	`161`	`{`
`138`	`162`	`return m_AuthoritativeValue.ExceedsDirtinessThreshold();`
`@@ -227,6 +251,10 @@ public T AuthoritativeValue`
`227`	`251`	`/// See <see cref="Mathf.Lerp"/>, <see cref="Vector3.Lerp"/>, <see cref="Vector3.Slerp"/>, and so on`
`228`	`252`	`/// for examples.`
`229`	`253`	`/// </summary>`
	`254`	`+ /// <param name="authoritativeValue">The authoritative value to interpolate from</param>`
	`255`	`+ /// <param name="anticipatedValue">The anticipated value to interpolate to</param>`
	`256`	`+ /// <param name="amount">The interpolation factor between 0 and 1</param>`
	`257`	`+ /// <returns>The interpolated value</returns>`
`230`	`258`	`public delegate T SmoothDelegate(T authoritativeValue, T anticipatedValue, float amount);`
`231`	`259`
`232`	`260`	`private SmoothDelegate m_SmoothDelegate = null;`
`@@ -242,6 +270,9 @@ public AnticipatedNetworkVariable(T value = default,`
`242`	`270`	`};`
`243`	`271`	`}`
`244`	`272`
	`273`	`+ /// <summary>`
	`274`	`+ /// Updates the smooth interpolation state if active`
	`275`	`+ /// </summary>`
`245`	`276`	`public void Update()`
`246`	`277`	`{`
`247`	`278`	`if (m_CurrentSmoothTime < m_SmoothDuration)`
`@@ -253,6 +284,9 @@ public void Update()`
`253`	`284`	`}`
`254`	`285`	`}`
`255`	`286`
	`287`	`+ /// <summary>`
	`288`	`+ /// Releases all resources used by this network variable`
	`289`	`+ /// </summary>`
`256`	`290`	`public override void Dispose()`
`257`	`291`	`{`
`258`	`292`	`if (m_IsDisposed)`
`@@ -357,33 +391,57 @@ public void Smooth(in T from, in T to, float durationSeconds, SmoothDelegate how`
`357`	`391`	`m_HasSmoothValues = true;`
`358`	`392`	`}`
`359`	`393`
	`394`	`+ /// <summary>`
	`395`	`+ /// Checks if the variable has been modified since the last network synchronization`
	`396`	`+ /// </summary>`
	`397`	`+ /// <returns>True if the variable needs to be synchronized, false otherwise</returns>`
`360`	`398`	`public override bool IsDirty()`
`361`	`399`	`{`
`362`	`400`	`return m_AuthoritativeValue.IsDirty();`
`363`	`401`	`}`
`364`	`402`
	`403`	`+ /// <summary>`
	`404`	`+ /// Resets the dirty state after network synchronization`
	`405`	`+ /// </summary>`
`365`	`406`	`public override void ResetDirty()`
`366`	`407`	`{`
`367`	`408`	`m_AuthoritativeValue.ResetDirty();`
`368`	`409`	`}`
`369`	`410`
	`411`	`+ /// <summary>`
	`412`	`+ /// Writes only the changes in the variable's value to the network stream`
	`413`	`+ /// </summary>`
	`414`	`+ /// <param name="writer">Buffer to write the delta to</param>`
`370`	`415`	`public override void WriteDelta(FastBufferWriter writer)`
`371`	`416`	`{`
`372`	`417`	`m_AuthoritativeValue.WriteDelta(writer);`
`373`	`418`	`}`
`374`	`419`
	`420`	`+ /// <summary>`
	`421`	`+ /// Writes the complete state of the variable to the network stream`
	`422`	`+ /// </summary>`
	`423`	`+ /// <param name="writer">Buffer to write the field to</param>`
`375`	`424`	`public override void WriteField(FastBufferWriter writer)`
`376`	`425`	`{`
`377`	`426`	`m_AuthoritativeValue.WriteField(writer);`
`378`	`427`	`}`
`379`	`428`
	`429`	`+ /// <summary>`
	`430`	`+ /// Reads the complete state of the variable from the network stream`
	`431`	`+ /// </summary>`
	`432`	`+ /// <param name="reader">Buffer to read the field from</param>`
`380`	`433`	`public override void ReadField(FastBufferReader reader)`
`381`	`434`	`{`
`382`	`435`	`m_AuthoritativeValue.ReadField(reader);`
`383`	`436`	`NetworkVariableSerialization<T>.Duplicate(m_AuthoritativeValue.Value, ref m_AnticipatedValue);`
`384`	`437`	`NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);`
`385`	`438`	`}`
`386`	`439`
	`440`	`+ /// <summary>`
	`441`	`+ /// Reads changes in the variable's value from the network stream`
	`442`	`+ /// </summary>`
	`443`	`+ /// <param name="reader">Buffer to read the delta from</param>`
	`444`	`+ /// <param name="keepDirtyDelta">Whether to maintain the dirty state after reading</param>`
`387`	`445`	`public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)`
`388`	`446`	`{`
`389`	`447`	`m_AuthoritativeValue.ReadDelta(reader, keepDirtyDelta);`