feat: Adding transport RTT to UI stats and using exponential moving average for calculations (#528)

Author: SamuelBellomo

Assets/BossRoom/Scripts/Shared/Net/NetworkStats.cs

@@ -16,35 +16,47 @@ namespace Unity.Multiplayer.Samples.BossRoom
     [RequireComponent(typeof(NetworkObject))]
     public class NetworkStats : NetworkBehaviour
     {
+        // For a value like RTT an exponential moving average is a better indication of the current rtt and fluctuates less.
+        struct ExponentialMovingAverageCalculator
+        {
+            readonly float m_Alpha;
+            float m_Average;
+
+            public float Average => m_Average;
+
+            public ExponentialMovingAverageCalculator(float average)
+            {
+                m_Alpha = 2f / (k_MaxWindowSize + 1);
+                m_Average = average;
+            }
+
+            public float NextValue(float value) => m_Average = (value - m_Average) * m_Alpha + m_Average;
+        }
+
         // RTT
         // Client sends a ping RPC to the server and starts it's timer.
         // The server receives the ping and sends a pong response to the client.
         // The client receives that pong response and stops its time.
         // The RPC value is using a moving average, so we don't have a value that moves too much, but is still reactive to RTT changes.
-        //
-        // Note: when adding more stats, it might be worth it to abstract these in their own classes instead of having a bunch
-        // of attributes floating around.
 
-        public float LastRTT { get; private set; }
+        const int k_MaxWindowSizeSeconds = 3; // it should take x seconds for the value to react to change
+        const float k_PingIntervalSeconds = 0.1f;
+        const float k_MaxWindowSize = k_MaxWindowSizeSeconds / k_PingIntervalSeconds;
+
+        ExponentialMovingAverageCalculator m_BossRoomRTT = new ExponentialMovingAverageCalculator(0);
+        ExponentialMovingAverageCalculator m_UtpRTT = new ExponentialMovingAverageCalculator(0);
 
-        [SerializeField]
-        [Tooltip("The interval to send ping RPCs to calculate the RTT. The bigger the number, the less reactive the stat will be to RTT changes")]
-        float m_PingIntervalSeconds = 0.1f;
         float m_LastPingTime;
         Text m_TextStat;
         Text m_TextHostType;
 
         // When receiving pong client RPCs, we need to know when the initiating ping sent it so we can calculate its individual RTT
         int m_CurrentRTTPingId;
 
-        Queue<float> m_MovingWindow = new Queue<float>();
-        const int k_MaxWindowSizeSeconds = 3; // it should take x seconds for the value to react to change
-        float m_MaxWindowSize => k_MaxWindowSizeSeconds / m_PingIntervalSeconds;
         Dictionary<int, float> m_PingHistoryStartTimes = new Dictionary<int, float>();
 
         ClientRpcParams m_PongClientParams;
 
-
         public override void OnNetworkSpawn()
         {
             bool isClientOnly = IsClient && !IsServer;
@@ -53,10 +65,12 @@ public override void OnNetworkSpawn()
                 Destroy(this);
                 return;
             }
+
             if (IsOwner)
             {
                 CreateNetworkStatsText();
             }
+
             m_PongClientParams = new ClientRpcParams() { Send = new ClientRpcSendParams() { TargetClientIds = new[] { OwnerClientId } } };
         }
 
@@ -71,7 +85,7 @@ void CreateNetworkStatsText()
             InitializeTextLine("No Stat", out m_TextStat);
         }
 
-        private void InitializeTextLine(string defaultText, out Text textComponent)
+        void InitializeTextLine(string defaultText, out Text textComponent)
         {
             GameObject rootGO = new GameObject("UI Stat Text");
             textComponent = rootGO.AddComponent<Text>();
@@ -91,19 +105,21 @@ void FixedUpdate()
             var textToDisplay = string.Empty;
             if (!IsServer)
             {
-                if (Time.realtimeSinceStartup - m_LastPingTime > m_PingIntervalSeconds)
+                if (Time.realtimeSinceStartup - m_LastPingTime > k_PingIntervalSeconds)
                 {
                     // We could have had a ping/pong where the ping sends the pong and the pong sends the ping. Issue with this
                     // is the higher the latency, the lower the sampling would be. We need pings to be sent at a regular interval
                     PingServerRPC(m_CurrentRTTPingId);
                     m_PingHistoryStartTimes[m_CurrentRTTPingId] = Time.realtimeSinceStartup;
                     m_CurrentRTTPingId++;
                     m_LastPingTime = Time.realtimeSinceStartup;
+
+                    m_UtpRTT.NextValue(NetworkManager.NetworkConfig.NetworkTransport.GetCurrentRtt(NetworkManager.ServerClientId));
                 }
 
                 if (m_TextStat != null)
                 {
-                    textToDisplay = $"{textToDisplay}RTT: {(LastRTT * 1000f).ToString()} ms ";
+                    textToDisplay = $"{textToDisplay}RTT: {(m_BossRoomRTT.Average * 1000).ToString("0")} ms;\nUTP RTT {m_UtpRTT.Average.ToString("0")} ms";
                 }
             }
 
@@ -118,36 +134,18 @@ void FixedUpdate()
             }
         }
 
-
         [ServerRpc]
-        public void PingServerRPC(int pingId, ServerRpcParams serverParams = default)
+        void PingServerRPC(int pingId, ServerRpcParams serverParams = default)
         {
             PongClientRPC(pingId, m_PongClientParams);
         }
 
         [ClientRpc]
-        public void PongClientRPC(int pingId, ClientRpcParams clientParams = default)
+        void PongClientRPC(int pingId, ClientRpcParams clientParams = default)
         {
             var startTime = m_PingHistoryStartTimes[pingId];
             m_PingHistoryStartTimes.Remove(pingId);
-            m_MovingWindow.Enqueue(Time.realtimeSinceStartup - startTime);
-            UpdateRTTSlidingWindowAverage();
-        }
-
-        void UpdateRTTSlidingWindowAverage()
-        {
-            if (m_MovingWindow.Count > m_MaxWindowSize)
-            {
-                m_MovingWindow.Dequeue();
-            }
-
-            float rttSum = 0;
-            foreach (var singleRTT in m_MovingWindow)
-            {
-                rttSum += singleRTT;
-            }
-
-            LastRTT = rttSum / m_MaxWindowSize;
+            m_BossRoomRTT.NextValue(Time.realtimeSinceStartup - startTime);
         }
 
         public override void OnNetworkDespawn()
@@ -156,6 +154,7 @@ public override void OnNetworkDespawn()
             {
                 Destroy(m_TextStat.gameObject);
             }
+
             if (m_TextHostType != null)
             {
                 Destroy(m_TextHostType.gameObject);