Add clicks/second counter to HUD

osu.Game.Tests/Skins/SkinDeserialisationTest.cs

@@ -36,7 +36,9 @@ public class SkinDeserialisationTest
             "Archives/modified-default-20220723.osk",
             "Archives/modified-classic-20220723.osk",
             // Covers legacy song progress, UR counter, colour hit error metre.
-            "Archives/modified-classic-20220801.osk"
+            "Archives/modified-classic-20220801.osk",
+            // Covers clicks/s counter
+            "Archives/modified-default-20220818.osk"
         };
 
         /// <summary>

osu.Game.Tests/Visual/Gameplay/TestSceneClicksPerSecondCalculator.cs

@@ -0,0 +1,124 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD.ClicksPerSecond;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneClicksPerSecondCalculator : OsuTestScene
+    {
+        private ClicksPerSecondCalculator calculator = null!;
+
+        private TestGameplayClock manualGameplayClock = null!;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create components", () =>
+            {
+                manualGameplayClock = new TestGameplayClock();
+
+                Child = new DependencyProvidingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = new (Type, object)[] { (typeof(IGameplayClock), manualGameplayClock) },
+                    Children = new Drawable[]
+                    {
+                        calculator = new ClicksPerSecondCalculator(),
+                        new DependencyProvidingContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            CachedDependencies = new (Type, object)[] { (typeof(ClicksPerSecondCalculator), calculator) },
+                            Child = new ClicksPerSecondCounter
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Scale = new Vector2(5),
+                            }
+                        }
+                    },
+                };
+            });
+        }
+
+        [Test]
+        public void TestBasicConsistency()
+        {
+            seek(1000);
+            AddStep("add inputs in past", () => addInputs(new double[] { 0, 100, 200, 300, 400, 500, 600, 700, 800, 900 }));
+            checkClicksPerSecondValue(10);
+        }
+
+        [Test]
+        public void TestRateAdjustConsistency()
+        {
+            seek(1000);
+            AddStep("add inputs in past", () => addInputs(new double[] { 0, 100, 200, 300, 400, 500, 600, 700, 800, 900 }));
+            checkClicksPerSecondValue(10);
+            AddStep("set rate 0.5x", () => manualGameplayClock.TrueGameplayRate = 0.5);
+            checkClicksPerSecondValue(5);
+        }
+
+        [Test]
+        public void TestInputsDiscardedOnRewind()
+        {
+            seek(1000);
+            AddStep("add inputs in past", () => addInputs(new double[] { 0, 100, 200, 300, 400, 500, 600, 700, 800, 900 }));
+            checkClicksPerSecondValue(10);
+            seek(500);
+            checkClicksPerSecondValue(6);
+            seek(1000);
+            checkClicksPerSecondValue(6);
+        }
+
+        private void checkClicksPerSecondValue(int i) => AddAssert("clicks/s is correct", () => calculator.Value, () => Is.EqualTo(i));
+
+        private void seekClockImmediately(double time) => manualGameplayClock.CurrentTime = time;
+
+        private void seek(double time) => AddStep($"Seek to {time}ms", () => seekClockImmediately(time));
+
+        private void addInputs(IEnumerable<double> inputs)
+        {
+            double baseTime = manualGameplayClock.CurrentTime;
+
+            foreach (double timestamp in inputs)
+            {
+                seekClockImmediately(timestamp);
+                calculator.AddInputTimestamp();
+            }
+
+            seekClockImmediately(baseTime);
+        }
+
+        private class TestGameplayClock : IGameplayClock
+        {
+            public double CurrentTime { get; set; }
+
+            public double Rate => 1;
+
+            public bool IsRunning => true;
+
+            public double TrueGameplayRate { get; set; } = 1;
+
+            public void ProcessFrame()
+            {
+            }
+
+            public double ElapsedFrameTime => throw new NotImplementedException();
+            public double FramesPerSecond => throw new NotImplementedException();
+            public FrameTimeInfo TimeInfo => throw new NotImplementedException();
+            public double StartTime => throw new NotImplementedException();
+            public IEnumerable<double> NonGameplayAdjustments => throw new NotImplementedException();
+            public IBindable<bool> IsPaused => throw new NotImplementedException();
+        }
+    }
+}

osu.Game/Rulesets/UI/DrawableRuleset.cs

@@ -30,6 +30,7 @@
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD.ClicksPerSecond;
 using osuTK;
 
 namespace osu.Game.Rulesets.UI
@@ -38,7 +39,7 @@ namespace osu.Game.Rulesets.UI
     /// Displays an interactive ruleset gameplay instance.
     /// </summary>
     /// <typeparam name="TObject">The type of HitObject contained by this DrawableRuleset.</typeparam>
-    public abstract class DrawableRuleset<TObject> : DrawableRuleset, IProvideCursor, ICanAttachKeyCounter
+    public abstract class DrawableRuleset<TObject> : DrawableRuleset, IProvideCursor, ICanAttachHUDPieces
         where TObject : HitObject
     {
         public override event Action<JudgementResult> NewResult;
@@ -338,7 +339,10 @@ public override void SetReplayScore(Score replayScore)
         public abstract DrawableHitObject<TObject> CreateDrawableRepresentation(TObject h);
 
         public void Attach(KeyCounterDisplay keyCounter) =>
-            (KeyBindingInputManager as ICanAttachKeyCounter)?.Attach(keyCounter);
+            (KeyBindingInputManager as ICanAttachHUDPieces)?.Attach(keyCounter);
+
+        public void Attach(ClicksPerSecondCalculator calculator) =>
+            (KeyBindingInputManager as ICanAttachHUDPieces)?.Attach(calculator);
 
         /// <summary>
         /// Creates a key conversion input manager. An exception will be thrown if a valid <see cref="RulesetInputManager{T}"/> is not returned.

osu.Game/Rulesets/UI/FrameStabilityContainer.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.UI
     /// </summary>
     [Cached(typeof(IGameplayClock))]
     [Cached(typeof(IFrameStableClock))]
-    public sealed class FrameStabilityContainer : Container, IHasReplayHandler, IFrameStableClock, IGameplayClock
+    public sealed class FrameStabilityContainer : Container, IHasReplayHandler, IFrameStableClock
     {
         public ReplayInputHandler? ReplayInputHandler { get; set; }
 

osu.Game/Rulesets/UI/IFrameStableClock.cs

@@ -2,11 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Bindables;
-using osu.Framework.Timing;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Rulesets.UI
 {
-    public interface IFrameStableClock : IFrameBasedClock
+    public interface IFrameStableClock : IGameplayClock
     {
         IBindable<bool> IsCatchingUp { get; }
 

osu.Game/Rulesets/UI/RulesetInputManager.cs

@@ -20,11 +20,12 @@
 using osu.Game.Input.Handlers;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD.ClicksPerSecond;
 using static osu.Game.Input.Handlers.ReplayInputHandler;
 
 namespace osu.Game.Rulesets.UI
 {
-    public abstract class RulesetInputManager<T> : PassThroughInputManager, ICanAttachKeyCounter, IHasReplayHandler, IHasRecordingHandler
+    public abstract class RulesetInputManager<T> : PassThroughInputManager, ICanAttachHUDPieces, IHasReplayHandler, IHasRecordingHandler
         where T : struct
     {
         public readonly KeyBindingContainer<T> KeyBindingContainer;
@@ -168,7 +169,7 @@ public void Attach(KeyCounterDisplay keyCounter)
                                                    .Select(action => new KeyCounterAction<T>(action)));
         }
 
-        public class ActionReceptor : KeyCounterDisplay.Receptor, IKeyBindingHandler<T>
+        private class ActionReceptor : KeyCounterDisplay.Receptor, IKeyBindingHandler<T>
         {
             public ActionReceptor(KeyCounterDisplay target)
                 : base(target)
@@ -186,6 +187,37 @@ public void OnReleased(KeyBindingReleaseEvent<T> e)
 
         #endregion
 
+        #region Keys per second Counter Attachment
+
+        public void Attach(ClicksPerSecondCalculator calculator)
+        {
+            var listener = new ActionListener(calculator);
+
+            KeyBindingContainer.Add(listener);
+        }
+
+        private class ActionListener : Component, IKeyBindingHandler<T>
+        {
+            private readonly ClicksPerSecondCalculator calculator;
+
+            public ActionListener(ClicksPerSecondCalculator calculator)
+            {
+                this.calculator = calculator;
+            }
+
+            public bool OnPressed(KeyBindingPressEvent<T> e)
+            {
+                calculator.AddInputTimestamp();
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<T> e)
+            {
+            }
+        }
+
+        #endregion
+
         protected virtual KeyBindingContainer<T> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
             => new RulesetKeyBindingContainer(ruleset, variant, unique);
 
@@ -221,12 +253,13 @@ public interface IHasRecordingHandler
     }
 
     /// <summary>
-    /// Supports attaching a <see cref="KeyCounterDisplay"/>.
+    /// Supports attaching various HUD pieces.
     /// Keys will be populated automatically and a receptor will be injected inside.
     /// </summary>
-    public interface ICanAttachKeyCounter
+    public interface ICanAttachHUDPieces
     {
         void Attach(KeyCounterDisplay keyCounter);
+        void Attach(ClicksPerSecondCalculator calculator);
     }
 
     public class RulesetInputManagerInputState<T> : InputState

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

@@ -0,0 +1,59 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Screens.Play.HUD.ClicksPerSecond
+{
+    public class ClicksPerSecondCalculator : Component
+    {
+        private readonly List<double> timestamps = new List<double>();
+
+        [Resolved]
+        private IGameplayClock gameplayClock { get; set; } = null!;
+
+        [Resolved(canBeNull: true)]
+        private DrawableRuleset? drawableRuleset { get; set; }
+
+        public int Value { get; private set; }
+
+        // Even though `FrameStabilityContainer` caches as a `GameplayClock`, we need to check it directly via `drawableRuleset`
+        // as this calculator is not contained within the `FrameStabilityContainer` and won't see the dependency.
+        private IGameplayClock clock => drawableRuleset?.FrameStableClock ?? gameplayClock;
+
+        public ClicksPerSecondCalculator()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        public void AddInputTimestamp() => timestamps.Add(clock.CurrentTime);
+
+        protected override void Update()
+        {
+            base.Update();
+
+            double latestValidTime = clock.CurrentTime;
+            double earliestTimeValid = latestValidTime - 1000 * gameplayClock.TrueGameplayRate;
+
+            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++;
+            }
+
+            Value = count;
+        }
+    }
+}