Merge pull request #11713 from peppy/fix-error-exit-during-results-transition

Fix a potential crash when exiting play during the results screen transition

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1202.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.128.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.211.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.219.1" />
   </ItemGroup>
 </Project>

osu.Android/OsuGameActivity.cs

@@ -20,7 +20,7 @@ namespace osu.Android
     [Activity(Theme = "@android:style/Theme.NoTitleBar", MainLauncher = true, ScreenOrientation = ScreenOrientation.FullUser, SupportsPictureInPicture = false, ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize, HardwareAccelerated = false, LaunchMode = LaunchMode.SingleInstance)]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\\\.osz", DataHost = "*", DataMimeType = "*/*")]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\\\.osk", DataHost = "*", DataMimeType = "*/*")]
-    [IntentFilter(new[] { Intent.ActionSend, Intent.ActionSendMultiple }, Categories = new[] { Intent.CategoryDefault }, DataMimeTypes = new[] { "application/zip", "application/octet-stream" })]
+    [IntentFilter(new[] { Intent.ActionSend, Intent.ActionSendMultiple }, Categories = new[] { Intent.CategoryDefault }, DataMimeTypes = new[] { "application/zip", "application/octet-stream", "application/download", "application/x-zip", "application/x-zip-compressed" })]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryBrowsable, Intent.CategoryDefault }, DataSchemes = new[] { "osu", "osump" })]
     public class OsuGameActivity : AndroidGameActivity
     {

osu.Desktop/DiscordRichPresence.cs

@@ -105,7 +105,7 @@ namespace osu.Desktop
             if (privacyMode.Value == DiscordRichPresenceMode.Limited)
                 presence.Assets.LargeImageText = string.Empty;
             else
-                presence.Assets.LargeImageText = $"{user.Value.Username}" + (user.Value.Statistics?.Ranks.Global > 0 ? $" (rank #{user.Value.Statistics.Ranks.Global:N0})" : string.Empty);
+                presence.Assets.LargeImageText = $"{user.Value.Username}" + (user.Value.Statistics?.GlobalRank > 0 ? $" (rank #{user.Value.Statistics.GlobalRank:N0})" : string.Empty);
 
             // update ruleset
             presence.Assets.SmallImageKey = ruleset.Value.ID <= 3 ? $"mode_{ruleset.Value.ID}" : "mode_custom";

osu.Desktop/OsuGameDesktop.cs

@@ -18,6 +18,7 @@ using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Updater;
 using osu.Desktop.Windows;
+using osu.Game.IO;
 
 namespace osu.Desktop
 {
@@ -32,7 +33,7 @@ namespace osu.Desktop
             noVersionOverlay = args?.Any(a => a == "--no-version-overlay") ?? false;
         }
 
-        public override Storage GetStorageForStableInstall()
+        public override StableStorage GetStorageForStableInstall()
         {
             try
             {
@@ -40,7 +41,7 @@ namespace osu.Desktop
                 {
                     string stablePath = getStableInstallPath();
                     if (!string.IsNullOrEmpty(stablePath))
-                        return new DesktopStorage(stablePath, desktopHost);
+                        return new StableStorage(stablePath, desktopHost);
                 }
             }
             catch (Exception)

osu.Game.Benchmarks/osu.Game.Benchmarks.csproj

@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
-    <PackageReference Include="nunit" Version="3.12.0" />
+    <PackageReference Include="nunit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
   </ItemGroup>
 

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -3,7 +3,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>

osu.Game.Rulesets.Catch/Mods/CatchModAutoplay.cs

@@ -1,6 +1,7 @@
 // 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.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
@@ -12,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModAutoplay : ModAutoplay<CatchHitObject>
     {
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "osu!salad!" } },
             Replay = new CatchAutoGenerator(beatmap).Generate(),

osu.Game.Rulesets.Catch/Mods/CatchModCinema.cs

@@ -1,6 +1,7 @@
 // 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.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Replays;
@@ -12,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModCinema : ModCinema<CatchHitObject>
     {
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "osu!salad!" } },
             Replay = new CatchAutoGenerator(beatmap).Generate(),

osu.Game.Rulesets.Catch/Mods/CatchModDifficultyAdjust.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Catch.Mods
     public class CatchModDifficultyAdjust : ModDifficultyAdjust
     {
         [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1)]
-        public BindableNumber<float> CircleSize { get; } = new BindableFloat
+        public BindableNumber<float> CircleSize { get; } = new BindableFloatWithLimitExtension
         {
             Precision = 0.1f,
             MinValue = 1,
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Mods
         };
 
         [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1)]
-        public BindableNumber<float> ApproachRate { get; } = new BindableFloat
+        public BindableNumber<float> ApproachRate { get; } = new BindableFloatWithLimitExtension
         {
             Precision = 0.1f,
             MinValue = 1,
@@ -31,6 +31,14 @@ namespace osu.Game.Rulesets.Catch.Mods
             Value = 5,
         };
 
+        protected override void ApplyLimits(bool extended)
+        {
+            base.ApplyLimits(extended);
+
+            CircleSize.MaxValue = extended ? 11 : 10;
+            ApproachRate.MaxValue = extended ? 11 : 10;
+        }
+
         public override string SettingDescription
         {
             get

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -3,7 +3,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>

osu.Game.Rulesets.Mania/Mods/ManiaModAutoplay.cs

@@ -1,6 +1,7 @@
 // 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.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
@@ -13,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModAutoplay : ModAutoplay<ManiaHitObject>
     {
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "osu!topus!" } },
             Replay = new ManiaAutoGenerator((ManiaBeatmap)beatmap).Generate(),

osu.Game.Rulesets.Mania/Mods/ManiaModCinema.cs

@@ -1,6 +1,7 @@
 // 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.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
@@ -13,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModCinema : ModCinema<ManiaHitObject>
     {
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "osu!topus!" } },
             Replay = new ManiaAutoGenerator((ManiaBeatmap)beatmap).Generate(),

osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs

@@ -140,11 +140,11 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             return animation == null ? null : new LegacyManiaJudgementPiece(result, animation);
         }
 
-        public override SampleChannel GetSample(ISampleInfo sampleInfo)
+        public override Sample GetSample(ISampleInfo sampleInfo)
         {
             // layered hit sounds never play in mania
             if (sampleInfo is ConvertHitObjectParser.LegacyHitSampleInfo legacySample && legacySample.IsLayered)
-                return new SampleChannelVirtual();
+                return new SampleVirtual();
 
             return Source.GetSample(sampleInfo);
         }

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAutoplay.cs

@@ -0,0 +1,65 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Skinning.Default;
+using osu.Game.Rulesets.Osu.UI;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModAutoplay : OsuModTestScene
+    {
+        [Test]
+        public void TestSpmUnaffectedByRateAdjust()
+            => runSpmTest(new OsuModDaycore
+            {
+                SpeedChange = { Value = 0.88 }
+            });
+
+        [Test]
+        public void TestSpmUnaffectedByTimeRamp()
+            => runSpmTest(new ModWindUp
+            {
+                InitialRate = { Value = 0.7 },
+                FinalRate = { Value = 1.3 }
+            });
+
+        private void runSpmTest(Mod mod)
+        {
+            SpinnerSpmCounter spmCounter = null;
+
+            CreateModTest(new ModTestData
+            {
+                Autoplay = true,
+                Mod = mod,
+                Beatmap = new Beatmap
+                {
+                    HitObjects =
+                    {
+                        new Spinner
+                        {
+                            Duration = 2000,
+                            Position = OsuPlayfield.BASE_SIZE / 2
+                        }
+                    }
+                },
+                PassCondition = () => Player.ScoreProcessor.JudgedHits >= 1
+            });
+
+            AddUntilStep("fetch SPM counter", () =>
+            {
+                spmCounter = this.ChildrenOfType<SpinnerSpmCounter>().SingleOrDefault();
+                return spmCounter != null;
+            });
+
+            AddUntilStep("SPM is correct", () => Precision.AlmostEquals(spmCounter.SpinsPerMinute, 477, 5));
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestSceneCursorTrail.cs

@@ -98,7 +98,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 return null;
             }
 
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
+            public Sample GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
 

osu.Game.Rulesets.Osu.Tests/TestSceneMissHitWindowJudgements.cs

@@ -1,9 +1,11 @@
 // 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 NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Replays;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
@@ -65,10 +67,10 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private class TestAutoMod : OsuModAutoplay
         {
-            public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+            public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
             {
                 ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
-                Replay = new MissingAutoGenerator(beatmap).Generate()
+                Replay = new MissingAutoGenerator(beatmap, mods).Generate()
             };
         }
 
@@ -76,8 +78,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             public new OsuBeatmap Beatmap => (OsuBeatmap)base.Beatmap;
 
-            public MissingAutoGenerator(IBeatmap beatmap)
-                : base(beatmap)
+            public MissingAutoGenerator(IBeatmap beatmap, IReadOnlyList<Mod> mods)
+                : base(beatmap, mods)
             {
             }
 

osu.Game.Rulesets.Osu.Tests/TestSceneObjectOrderedHitPolicy.cs

@@ -0,0 +1,491 @@
+// 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.Extensions.TypeExtensions;
+using osu.Framework.Screens;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneObjectOrderedHitPolicy : RateAdjustedBeatmapTestScene
+    {
+        private const double early_miss_window = 1000; // time after -1000 to -500 is considered a miss
+        private const double late_miss_window = 500; // time after +500 is considered a miss
+
+        /// <summary>
+        /// Tests clicking a future circle before the first circle's start time, while the first circle HAS NOT been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleBeforeFirstCircleTime()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle - 100, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            addJudgementAssert(hitObjects[1], HitResult.Miss);
+            addJudgementOffsetAssert(hitObjects[0], late_miss_window);
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle at the first circle's start time, while the first circle HAS NOT been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleAtFirstCircleTime()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            addJudgementAssert(hitObjects[1], HitResult.Miss);
+            addJudgementOffsetAssert(hitObjects[0], late_miss_window);
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle after the first circle's start time, while the first circle HAS NOT been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleAfterFirstCircleTime()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle + 100, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            addJudgementAssert(hitObjects[1], HitResult.Miss);
+            addJudgementOffsetAssert(hitObjects[0], late_miss_window);
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle before the first circle's start time, while the first circle HAS been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleBeforeFirstCircleTimeWithFirstCircleJudged()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle - 200, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_first_circle - 100, Position = positionSecondCircle, Actions = { OsuAction.RightButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[0], -200); // time_first_circle - 200
+            addJudgementOffsetAssert(hitObjects[0], -200); // time_second_circle - first_circle_time - 100
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle after the first circle's start time, while the first circle HAS been judged.
+        /// </summary>
+        [Test]
+        public void TestClickSecondCircleAfterFirstCircleTimeWithFirstCircleJudged()
+        {
+            const double time_first_circle = 1500;
+            const double time_second_circle = 1600;
+            Vector2 positionFirstCircle = Vector2.Zero;
+            Vector2 positionSecondCircle = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle - 200, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_first_circle, Position = positionSecondCircle, Actions = { OsuAction.RightButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[0], -200); // time_first_circle - 200
+            addJudgementOffsetAssert(hitObjects[1], -100); // time_second_circle - first_circle_time
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle after a slider's start time, but hitting all slider ticks.
+        /// </summary>
+        [Test]
+        public void TestMissSliderHeadAndHitAllSliderTicks()
+        {
+            const double time_slider = 1500;
+            const double time_circle = 1510;
+            Vector2 positionCircle = Vector2.Zero;
+            Vector2 positionSlider = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+                new TestSlider
+                {
+                    StartTime = time_slider,
+                    Position = positionSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_slider, Position = positionCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_slider + 10, Position = positionSlider, Actions = { OsuAction.RightButton } }
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementAssert("slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.LargeTickHit);
+            addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.LargeTickHit);
+        }
+
+        /// <summary>
+        /// Tests clicking hitting future slider ticks before a circle.
+        /// </summary>
+        [Test]
+        public void TestHitSliderTicksBeforeCircle()
+        {
+            const double time_slider = 1500;
+            const double time_circle = 1510;
+            Vector2 positionCircle = Vector2.Zero;
+            Vector2 positionSlider = new Vector2(30);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+                new TestSlider
+                {
+                    StartTime = time_slider,
+                    Position = positionSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_slider, Position = positionSlider, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_circle + late_miss_window - 100, Position = positionCircle, Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_circle + late_miss_window - 90, Position = positionSlider, Actions = { OsuAction.LeftButton } },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementAssert("slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.LargeTickHit);
+            addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.LargeTickHit);
+        }
+
+        /// <summary>
+        /// Tests clicking a future circle before a spinner.
+        /// </summary>
+        [Test]
+        public void TestHitCircleBeforeSpinner()
+        {
+            const double time_spinner = 1500;
+            const double time_circle = 1800;
+            Vector2 positionCircle = Vector2.Zero;
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestSpinner
+                {
+                    StartTime = time_spinner,
+                    Position = new Vector2(256, 192),
+                    EndTime = time_spinner + 1000,
+                },
+                new TestHitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_spinner - 100, Position = positionCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_spinner + 10, Position = new Vector2(236, 192), Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_spinner + 20, Position = new Vector2(256, 172), Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_spinner + 30, Position = new Vector2(276, 192), Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_spinner + 40, Position = new Vector2(256, 212), Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_spinner + 50, Position = new Vector2(236, 192), Actions = { OsuAction.RightButton } },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+        }
+
+        [Test]
+        public void TestHitSliderHeadBeforeHitCircle()
+        {
+            const double time_circle = 1000;
+            const double time_slider = 1200;
+            Vector2 positionCircle = Vector2.Zero;
+            Vector2 positionSlider = new Vector2(80);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestHitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+                new TestSlider
+                {
+                    StartTime = time_slider,
+                    Position = positionSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_circle - 100, Position = positionSlider, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_circle, Position = positionCircle, Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_slider, Position = positionSlider, Actions = { OsuAction.LeftButton } },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+        }
+
+        private void addJudgementAssert(OsuHitObject hitObject, HitResult result)
+        {
+            AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judgement is {result}",
+                () => judgementResults.Single(r => r.HitObject == hitObject).Type == result);
+        }
+
+        private void addJudgementAssert(string name, Func<OsuHitObject> hitObject, HitResult result)
+        {
+            AddAssert($"{name} judgement is {result}",
+                () => judgementResults.Single(r => r.HitObject == hitObject()).Type == result);
+        }
+
+        private void addJudgementOffsetAssert(OsuHitObject hitObject, double offset)
+        {
+            AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judged at {offset}",
+                () => Precision.AlmostEquals(judgementResults.Single(r => r.HitObject == hitObject).TimeOffset, offset, 100));
+        }
+
+        private ScoreAccessibleReplayPlayer currentPlayer;
+        private List<JudgementResult> judgementResults;
+
+        private void performTest(List<OsuHitObject> hitObjects, List<ReplayFrame> frames)
+        {
+            AddStep("load player", () =>
+            {
+                Beatmap.Value = CreateWorkingBeatmap(new Beatmap<OsuHitObject>
+                {
+                    HitObjects = hitObjects,
+                    BeatmapInfo =
+                    {
+                        BaseDifficulty = new BeatmapDifficulty { SliderTickRate = 3 },
+                        Ruleset = new OsuRuleset().RulesetInfo
+                    },
+                });
+
+                Beatmap.Value.Beatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 0.1f });
+
+                SelectedMods.Value = new[] { new OsuModClassic() };
+
+                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
+
+                p.OnLoadComplete += _ =>
+                {
+                    p.ScoreProcessor.NewJudgement += result =>
+                    {
+                        if (currentPlayer == p) judgementResults.Add(result);
+                    };
+                };
+
+                LoadScreen(currentPlayer = p);
+                judgementResults = new List<JudgementResult>();
+            });
+
+            AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
+            AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
+        }
+
+        private class TestHitCircle : HitCircle
+        {
+            protected override HitWindows CreateHitWindows() => new TestHitWindows();
+        }
+
+        private class TestSlider : Slider
+        {
+            public TestSlider()
+            {
+                DefaultsApplied += _ =>
+                {
+                    HeadCircle.HitWindows = new TestHitWindows();
+                    TailCircle.HitWindows = new TestHitWindows();
+
+                    HeadCircle.HitWindows.SetDifficulty(0);
+                    TailCircle.HitWindows.SetDifficulty(0);
+                };
+            }
+        }
+
+        private class TestSpinner : Spinner
+        {
+            protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+            {
+                base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
+                SpinsRequired = 1;
+            }
+        }
+
+        private class TestHitWindows : HitWindows
+        {
+            private static readonly DifficultyRange[] ranges =
+            {
+                new DifficultyRange(HitResult.Great, 500, 500, 500),
+                new DifficultyRange(HitResult.Miss, early_miss_window, early_miss_window, early_miss_window),
+            };
+
+            public override bool IsHitResultAllowed(HitResult result) => result == HitResult.Great || result == HitResult.Miss;
+
+            protected override DifficultyRange[] GetRanges() => ranges;
+        }
+
+        private class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            protected override bool PauseOnFocusLost => false;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score, new PlayerConfiguration
+                {
+                    AllowPause = false,
+                    ShowResults = false,
+                })
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestSceneSkinFallbacks.cs

@@ -162,7 +162,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => null;
 
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => null;
+            public Sample GetSample(ISampleInfo sampleInfo) => null;
 
             public TValue GetValue<TConfiguration, TValue>(Func<TConfiguration, TValue> query) where TConfiguration : SkinConfiguration => default;
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => null;

osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs

@@ -25,7 +25,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestSceneOutOfOrderHits : RateAdjustedBeatmapTestScene
+    public class TestSceneStartTimeOrderedHitPolicy : RateAdjustedBeatmapTestScene
     {
         private const double early_miss_window = 1000; // time after -1000 to -500 is considered a miss
         private const double late_miss_window = 500; // time after +500 is considered a miss
@@ -169,7 +169,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[0], HitResult.Great);
             addJudgementAssert(hitObjects[1], HitResult.Great);
             addJudgementOffsetAssert(hitObjects[0], -200); // time_first_circle - 200
-            addJudgementOffsetAssert(hitObjects[0], -200); // time_second_circle - first_circle_time - 100
+            addJudgementOffsetAssert(hitObjects[1], -200); // time_second_circle - first_circle_time - 100
         }
 
         /// <summary>

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj

@@ -3,7 +3,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleSelectionBlueprint.cs

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         {
             base.Update();
 
-            CirclePiece.UpdateFrom(position == SliderPosition.Start ? HitObject.HeadCircle : HitObject.TailCircle);
+            CirclePiece.UpdateFrom(position == SliderPosition.Start ? (HitCircle)HitObject.HeadCircle : HitObject.TailCircle);
         }
 
         // Todo: This is temporary, since the slider circle masks don't do anything special yet. In the future they will handle input.

osu.Game.Rulesets.Osu/Judgements/SliderTickJudgement.cs

@@ -0,0 +1,12 @@
+// 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.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Judgements
+{
+    public class SliderTickJudgement : OsuJudgement
+    {
+        public override HitResult MaxResult => HitResult.LargeTickHit;
+    }
+}

osu.Game.Rulesets.Osu/Mods/OsuModAutopilot.cs

@@ -62,7 +62,7 @@ namespace osu.Game.Rulesets.Osu.Mods
             inputManager.AllowUserCursorMovement = false;
 
             // Generate the replay frames the cursor should follow
-            replayFrames = new OsuAutoGenerator(drawableRuleset.Beatmap).Generate().Frames.Cast<OsuReplayFrame>().ToList();
+            replayFrames = new OsuAutoGenerator(drawableRuleset.Beatmap, drawableRuleset.Mods).Generate().Frames.Cast<OsuReplayFrame>().ToList();
         }
     }
 }

osu.Game.Rulesets.Osu/Mods/OsuModAutoplay.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
@@ -16,10 +17,10 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).Append(typeof(OsuModSpunOut)).ToArray();
 
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
-            Replay = new OsuAutoGenerator(beatmap).Generate()
+            Replay = new OsuAutoGenerator(beatmap, mods).Generate()
         };
     }
 }

osu.Game.Rulesets.Osu/Mods/OsuModCinema.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
@@ -16,10 +17,10 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).Append(typeof(OsuModSpunOut)).ToArray();
 
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
-            Replay = new OsuAutoGenerator(beatmap).Generate()
+            Replay = new OsuAutoGenerator(beatmap, mods).Generate()
         };
     }
 }

osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs

@@ -0,0 +1,86 @@
+// 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 System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModClassic : Mod, IApplicableToHitObject, IApplicableToDrawableHitObjects, IApplicableToDrawableRuleset<OsuHitObject>
+    {
+        public override string Name => "Classic";
+
+        public override string Acronym => "CL";
+
+        public override double ScoreMultiplier => 1;
+
+        public override IconUsage? Icon => FontAwesome.Solid.History;
+
+        public override string Description => "Feeling nostalgic?";
+
+        public override bool Ranked => false;
+
+        public override ModType Type => ModType.Conversion;
+
+        [SettingSource("No slider head accuracy requirement", "Scores sliders proportionally to the number of ticks hit.")]
+        public Bindable<bool> NoSliderHeadAccuracy { get; } = new BindableBool(true);
+
+        [SettingSource("No slider head movement", "Pins slider heads at their starting position, regardless of time.")]
+        public Bindable<bool> NoSliderHeadMovement { get; } = new BindableBool(true);
+
+        [SettingSource("Apply classic note lock", "Applies note lock to the full hit window.")]
+        public Bindable<bool> ClassicNoteLock { get; } = new BindableBool(true);
+
+        [SettingSource("Use fixed slider follow circle hit area", "Makes the slider follow circle track its final size at all times.")]
+        public Bindable<bool> FixedFollowCircleHitArea { get; } = new BindableBool(true);
+
+        public void ApplyToHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Slider slider:
+                    slider.OnlyJudgeNestedObjects = !NoSliderHeadAccuracy.Value;
+
+                    foreach (var head in slider.NestedHitObjects.OfType<SliderHeadCircle>())
+                        head.JudgeAsNormalHitCircle = !NoSliderHeadAccuracy.Value;
+
+                    break;
+            }
+        }
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            var osuRuleset = (DrawableOsuRuleset)drawableRuleset;
+
+            if (ClassicNoteLock.Value)
+                osuRuleset.Playfield.HitPolicy = new ObjectOrderedHitPolicy();
+        }
+
+        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        {
+            foreach (var obj in drawables)
+            {
+                switch (obj)
+                {
+                    case DrawableSlider slider:
+                        slider.Ball.InputTracksVisualSize = !FixedFollowCircleHitArea.Value;
+                        break;
+
+                    case DrawableSliderHead head:
+                        head.TrackFollowCircle = !NoSliderHeadMovement.Value;
+                        break;
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     public class OsuModDifficultyAdjust : ModDifficultyAdjust
     {
         [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1)]
-        public BindableNumber<float> CircleSize { get; } = new BindableFloat
+        public BindableNumber<float> CircleSize { get; } = new BindableFloatWithLimitExtension
         {
             Precision = 0.1f,
             MinValue = 0,
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         };
 
         [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1)]
-        public BindableNumber<float> ApproachRate { get; } = new BindableFloat
+        public BindableNumber<float> ApproachRate { get; } = new BindableFloatWithLimitExtension
         {
             Precision = 0.1f,
             MinValue = 0,
@@ -31,6 +31,14 @@ namespace osu.Game.Rulesets.Osu.Mods
             Value = 5,
         };
 
+        protected override void ApplyLimits(bool extended)
+        {
+            base.ApplyLimits(extended);
+
+            CircleSize.MaxValue = extended ? 11 : 10;
+            ApproachRate.MaxValue = extended ? 11 : 10;
+        }
+
         public override string SettingDescription
         {
             get

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs

@@ -110,8 +110,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
             double startTime = start.GetEndTime();
             double duration = end.StartTime - startTime;
 
+            // Preempt time can go below 800ms. Normally, this is achieved via the DT mod which uniformly speeds up all animations game wide regardless of AR.
+            // This uniform speedup is hard to match 1:1, however we can at least make AR>10 (via mods) feel good by extending the upper linear preempt function (see: OsuHitObject).
+            // Note that this doesn't exactly match the AR>10 visuals as they're classically known, but it feels good.
+            double preempt = PREEMPT * Math.Min(1, start.TimePreempt / OsuHitObject.PREEMPT_MIN);
+
             fadeOutTime = startTime + fraction * duration;
-            fadeInTime = fadeOutTime - PREEMPT;
+            fadeInTime = fadeOutTime - preempt;
         }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs

@@ -123,7 +123,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 return;
             }
 
-            var result = HitObject.HitWindows.ResultFor(timeOffset);
+            var result = ResultFor(timeOffset);
 
             if (result == HitResult.None || CheckHittable?.Invoke(this, Time.Current) == false)
             {
@@ -146,6 +146,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             });
         }
 
+        /// <summary>
+        /// Retrieves the <see cref="HitResult"/> for a time offset.
+        /// </summary>
+        /// <param name="timeOffset">The time offset.</param>
+        /// <returns>The hit result, or <see cref="HitResult.None"/> if <paramref name="timeOffset"/> doesn't result in a judgement.</returns>
+        protected virtual HitResult ResultFor(double timeOffset) => HitObject.HitWindows.ResultFor(timeOffset);
+
         protected override void UpdateInitialTransforms()
         {
             base.UpdateInitialTransforms();

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             if (JudgedObject?.HitObject is OsuHitObject osuObject)
             {
-                Position = osuObject.StackedPosition;
+                Position = osuObject.StackedEndPosition;
                 Scale = new Vector2(osuObject.Scale);
             }
         }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs

@@ -15,6 +15,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
 using osu.Game.Skinning;
 
@@ -30,7 +31,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public SliderBall Ball { get; private set; }
         public SkinnableDrawable Body { get; private set; }
 
-        public override bool DisplayResult => false;
+        public override bool DisplayResult => !HitObject.OnlyJudgeNestedObjects;
 
         private PlaySliderBody sliderBody => Body.Drawable as PlaySliderBody;
 
@@ -249,7 +250,30 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (userTriggered || Time.Current < HitObject.EndTime)
                 return;
 
-            ApplyResult(r => r.Type = NestedHitObjects.Any(h => h.Result.IsHit) ? r.Judgement.MaxResult : r.Judgement.MinResult);
+            // If only the nested hitobjects are judged, then the slider's own judgement is ignored for scoring purposes.
+            // But the slider needs to still be judged with a reasonable hit/miss result for visual purposes (hit/miss transforms, etc).
+            if (HitObject.OnlyJudgeNestedObjects)
+            {
+                ApplyResult(r => r.Type = NestedHitObjects.Any(h => h.Result.IsHit) ? r.Judgement.MaxResult : r.Judgement.MinResult);
+                return;
+            }
+
+            // Otherwise, if this slider also needs to be judged, apply judgement proportionally to the number of nested hitobjects hit. This is the classic osu!stable scoring.
+            ApplyResult(r =>
+            {
+                int totalTicks = NestedHitObjects.Count;
+                int hitTicks = NestedHitObjects.Count(h => h.IsHit);
+
+                if (hitTicks == totalTicks)
+                    r.Type = HitResult.Great;
+                else if (hitTicks == 0)
+                    r.Type = HitResult.Miss;
+                else
+                {
+                    double hitFraction = (double)hitTicks / totalTicks;
+                    r.Type = hitFraction >= 0.5 ? HitResult.Ok : HitResult.Meh;
+                }
+            });
         }
 
         public override void PlaySamples()

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs

@@ -7,16 +7,27 @@ using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableSliderHead : DrawableHitCircle
     {
+        public new SliderHeadCircle HitObject => (SliderHeadCircle)base.HitObject;
+
         [CanBeNull]
         public Slider Slider => DrawableSlider?.HitObject;
 
         protected DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
 
+        public override bool DisplayResult => HitObject?.JudgeAsNormalHitCircle ?? base.DisplayResult;
+
+        /// <summary>
+        /// Makes this <see cref="DrawableSliderHead"/> track the follow circle when the start time is reached.
+        /// If <c>false</c>, this <see cref="DrawableSliderHead"/> will be pinned to its initial position in the slider.
+        /// </summary>
+        public bool TrackFollowCircle = true;
+
         private readonly IBindable<int> pathVersion = new Bindable<int>();
 
         protected override OsuSkinComponents CirclePieceComponent => OsuSkinComponents.SliderHeadHitCircle;
@@ -59,12 +70,28 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.Update();
 
             Debug.Assert(Slider != null);
+            Debug.Assert(HitObject != null);
 
-            double completionProgress = Math.Clamp((Time.Current - Slider.StartTime) / Slider.Duration, 0, 1);
+            if (TrackFollowCircle)
+            {
+                double completionProgress = Math.Clamp((Time.Current - Slider.StartTime) / Slider.Duration, 0, 1);
 
-            //todo: we probably want to reconsider this before adding scoring, but it looks and feels nice.
-            if (!IsHit)
-                Position = Slider.CurvePositionAt(completionProgress);
+                //todo: we probably want to reconsider this before adding scoring, but it looks and feels nice.
+                if (!IsHit)
+                    Position = Slider.CurvePositionAt(completionProgress);
+            }
+        }
+
+        protected override HitResult ResultFor(double timeOffset)
+        {
+            Debug.Assert(HitObject != null);
+
+            if (HitObject.JudgeAsNormalHitCircle)
+                return base.ResultFor(timeOffset);
+
+            // If not judged as a normal hitcircle, judge as a slider tick instead. This is the classic osu!stable scoring.
+            var result = base.ResultFor(timeOffset);
+            return result.IsHit() ? HitResult.LargeTickHit : HitResult.LargeTickMiss;
         }
 
         public Action<double> OnShake;

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -130,7 +130,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             if (tracking.NewValue)
             {
-                spinningSample?.Play(!spinningSample.IsPlaying);
+                if (!spinningSample.IsPlaying)
+                    spinningSample?.Play();
                 spinningSample?.VolumeTo(1, 300);
             }
             else

osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs

@@ -1,6 +1,7 @@
 // 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.Linq;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
@@ -25,6 +26,11 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         internal const float BASE_SCORING_DISTANCE = 100;
 
+        /// <summary>
+        /// Minimum preempt time at AR=10.
+        /// </summary>
+        public const double PREEMPT_MIN = 450;
+
         public double TimePreempt = 600;
         public double TimeFadeIn = 400;
 
@@ -112,8 +118,13 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
-            TimePreempt = (float)BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
-            TimeFadeIn = 400; // as per osu-stable
+            TimePreempt = (float)BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, PREEMPT_MIN);
+
+            // Preempt time can go below 450ms. Normally, this is achieved via the DT mod which uniformly speeds up all animations game wide regardless of AR.
+            // This uniform speedup is hard to match 1:1, however we can at least make AR>10 (via mods) feel good by extending the upper linear function above.
+            // Note that this doesn't exactly match the AR>10 visuals as they're classically known, but it feels good.
+            // This adjustment is necessary for AR>10, otherwise TimePreempt can become smaller leading to hitcircles not fully fading in.
+            TimeFadeIn = 400 * Math.Min(1, TimePreempt / PREEMPT_MIN);
 
             Scale = (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5) / 2;
         }

osu.Game.Rulesets.Osu/Objects/Slider.cs

@@ -114,8 +114,14 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public double TickDistanceMultiplier = 1;
 
+        /// <summary>
+        /// Whether this <see cref="Slider"/>'s judgement is fully handled by its nested <see cref="HitObject"/>s.
+        /// If <c>false</c>, this <see cref="Slider"/> will be judged proportionally to the number of nested <see cref="HitObject"/>s hit.
+        /// </summary>
+        public bool OnlyJudgeNestedObjects = true;
+
         [JsonIgnore]
-        public HitCircle HeadCircle { get; protected set; }
+        public SliderHeadCircle HeadCircle { get; protected set; }
 
         [JsonIgnore]
         public SliderTailCircle TailCircle { get; protected set; }
@@ -140,7 +146,8 @@ namespace osu.Game.Rulesets.Osu.Objects
 
             // The samples should be attached to the slider tail, however this can only be done after LegacyLastTick is removed otherwise they would play earlier than they're intended to.
             // For now, the samples are attached to and played by the slider itself at the correct end time.
-            Samples = this.GetNodeSamples(repeatCount + 1);
+            // ToArray call is required as GetNodeSamples may fallback to Samples itself (without it it will get cleared due to the list reference being live).
+            Samples = this.GetNodeSamples(repeatCount + 1).ToArray();
         }
 
         protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
@@ -233,7 +240,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                 HeadCircle.Samples = this.GetNodeSamples(0);
         }
 
-        public override Judgement CreateJudgement() => new OsuIgnoreJudgement();
+        public override Judgement CreateJudgement() => OnlyJudgeNestedObjects ? new OsuIgnoreJudgement() : new OsuJudgement();
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
     }

osu.Game.Rulesets.Osu/Objects/SliderHeadCircle.cs

@@ -1,9 +1,19 @@
 // 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.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;
+
 namespace osu.Game.Rulesets.Osu.Objects
 {
     public class SliderHeadCircle : HitCircle
     {
+        /// <summary>
+        /// Whether to treat this <see cref="SliderHeadCircle"/> as a normal <see cref="HitCircle"/> for judgement purposes.
+        /// If <c>false</c>, this <see cref="SliderHeadCircle"/> will be judged as a <see cref="SliderTick"/> instead.
+        /// </summary>
+        public bool JudgeAsNormalHitCircle = true;
+
+        public override Judgement CreateJudgement() => JudgeAsNormalHitCircle ? base.CreateJudgement() : new SliderTickJudgement();
     }
 }

osu.Game.Rulesets.Osu/Objects/SliderTick.cs

@@ -33,10 +33,5 @@ namespace osu.Game.Rulesets.Osu.Objects
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
 
         public override Judgement CreateJudgement() => new SliderTickJudgement();
-
-        public class SliderTickJudgement : OsuJudgement
-        {
-            public override HitResult MaxResult => HitResult.LargeTickHit;
-        }
     }
 }

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Osu
 
         protected override bool Handle(UIEvent e)
         {
-            if (e is MouseMoveEvent && !AllowUserCursorMovement) return false;
+            if ((e is MouseMoveEvent || e is TouchMoveEvent) && !AllowUserCursorMovement) return false;
 
             return base.Handle(e);
         }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -163,6 +163,7 @@ namespace osu.Game.Rulesets.Osu
                     {
                         new OsuModTarget(),
                         new OsuModDifficultyAdjust(),
+                        new OsuModClassic()
                     };
 
                 case ModType.Automation:

osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs

@@ -6,10 +6,12 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Replays;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Scoring;
@@ -33,11 +35,6 @@ namespace osu.Game.Rulesets.Osu.Replays
 
         #region Constants
 
-        /// <summary>
-        /// The "reaction time" in ms between "seeing" a new hit object and moving to "react" to it.
-        /// </summary>
-        private readonly double reactionTime;
-
         private readonly HitWindows defaultHitWindows;
 
         /// <summary>
@@ -49,12 +46,9 @@ namespace osu.Game.Rulesets.Osu.Replays
 
         #region Construction / Initialisation
 
-        public OsuAutoGenerator(IBeatmap beatmap)
-            : base(beatmap)
+        public OsuAutoGenerator(IBeatmap beatmap, IReadOnlyList<Mod> mods)
+            : base(beatmap, mods)
         {
-            // Already superhuman, but still somewhat realistic
-            reactionTime = ApplyModsToRate(100);
-
             defaultHitWindows = new OsuHitWindows();
             defaultHitWindows.SetDifficulty(Beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
         }
@@ -240,7 +234,7 @@ namespace osu.Game.Rulesets.Osu.Replays
             OsuReplayFrame lastFrame = (OsuReplayFrame)Frames[^1];
 
             // Wait until Auto could "see and react" to the next note.
-            double waitTime = h.StartTime - Math.Max(0.0, h.TimePreempt - reactionTime);
+            double waitTime = h.StartTime - Math.Max(0.0, h.TimePreempt - getReactionTime(h.StartTime - h.TimePreempt));
 
             if (waitTime > lastFrame.Time)
             {
@@ -250,7 +244,7 @@ namespace osu.Game.Rulesets.Osu.Replays
 
             Vector2 lastPosition = lastFrame.Position;
 
-            double timeDifference = ApplyModsToTime(h.StartTime - lastFrame.Time);
+            double timeDifference = ApplyModsToTimeDelta(lastFrame.Time, h.StartTime);
 
             // Only "snap" to hitcircles if they are far enough apart. As the time between hitcircles gets shorter the snapping threshold goes up.
             if (timeDifference > 0 && // Sanity checks
@@ -258,7 +252,7 @@ namespace osu.Game.Rulesets.Osu.Replays
                  timeDifference >= 266)) // ... or the beats are slow enough to tap anyway.
             {
                 // Perform eased movement
-                for (double time = lastFrame.Time + FrameDelay; time < h.StartTime; time += FrameDelay)
+                for (double time = lastFrame.Time + GetFrameDelay(lastFrame.Time); time < h.StartTime; time += GetFrameDelay(time))
                 {
                     Vector2 currentPosition = Interpolation.ValueAt(time, lastPosition, targetPos, lastFrame.Time, h.StartTime, easing);
                     AddFrameToReplay(new OsuReplayFrame((int)time, new Vector2(currentPosition.X, currentPosition.Y)) { Actions = lastFrame.Actions });
@@ -272,6 +266,14 @@ namespace osu.Game.Rulesets.Osu.Replays
             }
         }
 
+        /// <summary>
+        /// Calculates the "reaction time" in ms between "seeing" a new hit object and moving to "react" to it.
+        /// </summary>
+        /// <remarks>
+        /// Already superhuman, but still somewhat realistic.
+        /// </remarks>
+        private double getReactionTime(double timeInstant) => ApplyModsToRate(timeInstant, 100);
+
         // Add frames to click the hitobject
         private void addHitObjectClickFrames(OsuHitObject h, Vector2 startPosition, float spinnerDirection)
         {
@@ -341,17 +343,23 @@ namespace osu.Game.Rulesets.Osu.Replays
                     float angle = radius == 0 ? 0 : MathF.Atan2(difference.Y, difference.X);
 
                     double t;
+                    double previousFrame = h.StartTime;
 
-                    for (double j = h.StartTime + FrameDelay; j < spinner.EndTime; j += FrameDelay)
+                    for (double nextFrame = h.StartTime + GetFrameDelay(h.StartTime); nextFrame < spinner.EndTime; nextFrame += GetFrameDelay(nextFrame))
                     {
-                        t = ApplyModsToTime(j - h.StartTime) * spinnerDirection;
+                        t = ApplyModsToTimeDelta(previousFrame, nextFrame) * spinnerDirection;
+                        angle += (float)t / 20;
 
-                        Vector2 pos = SPINNER_CENTRE + CirclePosition(t / 20 + angle, SPIN_RADIUS);
-                        AddFrameToReplay(new OsuReplayFrame((int)j, new Vector2(pos.X, pos.Y), action));
+                        Vector2 pos = SPINNER_CENTRE + CirclePosition(angle, SPIN_RADIUS);
+                        AddFrameToReplay(new OsuReplayFrame((int)nextFrame, new Vector2(pos.X, pos.Y), action));
+
+                        previousFrame = nextFrame;
                     }
 
-                    t = ApplyModsToTime(spinner.EndTime - h.StartTime) * spinnerDirection;
-                    Vector2 endPosition = SPINNER_CENTRE + CirclePosition(t / 20 + angle, SPIN_RADIUS);
+                    t = ApplyModsToTimeDelta(previousFrame, spinner.EndTime) * spinnerDirection;
+                    angle += (float)t / 20;
+
+                    Vector2 endPosition = SPINNER_CENTRE + CirclePosition(angle, SPIN_RADIUS);
 
                     AddFrameToReplay(new OsuReplayFrame(spinner.EndTime, new Vector2(endPosition.X, endPosition.Y), action));
 
@@ -359,7 +367,7 @@ namespace osu.Game.Rulesets.Osu.Replays
                     break;
 
                 case Slider slider:
-                    for (double j = FrameDelay; j < slider.Duration; j += FrameDelay)
+                    for (double j = GetFrameDelay(slider.StartTime); j < slider.Duration; j += GetFrameDelay(slider.StartTime + j))
                     {
                         Vector2 pos = slider.StackedPositionAt(j / slider.Duration);
                         AddFrameToReplay(new OsuReplayFrame(h.StartTime + j, new Vector2(pos.X, pos.Y), action));

osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs

@@ -5,7 +5,9 @@ using osuTK;
 using osu.Game.Beatmaps;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Replays;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Replays;
 
@@ -22,33 +24,61 @@ namespace osu.Game.Rulesets.Osu.Replays
 
         public const float SPIN_RADIUS = 50;
 
-        /// <summary>
-        /// The time in ms between each ReplayFrame.
-        /// </summary>
-        protected readonly double FrameDelay;
-
         #endregion
 
         #region Construction / Initialisation
 
         protected Replay Replay;
         protected List<ReplayFrame> Frames => Replay.Frames;
+        private readonly IReadOnlyList<IApplicableToRate> timeAffectingMods;
 
-        protected OsuAutoGeneratorBase(IBeatmap beatmap)
+        protected OsuAutoGeneratorBase(IBeatmap beatmap, IReadOnlyList<Mod> mods)
             : base(beatmap)
         {
             Replay = new Replay();
 
-            // We are using ApplyModsToRate and not ApplyModsToTime to counteract the speed up / slow down from HalfTime / DoubleTime so that we remain at a constant framerate of 60 fps.
-            FrameDelay = ApplyModsToRate(1000.0 / 60.0);
+            timeAffectingMods = mods.OfType<IApplicableToRate>().ToList();
         }
 
         #endregion
 
         #region Utilities
 
-        protected double ApplyModsToTime(double v) => v;
-        protected double ApplyModsToRate(double v) => v;
+        /// <summary>
+        /// Returns the real duration of time between <paramref name="startTime"/> and <paramref name="endTime"/>
+        /// after applying rate-affecting mods.
+        /// </summary>
+        /// <remarks>
+        /// This method should only be used when <paramref name="startTime"/> and <paramref name="endTime"/> are very close.
+        /// That is because the track rate might be changing with time,
+        /// and the method used here is a rough instantaneous approximation.
+        /// </remarks>
+        /// <param name="startTime">The start time of the time delta, in original track time.</param>
+        /// <param name="endTime">The end time of the time delta, in original track time.</param>
+        protected double ApplyModsToTimeDelta(double startTime, double endTime)
+        {
+            double delta = endTime - startTime;
+
+            foreach (var mod in timeAffectingMods)
+                delta /= mod.ApplyToRate(startTime);
+
+            return delta;
+        }
+
+        protected double ApplyModsToRate(double time, double rate)
+        {
+            foreach (var mod in timeAffectingMods)
+                rate = mod.ApplyToRate(time, rate);
+            return rate;
+        }
+
+        /// <summary>
+        /// Calculates the interval after which the next <see cref="ReplayFrame"/> should be generated,
+        /// in milliseconds.
+        /// </summary>
+        /// <param name="time">The time of the previous frame.</param>
+        protected double GetFrameDelay(double time)
+            => ApplyModsToRate(time, 1000.0 / 60);
 
         private class ReplayFrameComparer : IComparer<ReplayFrame>
         {

osu.Game.Rulesets.Osu/Skinning/Default/PlaySliderBody.cs

@@ -21,6 +21,8 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         [Resolved(CanBeNull = true)]
         private OsuRulesetConfigManager config { get; set; }
 
+        private readonly Bindable<bool> configSnakingOut = new Bindable<bool>();
+
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, DrawableHitObject drawableObject)
         {
@@ -36,10 +38,28 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
             accentColour.BindValueChanged(accent => updateAccentColour(skin, accent.NewValue), true);
 
             config?.BindWith(OsuRulesetSetting.SnakingInSliders, SnakingIn);
-            config?.BindWith(OsuRulesetSetting.SnakingOutSliders, SnakingOut);
+            config?.BindWith(OsuRulesetSetting.SnakingOutSliders, configSnakingOut);
+
+            SnakingOut.BindTo(configSnakingOut);
 
             BorderSize = skin.GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.SliderBorderSize)?.Value ?? 1;
             BorderColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBorder)?.Value ?? Color4.White;
+
+            drawableObject.HitObjectApplied += onHitObjectApplied;
+        }
+
+        private void onHitObjectApplied(DrawableHitObject obj)
+        {
+            var drawableSlider = (DrawableSlider)obj;
+            if (drawableSlider.HitObject == null)
+                return;
+
+            // When not tracking the follow circle, unbind from the config and forcefully disable snaking out - it looks better that way.
+            if (!drawableSlider.HeadCircle.TrackFollowCircle)
+            {
+                SnakingOut.UnbindFrom(configSnakingOut);
+                SnakingOut.Value = false;
+            }
         }
 
         private void updateAccentColour(ISkinSource skin, Color4 defaultAccentColour)

osu.Game.Rulesets.Osu/Skinning/Default/SliderBall.cs

@@ -31,6 +31,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
             set => ball.Colour = value;
         }
 
+        /// <summary>
+        /// Whether to track accurately to the visual size of this <see cref="SliderBall"/>.
+        /// If <c>false</c>, tracking will be performed at the final scale at all times.
+        /// </summary>
+        public bool InputTracksVisualSize = true;
+
         private readonly Drawable followCircle;
         private readonly DrawableSlider drawableSlider;
         private readonly Drawable ball;
@@ -94,7 +100,14 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
                 tracking = value;
 
-                followCircle.ScaleTo(tracking ? 2.4f : 1f, 300, Easing.OutQuint);
+                if (InputTracksVisualSize)
+                    followCircle.ScaleTo(tracking ? 2.4f : 1f, 300, Easing.OutQuint);
+                else
+                {
+                    // We need to always be tracking the final size, at both endpoints. For now, this is achieved by removing the scale duration.
+                    followCircle.ScaleTo(tracking ? 2.4f : 1f);
+                }
+
                 followCircle.FadeTo(tracking ? 1f : 0, 300, Easing.OutQuint);
             }
         }

osu.Game.Rulesets.Osu/UI/IHitPolicy.cs

@@ -0,0 +1,31 @@
+// 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.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public interface IHitPolicy
+    {
+        /// <summary>
+        /// The <see cref="IHitObjectContainer"/> containing the <see cref="DrawableHitObject"/>s which this <see cref="IHitPolicy"/> applies to.
+        /// </summary>
+        IHitObjectContainer HitObjectContainer { set; }
+
+        /// <summary>
+        /// Determines whether a <see cref="DrawableHitObject"/> can be hit at a point in time.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to check.</param>
+        /// <param name="time">The time to check.</param>
+        /// <returns>Whether <paramref name="hitObject"/> can be hit at the given <paramref name="time"/>.</returns>
+        bool IsHittable(DrawableHitObject hitObject, double time);
+
+        /// <summary>
+        /// Handles a <see cref="HitObject"/> being hit.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> that was hit.</param>
+        void HandleHit(DrawableHitObject hitObject);
+    }
+}

osu.Game.Rulesets.Osu/UI/ObjectOrderedHitPolicy.cs

@@ -0,0 +1,54 @@
+// 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 System.Linq;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    /// <summary>
+    /// Ensures that <see cref="HitObject"/>s are hit in order of appearance. The classic note lock.
+    /// <remarks>
+    /// Hits will be blocked until the previous <see cref="HitObject"/>s have been judged.
+    /// </remarks>
+    /// </summary>
+    public class ObjectOrderedHitPolicy : IHitPolicy
+    {
+        public IHitObjectContainer HitObjectContainer { get; set; }
+
+        public bool IsHittable(DrawableHitObject hitObject, double time) => enumerateHitObjectsUpTo(hitObject.HitObject.StartTime).All(obj => obj.AllJudged);
+
+        public void HandleHit(DrawableHitObject hitObject)
+        {
+        }
+
+        private IEnumerable<DrawableHitObject> enumerateHitObjectsUpTo(double targetTime)
+        {
+            foreach (var obj in HitObjectContainer.AliveObjects)
+            {
+                if (obj.HitObject.StartTime >= targetTime)
+                    yield break;
+
+                switch (obj)
+                {
+                    case DrawableSpinner _:
+                        continue;
+
+                    case DrawableSlider slider:
+                        yield return slider.HeadCircle;
+
+                        break;
+
+                    default:
+                        yield return obj;
+
+                        break;
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs

@@ -31,7 +31,6 @@ namespace osu.Game.Rulesets.Osu.UI
         private readonly ProxyContainer spinnerProxies;
         private readonly JudgementContainer<DrawableOsuJudgement> judgementLayer;
         private readonly FollowPointRenderer followPoints;
-        private readonly OrderedHitPolicy hitPolicy;
 
         public static readonly Vector2 BASE_SIZE = new Vector2(512, 384);
 
@@ -54,10 +53,9 @@ namespace osu.Game.Rulesets.Osu.UI
                 approachCircles = new ProxyContainer { RelativeSizeAxes = Axes.Both },
             };
 
-            hitPolicy = new OrderedHitPolicy(HitObjectContainer);
+            HitPolicy = new StartTimeOrderedHitPolicy();
 
             var hitWindows = new OsuHitWindows();
-
             foreach (var result in Enum.GetValues(typeof(HitResult)).OfType<HitResult>().Where(r => r > HitResult.None && hitWindows.IsHitResultAllowed(r)))
                 poolDictionary.Add(result, new DrawableJudgementPool(result, onJudgmentLoaded));
 
@@ -66,6 +64,18 @@ namespace osu.Game.Rulesets.Osu.UI
             NewResult += onNewResult;
         }
 
+        private IHitPolicy hitPolicy;
+
+        public IHitPolicy HitPolicy
+        {
+            get => hitPolicy;
+            set
+            {
+                hitPolicy = value ?? throw new ArgumentNullException(nameof(value));
+                hitPolicy.HitObjectContainer = HitObjectContainer;
+            }
+        }
+
         protected override void OnNewDrawableHitObject(DrawableHitObject drawable)
         {
             ((DrawableOsuHitObject)drawable).CheckHittable = hitPolicy.IsHittable;

osu.Game.Rulesets.Osu/UI/StartTimeOrderedHitPolicy.cs

@@ -11,28 +11,17 @@ using osu.Game.Rulesets.UI;
 namespace osu.Game.Rulesets.Osu.UI
 {
     /// <summary>
-    /// Ensures that <see cref="HitObject"/>s are hit in-order. Affectionately known as "note lock".
+    /// Ensures that <see cref="HitObject"/>s are hit in-order of their start times. Affectionately known as "note lock".
     /// If a <see cref="HitObject"/> is hit out of order:
     /// <list type="number">
     /// <item><description>The hit is blocked if it occurred earlier than the previous <see cref="HitObject"/>'s start time.</description></item>
     /// <item><description>The hit causes all previous <see cref="HitObject"/>s to missed otherwise.</description></item>
     /// </list>
     /// </summary>
-    public class OrderedHitPolicy
+    public class StartTimeOrderedHitPolicy : IHitPolicy
     {
-        private readonly HitObjectContainer hitObjectContainer;
+        public IHitObjectContainer HitObjectContainer { get; set; }
 
-        public OrderedHitPolicy(HitObjectContainer hitObjectContainer)
-        {
-            this.hitObjectContainer = hitObjectContainer;
-        }
-
-        /// <summary>
-        /// Determines whether a <see cref="DrawableHitObject"/> can be hit at a point in time.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to check.</param>
-        /// <param name="time">The time to check.</param>
-        /// <returns>Whether <paramref name="hitObject"/> can be hit at the given <paramref name="time"/>.</returns>
         public bool IsHittable(DrawableHitObject hitObject, double time)
         {
             DrawableHitObject blockingObject = null;
@@ -54,10 +43,6 @@ namespace osu.Game.Rulesets.Osu.UI
             return blockingObject.Judged || time >= blockingObject.HitObject.StartTime;
         }
 
-        /// <summary>
-        /// Handles a <see cref="HitObject"/> being hit to potentially miss all earlier <see cref="HitObject"/>s.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="HitObject"/> that was hit.</param>
         public void HandleHit(DrawableHitObject hitObject)
         {
             // Hitobjects which themselves don't block future hitobjects don't cause misses (e.g. slider ticks, spinners).
@@ -67,6 +52,7 @@ namespace osu.Game.Rulesets.Osu.UI
             if (!IsHittable(hitObject, hitObject.HitObject.StartTime + hitObject.Result.TimeOffset))
                 throw new InvalidOperationException($"A {hitObject} was hit before it became hittable!");
 
+            // Miss all hitobjects prior to the hit one.
             foreach (var obj in enumerateHitObjectsUpTo(hitObject.HitObject.StartTime))
             {
                 if (obj.Judged)
@@ -86,7 +72,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         private IEnumerable<DrawableHitObject> enumerateHitObjectsUpTo(double targetTime)
         {
-            foreach (var obj in hitObjectContainer.AliveObjects)
+            foreach (var obj in HitObjectContainer.AliveObjects)
             {
                 if (obj.HitObject.StartTime >= targetTime)
                     yield break;

osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj

@@ -3,7 +3,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>

osu.Game.Rulesets.Taiko/Mods/TaikoModAutoplay.cs

@@ -1,6 +1,7 @@
 // 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.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -12,7 +13,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
 {
     public class TaikoModAutoplay : ModAutoplay<TaikoHitObject>
     {
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "mekkadosu!" } },
             Replay = new TaikoAutoGenerator(beatmap).Generate(),

osu.Game.Rulesets.Taiko/Mods/TaikoModCinema.cs

@@ -1,6 +1,7 @@
 // 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.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -12,7 +13,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
 {
     public class TaikoModCinema : ModCinema<TaikoHitObject>
     {
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
             ScoreInfo = new ScoreInfo { User = new User { Username = "mekkadosu!" } },
             Replay = new TaikoAutoGenerator(beatmap).Generate(),

osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacySkinTransformer.cs

@@ -152,7 +152,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
             throw new ArgumentOutOfRangeException(nameof(component), $"Invalid component type: {component}");
         }
 
-        public override SampleChannel GetSample(ISampleInfo sampleInfo) => Source.GetSample(new LegacyTaikoSampleInfo(sampleInfo));
+        public override Sample GetSample(ISampleInfo sampleInfo) => Source.GetSample(new LegacyTaikoSampleInfo(sampleInfo));
 
         public override IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => Source.GetConfig<TLookup, TValue>(lookup);
 

osu.Game.Tests/Chat/MessageFormatterTests.cs

@@ -21,6 +21,27 @@ namespace osu.Game.Tests.Chat
             Assert.AreEqual(36, result.Links[0].Length);
         }
 
+        [TestCase(LinkAction.OpenBeatmap, "456", "https://dev.ppy.sh/beatmapsets/123#osu/456")]
+        [TestCase(LinkAction.OpenBeatmap, "456", "https://dev.ppy.sh/beatmapsets/123#osu/456?whatever")]
+        [TestCase(LinkAction.OpenBeatmap, "456", "https://dev.ppy.sh/beatmapsets/123/456")]
+        [TestCase(LinkAction.External, null, "https://dev.ppy.sh/beatmapsets/abc/def")]
+        [TestCase(LinkAction.OpenBeatmapSet, "123", "https://dev.ppy.sh/beatmapsets/123")]
+        [TestCase(LinkAction.OpenBeatmapSet, "123", "https://dev.ppy.sh/beatmapsets/123/whatever")]
+        [TestCase(LinkAction.External, null, "https://dev.ppy.sh/beatmapsets/abc")]
+        public void TestBeatmapLinks(LinkAction expectedAction, string expectedArg, string link)
+        {
+            MessageFormatter.WebsiteRootUrl = "dev.ppy.sh";
+
+            Message result = MessageFormatter.FormatMessage(new Message { Content = link });
+
+            Assert.AreEqual(result.Content, result.DisplayContent);
+            Assert.AreEqual(1, result.Links.Count);
+            Assert.AreEqual(expectedAction, result.Links[0].Action);
+            Assert.AreEqual(expectedArg, result.Links[0].Argument);
+            if (expectedAction == LinkAction.External)
+                Assert.AreEqual(link, result.Links[0].Url);
+        }
+
         [Test]
         public void TestMultipleComplexLinks()
         {

osu.Game.Tests/Gameplay/TestSceneHitObjectAccentColour.cs

@@ -121,7 +121,7 @@ namespace osu.Game.Tests.Gameplay
 
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
+            public Sample GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup)
             {

osu.Game.Tests/Gameplay/TestSceneStoryboardSamples.cs

@@ -35,7 +35,7 @@ namespace osu.Game.Tests.Gameplay
         public void TestRetrieveTopLevelSample()
         {
             ISkin skin = null;
-            SampleChannel channel = null;
+            Sample channel = null;
 
             AddStep("create skin", () => skin = new TestSkin("test-sample", this));
             AddStep("retrieve sample", () => channel = skin.GetSample(new SampleInfo("test-sample")));
@@ -47,7 +47,7 @@ namespace osu.Game.Tests.Gameplay
         public void TestRetrieveSampleInSubFolder()
         {
             ISkin skin = null;
-            SampleChannel channel = null;
+            Sample channel = null;
 
             AddStep("create skin", () => skin = new TestSkin("folder/test-sample", this));
             AddStep("retrieve sample", () => channel = skin.GetSample(new SampleInfo("folder/test-sample")));

osu.Game.Tests/NonVisual/Skinning/LegacySkinAnimationTest.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Tests.NonVisual.Skinning
             }
 
             public Drawable GetDrawableComponent(ISkinComponent component) => throw new NotSupportedException();
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotSupportedException();
+            public Sample GetSample(ISampleInfo sampleInfo) => throw new NotSupportedException();
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotSupportedException();
         }
 

osu.Game.Tests/NonVisual/TaskChainTest.cs

@@ -0,0 +1,111 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Game.Utils;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class TaskChainTest
+    {
+        private TaskChain taskChain;
+        private int currentTask;
+        private CancellationTokenSource globalCancellationToken;
+
+        [SetUp]
+        public void Setup()
+        {
+            globalCancellationToken = new CancellationTokenSource();
+            taskChain = new TaskChain();
+            currentTask = 0;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            globalCancellationToken?.Cancel();
+        }
+
+        [Test]
+        public async Task TestChainedTasksRunSequentially()
+        {
+            var task1 = addTask();
+            var task2 = addTask();
+            var task3 = addTask();
+
+            task3.mutex.Set();
+            task2.mutex.Set();
+            task1.mutex.Set();
+
+            await Task.WhenAll(task1.task, task2.task, task3.task);
+
+            Assert.That(task1.task.Result, Is.EqualTo(1));
+            Assert.That(task2.task.Result, Is.EqualTo(2));
+            Assert.That(task3.task.Result, Is.EqualTo(3));
+        }
+
+        [Test]
+        public async Task TestChainedTaskWithIntermediateCancelRunsInSequence()
+        {
+            var task1 = addTask();
+            var task2 = addTask();
+            var task3 = addTask();
+
+            // Cancel task2, allow task3 to complete.
+            task2.cancellation.Cancel();
+            task2.mutex.Set();
+            task3.mutex.Set();
+
+            // Allow task3 to potentially complete.
+            Thread.Sleep(1000);
+
+            // Allow task1 to complete.
+            task1.mutex.Set();
+
+            // Wait on both tasks.
+            await Task.WhenAll(task1.task, task3.task);
+
+            Assert.That(task1.task.Result, Is.EqualTo(1));
+            Assert.That(task2.task.IsCompleted, Is.False);
+            Assert.That(task3.task.Result, Is.EqualTo(2));
+        }
+
+        [Test]
+        public async Task TestChainedTaskDoesNotCompleteBeforeChildTasks()
+        {
+            var mutex = new ManualResetEventSlim(false);
+
+            var task = taskChain.Add(async () => await Task.Run(() => mutex.Wait(globalCancellationToken.Token)));
+
+            // Allow task to potentially complete
+            Thread.Sleep(1000);
+
+            Assert.That(task.IsCompleted, Is.False);
+
+            // Allow the task to complete.
+            mutex.Set();
+
+            await task;
+        }
+
+        private (Task<int> task, ManualResetEventSlim mutex, CancellationTokenSource cancellation) addTask()
+        {
+            var mutex = new ManualResetEventSlim(false);
+            var completionSource = new TaskCompletionSource<int>();
+
+            var cancellationSource = new CancellationTokenSource();
+            var token = CancellationTokenSource.CreateLinkedTokenSource(cancellationSource.Token, globalCancellationToken.Token);
+
+            taskChain.Add(() =>
+            {
+                mutex.Wait(globalCancellationToken.Token);
+                completionSource.SetResult(Interlocked.Increment(ref currentTask));
+            }, token.Token);
+
+            return (completionSource.Task, mutex, cancellationSource);
+        }
+    }
+}

osu.Game.Tests/Online/TestAPIModJsonSerialization.cs

@@ -68,12 +68,29 @@ namespace osu.Game.Tests.Online
             Assert.That(converted.FinalRate.Value, Is.EqualTo(0.25));
         }
 
+        [Test]
+        public void TestDeserialiseDifficultyAdjustModWithExtendedLimits()
+        {
+            var apiMod = new APIMod(new TestModDifficultyAdjust
+            {
+                OverallDifficulty = { Value = 11 },
+                ExtendedLimits = { Value = true }
+            });
+
+            var deserialised = JsonConvert.DeserializeObject<APIMod>(JsonConvert.SerializeObject(apiMod));
+            var converted = (TestModDifficultyAdjust)deserialised.ToMod(new TestRuleset());
+
+            Assert.That(converted.ExtendedLimits.Value, Is.True);
+            Assert.That(converted.OverallDifficulty.Value, Is.EqualTo(11));
+        }
+
         private class TestRuleset : Ruleset
         {
             public override IEnumerable<Mod> GetModsFor(ModType type) => new Mod[]
             {
                 new TestMod(),
                 new TestModTimeRamp(),
+                new TestModDifficultyAdjust()
             };
 
             public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => throw new System.NotImplementedException();
@@ -135,5 +152,9 @@ namespace osu.Game.Tests.Online
                 Value = true
             };
         }
+
+        private class TestModDifficultyAdjust : ModDifficultyAdjust
+        {
+        }
     }
 }

osu.Game.Tests/Online/TestAPIModMessagePackSerialization.cs

@@ -68,6 +68,16 @@ namespace osu.Game.Tests.Online
             Assert.That(converted.FinalRate.Value, Is.EqualTo(0.25));
         }
 
+        [Test]
+        public void TestDeserialiseEnumMod()
+        {
+            var apiMod = new APIMod(new TestModEnum { TestSetting = { Value = TestEnum.Value2 } });
+
+            var deserialized = MessagePackSerializer.Deserialize<APIMod>(MessagePackSerializer.Serialize(apiMod));
+
+            Assert.That(deserialized.Settings, Contains.Key("test_setting").With.ContainValue(1));
+        }
+
         private class TestRuleset : Ruleset
         {
             public override IEnumerable<Mod> GetModsFor(ModType type) => new Mod[]
@@ -135,5 +145,22 @@ namespace osu.Game.Tests.Online
                 Value = true
             };
         }
+
+        private class TestModEnum : Mod
+        {
+            public override string Name => "Test Mod";
+            public override string Acronym => "TM";
+            public override double ScoreMultiplier => 1;
+
+            [SettingSource("Test")]
+            public Bindable<TestEnum> TestSetting { get; } = new Bindable<TestEnum>();
+        }
+
+        private enum TestEnum
+        {
+            Value1 = 0,
+            Value2 = 1,
+            Value3 = 2
+        }
     }
 }

osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs

@@ -165,10 +165,10 @@ namespace osu.Game.Tests.Online
             {
             }
 
-            public override async Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, CancellationToken cancellationToken = default)
+            public override async Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
             {
                 await AllowImport.Task;
-                return await (CurrentImportTask = base.Import(item, archive, cancellationToken));
+                return await (CurrentImportTask = base.Import(item, archive, lowPriority, cancellationToken));
             }
         }
 

osu.Game.Tests/Rulesets/TestSceneDrawableRulesetDependencies.cs

@@ -105,9 +105,9 @@ namespace osu.Game.Tests.Rulesets
                 IsDisposed = true;
             }
 
-            public SampleChannel Get(string name) => null;
+            public Sample Get(string name) => null;
 
-            public Task<SampleChannel> GetAsync(string name) => null;
+            public Task<Sample> GetAsync(string name) => null;
 
             public Stream GetStream(string name) => null;
 
@@ -118,9 +118,9 @@ namespace osu.Game.Tests.Rulesets
             public BindableNumber<double> Frequency => throw new NotImplementedException();
             public BindableNumber<double> Tempo => throw new NotImplementedException();
 
-            public void AddAdjustment(AdjustableProperty type, BindableNumber<double> adjustBindable) => throw new NotImplementedException();
+            public void AddAdjustment(AdjustableProperty type, IBindable<double> adjustBindable) => throw new NotImplementedException();
 
-            public void RemoveAdjustment(AdjustableProperty type, BindableNumber<double> adjustBindable) => throw new NotImplementedException();
+            public void RemoveAdjustment(AdjustableProperty type, IBindable<double> adjustBindable) => throw new NotImplementedException();
 
             public void RemoveAllAdjustments(AdjustableProperty type) => throw new NotImplementedException();
 

osu.Game.Tests/Skins/TestSceneSkinConfigurationLookup.cs

@@ -219,7 +219,7 @@ namespace osu.Game.Tests.Skins
 
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => skin.GetTexture(componentName, wrapModeS, wrapModeT);
 
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => skin.GetSample(sampleInfo);
+            public Sample GetSample(ISampleInfo sampleInfo) => skin.GetSample(sampleInfo);
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => skin.GetConfig<TLookup, TValue>(lookup);
         }

osu.Game.Tests/Visual/Editing/TestSceneEditorSamplePlayback.cs

@@ -3,11 +3,11 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Graphics.Audio;
 using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Skinning;
 
 namespace osu.Game.Tests.Visual.Editing
 {
@@ -19,14 +19,14 @@ namespace osu.Game.Tests.Visual.Editing
         public void TestSlidingSampleStopsOnSeek()
         {
             DrawableSlider slider = null;
-            DrawableSample[] loopingSamples = null;
-            DrawableSample[] onceOffSamples = null;
+            PoolableSkinnableSample[] loopingSamples = null;
+            PoolableSkinnableSample[] onceOffSamples = null;
 
             AddStep("get first slider", () =>
             {
                 slider = Editor.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First();
-                onceOffSamples = slider.ChildrenOfType<DrawableSample>().Where(s => !s.Looping).ToArray();
-                loopingSamples = slider.ChildrenOfType<DrawableSample>().Where(s => s.Looping).ToArray();
+                onceOffSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => !s.Looping).ToArray();
+                loopingSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => s.Looping).ToArray();
             });
 
             AddStep("start playback", () => EditorClock.Start());

osu.Game.Tests/Visual/Editing/TestSceneTimelineHitObjectBlueprint.cs

@@ -0,0 +1,55 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osuTK;
+using osuTK.Input;
+using static osu.Game.Screens.Edit.Compose.Components.Timeline.TimelineHitObjectBlueprint;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneTimelineHitObjectBlueprint : TimelineTestScene
+    {
+        public override Drawable CreateTestComponent() => new TimelineBlueprintContainer(Composer);
+
+        [Test]
+        public void TestDisallowZeroDurationObjects()
+        {
+            DragBar dragBar;
+
+            AddStep("add spinner", () =>
+            {
+                EditorBeatmap.Clear();
+                EditorBeatmap.Add(new Spinner
+                {
+                    Position = new Vector2(256, 256),
+                    StartTime = 150,
+                    Duration = 500
+                });
+            });
+
+            AddStep("hold down drag bar", () =>
+            {
+                // distinguishes between the actual drag bar and its "underlay shadow".
+                dragBar = this.ChildrenOfType<DragBar>().Single(bar => bar.HandlePositionalInput);
+                InputManager.MoveMouseTo(dragBar);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("try to drag bar past start", () =>
+            {
+                var blueprint = this.ChildrenOfType<TimelineHitObjectBlueprint>().Single();
+                InputManager.MoveMouseTo(blueprint.SelectionQuad.TopLeft - new Vector2(100, 0));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("object has non-zero duration", () => EditorBeatmap.HitObjects.OfType<IHasDuration>().Single().Duration > 0);
+        }
+    }
+}

osu.Game.Tests/Visual/Editing/TimelineTestScene.cs

@@ -23,22 +23,24 @@ namespace osu.Game.Tests.Visual.Editing
 
         protected HitObjectComposer Composer { get; private set; }
 
+        protected EditorBeatmap EditorBeatmap { get; private set; }
+
         [BackgroundDependencyLoader]
         private void load(AudioManager audio)
         {
             Beatmap.Value = new WaveformTestBeatmap(audio);
 
             var playable = Beatmap.Value.GetPlayableBeatmap(Beatmap.Value.BeatmapInfo.Ruleset);
-            var editorBeatmap = new EditorBeatmap(playable);
+            EditorBeatmap = new EditorBeatmap(playable);
 
-            Dependencies.Cache(editorBeatmap);
-            Dependencies.CacheAs<IBeatSnapProvider>(editorBeatmap);
+            Dependencies.Cache(EditorBeatmap);
+            Dependencies.CacheAs<IBeatSnapProvider>(EditorBeatmap);
 
             Composer = playable.BeatmapInfo.Ruleset.CreateInstance().CreateHitObjectComposer().With(d => d.Alpha = 0);
 
             AddRange(new Drawable[]
             {
-                editorBeatmap,
+                EditorBeatmap,
                 Composer,
                 new FillFlowContainer
                 {

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Graphics.Audio;
 using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
@@ -20,14 +19,14 @@ namespace osu.Game.Tests.Visual.Gameplay
         public void TestAllSamplesStopDuringSeek()
         {
             DrawableSlider slider = null;
-            DrawableSample[] samples = null;
+            PoolableSkinnableSample[] samples = null;
             ISamplePlaybackDisabler sampleDisabler = null;
 
             AddUntilStep("get variables", () =>
             {
                 sampleDisabler = Player;
                 slider = Player.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).FirstOrDefault();
-                samples = slider?.ChildrenOfType<DrawableSample>().ToArray();
+                samples = slider?.ChildrenOfType<PoolableSkinnableSample>().ToArray();
 
                 return slider != null;
             });

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

@@ -56,9 +56,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             pauseAndConfirm();
             resume();
 
-            confirmClockRunning(false);
-            confirmPauseOverlayShown(false);
-
+            confirmPausedWithNoOverlay();
             AddStep("click to resume", () => InputManager.Click(MouseButton.Left));
 
             confirmClockRunning(true);
@@ -71,15 +69,14 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("wait for hitobjects", () => Player.HealthProcessor.Health.Value < 1);
 
             pauseAndConfirm();
-
             resume();
-            confirmClockRunning(false);
-            confirmPauseOverlayShown(false);
 
+            confirmPausedWithNoOverlay();
             pauseAndConfirm();
 
             AddUntilStep("resume overlay is not active", () => Player.DrawableRuleset.ResumeOverlay.State.Value == Visibility.Hidden);
             confirmPaused();
+            confirmNotExited();
         }
 
         [Test]
@@ -94,33 +91,45 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
-        public void TestPauseTooSoon()
+        public void TestUserPauseDuringCooldownTooSoon()
         {
             AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
 
             pauseAndConfirm();
 
             resume();
-            pause();
+            pauseFromUserExitKey();
 
-            confirmClockRunning(true);
-            confirmPauseOverlayShown(false);
+            confirmResumed();
+            confirmNotExited();
         }
 
         [Test]
-        public void TestExitTooSoon()
+        public void TestQuickExitDuringCooldownTooSoon()
+        {
+            AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
+
+            pauseAndConfirm();
+
+            resume();
+            AddStep("pause via exit key", () => Player.ExitViaQuickExit());
+
+            confirmResumed();
+            AddAssert("exited", () => !Player.IsCurrentScreen());
+        }
+
+        [Test]
+        public void TestExitSoonAfterResumeSucceeds()
         {
             AddStep("seek before gameplay", () => Player.GameplayClockContainer.Seek(-5000));
 
             pauseAndConfirm();
             resume();
 
-            AddStep("exit too soon", () => Player.Exit());
+            AddStep("exit quick", () => Player.Exit());
 
-            confirmClockRunning(true);
-            confirmPauseOverlayShown(false);
-
-            AddAssert("not exited", () => Player.IsCurrentScreen());
+            confirmResumed();
+            AddAssert("exited", () => !Player.IsCurrentScreen());
         }
 
         [Test]
@@ -131,22 +140,37 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             confirmClockRunning(false);
 
-            pause();
-
-            confirmClockRunning(false);
-            confirmPauseOverlayShown(false);
+            AddStep("pause via forced pause", () => Player.Pause());
 
+            confirmPausedWithNoOverlay();
             AddAssert("fail overlay still shown", () => Player.FailOverlayVisible);
 
             exitAndConfirm();
         }
 
         [Test]
-        public void TestExitFromFailedGameplay()
+        public void TestExitFromFailedGameplayAfterFailAnimation()
         {
             AddUntilStep("wait for fail", () => Player.HasFailed);
-            AddStep("exit", () => Player.Exit());
+            AddUntilStep("wait for fail overlay shown", () => Player.FailOverlayVisible);
 
+            confirmClockRunning(false);
+
+            AddStep("exit via user pause", () => Player.ExitViaPause());
+            confirmExited();
+        }
+
+        [Test]
+        public void TestExitFromFailedGameplayDuringFailAnimation()
+        {
+            AddUntilStep("wait for fail", () => Player.HasFailed);
+
+            // will finish the fail animation and show the fail/pause screen.
+            AddStep("attempt exit via pause key", () => Player.ExitViaPause());
+            AddAssert("fail overlay shown", () => Player.FailOverlayVisible);
+
+            // will actually exit.
+            AddStep("exit via pause key", () => Player.ExitViaPause());
             confirmExited();
         }
 
@@ -245,7 +269,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void pauseAndConfirm()
         {
-            pause();
+            pauseFromUserExitKey();
             confirmPaused();
         }
 
@@ -257,7 +281,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void exitAndConfirm()
         {
-            AddUntilStep("player not exited", () => Player.IsCurrentScreen());
+            confirmNotExited();
             AddStep("exit", () => Player.Exit());
             confirmExited();
             confirmNoTrackAdjustments();
@@ -266,7 +290,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         private void confirmPaused()
         {
             confirmClockRunning(false);
-            AddAssert("player not exited", () => Player.IsCurrentScreen());
+            confirmNotExited();
             AddAssert("player not failed", () => !Player.HasFailed);
             AddAssert("pause overlay shown", () => Player.PauseOverlayVisible);
         }
@@ -277,18 +301,22 @@ namespace osu.Game.Tests.Visual.Gameplay
             confirmPauseOverlayShown(false);
         }
 
-        private void confirmExited()
+        private void confirmPausedWithNoOverlay()
         {
-            AddUntilStep("player exited", () => !Player.IsCurrentScreen());
+            confirmClockRunning(false);
+            confirmPauseOverlayShown(false);
         }
 
+        private void confirmExited() => AddUntilStep("player exited", () => !Player.IsCurrentScreen());
+        private void confirmNotExited() => AddAssert("player not exited", () => Player.IsCurrentScreen());
+
         private void confirmNoTrackAdjustments()
         {
             AddAssert("track has no adjustments", () => Beatmap.Value.Track.AggregateFrequency.Value == 1);
         }
 
         private void restart() => AddStep("restart", () => Player.Restart());
-        private void pause() => AddStep("pause", () => Player.Pause());
+        private void pauseFromUserExitKey() => AddStep("user pause", () => Player.ExitViaPause());
         private void resume() => AddStep("resume", () => Player.Resume());
 
         private void confirmPauseOverlayShown(bool isShown) =>
@@ -307,6 +335,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public bool PauseOverlayVisible => PauseOverlay.State.Value == Visibility.Visible;
 
+            public void ExitViaPause() => PerformExit(true);
+
+            public void ExitViaQuickExit() => PerformExit(false);
+
             public override void OnEntering(IScreen last)
             {
                 base.OnEntering(last);

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

@@ -19,7 +19,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             var beatmap = Beatmap.Value.GetPlayableBeatmap(ruleset.RulesetInfo, Array.Empty<Mod>());
 
-            return new ScoreAccessibleReplayPlayer(ruleset.GetAutoplayMod()?.CreateReplayScore(beatmap));
+            return new ScoreAccessibleReplayPlayer(ruleset.GetAutoplayMod()?.CreateReplayScore(beatmap, Array.Empty<Mod>()));
         }
 
         protected override void AddCheckSteps()

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

@@ -298,7 +298,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
+            public Sample GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
         }
@@ -309,7 +309,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
+            public Sample GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
         }
@@ -321,7 +321,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
+            public Sample GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
 

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

@@ -43,70 +43,60 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestStoppedSoundDoesntResumeAfterPause()
         {
-            DrawableSample sample = null;
             AddStep("start sample with looping", () =>
             {
-                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
-
                 skinnableSound.Looping = true;
                 skinnableSound.Play();
             });
 
-            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+            AddUntilStep("wait for sample to start playing", () => skinnableSound.IsPlaying);
 
             AddStep("stop sample", () => skinnableSound.Stop());
 
-            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+            AddUntilStep("wait for sample to stop playing", () => !skinnableSound.IsPlaying);
 
             AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
 
             AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
 
             AddWaitStep("wait a bit", 5);
-            AddAssert("sample not playing", () => !sample.Playing);
+            AddAssert("sample not playing", () => !skinnableSound.IsPlaying);
         }
 
         [Test]
         public void TestLoopingSoundResumesAfterPause()
         {
-            DrawableSample sample = null;
             AddStep("start sample with looping", () =>
             {
                 skinnableSound.Looping = true;
                 skinnableSound.Play();
-                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
             });
 
-            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+            AddUntilStep("wait for sample to start playing", () => skinnableSound.IsPlaying);
 
             AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
-            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+            AddUntilStep("wait for sample to stop playing", () => !skinnableSound.IsPlaying);
 
             AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
-            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+            AddUntilStep("wait for sample to start playing", () => skinnableSound.IsPlaying);
         }
 
         [Test]
         public void TestNonLoopingStopsWithPause()
         {
-            DrawableSample sample = null;
-            AddStep("start sample", () =>
-            {
-                skinnableSound.Play();
-                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
-            });
+            AddStep("start sample", () => skinnableSound.Play());
 
-            AddAssert("sample playing", () => sample.Playing);
+            AddAssert("sample playing", () => skinnableSound.IsPlaying);
 
             AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
 
-            AddUntilStep("sample not playing", () => !sample.Playing);
+            AddUntilStep("sample not playing", () => !skinnableSound.IsPlaying);
 
             AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
 
-            AddAssert("sample not playing", () => !sample.Playing);
-            AddAssert("sample not playing", () => !sample.Playing);
-            AddAssert("sample not playing", () => !sample.Playing);
+            AddAssert("sample not playing", () => !skinnableSound.IsPlaying);
+            AddAssert("sample not playing", () => !skinnableSound.IsPlaying);
+            AddAssert("sample not playing", () => !skinnableSound.IsPlaying);
         }
 
         [Test]
@@ -119,10 +109,10 @@ namespace osu.Game.Tests.Visual.Gameplay
                 sample = skinnableSound.ChildrenOfType<DrawableSample>().Single();
             });
 
-            AddAssert("sample playing", () => sample.Playing);
+            AddAssert("sample playing", () => skinnableSound.IsPlaying);
 
             AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
-            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+            AddUntilStep("wait for sample to stop playing", () => !skinnableSound.IsPlaying);
 
             AddStep("trigger skin change", () => skinSource.TriggerSourceChanged());
 
@@ -133,11 +123,11 @@ namespace osu.Game.Tests.Visual.Gameplay
                 return sample != oldSample;
             });
 
-            AddAssert("new sample stopped", () => !sample.Playing);
+            AddAssert("new sample stopped", () => !skinnableSound.IsPlaying);
             AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
 
             AddWaitStep("wait a bit", 5);
-            AddAssert("new sample not played", () => !sample.Playing);
+            AddAssert("new sample not played", () => !skinnableSound.IsPlaying);
         }
 
         [Cached(typeof(ISkinSource))]
@@ -155,7 +145,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public Drawable GetDrawableComponent(ISkinComponent component) => source?.GetDrawableComponent(component);
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => source?.GetTexture(componentName, wrapModeS, wrapModeT);
-            public SampleChannel GetSample(ISampleInfo sampleInfo) => source?.GetSample(sampleInfo);
+            public Sample GetSample(ISampleInfo sampleInfo) => source?.GetSample(sampleInfo);
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => source?.GetConfig<TLookup, TValue>(lookup);
 
             public void TriggerSourceChanged()

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

@@ -3,7 +3,6 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -244,11 +243,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
             }
 
-            protected override Task Connect()
-            {
-                return Task.CompletedTask;
-            }
-
             public void StartPlay(int beatmapId)
             {
                 this.beatmapId = beatmapId;

osu.Game.Tests/Visual/Multiplayer/TestSceneLoungeRoomsContainer.cs

@@ -69,6 +69,20 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("last room joined", () => RoomManager.Rooms.Last().Status.Value is JoinedRoomStatus);
         }
 
+        [Test]
+        public void TestClickDeselection()
+        {
+            AddRooms(1);
+
+            AddAssert("no selection", () => checkRoomSelected(null));
+
+            press(Key.Down);
+            AddAssert("first room selected", () => checkRoomSelected(RoomManager.Rooms.First()));
+
+            AddStep("click away", () => InputManager.Click(MouseButton.Left));
+            AddAssert("no selection", () => checkRoomSelected(null));
+        }
+
         private void press(Key down)
         {
             AddStep($"press {down}", () => InputManager.Key(down));

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboard.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -14,6 +13,7 @@ using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Database;
 using osu.Game.Online;
+using osu.Game.Online.API;
 using osu.Game.Online.Spectator;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Osu.Scoring;
@@ -51,6 +51,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [SetUpSteps]
         public override void SetUpSteps()
         {
+            AddStep("set local user", () => ((DummyAPIAccess)API).LocalUser.Value = lookupCache.GetUserAsync(1).Result);
+
             AddStep("create leaderboard", () =>
             {
                 leaderboard?.Expire();
@@ -86,6 +88,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         public void TestScoreUpdates()
         {
             AddRepeatStep("update state", () => streamingClient.RandomlyUpdateState(), 100);
+            AddToggleStep("switch compact mode", expanded => leaderboard.Expanded.Value = expanded);
         }
 
         [Test]
@@ -163,8 +166,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     ((ISpectatorClient)this).UserSentFrames(userId, new FrameDataBundle(header, Array.Empty<LegacyReplayFrame>()));
                 }
             }
-
-            protected override Task Connect() => Task.CompletedTask;
         }
     }
 }

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerParticipantsList.cs

@@ -1,13 +1,17 @@
 // 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 System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Participants;
@@ -19,16 +23,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
     public class TestSceneMultiplayerParticipantsList : MultiplayerTestScene
     {
         [SetUp]
-        public new void Setup() => Schedule(() =>
-        {
-            Child = new ParticipantsList
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                RelativeSizeAxes = Axes.Y,
-                Size = new Vector2(380, 0.7f)
-            };
-        });
+        public new void Setup() => Schedule(createNewParticipantsList);
 
         [Test]
         public void TestAddUser()
@@ -75,6 +70,50 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("single panel is for second user", () => this.ChildrenOfType<ParticipantPanel>().Single().User.User == secondUser);
         }
 
+        [Test]
+        public void TestGameStateHasPriorityOverDownloadState()
+        {
+            AddStep("set to downloading map", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(0)));
+            checkProgressBarVisibility(true);
+
+            AddStep("make user ready", () => Client.ChangeState(MultiplayerUserState.Results));
+            checkProgressBarVisibility(false);
+            AddUntilStep("ready mark visible", () => this.ChildrenOfType<StateDisplay>().Single().IsPresent);
+
+            AddStep("make user ready", () => Client.ChangeState(MultiplayerUserState.Idle));
+            checkProgressBarVisibility(true);
+        }
+
+        [Test]
+        public void TestCorrectInitialState()
+        {
+            AddStep("set to downloading map", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(0)));
+            AddStep("recreate list", createNewParticipantsList);
+            checkProgressBarVisibility(true);
+        }
+
+        [Test]
+        public void TestBeatmapDownloadingStates()
+        {
+            AddStep("set to no map", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.NotDownloaded()));
+            AddStep("set to downloading map", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(0)));
+
+            checkProgressBarVisibility(true);
+
+            AddRepeatStep("increment progress", () =>
+            {
+                var progress = this.ChildrenOfType<ParticipantPanel>().Single().User.BeatmapAvailability.DownloadProgress ?? 0;
+                Client.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(progress + RNG.NextSingle(0.1f)));
+            }, 25);
+
+            AddAssert("progress bar increased", () => this.ChildrenOfType<ProgressBar>().Single().Current.Value > 0);
+
+            AddStep("set to importing map", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.Importing()));
+            checkProgressBarVisibility(false);
+
+            AddStep("set to available", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.LocallyAvailable()));
+        }
+
         [Test]
         public void TestToggleReadyState()
         {
@@ -117,11 +156,37 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     {
                         Id = i,
                         Username = $"User {i}",
-                        CurrentModeRank = RNG.Next(1, 100000),
+                        RulesetsStatistics = new Dictionary<string, UserStatistics>
+                        {
+                            {
+                                Ruleset.Value.ShortName,
+                                new UserStatistics { GlobalRank = RNG.Next(1, 100000), }
+                            }
+                        },
                         CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
                     });
 
                     Client.ChangeUserState(i, (MultiplayerUserState)RNG.Next(0, (int)MultiplayerUserState.Results + 1));
+
+                    if (RNG.NextBool())
+                    {
+                        var beatmapState = (DownloadState)RNG.Next(0, (int)DownloadState.LocallyAvailable + 1);
+
+                        switch (beatmapState)
+                        {
+                            case DownloadState.NotDownloaded:
+                                Client.ChangeUserBeatmapAvailability(i, BeatmapAvailability.NotDownloaded());
+                                break;
+
+                            case DownloadState.Downloading:
+                                Client.ChangeUserBeatmapAvailability(i, BeatmapAvailability.Downloading(RNG.NextSingle()));
+                                break;
+
+                            case DownloadState.Importing:
+                                Client.ChangeUserBeatmapAvailability(i, BeatmapAvailability.Importing());
+                                break;
+                        }
+                    }
                 }
             });
         }
@@ -135,7 +200,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 {
                     Id = 0,
                     Username = "User 0",
-                    CurrentModeRank = RNG.Next(1, 100000),
+                    RulesetsStatistics = new Dictionary<string, UserStatistics>
+                    {
+                        {
+                            Ruleset.Value.ShortName,
+                            new UserStatistics { GlobalRank = RNG.Next(1, 100000), }
+                        }
+                    },
                     CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
                 });
 
@@ -152,5 +223,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 AddStep($"set state: {state}", () => Client.ChangeUserState(0, state));
             }
         }
+
+        private void createNewParticipantsList()
+        {
+            Child = new ParticipantsList { Anchor = Anchor.Centre, Origin = Anchor.Centre, RelativeSizeAxes = Axes.Y, Size = new Vector2(380, 0.7f) };
+        }
+
+        private void checkProgressBarVisibility(bool visible) =>
+            AddUntilStep($"progress bar {(visible ? "is" : "is not")}visible", () =>
+                this.ChildrenOfType<ProgressBar>().Single().IsPresent == visible);
     }
 }

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerRoomManager.cs

@@ -101,7 +101,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 });
             });
 
-            AddAssert("multiplayer room joined", () => roomContainer.Client.Room != null);
+            AddUntilStep("multiplayer room joined", () => roomContainer.Client.Room != null);
         }
 
         [Test]
@@ -133,7 +133,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 });
             });
 
-            AddAssert("multiplayer room joined", () => roomContainer.Client.Room != null);
+            AddUntilStep("multiplayer room joined", () => roomContainer.Client.Room != null);
         }
 
         private TestMultiplayerRoomManager createRoomManager()

osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs

@@ -87,6 +87,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             {
                 Ruleset.Value = new OsuRuleset().RulesetInfo;
                 Beatmap.SetDefault();
+                SelectedMods.Value = Array.Empty<Mod>();
             });
 
             AddStep("create song select", () => LoadScreen(songSelect = new TestPlaylistsSongSelect()));

osu.Game.Tests/Visual/Navigation/OsuGameTestScene.cs

@@ -17,6 +17,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 using osu.Game.Screens;
 using osu.Game.Screens.Menu;
@@ -115,6 +116,8 @@ namespace osu.Game.Tests.Visual.Navigation
 
             public new Bindable<RulesetInfo> Ruleset => base.Ruleset;
 
+            public new Bindable<IReadOnlyList<Mod>> SelectedMods => base.SelectedMods;
+
             // if we don't do this, when running under nUnit the version that gets populated is that of nUnit.
             public override string Version => "test game";
 

osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs

@@ -11,7 +11,9 @@ using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Toolbar;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Options;
 using osu.Game.Tests.Beatmaps.IO;
@@ -41,6 +43,30 @@ namespace osu.Game.Tests.Visual.Navigation
             exitViaEscapeAndConfirm();
         }
 
+        [Test]
+        public void TestRetryFromResults()
+        {
+            Player player = null;
+            ResultsScreen results = null;
+
+            WorkingBeatmap beatmap() => Game.Beatmap.Value;
+
+            PushAndConfirm(() => new TestSongSelect());
+
+            AddStep("import beatmap", () => ImportBeatmapTest.LoadOszIntoOsu(Game, virtualTrack: true).Wait());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("set autoplay", () => Game.SelectedMods.Value = new[] { new OsuModAutoplay() });
+
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+            AddUntilStep("wait for player", () => (player = Game.ScreenStack.CurrentScreen as Player) != null);
+            AddStep("seek to end", () => beatmap().Track.Seek(beatmap().Track.Length));
+            AddUntilStep("wait for pass", () => (results = Game.ScreenStack.CurrentScreen as ResultsScreen) != null && results.IsLoaded);
+            AddStep("attempt to retry", () => results.ChildrenOfType<HotkeyRetryOverlay>().First().Action());
+            AddUntilStep("wait for player", () => Game.ScreenStack.CurrentScreen != player && Game.ScreenStack.CurrentScreen is Player);
+        }
+
         [TestCase(true)]
         [TestCase(false)]
         public void TestSongContinuesAfterExitPlayer(bool withUserPause)

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

@@ -103,26 +103,26 @@ namespace osu.Game.Tests.Visual.Online
         private void testLinksGeneral()
         {
             addMessageWithChecks("test!");
-            addMessageWithChecks("osu.ppy.sh!");
-            addMessageWithChecks("https://osu.ppy.sh!", 1, expectedActions: LinkAction.External);
+            addMessageWithChecks("dev.ppy.sh!");
+            addMessageWithChecks("https://dev.ppy.sh!", 1, expectedActions: LinkAction.External);
             addMessageWithChecks("00:12:345 (1,2) - Test?", 1, expectedActions: LinkAction.OpenEditorTimestamp);
             addMessageWithChecks("Wiki link for tasty [[Performance Points]]", 1, expectedActions: LinkAction.External);
-            addMessageWithChecks("(osu forums)[https://osu.ppy.sh/forum] (old link format)", 1, expectedActions: LinkAction.External);
-            addMessageWithChecks("[https://osu.ppy.sh/home New site] (new link format)", 1, expectedActions: LinkAction.External);
-            addMessageWithChecks("[osu forums](https://osu.ppy.sh/forum) (new link format 2)", 1, expectedActions: LinkAction.External);
-            addMessageWithChecks("[https://osu.ppy.sh/home This is only a link to the new osu webpage but this is supposed to test word wrap.]", 1, expectedActions: LinkAction.External);
-            addMessageWithChecks("is now listening to [https://osu.ppy.sh/s/93523 IMAGE -MATERIAL- <Version 0>]", 1, true, expectedActions: LinkAction.OpenBeatmapSet);
-            addMessageWithChecks("is now playing [https://osu.ppy.sh/b/252238 IMAGE -MATERIAL- <Version 0>]", 1, true, expectedActions: LinkAction.OpenBeatmap);
-            addMessageWithChecks("Let's (try)[https://osu.ppy.sh/home] [https://osu.ppy.sh/b/252238 multiple links] https://osu.ppy.sh/home", 3,
+            addMessageWithChecks("(osu forums)[https://dev.ppy.sh/forum] (old link format)", 1, expectedActions: LinkAction.External);
+            addMessageWithChecks("[https://dev.ppy.sh/home New site] (new link format)", 1, expectedActions: LinkAction.External);
+            addMessageWithChecks("[osu forums](https://dev.ppy.sh/forum) (new link format 2)", 1, expectedActions: LinkAction.External);
+            addMessageWithChecks("[https://dev.ppy.sh/home This is only a link to the new osu webpage but this is supposed to test word wrap.]", 1, expectedActions: LinkAction.External);
+            addMessageWithChecks("is now listening to [https://dev.ppy.sh/s/93523 IMAGE -MATERIAL- <Version 0>]", 1, true, expectedActions: LinkAction.OpenBeatmapSet);
+            addMessageWithChecks("is now playing [https://dev.ppy.sh/b/252238 IMAGE -MATERIAL- <Version 0>]", 1, true, expectedActions: LinkAction.OpenBeatmap);
+            addMessageWithChecks("Let's (try)[https://dev.ppy.sh/home] [https://dev.ppy.sh/b/252238 multiple links] https://dev.ppy.sh/home", 3,
                 expectedActions: new[] { LinkAction.External, LinkAction.OpenBeatmap, LinkAction.External });
-            addMessageWithChecks("[https://osu.ppy.sh/home New link format with escaped [and \\[ paired] braces]", 1, expectedActions: LinkAction.External);
-            addMessageWithChecks("[Markdown link format with escaped [and \\[ paired] braces](https://osu.ppy.sh/home)", 1, expectedActions: LinkAction.External);
-            addMessageWithChecks("(Old link format with escaped (and \\( paired) parentheses)[https://osu.ppy.sh/home] and [[also a rogue wiki link]]", 2, expectedActions: new[] { LinkAction.External, LinkAction.External });
+            addMessageWithChecks("[https://dev.ppy.sh/home New link format with escaped [and \\[ paired] braces]", 1, expectedActions: LinkAction.External);
+            addMessageWithChecks("[Markdown link format with escaped [and \\[ paired] braces](https://dev.ppy.sh/home)", 1, expectedActions: LinkAction.External);
+            addMessageWithChecks("(Old link format with escaped (and \\( paired) parentheses)[https://dev.ppy.sh/home] and [[also a rogue wiki link]]", 2, expectedActions: new[] { LinkAction.External, LinkAction.External });
             // note that there's 0 links here (they get removed if a channel is not found)
             addMessageWithChecks("#lobby or #osu would be blue (and work) in the ChatDisplay test (when a proper ChatOverlay is present).");
             addMessageWithChecks("I am important!", 0, false, true);
             addMessageWithChecks("feels important", 0, true, true);
-            addMessageWithChecks("likes to post this [https://osu.ppy.sh/home link].", 1, true, true, expectedActions: LinkAction.External);
+            addMessageWithChecks("likes to post this [https://dev.ppy.sh/home link].", 1, true, true, expectedActions: LinkAction.External);
             addMessageWithChecks("Join my multiplayer game osump://12346.", 1, expectedActions: LinkAction.JoinMultiplayerMatch);
             addMessageWithChecks("Join my [multiplayer game](osump://12346).", 1, expectedActions: LinkAction.JoinMultiplayerMatch);
             addMessageWithChecks("Join my [#english](osu://chan/#english).", 1, expectedActions: LinkAction.OpenChannel);
@@ -136,9 +136,9 @@ namespace osu.Game.Tests.Visual.Online
             int echoCounter = 0;
 
             addEchoWithWait("sent!", "received!");
-            addEchoWithWait("https://osu.ppy.sh/home", null, 500);
-            addEchoWithWait("[https://osu.ppy.sh/forum let's try multiple words too!]");
-            addEchoWithWait("(long loading times! clickable while loading?)[https://osu.ppy.sh/home]", null, 5000);
+            addEchoWithWait("https://dev.ppy.sh/home", null, 500);
+            addEchoWithWait("[https://dev.ppy.sh/forum let's try multiple words too!]");
+            addEchoWithWait("(long loading times! clickable while loading?)[https://dev.ppy.sh/home]", null, 5000);
 
             void addEchoWithWait(string text, string completeText = null, double delay = 250)
             {

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

@@ -41,7 +41,7 @@ namespace osu.Game.Tests.Visual.Online
         private class TestFullscreenOverlay : FullscreenOverlay<OverlayHeader>
         {
             public TestFullscreenOverlay()
-                : base(OverlayColourScheme.Pink, null)
+                : base(OverlayColourScheme.Pink)
             {
                 Children = new Drawable[]
                 {
@@ -52,6 +52,17 @@ namespace osu.Game.Tests.Visual.Online
                     },
                 };
             }
+
+            protected override OverlayHeader CreateHeader() => new TestHeader();
+
+            internal class TestHeader : OverlayHeader
+            {
+                protected override OverlayTitle CreateTitle() => new TestTitle();
+
+                internal class TestTitle : OverlayTitle
+                {
+                }
+            }
         }
     }
 }

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

@@ -70,7 +70,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 graph.Statistics.Value = new UserStatistics
                 {
-                    Ranks = new UserStatistics.UserRanks { Global = 123456 },
+                    GlobalRank = 123456,
                     PP = 12345,
                 };
             });
@@ -79,7 +79,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 graph.Statistics.Value = new UserStatistics
                 {
-                    Ranks = new UserStatistics.UserRanks { Global = 89000 },
+                    GlobalRank = 89000,
                     PP = 12345,
                     RankHistory = new User.RankHistoryData
                     {
@@ -92,7 +92,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 graph.Statistics.Value = new UserStatistics
                 {
-                    Ranks = new UserStatistics.UserRanks { Global = 89000 },
+                    GlobalRank = 89000,
                     PP = 12345,
                     RankHistory = new User.RankHistoryData
                     {
@@ -105,7 +105,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 graph.Statistics.Value = new UserStatistics
                 {
-                    Ranks = new UserStatistics.UserRanks { Global = 12000 },
+                    GlobalRank = 12000,
                     PP = 12345,
                     RankHistory = new User.RankHistoryData
                     {
@@ -118,7 +118,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 graph.Statistics.Value = new UserStatistics
                 {
-                    Ranks = new UserStatistics.UserRanks { Global = 12000 },
+                    GlobalRank = 12000,
                     PP = 12345,
                     RankHistory = new User.RankHistoryData
                     {

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

@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Visual.Online
             Add(rankingsOverlay = new TestRankingsOverlay
             {
                 Country = { BindTarget = countryBindable },
-                Scope = { BindTarget = scope },
+                Header = { Current = { BindTarget = scope } },
             });
         }
 
@@ -65,8 +65,6 @@ namespace osu.Game.Tests.Visual.Online
         private class TestRankingsOverlay : RankingsOverlay
         {
             public new Bindable<Country> Country => base.Country;
-
-            public new Bindable<RankingsScope> Scope => base.Scope;
         }
     }
 }

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

@@ -33,7 +33,8 @@ namespace osu.Game.Tests.Visual.Online
             ProfileOrder = new[] { "me" },
             Statistics = new UserStatistics
             {
-                Ranks = new UserStatistics.UserRanks { Global = 2148, Country = 1 },
+                GlobalRank = 2148,
+                CountryRank = 1,
                 PP = 4567.89m,
                 Level = new UserStatistics.LevelInfo
                 {

osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs

@@ -39,7 +39,11 @@ namespace osu.Game.Tests.Visual.UserInterface
         }
 
         [SetUp]
-        public void SetUp() => Schedule(() => createDisplay(() => new TestModSelectOverlay()));
+        public void SetUp() => Schedule(() =>
+        {
+            SelectedMods.Value = Array.Empty<Mod>();
+            createDisplay(() => new TestModSelectOverlay());
+        });
 
         [SetUpSteps]
         public void SetUpSteps()
@@ -47,6 +51,24 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddStep("show", () => modSelect.Show());
         }
 
+        [Test]
+        public void TestSettingsResetOnDeselection()
+        {
+            var osuModDoubleTime = new OsuModDoubleTime { SpeedChange = { Value = 1.2 } };
+
+            changeRuleset(0);
+
+            AddStep("set dt mod with custom rate", () => { SelectedMods.Value = new[] { osuModDoubleTime }; });
+
+            AddAssert("selected mod matches", () => (SelectedMods.Value.Single() as OsuModDoubleTime)?.SpeedChange.Value == 1.2);
+
+            AddStep("deselect", () => modSelect.DeselectAllButton.Click());
+            AddAssert("selected mods empty", () => SelectedMods.Value.Count == 0);
+
+            AddStep("reselect", () => modSelect.GetModButton(osuModDoubleTime).Click());
+            AddAssert("selected mod has default value", () => (SelectedMods.Value.Single() as OsuModDoubleTime)?.SpeedChange.IsDefault == true);
+        }
+
         [Test]
         public void TestAnimationFlushOnClose()
         {
@@ -152,6 +174,45 @@ namespace osu.Game.Tests.Visual.UserInterface
             });
         }
 
+        [Test]
+        public void TestSettingsAreRetainedOnReload()
+        {
+            changeRuleset(0);
+
+            AddStep("set customized mod externally", () => SelectedMods.Value = new[] { new OsuModDoubleTime { SpeedChange = { Value = 1.01 } } });
+
+            AddAssert("setting remains", () => (SelectedMods.Value.SingleOrDefault() as OsuModDoubleTime)?.SpeedChange.Value == 1.01);
+
+            AddStep("create overlay", () => createDisplay(() => new TestNonStackedModSelectOverlay()));
+
+            AddAssert("setting remains", () => (SelectedMods.Value.SingleOrDefault() as OsuModDoubleTime)?.SpeedChange.Value == 1.01);
+        }
+
+        [Test]
+        public void TestExternallySetModIsReplacedByOverlayInstance()
+        {
+            Mod external = new OsuModDoubleTime();
+            Mod overlayButtonMod = null;
+
+            changeRuleset(0);
+
+            AddStep("set mod externally", () => { SelectedMods.Value = new[] { external }; });
+
+            AddAssert("ensure button is selected", () =>
+            {
+                var button = modSelect.GetModButton(SelectedMods.Value.Single());
+                overlayButtonMod = button.SelectedMod;
+                return overlayButtonMod.GetType() == external.GetType();
+            });
+
+            // Right now, when an external change occurs, the ModSelectOverlay will replace the global instance with its own
+            AddAssert("mod instance doesn't match", () => external != overlayButtonMod);
+
+            AddAssert("one mod present in global selected", () => SelectedMods.Value.Count == 1);
+            AddAssert("globally selected matches button's mod instance", () => SelectedMods.Value.Contains(overlayButtonMod));
+            AddAssert("globally selected doesn't contain original external change", () => !SelectedMods.Value.Contains(external));
+        }
+
         [Test]
         public void TestNonStacked()
         {
@@ -313,7 +374,6 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private void createDisplay(Func<TestModSelectOverlay> createOverlayFunc)
         {
-            SelectedMods.Value = Array.Empty<Mod>();
             Children = new Drawable[]
             {
                 modSelect = createOverlayFunc().With(d =>

osu.Game.Tests/Visual/UserInterface/TestSceneNotificationOverlay.cs

@@ -105,6 +105,15 @@ namespace osu.Game.Tests.Visual.UserInterface
             checkDisplayedCount(3);
         }
 
+        [Test]
+        public void TestError()
+        {
+            setState(Visibility.Visible);
+            AddStep(@"error #1", sendErrorNotification);
+            AddAssert("Is visible", () => notificationOverlay.State.Value == Visibility.Visible);
+            checkDisplayedCount(1);
+        }
+
         [Test]
         public void TestSpam()
         {
@@ -179,7 +188,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private void sendBarrage()
         {
-            switch (RNG.Next(0, 4))
+            switch (RNG.Next(0, 5))
             {
                 case 0:
                     sendHelloNotification();
@@ -196,6 +205,10 @@ namespace osu.Game.Tests.Visual.UserInterface
                 case 3:
                     sendDownloadProgress();
                     break;
+
+                case 4:
+                    sendErrorNotification();
+                    break;
             }
         }
 
@@ -214,6 +227,11 @@ namespace osu.Game.Tests.Visual.UserInterface
             notificationOverlay.Post(new BackgroundNotification { Text = @"Welcome to osu!. Enjoy your stay!" });
         }
 
+        private void sendErrorNotification()
+        {
+            notificationOverlay.Post(new SimpleErrorNotification { Text = @"Rut roh!. Something went wrong!" });
+        }
+
         private void sendManyNotifications()
         {
             for (int i = 0; i < 10; i++)

osu.Game.Tests/osu.Game.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
     <PackageReference Include="Moq" Version="4.16.0" />

osu.Game.Tournament.Tests/TournamentTestBrowser.cs

@@ -13,15 +13,18 @@ namespace osu.Game.Tournament.Tests
         {
             base.LoadComplete();
 
-            LoadComponentAsync(new Background("Menu/menu-background-0")
+            BracketLoadTask.ContinueWith(_ => Schedule(() =>
             {
-                Colour = OsuColour.Gray(0.5f),
-                Depth = 10
-            }, AddInternal);
+                LoadComponentAsync(new Background("Menu/menu-background-0")
+                {
+                    Colour = OsuColour.Gray(0.5f),
+                    Depth = 10
+                }, AddInternal);
 
-            // Have to construct this here, rather than in the constructor, because
-            // we depend on some dependencies to be loaded within OsuGameBase.load().
-            Add(new TestBrowser());
+                // Have to construct this here, rather than in the constructor, because
+                // we depend on some dependencies to be loaded within OsuGameBase.load().
+                Add(new TestBrowser());
+            }));
         }
     }
 }

osu.Game.Tournament.Tests/TournamentTestScene.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
@@ -112,11 +113,11 @@ namespace osu.Game.Tournament.Tests
                     },
                     Players =
                     {
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 12 } } },
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 16 } } },
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 20 } } },
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 24 } } },
-                        new User { Username = "Hello", Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 30 } } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { GlobalRank = 12 } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { GlobalRank = 16 } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { GlobalRank = 20 } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { GlobalRank = 24 } },
+                        new User { Username = "Hello", Statistics = new UserStatistics { GlobalRank = 30 } },
                     }
                 }
             },
@@ -154,13 +155,22 @@ namespace osu.Game.Tournament.Tests
 
             protected override void LoadAsyncComplete()
             {
-                // this has to be run here rather than LoadComplete because
-                // TestScene.cs is checking the IsLoaded state (on another thread) and expects
-                // the runner to be loaded at that point.
-                Add(runner = new TestSceneTestRunner.TestRunner());
+                BracketLoadTask.ContinueWith(_ => Schedule(() =>
+                {
+                    // this has to be run here rather than LoadComplete because
+                    // TestScene.cs is checking the IsLoaded state (on another thread) and expects
+                    // the runner to be loaded at that point.
+                    Add(runner = new TestSceneTestRunner.TestRunner());
+                }));
             }
 
-            public void RunTestBlocking(TestScene test) => runner.RunTestBlocking(test);
+            public void RunTestBlocking(TestScene test)
+            {
+                while (runner?.IsLoaded != true && Host.ExecutionState == ExecutionState.Running)
+                    Thread.Sleep(10);
+
+                runner?.RunTestBlocking(test);
+            }
         }
     }
 }

osu.Game.Tournament.Tests/osu.Game.Tournament.Tests.csproj

@@ -6,7 +6,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Tournament/Models/TournamentTeam.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Tournament.Models
         {
             get
             {
-                var ranks = Players.Select(p => p.Statistics?.Ranks.Global)
+                var ranks = Players.Select(p => p.Statistics?.GlobalRank)
                                    .Where(i => i.HasValue)
                                    .Select(i => i.Value)
                                    .ToArray();

osu.Game.Tournament/Screens/TeamIntro/SeedingScreen.cs

@@ -250,7 +250,7 @@ namespace osu.Game.Tournament.Screens.TeamIntro
                 };
 
                 foreach (var p in team.Players)
-                    fill.Add(new RowDisplay(p.Username, p.Statistics?.Ranks.Global?.ToString("\\##,0") ?? "-"));
+                    fill.Add(new RowDisplay(p.Username, p.Statistics?.GlobalRank?.ToString("\\##,0") ?? "-"));
             }
 
             internal class RowDisplay : CompositeDrawable

osu.Game.Tournament/TournamentGame.cs

@@ -13,6 +13,7 @@ using osu.Framework.Graphics.Colour;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Tournament.Models;
 using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
 using osuTK;
 using osuTK.Graphics;
 
@@ -32,25 +33,24 @@ namespace osu.Game.Tournament
         private Drawable heightWarning;
         private Bindable<Size> windowSize;
         private Bindable<WindowMode> windowMode;
+        private LoadingSpinner loadingSpinner;
 
         [BackgroundDependencyLoader]
         private void load(FrameworkConfigManager frameworkConfig)
         {
             windowSize = frameworkConfig.GetBindable<Size>(FrameworkSetting.WindowedSize);
-            windowSize.BindValueChanged(size => ScheduleAfterChildren(() =>
-            {
-                var minWidth = (int)(size.NewValue.Height / 768f * TournamentSceneManager.REQUIRED_WIDTH) - 1;
-
-                heightWarning.Alpha = size.NewValue.Width < minWidth ? 1 : 0;
-            }), true);
-
             windowMode = frameworkConfig.GetBindable<WindowMode>(FrameworkSetting.WindowMode);
-            windowMode.BindValueChanged(mode => ScheduleAfterChildren(() =>
-            {
-                windowMode.Value = WindowMode.Windowed;
-            }), true);
 
-            AddRange(new[]
+            Add(loadingSpinner = new LoadingSpinner(true, true)
+            {
+                Anchor = Anchor.BottomRight,
+                Origin = Anchor.BottomRight,
+                Margin = new MarginPadding(40),
+            });
+
+            loadingSpinner.Show();
+
+            BracketLoadTask.ContinueWith(_ => LoadComponentsAsync(new[]
             {
                 new Container
                 {
@@ -93,7 +93,24 @@ namespace osu.Game.Tournament
                     RelativeSizeAxes = Axes.Both,
                     Child = new TournamentSceneManager()
                 }
-            });
+            }, drawables =>
+            {
+                loadingSpinner.Hide();
+                loadingSpinner.Expire();
+
+                AddRange(drawables);
+
+                windowSize.BindValueChanged(size => ScheduleAfterChildren(() =>
+                {
+                    var minWidth = (int)(size.NewValue.Height / 768f * TournamentSceneManager.REQUIRED_WIDTH) - 1;
+                    heightWarning.Alpha = size.NewValue.Width < minWidth ? 1 : 0;
+                }), true);
+
+                windowMode.BindValueChanged(mode => ScheduleAfterChildren(() =>
+                {
+                    windowMode.Value = WindowMode.Windowed;
+                }), true);
+            }));
         }
     }
 }

osu.Game.Tournament/TournamentGameBase.cs

@@ -4,6 +4,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Newtonsoft.Json;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Textures;
@@ -29,6 +30,10 @@ namespace osu.Game.Tournament
         private DependencyContainer dependencies;
         private FileBasedIPC ipc;
 
+        protected Task BracketLoadTask => taskCompletionSource.Task;
+
+        private readonly TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
             return dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
@@ -46,14 +51,9 @@ namespace osu.Game.Tournament
 
             Textures.AddStore(new TextureLoaderStore(new StorageBackedResourceStore(storage)));
 
-            readBracket();
-
-            ladder.CurrentMatch.Value = ladder.Matches.FirstOrDefault(p => p.Current.Value);
-
             dependencies.CacheAs(new StableInfo(storage));
 
-            dependencies.CacheAs<MatchIPCInfo>(ipc = new FileBasedIPC());
-            Add(ipc);
+            Task.Run(readBracket);
         }
 
         private void readBracket()
@@ -68,10 +68,6 @@ namespace osu.Game.Tournament
             ladder ??= new LadderInfo();
             ladder.Ruleset.Value ??= RulesetStore.AvailableRulesets.First();
 
-            Ruleset.BindTo(ladder.Ruleset);
-
-            dependencies.Cache(ladder);
-
             bool addedInfo = false;
 
             // assign teams
@@ -127,6 +123,19 @@ namespace osu.Game.Tournament
 
             if (addedInfo)
                 SaveChanges();
+
+            ladder.CurrentMatch.Value = ladder.Matches.FirstOrDefault(p => p.Current.Value);
+
+            Schedule(() =>
+            {
+                Ruleset.BindTo(ladder.Ruleset);
+
+                dependencies.Cache(ladder);
+                dependencies.CacheAs<MatchIPCInfo>(ipc = new FileBasedIPC());
+                Add(ipc);
+
+                taskCompletionSource.SetResult(true);
+            });
         }
 
         /// <summary>
@@ -141,9 +150,9 @@ namespace osu.Game.Tournament
             {
                 foreach (var p in t.Players)
                 {
-                    if (string.IsNullOrEmpty(p.Username) || p.Statistics == null)
+                    if (string.IsNullOrEmpty(p.Username) || p.Statistics?.GlobalRank == null)
                     {
-                        PopulateUser(p);
+                        PopulateUser(p, immediate: true);
                         addedInfo = true;
                     }
                 }
@@ -202,12 +211,14 @@ namespace osu.Game.Tournament
             return addedInfo;
         }
 
-        public void PopulateUser(User user, Action success = null, Action failure = null)
+        public void PopulateUser(User user, Action success = null, Action failure = null, bool immediate = false)
         {
             var req = new GetUserRequest(user.Id, Ruleset.Value);
 
             req.Success += res =>
             {
+                user.Id = res.Id;
+
                 user.Username = res.Username;
                 user.Statistics = res.Statistics;
                 user.Country = res.Country;
@@ -222,7 +233,10 @@ namespace osu.Game.Tournament
                 failure?.Invoke();
             };
 
-            API.Queue(req);
+            if (immediate)
+                API.Perform(req);
+            else
+                API.Queue(req);
         }
 
         protected override void LoadComplete()

osu.Game/Audio/PreviewTrackManager.cs

@@ -27,6 +27,8 @@ namespace osu.Game.Audio
 
         protected TrackManagerPreviewTrack CurrentTrack;
 
+        private readonly BindableNumber<double> globalTrackVolumeAdjust = new BindableNumber<double>(OsuGameBase.GLOBAL_TRACK_VOLUME_ADJUST);
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -35,6 +37,7 @@ namespace osu.Game.Audio
             trackStore = new PreviewTrackStore(new OnlineStore());
 
             audio.AddItem(trackStore);
+            trackStore.AddAdjustment(AdjustableProperty.Volume, globalTrackVolumeAdjust);
             trackStore.AddAdjustment(AdjustableProperty.Volume, audio.VolumeTrack);
         }
 

osu.Game/Beatmaps/Beatmap.cs

@@ -1,6 +1,7 @@
 // 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.Beatmaps.Timing;
 using osu.Game.Rulesets.Objects;
 using System.Collections.Generic;
@@ -48,6 +49,31 @@ namespace osu.Game.Beatmaps
 
         public virtual IEnumerable<BeatmapStatistic> GetStatistics() => Enumerable.Empty<BeatmapStatistic>();
 
+        public double GetMostCommonBeatLength()
+        {
+            // The last playable time in the beatmap - the last timing point extends to this time.
+            // Note: This is more accurate and may present different results because osu-stable didn't have the ability to calculate slider durations in this context.
+            double lastTime = HitObjects.LastOrDefault()?.GetEndTime() ?? ControlPointInfo.TimingPoints.LastOrDefault()?.Time ?? 0;
+
+            var mostCommon =
+                // Construct a set of (beatLength, duration) tuples for each individual timing point.
+                ControlPointInfo.TimingPoints.Select((t, i) =>
+                                {
+                                    if (t.Time > lastTime)
+                                        return (beatLength: t.BeatLength, 0);
+
+                                    var nextTime = i == ControlPointInfo.TimingPoints.Count - 1 ? lastTime : ControlPointInfo.TimingPoints[i + 1].Time;
+                                    return (beatLength: t.BeatLength, duration: nextTime - t.Time);
+                                })
+                                // Aggregate durations into a set of (beatLength, duration) tuples for each beat length
+                                .GroupBy(t => Math.Round(t.beatLength * 1000) / 1000)
+                                .Select(g => (beatLength: g.Key, duration: g.Sum(t => t.duration)))
+                                // Get the most common one, or 0 as a suitable default
+                                .OrderByDescending(i => i.duration).FirstOrDefault();
+
+            return mostCommon.beatLength;
+        }
+
         IBeatmap IBeatmap.Clone() => Clone();
 
         public Beatmap<T> Clone() => (Beatmap<T>)MemberwiseClone();

osu.Game/Beatmaps/BeatmapManager.cs

@@ -64,7 +64,9 @@ namespace osu.Game.Beatmaps
 
         protected override string[] HashableFileTypes => new[] { ".osu" };
 
-        protected override string ImportFromStablePath => "Songs";
+        protected override string ImportFromStablePath => ".";
+
+        protected override Storage PrepareStableStorage(StableStorage stableStorage) => stableStorage.GetSongStorage();
 
         private readonly RulesetStore rulesets;
         private readonly BeatmapStore beatmaps;
@@ -451,7 +453,7 @@ namespace osu.Game.Beatmaps
                     // TODO: this should be done in a better place once we actually need to dynamically update it.
                     beatmap.BeatmapInfo.StarDifficulty = ruleset?.CreateInstance().CreateDifficultyCalculator(new DummyConversionBeatmap(beatmap)).Calculate().StarRating ?? 0;
                     beatmap.BeatmapInfo.Length = calculateLength(beatmap);
-                    beatmap.BeatmapInfo.BPM = beatmap.ControlPointInfo.BPMMode;
+                    beatmap.BeatmapInfo.BPM = 60000 / beatmap.GetMostCommonBeatLength();
 
                     beatmapInfos.Add(beatmap.BeatmapInfo);
                 }

osu.Game/Beatmaps/BeatmapMetadata.cs

@@ -51,7 +51,12 @@ namespace osu.Game.Beatmaps
         [JsonProperty(@"tags")]
         public string Tags { get; set; }
 
+        /// <summary>
+        /// The time in milliseconds to begin playing the track for preview purposes.
+        /// If -1, the track should begin playing at 40% of its length.
+        /// </summary>
         public int PreviewTime { get; set; }
+
         public string AudioFile { get; set; }
         public string BackgroundFile { get; set; }
 

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -101,13 +101,6 @@ namespace osu.Game.Beatmaps.ControlPoints
         public double BPMMinimum =>
             60000 / (TimingPoints.OrderByDescending(c => c.BeatLength).FirstOrDefault() ?? TimingControlPoint.DEFAULT).BeatLength;
 
-        /// <summary>
-        /// Finds the mode BPM (most common BPM) represented by the control points.
-        /// </summary>
-        [JsonIgnore]
-        public double BPMMode =>
-            60000 / (TimingPoints.GroupBy(c => c.BeatLength).OrderByDescending(grp => grp.Count()).FirstOrDefault()?.FirstOrDefault() ?? TimingControlPoint.DEFAULT).BeatLength;
-
         /// <summary>
         /// Remove all <see cref="ControlPointGroup"/>s and return to a pristine state.
         /// </summary>

osu.Game/Beatmaps/Drawables/UpdateableBeatmapBackgroundSprite.cs

@@ -34,8 +34,8 @@ namespace osu.Game.Beatmaps.Drawables
         /// </summary>
         protected virtual double UnloadDelay => 10000;
 
-        protected override DelayedLoadWrapper CreateDelayedLoadWrapper(Func<Drawable> createContentFunc, double timeBeforeLoad)
-            => new DelayedLoadUnloadWrapper(createContentFunc, timeBeforeLoad, UnloadDelay);
+        protected override DelayedLoadWrapper CreateDelayedLoadWrapper(Func<Drawable> createContentFunc, double timeBeforeLoad) =>
+            new DelayedLoadUnloadWrapper(createContentFunc, timeBeforeLoad, UnloadDelay) { RelativeSizeAxes = Axes.Both };
 
         protected override double TransformDuration => 400;
 

osu.Game/Beatmaps/IBeatmap.cs

@@ -47,6 +47,11 @@ namespace osu.Game.Beatmaps
         /// <returns></returns>
         IEnumerable<BeatmapStatistic> GetStatistics();
 
+        /// <summary>
+        /// Finds the most common beat length represented by the control points in this beatmap.
+        /// </summary>
+        double GetMostCommonBeatLength();
+
         /// <summary>
         /// Creates a shallow-clone of this beatmap and returns it.
         /// </summary>

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -266,6 +266,26 @@ namespace osu.Game.Beatmaps
         [NotNull]
         public Track LoadTrack() => loadedTrack = GetBeatmapTrack() ?? GetVirtualTrack(1000);
 
+        /// <summary>
+        /// Reads the correct track restart point from beatmap metadata and sets looping to enabled.
+        /// </summary>
+        public void PrepareTrackForPreviewLooping()
+        {
+            Track.Looping = true;
+            Track.RestartPoint = Metadata.PreviewTime;
+
+            if (Track.RestartPoint == -1)
+            {
+                if (!Track.IsLoaded)
+                {
+                    // force length to be populated (https://github.com/ppy/osu-framework/issues/4202)
+                    Track.Seek(Track.CurrentTime);
+                }
+
+                Track.RestartPoint = 0.4f * Track.Length;
+            }
+        }
+
         /// <summary>
         /// Transfer a valid audio track into this working beatmap. Used as an optimisation to avoid reload / track swap
         /// across difficulties in the same beatmap set.