perf: optimize gameplay hot paths — ClicksPerSecondController, GameplaySampleTriggerSource, HitEventExtensions

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/adbddea2-3da1-47fd-b556-24d1a5d61ad5

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>

Author: Copilot

osu.Game/Rulesets/Scoring/HitEventExtensions.cs

@@ -63,12 +63,23 @@ public static class HitEventExtensions
         /// </returns>
         public static double? CalculateAverageHitError(this IEnumerable<HitEvent> hitEvents)
         {
-            double[] timeOffsets = hitEvents.Where(AffectsUnstableRate).Select(ev => ev.TimeOffset).ToArray();
+            // Single-pass mean using running sum — avoids allocating a temporary array.
+            double sum = 0;
+            int count = 0;
 
-            if (timeOffsets.Length == 0)
+            foreach (var ev in hitEvents)
+            {
+                if (!AffectsUnstableRate(ev))
+                    continue;
+
+                sum += ev.TimeOffset;
+                count++;
+            }
+
+            if (count == 0)
                 return null;
 
-            return timeOffsets.Average();
+            return sum / count;
         }
 
         /// <summary>

osu.Game/Rulesets/UI/GameplaySampleTriggerSource.cs

@@ -64,9 +64,8 @@ public virtual void Play()
             if (nextObject == null)
                 return;
 
-            var samples = nextObject.Samples
-                                    .Cast<ISampleInfo>()
-                                    .ToArray();
+            // HitSampleInfo implements ISampleInfo, so array covariance lets us skip .Cast<>().
+            var samples = nextObject.Samples.ToArray();
 
             PlaySamples(samples);
         }
@@ -135,7 +134,23 @@ protected override void Update()
 
             // Else we want the earliest valid nested.
             // In cases of nested objects, they will always have earlier sample data than their parent object.
-            return getAllNested(mostValidObject.HitObject).OrderBy(h => h.GetEndTime()).SkipWhile(h => h.GetEndTime() <= getReferenceTime()).FirstOrDefault() ?? mostValidObject.HitObject;
+            // Single-pass scan avoids the OrderBy + SkipWhile + FirstOrDefault LINQ chain.
+            double referenceTime = getReferenceTime();
+            HitObject? best = null;
+            double bestEnd = double.MaxValue;
+
+            foreach (var nested in getAllNested(mostValidObject.HitObject))
+            {
+                double end = nested.GetEndTime();
+
+                if (end > referenceTime && end < bestEnd)
+                {
+                    best = nested;
+                    bestEnd = end;
+                }
+            }
+
+            return best ?? mostValidObject.HitObject;
         }
 
         private bool isAlreadyHit(HitObjectLifetimeEntry h) => h.AllJudged;

osu.Game/Screens/Play/HUD/ClicksPerSecond/ClicksPerSecondController.cs

@@ -36,19 +36,23 @@ protected override void Update()
             double latestValidTime = clock.CurrentTime;
             double earliestTimeValid = latestValidTime - 1000 * gameplayClock.GetTrueGameplayRate();
 
+            // Timestamps are added in chronological order (from clock.CurrentTime),
+            // so we can use binary-search-style trimming instead of per-element RemoveAt.
+
+            // Trim future timestamps caused by rewinding (remove from the end in one batch).
+            while (timestamps.Count > 0 && timestamps[^1] > latestValidTime)
+                timestamps.RemoveAt(timestamps.Count - 1);
+
+            // Count timestamps within the valid 1-second window.
+            // Since the list is in chronological order, scan backwards until we leave the window.
             int count = 0;
 
             for (int i = timestamps.Count - 1; i >= 0; i--)
             {
-                // handle rewinding by removing future timestamps as we go
-                if (timestamps[i] > latestValidTime)
-                {
-                    timestamps.RemoveAt(i);
-                    continue;
-                }
-
-                if (timestamps[i] >= earliestTimeValid)
-                    count++;
+                if (timestamps[i] < earliestTimeValid)
+                    break;
+
+                count++;
             }
 
             Value = count;