feat: Adding "previousValue" in NetworkListEvent (#1528)

* Quality of life, adding "previousValue" field in list events. This way, instead of users having to maintain a local value themselves, we just add it when individual values changes. It'll stay to default with other event types (just like "index" stays to default when the event type doesn't have an index)

* update to changelog

Author: SamuelBellomo

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -9,6 +9,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 ## [Unreleased]
 
 ### Added
+- Adding `PreviousValue` in NetworkListEvent, when `Value` has changed
 
 ### Removed
 

com.unity.netcode.gameobjects/Runtime/NetworkVariable/Collections/NetworkList.cs

@@ -272,18 +272,22 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
                         {
                             reader.ReadValueSafe(out int index);
                             reader.ReadValueSafe(out T value);
-                            if (index < m_List.Length)
+                            if (index >= m_List.Length)
                             {
-                                m_List[index] = value;
+                                throw new Exception("Shouldn't be here, index is higher than list length");
                             }
 
+                            var previousValue = m_List[index];
+                            m_List[index] = value;
+
                             if (OnListChanged != null)
                             {
                                 OnListChanged(new NetworkListEvent<T>
                                 {
                                     Type = eventType,
                                     Index = index,
-                                    Value = value
+                                    Value = value,
+                                    PreviousValue = previousValue
                                 });
                             }
 
@@ -293,7 +297,8 @@ public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
                                 {
                                     Type = eventType,
                                     Index = index,
-                                    Value = value
+                                    Value = value,
+                                    PreviousValue = previousValue
                                 });
                             }
                         }
@@ -528,6 +533,11 @@ public enum EventType : byte
         /// </summary>
         public T Value;
 
+        /// <summary>
+        /// The previous value when "Value" has changed, if available.
+        /// </summary>
+        public T PreviousValue;
+
         /// <summary>
         /// the index changed, added or removed if available
         /// </summary>

com.unity.netcode.gameobjects/Tests/Runtime/NetworkVariableTests.cs

@@ -364,6 +364,58 @@ public IEnumerator NetworkListArrayOperator([Values(true, false)] bool useHost)
             );
         }
 
+
+        [UnityTest]
+        public IEnumerator NetworkListValueUpdate([Values(true, false)] bool useHost)
+        {
+            m_TestWithHost = useHost;
+            yield return MultiInstanceHelpers.RunAndWaitForCondition(
+                () =>
+                {
+                    m_Player1OnServer.TheList.Add(k_TestVal1);
+                },
+                () =>
+                {
+                    return m_Player1OnServer.TheList.Count == 1 &&
+                           m_Player1OnClient1.TheList.Count == 1 &&
+                           m_Player1OnServer.TheList[0] == k_TestVal1 &&
+                           m_Player1OnClient1.TheList[0] == k_TestVal1;
+                }
+            );
+
+            var testSucceeded = false;
+
+            void TestValueUpdatedCallback(NetworkListEvent<int> changedEvent)
+            {
+                testSucceeded = changedEvent.PreviousValue == k_TestVal1 &&
+                                changedEvent.Value == k_TestVal3;
+            }
+
+            try
+            {
+                yield return MultiInstanceHelpers.RunAndWaitForCondition(
+                    () =>
+                    {
+                        m_Player1OnServer.TheList[0] = k_TestVal3;
+                        m_Player1OnClient1.TheList.OnListChanged += TestValueUpdatedCallback;
+                    },
+                    () =>
+                    {
+                        return m_Player1OnServer.TheList.Count == 1 &&
+                               m_Player1OnClient1.TheList.Count == 1 &&
+                               m_Player1OnServer.TheList[0] == k_TestVal3 &&
+                               m_Player1OnClient1.TheList[0] == k_TestVal3;
+                    }
+                );
+            }
+            finally
+            {
+                m_Player1OnClient1.TheList.OnListChanged -= TestValueUpdatedCallback;
+            }
+
+            Assert.That(testSucceeded);
+        }
+
         [Test]
         public void NetworkListIEnumerator([Values(true, false)] bool useHost)
         {