From 84765b99b36bb66f7aded738867593ad9cb5936b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Thu, 6 Jan 2022 12:57:26 +0100
Subject: [PATCH 01/20] Handle score submission request in submission test
 scene

Was previously not handled at all, therefore displaying request failures
in the test log output. While that was mostly a red herring and
shouldn't have caused any actual *test* failures, it is still better to
handle this explicitly in a realistic manner.
---
 .../TestScenePlayerScoreSubmission.cs         | 51 ++++++++++++++-----
 .../Online/Solo/SubmitSoloScoreRequest.cs     |  8 +--
 2 files changed, 42 insertions(+), 17 deletions(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
index 25808d307d..5ee1f9dd8f 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
@@ -57,7 +57,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestNoSubmissionOnResultsWithNoToken()
         {
-            prepareTokenResponse(false);
+            prepareTestAPI(false);
 
             createPlayerTest();
 
@@ -77,7 +77,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestSubmissionOnResults()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest();
 
@@ -96,7 +96,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestSubmissionForDifferentRuleset()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest(createRuleset: () => new TaikoRuleset());
 
@@ -116,7 +116,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestSubmissionForConvertedBeatmap()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest(createRuleset: () => new ManiaRuleset(), createBeatmap: _ => createTestBeatmap(new OsuRuleset().RulesetInfo));
 
@@ -136,7 +136,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestNoSubmissionOnExitWithNoToken()
         {
-            prepareTokenResponse(false);
+            prepareTestAPI(false);
 
             createPlayerTest();
 
@@ -153,7 +153,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestNoSubmissionOnEmptyFail()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest(true);
 
@@ -168,7 +168,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestSubmissionOnFail()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest(true);
 
@@ -185,7 +185,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestNoSubmissionOnEmptyExit()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest();
 
@@ -198,7 +198,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestSubmissionOnExit()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest();
 
@@ -213,7 +213,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestSubmissionOnExitDuringImport()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest();
             AddStep("block imports", () => Player.AllowImportCompletion.Wait());
@@ -232,7 +232,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestNoSubmissionOnLocalBeatmap()
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest(false, r =>
             {
@@ -253,7 +253,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [TestCase(10)]
         public void TestNoSubmissionOnCustomRuleset(int? rulesetId)
         {
-            prepareTokenResponse(true);
+            prepareTestAPI(true);
 
             createPlayerTest(false, createRuleset: () => new OsuRuleset { RulesetInfo = { OnlineID = rulesetId ?? -1 } });
 
@@ -275,7 +275,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             }));
         }
 
-        private void prepareTokenResponse(bool validToken)
+        private void prepareTestAPI(bool validToken)
         {
             AddStep("Prepare test API", () =>
             {
@@ -289,6 +289,31 @@ namespace osu.Game.Tests.Visual.Gameplay
                             else
                                 tokenRequest.TriggerFailure(new APIException("something went wrong!", null));
                             return true;
+
+                        case SubmitSoloScoreRequest submissionRequest:
+                            if (validToken)
+                            {
+                                var requestScore = submissionRequest.Score;
+
+                                submissionRequest.TriggerSuccess(new MultiplayerScore
+                                {
+                                    ID = 1234,
+                                    User = dummyAPI.LocalUser.Value,
+                                    Rank = requestScore.Rank,
+                                    TotalScore = requestScore.TotalScore,
+                                    Accuracy = requestScore.Accuracy,
+                                    MaxCombo = requestScore.MaxCombo,
+                                    Mods = requestScore.Mods,
+                                    Statistics = requestScore.Statistics,
+                                    Passed = requestScore.Passed,
+                                    EndedAt = DateTimeOffset.Now,
+                                    Position = 1
+                                });
+
+                                return true;
+                            }
+
+                            break;
                     }
 
                     return false;
diff --git a/osu.Game/Online/Solo/SubmitSoloScoreRequest.cs b/osu.Game/Online/Solo/SubmitSoloScoreRequest.cs
index 99cf5ceff5..78ebddb2e6 100644
--- a/osu.Game/Online/Solo/SubmitSoloScoreRequest.cs
+++ b/osu.Game/Online/Solo/SubmitSoloScoreRequest.cs
@@ -12,17 +12,17 @@ namespace osu.Game.Online.Solo
 {
     public class SubmitSoloScoreRequest : APIRequest<MultiplayerScore>
     {
+        public readonly SubmittableScore Score;
+
         private readonly long scoreId;
 
         private readonly int beatmapId;
 
-        private readonly SubmittableScore score;
-
         public SubmitSoloScoreRequest(int beatmapId, long scoreId, ScoreInfo scoreInfo)
         {
             this.beatmapId = beatmapId;
             this.scoreId = scoreId;
-            score = new SubmittableScore(scoreInfo);
+            Score = new SubmittableScore(scoreInfo);
         }
 
         protected override WebRequest CreateWebRequest()
@@ -33,7 +33,7 @@ namespace osu.Game.Online.Solo
             req.Method = HttpMethod.Put;
             req.Timeout = 30000;
 
-            req.AddRaw(JsonConvert.SerializeObject(score, new JsonSerializerSettings
+            req.AddRaw(JsonConvert.SerializeObject(Score, new JsonSerializerSettings
             {
                 ReferenceLoopHandling = ReferenceLoopHandling.Ignore
             }));

From 66613cbaa4551c055a5e756787cb36ab0fe9072c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Thu, 6 Jan 2022 13:09:25 +0100
Subject: [PATCH 02/20] Wait for async continuation in score submission test

The previous assert step was optimistically assuming that the async
continuation that writes the value of
`FakeImportingPlayer.ImportedScore` always completes before it, but
that's not necessarily true even if the continuation is instant (it is
still subject to things like task scheduling and TPL thread pool
limits).

To ensure no spurious failures, swap out the assert step for an until
step instead.
---
 .../Visual/Gameplay/TestScenePlayerScoreSubmission.cs           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
index 5ee1f9dd8f..cf5aadde6d 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
@@ -226,7 +226,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("exit", () => Player.Exit());
             AddStep("allow import to proceed", () => Player.AllowImportCompletion.Release(1));
-            AddAssert("ensure submission", () => Player.SubmittedScore != null && Player.ImportedScore != null);
+            AddUntilStep("ensure submission", () => Player.SubmittedScore != null && Player.ImportedScore != null);
         }
 
         [Test]

From 12c3e56881d9dbc38ecec16c877397a8a7ea6a27 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 7 Jan 2022 19:01:05 +0900
Subject: [PATCH 03/20] Fix `IPCLocationTest` not waiting for load of component

As seen at
https://github.com/ppy/osu/runs/4731480384?check_suite_focus=true.
---
 osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs b/osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs
index 952eb72bf4..03252e3be6 100644
--- a/osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs
+++ b/osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Tournament.Tests.NonVisual
                     TournamentStorage storage = (TournamentStorage)osu.Dependencies.Get<Storage>();
                     FileBasedIPC ipc = null;
 
-                    WaitForOrAssert(() => (ipc = osu.Dependencies.Get<MatchIPCInfo>() as FileBasedIPC) != null, @"ipc could not be populated in a reasonable amount of time");
+                    WaitForOrAssert(() => (ipc = osu.Dependencies.Get<MatchIPCInfo>() as FileBasedIPC)?.IsLoaded == true, @"ipc could not be populated in a reasonable amount of time");
 
                     Assert.True(ipc.SetIPCLocation(testStableInstallDirectory));
                     Assert.True(storage.AllTournaments.Exists("stable.json"));

From 881fa2b86b17aa87119ce58d20fbc27011217c52 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Thu, 6 Jan 2022 14:49:56 +0100
Subject: [PATCH 04/20] Add basic test scene for scoreboard time

---
 .../Visual/Online/TestSceneScoreboardTime.cs  | 57 +++++++++++++++++++
 .../BeatmapSet/Scores/ScoreboardTime.cs       | 21 +++++++
 2 files changed, 78 insertions(+)
 create mode 100644 osu.Game.Tests/Visual/Online/TestSceneScoreboardTime.cs
 create mode 100644 osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs

diff --git a/osu.Game.Tests/Visual/Online/TestSceneScoreboardTime.cs b/osu.Game.Tests/Visual/Online/TestSceneScoreboardTime.cs
new file mode 100644
index 0000000000..7e33b5240c
--- /dev/null
+++ b/osu.Game.Tests/Visual/Online/TestSceneScoreboardTime.cs
@@ -0,0 +1,57 @@
+// 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 System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Overlays.BeatmapSet.Scores;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneScoreboardTime : OsuTestScene
+    {
+        private StopwatchClock stopwatch;
+
+        [Test]
+        public void TestVariousUnits()
+        {
+            AddStep("create various scoreboard times", () => Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Clock = new FramedClock(stopwatch = new StopwatchClock()), // prevent time from naturally elapsing.
+                Direction = FillDirection.Vertical,
+                ChildrenEnumerable = testCases.Select(dateTime => new ScoreboardTime(dateTime, 24).With(time => time.Anchor = time.Origin = Anchor.TopCentre))
+            });
+
+            AddStep("start stopwatch", () => stopwatch.Start());
+        }
+
+        private static IEnumerable<DateTimeOffset> testCases => new[]
+        {
+            DateTimeOffset.Now,
+            DateTimeOffset.Now.AddSeconds(-1),
+            DateTimeOffset.Now.AddSeconds(-25),
+            DateTimeOffset.Now.AddSeconds(-59),
+            DateTimeOffset.Now.AddMinutes(-1),
+            DateTimeOffset.Now.AddMinutes(-25),
+            DateTimeOffset.Now.AddMinutes(-59),
+            DateTimeOffset.Now.AddHours(-1),
+            DateTimeOffset.Now.AddHours(-13),
+            DateTimeOffset.Now.AddHours(-23),
+            DateTimeOffset.Now.AddDays(-1),
+            DateTimeOffset.Now.AddDays(-6),
+            DateTimeOffset.Now.AddDays(-16),
+            DateTimeOffset.Now.AddMonths(-1),
+            DateTimeOffset.Now.AddMonths(-11),
+            DateTimeOffset.Now.AddYears(-1),
+            DateTimeOffset.Now.AddYears(-5)
+        };
+    }
+}
diff --git a/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs b/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs
new file mode 100644
index 0000000000..db421ec6b7
--- /dev/null
+++ b/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs
@@ -0,0 +1,21 @@
+// 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.Game.Graphics;
+
+namespace osu.Game.Overlays.BeatmapSet.Scores
+{
+    public class ScoreboardTime : DrawableDate
+    {
+        public ScoreboardTime(DateTimeOffset date, float textSize = OsuFont.DEFAULT_FONT_SIZE, bool italic = true)
+            : base(date, textSize, italic)
+        {
+        }
+
+        protected override string Format()
+        {
+            return base.Format();
+        }
+    }
+}

From 87f7c7e6915757752a6b978cbf5ca859bc03368f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Thu, 6 Jan 2022 16:00:45 +0100
Subject: [PATCH 05/20] Implement scoreboard-specific time formatting

---
 .../BeatmapSet/Scores/ScoreboardTime.cs       | 37 ++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs b/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs
index db421ec6b7..ff1d3490b4 100644
--- a/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs
+++ b/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs
@@ -2,7 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using Humanizer;
 using osu.Game.Graphics;
+using osu.Game.Resources.Localisation.Web;
 
 namespace osu.Game.Overlays.BeatmapSet.Scores
 {
@@ -15,7 +17,40 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
 
         protected override string Format()
         {
-            return base.Format();
+            var now = DateTime.Now;
+            var difference = now - Date;
+
+            // web uses momentjs's custom locales to format the date for the purposes of the scoreboard.
+            // this is intended to be a best-effort, more legible approximation of that.
+            // compare:
+            // * https://github.com/ppy/osu-web/blob/a8f5a68fb435cb19a4faa4c7c4bce08c4f096933/resources/assets/lib/scoreboard-time.tsx
+            // * https://momentjs.com/docs/#/customization/ (reference for the customisation format)
+
+            // TODO: support localisation (probably via `CommonStrings.CountHours()` etc.)
+            // requires pluralisable string support framework-side
+
+            if (difference.TotalHours < 1)
+                return CommonStrings.TimeNow.ToString();
+            if (difference.TotalDays < 1)
+                return "hr".ToQuantity((int)difference.TotalHours);
+
+            // this is where this gets more complicated because of how the calendar works.
+            // since there's no `TotalMonths` / `TotalYears`, we have to iteratively add months/years
+            // and test against cutoff dates to determine how many months/years to show.
+
+            if (Date > now.AddMonths(-1))
+                return difference.TotalDays < 2 ? "1dy" : $"{(int)difference.TotalDays}dys";
+
+            for (int months = 1; months <= 11; ++months)
+            {
+                if (Date > now.AddMonths(-(months + 1)))
+                    return months == 1 ? "1mo" : $"{months}mos";
+            }
+
+            int years = 1;
+            while (Date <= now.AddYears(-(years + 1)))
+                years += 1;
+            return years == 1 ? "1yr" : $"{years}yrs";
         }
     }
 }

From 9e84e31eacd3008ae518fee266de58007eb46357 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Thu, 6 Jan 2022 16:14:26 +0100
Subject: [PATCH 06/20] Add score time to beatmap set overlay scoreboard table

---
 osu.Game/Overlays/BeatmapSet/Scores/ScoreTable.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/osu.Game/Overlays/BeatmapSet/Scores/ScoreTable.cs b/osu.Game/Overlays/BeatmapSet/Scores/ScoreTable.cs
index 018faf2011..2c78fa264e 100644
--- a/osu.Game/Overlays/BeatmapSet/Scores/ScoreTable.cs
+++ b/osu.Game/Overlays/BeatmapSet/Scores/ScoreTable.cs
@@ -128,6 +128,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
             if (showPerformancePoints)
                 columns.Add(new TableColumn(BeatmapsetsStrings.ShowScoreboardHeaderspp, Anchor.CentreLeft, new Dimension(GridSizeMode.Absolute, 30)));
 
+            columns.Add(new TableColumn(BeatmapsetsStrings.ShowScoreboardHeadersTime, Anchor.CentreLeft, new Dimension(GridSizeMode.AutoSize)));
             columns.Add(new TableColumn(BeatmapsetsStrings.ShowScoreboardHeadersMods, Anchor.CentreLeft, new Dimension(GridSizeMode.AutoSize)));
 
             return columns.ToArray();
@@ -202,6 +203,11 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
                 });
             }
 
+            content.Add(new ScoreboardTime(score.Date, text_size)
+            {
+                Margin = new MarginPadding { Right = 10 }
+            });
+
             content.Add(new FillFlowContainer
             {
                 Direction = FillDirection.Horizontal,

From f6f24220c2a0b9799d4eac60400ac3659ac400c5 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Sat, 8 Jan 2022 15:28:11 +0900
Subject: [PATCH 07/20] Fix `LegacyScoreDecoderTest` incorrectly comparing
 unset beatmap IDs

This has been wrong from the outside, but hidden by the fact that the
default values are equal. I've changed to MD5Hash which actually asserts
that the correct beatmap has likely arrived.

Found this in my realm changes, where it fails due to the beatmap ID
being a differing Guid in each case.
---
 osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs b/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
index 81d89359e0..b886a61c0f 100644
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
@@ -95,7 +95,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.That(decodedAfterEncode, Is.Not.Null);
 
                 Assert.That(decodedAfterEncode.ScoreInfo.User.Username, Is.EqualTo(scoreInfo.User.Username));
-                Assert.That(decodedAfterEncode.ScoreInfo.BeatmapInfoID, Is.EqualTo(scoreInfo.BeatmapInfoID));
+                Assert.That(decodedAfterEncode.ScoreInfo.BeatmapInfo.MD5Hash, Is.EqualTo(scoreInfo.BeatmapInfo.MD5Hash));
                 Assert.That(decodedAfterEncode.ScoreInfo.Ruleset, Is.EqualTo(scoreInfo.Ruleset));
                 Assert.That(decodedAfterEncode.ScoreInfo.TotalScore, Is.EqualTo(scoreInfo.TotalScore));
                 Assert.That(decodedAfterEncode.ScoreInfo.MaxCombo, Is.EqualTo(scoreInfo.MaxCombo));

From f026973b19316c828696f0e34a4cd8230215b741 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sat, 8 Jan 2022 14:16:05 +0100
Subject: [PATCH 08/20] Add failing test for ruleset incorrectly applying from
 latest picked item

---
 .../TestSceneAllPlayersQueueMode.cs           | 33 ++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneAllPlayersQueueMode.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneAllPlayersQueueMode.cs
index a5744f9986..a06bf44d88 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneAllPlayersQueueMode.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneAllPlayersQueueMode.cs
@@ -1,13 +1,21 @@
 // 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.
 
+#nullable enable
+
 using System;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
+using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
+using osu.Game.Screens.Play;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
@@ -83,7 +91,24 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("selected beatmap is initial beatmap", () => Beatmap.Value.BeatmapInfo.OnlineID == InitialBeatmap.OnlineID);
         }
 
-        private void addItem(Func<BeatmapInfo> beatmap)
+        [Test]
+        public void TestCorrectRulesetSelectedAfterNewItemAdded()
+        {
+            addItem(() => OtherBeatmap, new CatchRuleset().RulesetInfo);
+            AddUntilStep("selected beatmap is initial beatmap", () => Beatmap.Value.BeatmapInfo.OnlineID == InitialBeatmap.OnlineID);
+
+            AddUntilStep("wait for idle", () => Client.LocalUser?.State == MultiplayerUserState.Idle);
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+
+            AddUntilStep("wait for ready", () => Client.LocalUser?.State == MultiplayerUserState.Ready);
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+
+            AddUntilStep("wait for player", () => CurrentScreen is Player player && player.IsLoaded);
+            AddAssert("ruleset is correct", () => ((Player)CurrentScreen).Ruleset.Value.Equals(new OsuRuleset().RulesetInfo));
+            AddStep("exit player", () => CurrentScreen.Exit());
+        }
+
+        private void addItem(Func<BeatmapInfo> beatmap, RulesetInfo? ruleset = null)
         {
             AddStep("click add button", () =>
             {
@@ -92,6 +117,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddUntilStep("wait for song select", () => CurrentSubScreen is Screens.Select.SongSelect select && select.BeatmapSetsLoaded);
+
+            if (ruleset != null)
+            {
+                AddStep($"set {ruleset.Name} ruleset", () => ((Screens.Select.SongSelect)CurrentSubScreen).Ruleset.Value = ruleset);
+            }
+
             AddStep("select other beatmap", () => ((Screens.Select.SongSelect)CurrentSubScreen).FinaliseSelection(beatmap()));
             AddUntilStep("wait for return to match", () => CurrentSubScreen is MultiplayerMatchSubScreen);
         }

From 50077f05bdb07468a93a0ba844b1ea00ec1823d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sat, 8 Jan 2022 14:39:22 +0100
Subject: [PATCH 09/20] Add test coverage for correct revert of ruleset when
 play starts at song select

---
 .../Multiplayer/TestSceneMultiplayer.cs       | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index 4eebda94e9..1221a9f080 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -22,6 +22,7 @@ using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay.Components;
@@ -438,6 +439,45 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("Beatmap matches current item", () => Beatmap.Value.BeatmapInfo.OnlineID == client.Room?.Playlist.First().BeatmapID);
         }
 
+        [Test]
+        public void TestPlayStartsWithCorrectRulesetWhileAtSongSelect()
+        {
+            createRoom(() => new Room
+            {
+                Name = { Value = "Test Room" },
+                Playlist =
+                {
+                    new PlaylistItem
+                    {
+                        Beatmap = { Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.RulesetID == 0)).BeatmapInfo },
+                        Ruleset = { Value = new OsuRuleset().RulesetInfo },
+                    }
+                }
+            });
+
+            pressReadyButton();
+
+            AddStep("Enter song select", () =>
+            {
+                var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerComponents.CurrentScreen).CurrentSubScreen;
+                ((MultiplayerMatchSubScreen)currentSubScreen).OpenSongSelection(client.Room?.Settings.PlaylistItemId);
+            });
+
+            AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
+
+            AddAssert("Ruleset matches current item", () => Ruleset.Value.OnlineID == client.Room?.Playlist.First().RulesetID);
+
+            AddStep("Switch ruleset", () => ((MultiplayerMatchSongSelect)multiplayerComponents.MultiplayerScreen.CurrentSubScreen).Ruleset.Value = new CatchRuleset().RulesetInfo);
+
+            AddUntilStep("Ruleset doesn't match current item", () => Ruleset.Value.OnlineID != client.Room?.Playlist.First().RulesetID);
+
+            AddStep("start match externally", () => client.StartMatch());
+
+            AddUntilStep("play started", () => multiplayerComponents.CurrentScreen is Player);
+
+            AddAssert("Ruleset matches current item", () => Ruleset.Value.OnlineID == client.Room?.Playlist.First().RulesetID);
+        }
+
         [Test]
         public void TestLocalPlayDoesNotStartWhileSpectatingWithNoBeatmap()
         {

From 3dd5705a810d8f1f68e3bf8c9accb5cda865d6f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sat, 8 Jan 2022 14:46:41 +0100
Subject: [PATCH 10/20] Add test coverage for correct revert of mods after new
 item is queued

---
 .../TestSceneAllPlayersQueueMode.cs           | 37 ++++++++++++++++---
 1 file changed, 31 insertions(+), 6 deletions(-)

diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneAllPlayersQueueMode.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneAllPlayersQueueMode.cs
index a06bf44d88..ad60ac824d 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneAllPlayersQueueMode.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneAllPlayersQueueMode.cs
@@ -4,15 +4,19 @@
 #nullable enable
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
 using osu.Game.Screens.Play;
@@ -108,22 +112,43 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("exit player", () => CurrentScreen.Exit());
         }
 
-        private void addItem(Func<BeatmapInfo> beatmap, RulesetInfo? ruleset = null)
+        [Test]
+        public void TestCorrectModsSelectedAfterNewItemAdded()
         {
+            addItem(() => OtherBeatmap, mods: new Mod[] { new OsuModDoubleTime() });
+            AddUntilStep("selected beatmap is initial beatmap", () => Beatmap.Value.BeatmapInfo.OnlineID == InitialBeatmap.OnlineID);
+
+            AddUntilStep("wait for idle", () => Client.LocalUser?.State == MultiplayerUserState.Idle);
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+
+            AddUntilStep("wait for ready", () => Client.LocalUser?.State == MultiplayerUserState.Ready);
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+
+            AddUntilStep("wait for player", () => CurrentScreen is Player player && player.IsLoaded);
+            AddAssert("mods are correct", () => !((Player)CurrentScreen).Mods.Value.Any());
+            AddStep("exit player", () => CurrentScreen.Exit());
+        }
+
+        private void addItem(Func<BeatmapInfo> beatmap, RulesetInfo? ruleset = null, IReadOnlyList<Mod>? mods = null)
+        {
+            Screens.Select.SongSelect? songSelect = null;
+
             AddStep("click add button", () =>
             {
                 InputManager.MoveMouseTo(this.ChildrenOfType<MultiplayerMatchSubScreen.AddItemButton>().Single());
                 InputManager.Click(MouseButton.Left);
             });
 
-            AddUntilStep("wait for song select", () => CurrentSubScreen is Screens.Select.SongSelect select && select.BeatmapSetsLoaded);
+            AddUntilStep("wait for song select", () => (songSelect = CurrentSubScreen as Screens.Select.SongSelect) != null);
+            AddUntilStep("wait for loaded", () => songSelect.AsNonNull().BeatmapSetsLoaded);
 
             if (ruleset != null)
-            {
-                AddStep($"set {ruleset.Name} ruleset", () => ((Screens.Select.SongSelect)CurrentSubScreen).Ruleset.Value = ruleset);
-            }
+                AddStep($"set {ruleset.Name} ruleset", () => songSelect.AsNonNull().Ruleset.Value = ruleset);
 
-            AddStep("select other beatmap", () => ((Screens.Select.SongSelect)CurrentSubScreen).FinaliseSelection(beatmap()));
+            if (mods != null)
+                AddStep($"set mods to {string.Join(",", mods.Select(m => m.Acronym))}", () => songSelect.AsNonNull().Mods.Value = mods);
+
+            AddStep("select other beatmap", () => songSelect.AsNonNull().FinaliseSelection(beatmap()));
             AddUntilStep("wait for return to match", () => CurrentSubScreen is MultiplayerMatchSubScreen);
         }
     }

From 446962446ea3e8970a2da3712d1ceca493396d6e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sat, 8 Jan 2022 14:50:49 +0100
Subject: [PATCH 11/20] Add test coverage for correct revert of mods when play
 starts at song select

---
 .../Multiplayer/TestSceneMultiplayer.cs       | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index 1221a9f080..43f9b6636a 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -7,6 +7,7 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
@@ -23,6 +24,7 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay.Components;
@@ -478,6 +480,45 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("Ruleset matches current item", () => Ruleset.Value.OnlineID == client.Room?.Playlist.First().RulesetID);
         }
 
+        [Test]
+        public void TestPlayStartsWithCorrectModsWhileAtSongSelect()
+        {
+            createRoom(() => new Room
+            {
+                Name = { Value = "Test Room" },
+                Playlist =
+                {
+                    new PlaylistItem
+                    {
+                        Beatmap = { Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.RulesetID == 0)).BeatmapInfo },
+                        Ruleset = { Value = new OsuRuleset().RulesetInfo },
+                    }
+                }
+            });
+
+            pressReadyButton();
+
+            AddStep("Enter song select", () =>
+            {
+                var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerComponents.CurrentScreen).CurrentSubScreen;
+                ((MultiplayerMatchSubScreen)currentSubScreen).OpenSongSelection(client.Room?.Settings.PlaylistItemId);
+            });
+
+            AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
+
+            AddAssert("Mods match current item", () => SelectedMods.Value.Select(m => m.Acronym).SequenceEqual(client.Room.AsNonNull().Playlist.First().RequiredMods.Select(m => m.Acronym)));
+
+            AddStep("Switch required mods", () => ((MultiplayerMatchSongSelect)multiplayerComponents.MultiplayerScreen.CurrentSubScreen).Mods.Value = new Mod[] { new OsuModDoubleTime() });
+
+            AddAssert("Mods don't match current item", () => !SelectedMods.Value.Select(m => m.Acronym).SequenceEqual(client.Room.AsNonNull().Playlist.First().RequiredMods.Select(m => m.Acronym)));
+
+            AddStep("start match externally", () => client.StartMatch());
+
+            AddUntilStep("play started", () => multiplayerComponents.CurrentScreen is Player);
+
+            AddAssert("Mods match current item", () => SelectedMods.Value.Select(m => m.Acronym).SequenceEqual(client.Room.AsNonNull().Playlist.First().RequiredMods.Select(m => m.Acronym)));
+        }
+
         [Test]
         public void TestLocalPlayDoesNotStartWhileSpectatingWithNoBeatmap()
         {

From c5ac996e3f73ee45ee07a21e1de04fe550c5f966 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sat, 8 Jan 2022 14:55:40 +0100
Subject: [PATCH 12/20] Restore ruleset using current playlist item on resuming
 room sub screen

Ensures that the ruleset selected at the multiplayer song selection
screen does not overwrite the current playlist item's ruleset.
---
 osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
index a0e7e8de87..c31239616c 100644
--- a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
@@ -300,6 +300,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
             updateWorkingBeatmap();
             beginHandlingTrack();
             Scheduler.AddOnce(UpdateMods);
+            Scheduler.AddOnce(updateRuleset);
         }
 
         public override bool OnExiting(IScreen next)
@@ -353,8 +354,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
                                      .ToList();
 
             UpdateMods();
-
-            Ruleset.Value = rulesets.GetRuleset(selected.RulesetID);
+            updateRuleset();
 
             if (!selected.AllowedMods.Any())
             {
@@ -387,6 +387,14 @@ namespace osu.Game.Screens.OnlinePlay.Match
             Mods.Value = UserMods.Value.Concat(SelectedItem.Value.RequiredMods).ToList();
         }
 
+        private void updateRuleset()
+        {
+            if (SelectedItem.Value == null || !this.IsCurrentScreen())
+                return;
+
+            Ruleset.Value = rulesets.GetRuleset(SelectedItem.Value.RulesetID);
+        }
+
         private void beginHandlingTrack()
         {
             Beatmap.BindValueChanged(applyLoopingToTrack, true);

From 9370e8446047af81f1fa1ae3cec83456462d923d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sat, 8 Jan 2022 16:12:52 +0100
Subject: [PATCH 13/20] Fix effect point multiplier text box displaying too
 much decimal digits

---
 osu.Game/Screens/Edit/Timing/SliderWithTextBoxInput.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/osu.Game/Screens/Edit/Timing/SliderWithTextBoxInput.cs b/osu.Game/Screens/Edit/Timing/SliderWithTextBoxInput.cs
index 8738d36bf4..67f1dacec4 100644
--- a/osu.Game/Screens/Edit/Timing/SliderWithTextBoxInput.cs
+++ b/osu.Game/Screens/Edit/Timing/SliderWithTextBoxInput.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Globalization;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -9,6 +10,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays.Settings;
+using osu.Game.Utils;
 
 namespace osu.Game.Screens.Edit.Timing
 {
@@ -66,7 +68,8 @@ namespace osu.Game.Screens.Edit.Timing
 
             Current.BindValueChanged(val =>
             {
-                textBox.Text = val.NewValue.ToString();
+                decimal decimalValue = slider.Current.Value.ToDecimal(NumberFormatInfo.InvariantInfo);
+                textBox.Text = decimalValue.ToString($@"N{FormatUtils.FindPrecision(decimalValue)}");
             }, true);
         }
 

From 82d6639a3b3e8c576e036f95b50367b7c97e8d2f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sun, 9 Jan 2022 14:31:37 +0100
Subject: [PATCH 14/20] Decouple rankings table test from online API

---
 .../Visual/Online/TestSceneRankingsTables.cs  | 158 +++++++++++-------
 1 file changed, 97 insertions(+), 61 deletions(-)

diff --git a/osu.Game.Tests/Visual/Online/TestSceneRankingsTables.cs b/osu.Game.Tests/Visual/Online/TestSceneRankingsTables.cs
index ee109189c7..35e219f839 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneRankingsTables.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneRankingsTables.cs
@@ -1,38 +1,27 @@
 // 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.Graphics.Containers;
 using osu.Game.Overlays.Rankings.Tables;
 using osu.Framework.Graphics;
-using osu.Game.Online.API.Requests;
-using osu.Game.Rulesets;
 using System.Threading;
-using osu.Game.Online.API;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Mania;
-using osu.Game.Rulesets.Taiko;
-using osu.Game.Rulesets.Catch;
 using osu.Framework.Allocation;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
-using osu.Game.Overlays.Rankings;
+using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual.Online
 {
     public class TestSceneRankingsTables : OsuTestScene
     {
-        protected override bool UseOnlineAPI => true;
-
-        [Resolved]
-        private IAPIProvider api { get; set; }
-
         [Cached]
         private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Green);
 
         private readonly BasicScrollContainer scrollFlow;
         private readonly LoadingLayer loading;
         private CancellationTokenSource cancellationToken;
-        private APIRequest request;
 
         public TestSceneRankingsTables()
         {
@@ -53,73 +42,120 @@ namespace osu.Game.Tests.Visual.Online
         {
             base.LoadComplete();
 
-            AddStep("Osu performance", () => createPerformanceTable(new OsuRuleset().RulesetInfo, null));
-            AddStep("Mania scores", () => createScoreTable(new ManiaRuleset().RulesetInfo));
-            AddStep("Taiko country scores", () => createCountryTable(new TaikoRuleset().RulesetInfo));
-            AddStep("Catch US performance page 10", () => createPerformanceTable(new CatchRuleset().RulesetInfo, "US", 10));
-            AddStep("Osu spotlight table (chart 271)", () => createSpotlightTable(new OsuRuleset().RulesetInfo, 271));
+            AddStep("User performance", createPerformanceTable);
+            AddStep("User scores", createScoreTable);
+            AddStep("Country scores", createCountryTable);
         }
 
-        private void createCountryTable(RulesetInfo ruleset, int page = 1)
+        private void createCountryTable()
         {
             onLoadStarted();
 
-            request = new GetCountryRankingsRequest(ruleset, page);
-            ((GetCountryRankingsRequest)request).Success += rankings => Schedule(() =>
+            var countries = new List<CountryStatistics>
             {
-                var table = new CountriesTable(page, rankings.Countries);
-                loadTable(table);
-            });
+                new CountryStatistics
+                {
+                    Country = new Country { FlagName = "US", FullName = "United States" },
+                    FlagName = "US",
+                    ActiveUsers = 2_972_623,
+                    PlayCount = 3_086_515_743,
+                    RankedScore = 449_407_643_332_546,
+                    Performance = 371_974_024
+                },
+                new CountryStatistics
+                {
+                    Country = new Country { FlagName = "RU", FullName = "Russian Federation" },
+                    FlagName = "RU",
+                    ActiveUsers = 1_609_989,
+                    PlayCount = 1_637_052_841,
+                    RankedScore = 221_660_827_473_004,
+                    Performance = 163_426_476
+                }
+            };
 
-            api.Queue(request);
+            var table = new CountriesTable(1, countries);
+            loadTable(table);
         }
 
-        private void createPerformanceTable(RulesetInfo ruleset, string country, int page = 1)
+        private static List<UserStatistics> createUserStatistics() => new List<UserStatistics>
+        {
+            new UserStatistics
+            {
+                User = new APIUser
+                {
+                    Username = "first active user",
+                    Country = new Country { FlagName = "JP" },
+                    Active = true,
+                },
+                Accuracy = 0.9972,
+                PlayCount = 233_215,
+                TotalScore = 983_231_234_656,
+                RankedScore = 593_231_345_897,
+                PP = 23_934,
+                GradesCount = new UserStatistics.Grades
+                {
+                    SS = 35_132,
+                    S = 23_345,
+                    A = 12_234
+                }
+            },
+            new UserStatistics
+            {
+                User = new APIUser
+                {
+                    Username = "inactive user",
+                    Country = new Country { FlagName = "AU" },
+                    Active = false,
+                },
+                Accuracy = 0.9831,
+                PlayCount = 195_342,
+                TotalScore = 683_231_234_656,
+                RankedScore = 393_231_345_897,
+                PP = 20_934,
+                GradesCount = new UserStatistics.Grades
+                {
+                    SS = 32_132,
+                    S = 20_345,
+                    A = 9_234
+                }
+            },
+            new UserStatistics
+            {
+                User = new APIUser
+                {
+                    Username = "second active user",
+                    Country = new Country { FlagName = "PL" },
+                    Active = true,
+                },
+                Accuracy = 0.9584,
+                PlayCount = 100_903,
+                TotalScore = 97_242_983_434,
+                RankedScore = 3_156_345_897,
+                PP = 9_568,
+                GradesCount = new UserStatistics.Grades
+                {
+                    SS = 13_152,
+                    S = 24_375,
+                    A = 9_960
+                }
+            },
+        };
+
+        private void createPerformanceTable()
         {
             onLoadStarted();
-
-            request = new GetUserRankingsRequest(ruleset, country: country, page: page);
-            ((GetUserRankingsRequest)request).Success += rankings => Schedule(() =>
-            {
-                var table = new PerformanceTable(page, rankings.Users);
-                loadTable(table);
-            });
-
-            api.Queue(request);
+            loadTable(new PerformanceTable(1, createUserStatistics()));
         }
 
-        private void createScoreTable(RulesetInfo ruleset, int page = 1)
+        private void createScoreTable()
         {
             onLoadStarted();
-
-            request = new GetUserRankingsRequest(ruleset, UserRankingsType.Score, page);
-            ((GetUserRankingsRequest)request).Success += rankings => Schedule(() =>
-            {
-                var table = new ScoresTable(page, rankings.Users);
-                loadTable(table);
-            });
-
-            api.Queue(request);
-        }
-
-        private void createSpotlightTable(RulesetInfo ruleset, int spotlight)
-        {
-            onLoadStarted();
-
-            request = new GetSpotlightRankingsRequest(ruleset, spotlight, RankingsSortCriteria.All);
-            ((GetSpotlightRankingsRequest)request).Success += rankings => Schedule(() =>
-            {
-                var table = new ScoresTable(1, rankings.Users);
-                loadTable(table);
-            });
-
-            api.Queue(request);
+            loadTable(new ScoresTable(1, createUserStatistics()));
         }
 
         private void onLoadStarted()
         {
             loading.Show();
-            request?.Cancel();
             cancellationToken?.Cancel();
             cancellationToken = new CancellationTokenSource();
         }

From 12c8243a9b55b6ed2c1509852c191fb7b13a8898 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sun, 9 Jan 2022 14:32:33 +0100
Subject: [PATCH 15/20] Fade out inactive player rows on user ranking table

---
 .../Overlays/Rankings/Tables/RankingsTable.cs |  8 ++++---
 .../Rankings/Tables/UserBasedTable.cs         | 23 +++++++++++++++++++
 2 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/osu.Game/Overlays/Rankings/Tables/RankingsTable.cs b/osu.Game/Overlays/Rankings/Tables/RankingsTable.cs
index 6e6230f958..fd69b6c80a 100644
--- a/osu.Game/Overlays/Rankings/Tables/RankingsTable.cs
+++ b/osu.Game/Overlays/Rankings/Tables/RankingsTable.cs
@@ -54,13 +54,15 @@ namespace osu.Game.Overlays.Rankings.Tables
                 Spacing = new Vector2(0, row_spacing),
             });
 
-            rankings.ForEach(_ => backgroundFlow.Add(new TableRowBackground { Height = row_height }));
+            rankings.ForEach(s => backgroundFlow.Add(CreateRowBackground(s)));
 
             Columns = mainHeaders.Concat(CreateAdditionalHeaders()).Cast<TableColumn>().ToArray();
-            Content = rankings.Select((s, i) => createContent((page - 1) * items_per_page + i, s)).ToArray().ToRectangular();
+            Content = rankings.Select((s, i) => CreateRowContent((page - 1) * items_per_page + i, s)).ToArray().ToRectangular();
         }
 
-        private Drawable[] createContent(int index, TModel item) => new Drawable[] { createIndexDrawable(index), createMainContent(item) }.Concat(CreateAdditionalContent(item)).ToArray();
+        protected virtual Drawable CreateRowBackground(TModel item) => new TableRowBackground { Height = row_height };
+
+        protected virtual Drawable[] CreateRowContent(int index, TModel item) => new Drawable[] { createIndexDrawable(index), createMainContent(item) }.Concat(CreateAdditionalContent(item)).ToArray();
 
         private static RankingsTableColumn[] mainHeaders => new[]
         {
diff --git a/osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs b/osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs
index cc2ef55a2b..c403d734d3 100644
--- a/osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs
+++ b/osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs
@@ -24,6 +24,29 @@ namespace osu.Game.Overlays.Rankings.Tables
 
         protected virtual IEnumerable<LocalisableString> GradeColumns => new List<LocalisableString> { RankingsStrings.Statss, RankingsStrings.Stats, RankingsStrings.Stata };
 
+        protected override Drawable CreateRowBackground(UserStatistics item)
+        {
+            var background = base.CreateRowBackground(item);
+
+            if (!item.User.Active)
+                background.Alpha = 0.5f;
+
+            return background;
+        }
+
+        protected override Drawable[] CreateRowContent(int index, UserStatistics item)
+        {
+            var content = base.CreateRowContent(index, item);
+
+            if (!item.User.Active)
+            {
+                foreach (var d in content)
+                    d.Alpha = 0.5f;
+            }
+
+            return content;
+        }
+
         protected override RankingsTableColumn[] CreateAdditionalHeaders() => new[]
             {
                 new RankingsTableColumn(RankingsStrings.StatAccuracy, Anchor.Centre, new Dimension(GridSizeMode.AutoSize)),

From 2e9ba40ae27fb3b177e8e86038a4328b8f2bb02c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?= <dach.bartlomiej@gmail.com>
Date: Sun, 9 Jan 2022 14:46:15 +0100
Subject: [PATCH 16/20] Add references to web implementation wrt property used

---
 osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs b/osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs
index c403d734d3..5d150c9535 100644
--- a/osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs
+++ b/osu.Game/Overlays/Rankings/Tables/UserBasedTable.cs
@@ -28,6 +28,7 @@ namespace osu.Game.Overlays.Rankings.Tables
         {
             var background = base.CreateRowBackground(item);
 
+            // see: https://github.com/ppy/osu-web/blob/9de00a0b874c56893d98261d558d78d76259d81b/resources/views/multiplayer/rooms/_rankings_table.blade.php#L23
             if (!item.User.Active)
                 background.Alpha = 0.5f;
 
@@ -38,6 +39,7 @@ namespace osu.Game.Overlays.Rankings.Tables
         {
             var content = base.CreateRowContent(index, item);
 
+            // see: https://github.com/ppy/osu-web/blob/9de00a0b874c56893d98261d558d78d76259d81b/resources/views/multiplayer/rooms/_rankings_table.blade.php#L23
             if (!item.User.Active)
             {
                 foreach (var d in content)

From ca162ed09a68693cbef2c0bc2c1ae3b1ae3e7c44 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Mon, 10 Jan 2022 11:36:26 +0900
Subject: [PATCH 17/20] Update resources

---
 osu.Android.props        | 2 +-
 osu.Game/osu.Game.csproj | 2 +-
 osu.iOS.props            | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/osu.Android.props b/osu.Android.props
index 67a9cd41dd..3b75014aad 100644
--- a/osu.Android.props
+++ b/osu.Android.props
@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1215.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.109.0" />
     <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1227.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index c7913cb71d..24e5858cb0 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -37,7 +37,7 @@
     </PackageReference>
     <PackageReference Include="Realm" Version="10.7.1" />
     <PackageReference Include="ppy.osu.Framework" Version="2021.1227.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1215.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.109.0" />
     <PackageReference Include="Sentry" Version="3.12.1" />
     <PackageReference Include="SharpCompress" Version="0.30.1" />
     <PackageReference Include="NUnit" Version="3.13.2" />
diff --git a/osu.iOS.props b/osu.iOS.props
index 63dc889e3c..b0dafa1daa 100644
--- a/osu.iOS.props
+++ b/osu.iOS.props
@@ -61,7 +61,7 @@
   </ItemGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="ppy.osu.Framework.iOS" Version="2021.1227.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1215.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.109.0" />
   </ItemGroup>
   <!-- See https://github.com/dotnet/runtime/issues/35988 (can be removed after Xamarin uses net5.0 / net6.0) -->
   <PropertyGroup>

From 3d14511286f8badd817e4543c4f07123d4deb5d6 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Mon, 10 Jan 2022 12:17:32 +0900
Subject: [PATCH 18/20] Remove MD5 comparison also

---
 osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs b/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
index b886a61c0f..9ac7838821 100644
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs
@@ -95,7 +95,6 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.That(decodedAfterEncode, Is.Not.Null);
 
                 Assert.That(decodedAfterEncode.ScoreInfo.User.Username, Is.EqualTo(scoreInfo.User.Username));
-                Assert.That(decodedAfterEncode.ScoreInfo.BeatmapInfo.MD5Hash, Is.EqualTo(scoreInfo.BeatmapInfo.MD5Hash));
                 Assert.That(decodedAfterEncode.ScoreInfo.Ruleset, Is.EqualTo(scoreInfo.Ruleset));
                 Assert.That(decodedAfterEncode.ScoreInfo.TotalScore, Is.EqualTo(scoreInfo.TotalScore));
                 Assert.That(decodedAfterEncode.ScoreInfo.MaxCombo, Is.EqualTo(scoreInfo.MaxCombo));

From 02d8a6359a98a3c8ed393eda5c26376079d8cd79 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Mon, 10 Jan 2022 12:28:09 +0900
Subject: [PATCH 19/20] Update `FilterMatchingTest` and filter code to use
 ruleset's `OnlineID`

The tests were relying on the `RulesetID` being set to 0 in the example
beatmap, even though the ruleset *instance* was set to ID 5.

This explicitly adds that 0 value to show intent, and also removes the
incorrect specification of 5 (which would cause the convert filter tests
to fail).

Also updates the filter code to use `OnlineID`, which is required in
realm changes.
---
 osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs | 3 ++-
 osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs      | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs b/osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs
index 55378043e6..8ba3d1a6c7 100644
--- a/osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs
+++ b/osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs
@@ -16,7 +16,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
     {
         private BeatmapInfo getExampleBeatmap() => new BeatmapInfo
         {
-            Ruleset = new RulesetInfo { OnlineID = 5 },
+            Ruleset = new RulesetInfo { OnlineID = 0 },
+            RulesetID = 0,
             StarRating = 4.0d,
             BaseDifficulty = new BeatmapDifficulty
             {
diff --git a/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs b/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
index cc2db6ed31..d2c7c75da8 100644
--- a/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
+++ b/osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs
@@ -28,8 +28,8 @@ namespace osu.Game.Screens.Select.Carousel
 
             bool match =
                 criteria.Ruleset == null ||
-                BeatmapInfo.RulesetID == criteria.Ruleset.ID ||
-                (BeatmapInfo.RulesetID == 0 && criteria.Ruleset.ID > 0 && criteria.AllowConvertedBeatmaps);
+                BeatmapInfo.RulesetID == criteria.Ruleset.OnlineID ||
+                (BeatmapInfo.RulesetID == 0 && criteria.Ruleset.OnlineID > 0 && criteria.AllowConvertedBeatmaps);
 
             if (BeatmapInfo.BeatmapSet?.Equals(criteria.SelectedBeatmapSet) == true)
             {

From d072f1d08d2e045e7546edc20df60959a4193032 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Mon, 10 Jan 2022 12:54:24 +0900
Subject: [PATCH 20/20] Add mention to detach methods of only running once

---
 osu.Game/Database/RealmObjectExtensions.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/osu.Game/Database/RealmObjectExtensions.cs b/osu.Game/Database/RealmObjectExtensions.cs
index e5177823ba..e09f046421 100644
--- a/osu.Game/Database/RealmObjectExtensions.cs
+++ b/osu.Game/Database/RealmObjectExtensions.cs
@@ -26,6 +26,9 @@ namespace osu.Game.Database
         /// <summary>
         /// Create a detached copy of the each item in the collection.
         /// </summary>
+        /// <remarks>
+        /// Items which are already detached (ie. not managed by realm) will not be modified.
+        /// </remarks>
         /// <param name="items">A list of managed <see cref="RealmObject"/>s to detach.</param>
         /// <typeparam name="T">The type of object.</typeparam>
         /// <returns>A list containing non-managed copies of provided items.</returns>
@@ -42,6 +45,9 @@ namespace osu.Game.Database
         /// <summary>
         /// Create a detached copy of the item.
         /// </summary>
+        /// <remarks>
+        /// If the item if already detached (ie. not managed by realm) it will not be detached again and the original instance will be returned. This allows this method to be potentially called at multiple levels while only incurring the clone overhead once.
+        /// </remarks>
         /// <param name="item">The managed <see cref="RealmObject"/> to detach.</param>
         /// <typeparam name="T">The type of object.</typeparam>
         /// <returns>A non-managed copy of provided item. Will return the provided item if already detached.</returns>