Group HitResults with the same name into one column in beatmap ranking

Closes ppy#29911

osu.Game.Tests/Visual/Online/TestSceneScoresContainer.cs

@@ -8,11 +8,13 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
@@ -90,6 +92,41 @@ public void TestNoUserBest()
             AddAssert("no best score displayed", () => scoresContainer.ChildrenOfType<DrawableTopScore>().Count() == 1);
         }
 
+        [Test]
+        public void TestHitResultsWithSameNameAreGrouped()
+        {
+            AddStep("Load scores without user best", () =>
+            {
+                var allScores = createScores();
+                allScores.UserScore = null;
+                scoresContainer.Scores = allScores;
+            });
+
+            AddUntilStep("wait for scores displayed", () => scoresContainer.ChildrenOfType<ScoreTableRowBackground>().Any());
+            AddAssert("only one column for slider end", () => scoresContainer.ScoreTable.Columns.Where(c => c.Header.Equals("slider end")).Count() == 1);
+
+            AddAssert("all rows show non-zero slider ends", () =>
+            {
+                int sliderEndColumnIndex = Array.FindIndex(scoresContainer.ScoreTable.Columns, c => c != null && c.Header.Equals("slider end"));
+                bool sliderEndFilledInEachRow = true;
+                for (int i = 0; i < scoresContainer.ScoreTable.Content.GetLength(0); i++)
+                {
+                    switch (scoresContainer.ScoreTable.Content[i, sliderEndColumnIndex])
+                    {
+                        case OsuSpriteText text:
+                            if (text.Text.Equals(0.0d.ToLocalisableString(@"N0")))
+                                sliderEndFilledInEachRow = false;
+                            break;
+                        default:
+                            sliderEndFilledInEachRow = false;
+                            break;
+                    }
+                }
+                return sliderEndFilledInEachRow;
+            });
+        }
+
+
         [Test]
         public void TestUserBest()
         {
@@ -287,24 +324,37 @@ private APIScoresCollection createScores()
 
             const int initial_great_count = 2000;
             const int initial_tick_count = 100;
+            const int initial_slider_end_count = 500;
 
             int greatCount = initial_great_count;
             int tickCount = initial_tick_count;
+            int sliderEndCount = initial_slider_end_count;
 
-            foreach (var s in scores.Scores)
+            foreach (var (score, index) in scores.Scores.Select((s, i) => (s, i)))
             {
-                s.Statistics = new Dictionary<HitResult, int>
+                HitResult sliderEndResult = index % 2 == 0 ? HitResult.SliderTailHit : HitResult.SmallTickHit;
+
+                score.Statistics = new Dictionary<HitResult, int>
                 {
                     { HitResult.Great, greatCount },
                     { HitResult.LargeTickHit, tickCount },
                     { HitResult.Ok, RNG.Next(100) },
                     { HitResult.Meh, RNG.Next(100) },
                     { HitResult.Miss, initial_great_count - greatCount },
                     { HitResult.LargeTickMiss, initial_tick_count - tickCount },
+                    { sliderEndResult , sliderEndCount },
+                };
+
+                // Some hit results, including SliderTailHit and SmallTickHit, are only displayed
+                // when the maximum number is known
+                score.MaximumStatistics = new Dictionary<HitResult, int>
+                {
+                    { sliderEndResult, initial_slider_end_count },
                 };
 
                 greatCount -= 100;
                 tickCount -= RNG.Next(1, 5);
+                sliderEndCount -= 20;
             }
 
             return scores;

osu.Game/Overlays/BeatmapSet/Scores/ScoreTable.cs

@@ -9,7 +9,6 @@
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions;
-using osu.Framework.Extensions.EnumExtensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -58,9 +57,11 @@ public ScoreTable()
         }
 
         /// <summary>
-        /// The statistics that appear in the table, in order of appearance.
+        /// The statistics that appear in the table, grouped by their display name. If multiple HitResults have the same
+        /// DisplayName (for example, "slider end" is the name for both HitResult.SliderTailTick and HitResult.SmallTickHit
+        /// in osu!std) the name will only be listed once.
         /// </summary>
-        private readonly List<(HitResult result, LocalisableString displayName)> statisticResultTypes = new List<(HitResult, LocalisableString)>();
+        private readonly List<(LocalisableString displayName, IEnumerable<HitResult> results)> statisticResults = new();
 
         private bool showPerformancePoints;
 
@@ -72,7 +73,7 @@ public void DisplayScores(IReadOnlyList<ScoreInfo> scores, bool showPerformanceC
                 return;
 
             showPerformancePoints = showPerformanceColumn;
-            statisticResultTypes.Clear();
+            statisticResults.Clear();
 
             for (int i = 0; i < scores.Count; i++)
                 backgroundFlow.Add(new ScoreTableRowBackground(i, scores[i], row_height));
@@ -105,20 +106,18 @@ private TableColumn[] createHeaders(IReadOnlyList<ScoreInfo> scores)
 
             var ruleset = scores.First().Ruleset.CreateInstance();
 
-            foreach (var result in EnumExtensions.GetValuesInOrder<HitResult>())
+            foreach (var resultGroup in ruleset.GetHitResults().GroupBy(r => r.displayName))
             {
-                if (!allScoreStatistics.Contains(result))
+                if (!resultGroup.Any(r => allScoreStatistics.Contains(r.result)))
                     continue;
 
                 // for the time being ignore bonus result types.
                 // this is not being sent from the API and will be empty in all cases.
-                if (result.IsBonus())
+                if (resultGroup.All(r => r.result.IsBonus()))
                     continue;
 
-                var displayName = ruleset.GetDisplayNameForHitResult(result);
-
-                columns.Add(new TableColumn(displayName, Anchor.CentreLeft, new Dimension(minSize: 35, maxSize: 60)));
-                statisticResultTypes.Add((result, displayName));
+                columns.Add(new TableColumn(resultGroup.Key, Anchor.CentreLeft, new Dimension(minSize: 35, maxSize: 60)));
+                statisticResults.Add((resultGroup.Key, resultGroup.Select(r => r.result)));
             }
 
             if (showPerformancePoints)
@@ -167,12 +166,16 @@ private Drawable[] createContent(int index, ScoreInfo score)
 #pragma warning restore 618
             };
 
-            var availableStatistics = score.GetStatisticsForDisplay().ToDictionary(tuple => tuple.Result);
+            var availableStatistics = score.GetStatisticsForDisplay().ToLookup(touple => touple.DisplayName);
 
-            foreach (var result in statisticResultTypes)
+            foreach (var (columnName, resultTypes) in statisticResults)
             {
-                if (!availableStatistics.TryGetValue(result.result, out var stat))
-                    stat = new HitResultDisplayStatistic(result.result, 0, null, result.displayName);
+                HitResultDisplayStatistic stat = null;
+                if (!availableStatistics.Contains(columnName))
+                    stat = new HitResultDisplayStatistic(resultTypes.First(), 0, null, columnName);
+                else
+                    foreach (var s in availableStatistics[columnName])
+                        stat = s;
 
                 content.Add(new StatisticText(stat.Count, stat.MaxCount, @"N0") { Colour = stat.Count == 0 ? Color4.Gray : Color4.White });
             }

osu.Game/Overlays/BeatmapSet/Scores/ScoresContainer.cs

@@ -34,7 +34,7 @@ public partial class ScoresContainer : BeatmapSetLayoutSection
         private readonly IBindable<APIUser> user = new Bindable<APIUser>();
 
         private readonly Box background;
-        private readonly ScoreTable scoreTable;
+        public readonly ScoreTable ScoreTable;
         private readonly FillFlowContainer topScoresContainer;
         private readonly LoadingLayer loading;
         private readonly LeaderboardModSelector modSelector;
@@ -59,8 +59,8 @@ protected APIScoresCollection Scores
                 loadCancellationSource = new CancellationTokenSource();
 
                 topScoresContainer.Clear();
-                scoreTable.ClearScores();
-                scoreTable.Hide();
+                ScoreTable.ClearScores();
+                ScoreTable.Hide();
 
                 loading.Hide();
                 loading.FinishTransforms();
@@ -85,8 +85,8 @@ protected APIScoresCollection Scores
                 var scores = value.Scores.Select(s => s.ToScoreInfo(rulesets, beatmapInfo)).OrderByTotalScore().ToArray();
                 var topScore = scores.First();
 
-                scoreTable.DisplayScores(scores, apiBeatmap.Status.GrantsPerformancePoints());
-                scoreTable.Show();
+                ScoreTable.DisplayScores(scores, apiBeatmap.Status.GrantsPerformancePoints());
+                ScoreTable.Show();
 
                 var userScore = value.UserScore;
                 var userScoreInfo = userScore?.Score.ToScoreInfo(rulesets, beatmapInfo);
@@ -175,7 +175,7 @@ public ScoresContainer()
                                             Direction = FillDirection.Vertical,
                                             Spacing = new Vector2(0, 5),
                                         },
-                                        scoreTable = new ScoreTable
+                                        ScoreTable = new ScoreTable
                                         {
                                             Anchor = Anchor.TopCentre,
                                             Origin = Anchor.TopCentre,