Update ScoreCounter components to bind outwards

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

@@ -4,10 +4,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play.HUD;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -18,37 +20,27 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
 
+        [Cached]
+        private ScoreProcessor scoreProcessor = new ScoreProcessor();
+
         [SetUpSteps]
         public void SetUpSteps()
         {
-            AddStep("Create combo counters", () => SetContents(() =>
+            AddStep("Create score counters", () => SetContents(() => new SkinnableScoreCounter()));
-            {
-                var comboCounter = new SkinnableScoreCounter();
-                comboCounter.Current.Value = 1;
-                return comboCounter;
-            }));
         }
 
         [Test]
         public void TestScoreCounterIncrementing()
         {
-            AddStep(@"Reset all", delegate
+            AddStep(@"Reset all", () => scoreProcessor.TotalScore.Value = 0);
-            {
-                foreach (var s in scoreCounters)
-                    s.Current.Value = 0;
-            });
 
-            AddStep(@"Hit! :D", delegate
+            AddStep(@"Hit! :D", () => scoreProcessor.TotalScore.Value += 300);
-            {
-                foreach (var s in scoreCounters)
-                    s.Current.Value += 300;
-            });
         }
 
         [Test]
         public void TestVeryLargeScore()
         {
-            AddStep("set large score", () => scoreCounters.ForEach(counter => counter.Current.Value = 1_000_000_000));
+            AddStep("set large score", () => scoreCounters.ForEach(counter => scoreProcessor.TotalScore.Value = 1_000_000_000));
         }
     }
 }

osu.Game/Graphics/UserInterface/ScoreCounter.cs

@@ -4,11 +4,10 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Screens.Play.HUD;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public abstract class ScoreCounter : RollingCounter<double>, IScoreCounter
+    public abstract class ScoreCounter : RollingCounter<double>
     {
         protected override double RollingDuration => 1000;
         protected override Easing RollingEasing => Easing.Out;

osu.Game/Screens/Play/HUD/DefaultScoreCounter.cs

@@ -4,11 +4,10 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Graphics;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Screens.Play.HUD
 {
-    public class DefaultScoreCounter : ScoreCounter
+    public class DefaultScoreCounter : GameplayScoreCounter
     {
         public DefaultScoreCounter()
             : base(6)

osu.Game/Screens/Play/HUD/GameplayScoreCounter.cs

@@ -0,0 +1,46 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Screens.Play.HUD
+{
+    public abstract class GameplayScoreCounter : ScoreCounter
+    {
+        private Bindable<ScoringMode> scoreDisplayMode;
+
+        protected GameplayScoreCounter(int leading = 0, bool useCommaSeparator = false)
+            : base(leading, useCommaSeparator)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config, ScoreProcessor scoreProcessor)
+        {
+            scoreDisplayMode = config.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode);
+            scoreDisplayMode.BindValueChanged(scoreMode =>
+            {
+                switch (scoreMode.NewValue)
+                {
+                    case ScoringMode.Standardised:
+                        RequiredDisplayDigits.Value = 6;
+                        break;
+
+                    case ScoringMode.Classic:
+                        RequiredDisplayDigits.Value = 8;
+                        break;
+
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(scoreMode));
+                }
+            }, true);
+
+            Current.BindTo(scoreProcessor.TotalScore);
+        }
+    }
+}

osu.Game/Screens/Play/HUD/IScoreCounter.cs

@@ -1,25 +0,0 @@
-// 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 osu.Framework.Bindables;
-using osu.Framework.Graphics;
-
-namespace osu.Game.Screens.Play.HUD
-{
-    /// <summary>
-    /// An interface providing a set of methods to update a score counter.
-    /// </summary>
-    public interface IScoreCounter : IDrawable
-    {
-        /// <summary>
-        /// The current score to be displayed.
-        /// </summary>
-        Bindable<double> Current { get; }
-
-        /// <summary>
-        /// The number of digits required to display most sane scores.
-        /// This may be exceeded in very rare cases, but is useful to pad or space the display to avoid it jumping around.
-        /// </summary>
-        Bindable<int> RequiredDisplayDigits { get; }
-    }
-}

osu.Game/Screens/Play/HUD/SkinnableScoreCounter.cs

@@ -1,61 +1,16 @@
 // 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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Configuration;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 
 namespace osu.Game.Screens.Play.HUD
 {
-    public class SkinnableScoreCounter : SkinnableDrawable, IScoreCounter
+    public class SkinnableScoreCounter : SkinnableDrawable
     {
-        public Bindable<double> Current { get; } = new Bindable<double>();
-
-        private Bindable<ScoringMode> scoreDisplayMode;
-
-        public Bindable<int> RequiredDisplayDigits { get; } = new Bindable<int>();
-
         public SkinnableScoreCounter()
             : base(new HUDSkinComponent(HUDSkinComponents.ScoreCounter), _ => new DefaultScoreCounter())
         {
             CentreComponent = false;
         }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            scoreDisplayMode = config.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode);
-            scoreDisplayMode.BindValueChanged(scoreMode =>
-            {
-                switch (scoreMode.NewValue)
-                {
-                    case ScoringMode.Standardised:
-                        RequiredDisplayDigits.Value = 6;
-                        break;
-
-                    case ScoringMode.Classic:
-                        RequiredDisplayDigits.Value = 8;
-                        break;
-
-                    default:
-                        throw new ArgumentOutOfRangeException(nameof(scoreMode));
-                }
-            }, true);
-        }
-
-        private IScoreCounter skinnedCounter;
-
-        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
-        {
-            base.SkinChanged(skin, allowFallback);
-
-            skinnedCounter = Drawable as IScoreCounter;
-
-            skinnedCounter?.Current.BindTo(Current);
-            skinnedCounter?.RequiredDisplayDigits.BindTo(RequiredDisplayDigits);
-        }
     }
 }

osu.Game/Screens/Play/HUDOverlay.cs

@@ -320,7 +320,6 @@ namespace osu.Game.Screens.Play
 
         protected virtual void BindScoreProcessor(ScoreProcessor processor)
         {
-            ScoreCounter?.Current.BindTo(processor.TotalScore);
             AccuracyCounter?.Current.BindTo(processor.Accuracy);
 
             if (HealthDisplay is IHealthDisplay shd)

osu.Game/Skinning/LegacyScoreCounter.cs

@@ -4,12 +4,12 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Play.HUD;
 using osuTK;
 
 namespace osu.Game.Skinning
 {
-    public class LegacyScoreCounter : ScoreCounter
+    public class LegacyScoreCounter : GameplayScoreCounter
     {
         private readonly ISkin skin;