Merge branch 'master' into multi-queueing-modes

.github/workflows/report-nunit.yml

@@ -30,3 +30,5 @@ jobs:
           name: Test Results (${{matrix.os.prettyname}}, ${{matrix.threadingMode}})
           path: "*.trx"
           reporter: dotnet-trx
+          list-suites: 'failed'
+          list-tests: 'failed'

osu.Android.props

@@ -51,8 +51,8 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1004.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1013.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1015.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1014.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
     <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->

osu.Game.Rulesets.Catch/Objects/JuiceStream.cs

@@ -42,9 +42,8 @@ namespace osu.Game.Rulesets.Catch.Objects
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
-            DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
 
-            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
+            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier * DifficultyControlPoint.SliderVelocity;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
             TickDistance = scoringDistance / difficulty.SliderTickRate;

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaBeatSnapGrid.cs

@@ -13,6 +13,7 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Edit;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -101,27 +102,27 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             throw new System.NotImplementedException();
         }
 
-        public override float GetBeatSnapDistanceAt(double referenceTime)
+        public override float GetBeatSnapDistanceAt(HitObject referenceObject)
         {
             throw new System.NotImplementedException();
         }
 
-        public override float DurationToDistance(double referenceTime, double duration)
+        public override float DurationToDistance(HitObject referenceObject, double duration)
         {
             throw new System.NotImplementedException();
         }
 
-        public override double DistanceToDuration(double referenceTime, float distance)
+        public override double DistanceToDuration(HitObject referenceObject, float distance)
         {
             throw new System.NotImplementedException();
         }
 
-        public override double GetSnappedDurationFromDistance(double referenceTime, float distance)
+        public override double GetSnappedDurationFromDistance(HitObject referenceObject, float distance)
         {
             throw new System.NotImplementedException();
         }
 
-        public override float GetSnappedDistanceFromDistance(double referenceTime, float distance)
+        public override float GetSnappedDistanceFromDistance(HitObject referenceObject, float distance)
         {
             throw new System.NotImplementedException();
         }

osu.Game.Rulesets.Mania.Tests/TestSceneHoldNoteInput.cs

@@ -388,7 +388,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                     },
                 };
 
-                beatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 0.1f });
+                beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 0.1f });
             }
 
             AddStep("load player", () =>

osu.Game.Rulesets.Mania.Tests/TestSceneOutOfOrderHits.cs

@@ -148,7 +148,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                     },
                 });
 
-                Beatmap.Value.Beatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 0.1f });
+                Beatmap.Value.Beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 0.1f });
 
                 var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
 

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs

@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             Debug.Assert(distanceData != null);
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
-            DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(hitObject.StartTime);
+            DifficultyControlPoint difficultyPoint = hitObject.DifficultyControlPoint;
 
             double beatLength;
 #pragma warning disable 618
@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 #pragma warning restore 618
                 beatLength = timingPoint.BeatLength * legacyDifficultyPoint.BpmMultiplier;
             else
-                beatLength = timingPoint.BeatLength / difficultyPoint.SpeedMultiplier;
+                beatLength = timingPoint.BeatLength / difficultyPoint.SliderVelocity;
 
             SpanCount = repeatsData?.SpanCount() ?? 1;
             StartTime = (int)Math.Round(hitObject.StartTime);

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs

@@ -28,7 +28,12 @@ namespace osu.Game.Rulesets.Mania.Configuration
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
         {
             new TrackedSetting<double>(ManiaRulesetSetting.ScrollTime,
-                v => new SettingDescription(v, "Scroll Speed", $"{(int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / v)} ({v}ms)"))
+                scrollTime => new SettingDescription(
+                    rawValue: scrollTime,
+                    name: "Scroll Speed",
+                    value: $"{(int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime)} ({scrollTime}ms)"
+                )
+            )
         };
     }
 

osu.Game.Rulesets.Mania/Resources/Testing/Beatmaps/mania-samples.osu

@@ -13,6 +13,7 @@ SliderTickRate:1
 
 [TimingPoints]
 0,500,4,1,0,100,1,0
+10000,-150,4,1,0,100,1,0
 
 [HitObjects]
 51,192,500,128,0,1500:1:0:0:0:

osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs

@@ -94,7 +94,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
                 // For non-mania beatmap, speed changes should only happen through timing points
                 if (!isForCurrentRuleset)
-                    p.DifficultyPoint = new DifficultyControlPoint();
+                    p.EffectPoint = new EffectControlPoint();
             }
 
             BarLines.ForEach(Playfield.Add);

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuDistanceSnapGrid.cs

@@ -11,6 +11,7 @@ using osu.Framework.Input.Events;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Objects;
@@ -179,15 +180,15 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
             public SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition) => new SnapResult(screenSpacePosition, 0);
 
-            public float GetBeatSnapDistanceAt(double referenceTime) => (float)beat_length;
+            public float GetBeatSnapDistanceAt(HitObject referenceObject) => (float)beat_length;
 
-            public float DurationToDistance(double referenceTime, double duration) => (float)duration;
+            public float DurationToDistance(HitObject referenceObject, double duration) => (float)duration;
 
-            public double DistanceToDuration(double referenceTime, float distance) => distance;
+            public double DistanceToDuration(HitObject referenceObject, float distance) => distance;
 
-            public double GetSnappedDurationFromDistance(double referenceTime, float distance) => 0;
+            public double GetSnappedDurationFromDistance(HitObject referenceObject, float distance) => 0;
 
-            public float GetSnappedDistanceFromDistance(double referenceTime, float distance) => 0;
+            public float GetSnappedDistanceFromDistance(HitObject referenceObject, float distance) => 0;
         }
     }
 }

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

@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 config.SetValue(OsuSetting.AutoCursorSize, true);
                 gameplayState.Beatmap.Difficulty.CircleSize = val;
-                Scheduler.AddOnce(() => loadContent(false));
+                Scheduler.AddOnce(loadContent);
             });
 
             AddStep("test cursor container", () => loadContent(false));
@@ -78,7 +78,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddStep($"adjust cs to {circleSize}", () => gameplayState.Beatmap.Difficulty.CircleSize = circleSize);
             AddStep("turn on autosizing", () => config.SetValue(OsuSetting.AutoCursorSize, true));
 
-            AddStep("load content", () => loadContent());
+            AddStep("load content", loadContent);
 
             AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == OsuCursorContainer.GetScaleForCircleSize(circleSize) * userScale);
 
@@ -98,7 +98,9 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddStep("load content", () => loadContent(false, () => new SkinProvidingContainer(new TopLeftCursorSkin())));
         }
 
-        private void loadContent(bool automated = true, Func<SkinProvidingContainer> skinProvider = null)
+        private void loadContent() => loadContent(false);
+
+        private void loadContent(bool automated, Func<SkinProvidingContainer> skinProvider = null)
         {
             SetContents(_ =>
             {

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

@@ -407,8 +407,6 @@ namespace osu.Game.Rulesets.Osu.Tests
                     },
                 });
 
-                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 } });
@@ -439,6 +437,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             public TestSlider()
             {
+                DifficultyControlPoint = new DifficultyControlPoint { SliderVelocity = 0.1f };
+
                 DefaultsApplied += _ =>
                 {
                     HeadCircle.HitWindows = new TestHitWindows();

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

@@ -13,6 +13,7 @@ using osuTK.Graphics;
 using osu.Game.Rulesets.Mods;
 using System.Linq;
 using NUnit.Framework;
+using osu.Game.Beatmaps.Legacy;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Judgements;
@@ -328,10 +329,14 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private Drawable createDrawable(Slider slider, float circleSize, double speedMultiplier)
         {
-            var cpi = new ControlPointInfo();
-            cpi.Add(0, new DifficultyControlPoint { SpeedMultiplier = speedMultiplier });
+            var cpi = new LegacyControlPointInfo();
+            cpi.Add(0, new DifficultyControlPoint { SliderVelocity = speedMultiplier });
 
-            slider.ApplyDefaults(cpi, new BeatmapDifficulty { CircleSize = circleSize, SliderTickRate = 3 });
+            slider.ApplyDefaults(cpi, new BeatmapDifficulty
+            {
+                CircleSize = circleSize,
+                SliderTickRate = 3
+            });
 
             var drawable = CreateDrawableSlider(slider);
 

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

@@ -348,6 +348,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                         {
                             StartTime = time_slider_start,
                             Position = new Vector2(0, 0),
+                            DifficultyControlPoint = new DifficultyControlPoint { SliderVelocity = 0.1f },
                             Path = new SliderPath(PathType.PerfectCurve, new[]
                             {
                                 Vector2.Zero,
@@ -362,8 +363,6 @@ namespace osu.Game.Rulesets.Osu.Tests
                     },
                 });
 
-                Beatmap.Value.Beatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 0.1f });
-
                 var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
 
                 p.OnLoadComplete += _ =>

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

@@ -369,8 +369,6 @@ namespace osu.Game.Rulesets.Osu.Tests
                     },
                 });
 
-                Beatmap.Value.Beatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 0.1f });
-
                 var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
 
                 p.OnLoadComplete += _ =>
@@ -399,6 +397,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             public TestSlider()
             {
+                DifficultyControlPoint = new DifficultyControlPoint { SliderVelocity = 0.1f };
+
                 DefaultsApplied += _ =>
                 {
                     HeadCircle.HitWindows = new TestHitWindows();

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs

@@ -11,6 +11,7 @@ using System.Linq;
 using System.Threading;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps.Legacy;
 
 namespace osu.Game.Rulesets.Osu.Beatmaps
 {
@@ -44,7 +45,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         LegacyLastTickOffset = (original as IHasLegacyLastTickOffset)?.LegacyLastTickOffset,
                         // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / beatmap.ControlPointInfo.DifficultyPointAt(original.StartTime).SpeedMultiplier : 1
+                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1
                     }.Yield();
 
                 case IHasDuration endTimeData:

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs

@@ -14,6 +14,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         public double OverallDifficulty { get; set; }
         public double DrainRate { get; set; }
         public int HitCircleCount { get; set; }
+        public int SliderCount { get; set; }
         public int SpinnerCount { get; set; }
     }
 }

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs

@@ -64,6 +64,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             maxCombo += beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
 
             int hitCirclesCount = beatmap.HitObjects.Count(h => h is HitCircle);
+            int sliderCount = beatmap.HitObjects.Count(h => h is Slider);
             int spinnerCount = beatmap.HitObjects.Count(h => h is Spinner);
 
             return new OsuDifficultyAttributes
@@ -78,6 +79,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 DrainRate = drainRate,
                 MaxCombo = maxCombo,
                 HitCircleCount = hitCirclesCount,
+                SliderCount = sliderCount,
                 SpinnerCount = spinnerCount,
                 Skills = skills
             };

osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs

@@ -25,6 +25,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         private int countMeh;
         private int countMiss;
 
+        private int effectiveMissCount;
+
         public OsuPerformanceCalculator(Ruleset ruleset, DifficultyAttributes attributes, ScoreInfo score)
             : base(ruleset, attributes, score)
         {
@@ -39,19 +41,20 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             countOk = Score.Statistics.GetValueOrDefault(HitResult.Ok);
             countMeh = Score.Statistics.GetValueOrDefault(HitResult.Meh);
             countMiss = Score.Statistics.GetValueOrDefault(HitResult.Miss);
+            effectiveMissCount = calculateEffectiveMissCount();
 
             double multiplier = 1.12; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
 
             // Custom multipliers for NoFail and SpunOut.
             if (mods.Any(m => m is OsuModNoFail))
-                multiplier *= Math.Max(0.90, 1.0 - 0.02 * countMiss);
+                multiplier *= Math.Max(0.90, 1.0 - 0.02 * effectiveMissCount);
 
             if (mods.Any(m => m is OsuModSpunOut))
                 multiplier *= 1.0 - Math.Pow((double)Attributes.SpinnerCount / totalHits, 0.85);
 
             if (mods.Any(h => h is OsuModRelax))
             {
-                countMiss += countOk + countMeh;
+                effectiveMissCount += countOk + countMeh;
                 multiplier *= 0.6;
             }
 
@@ -97,8 +100,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             aimValue *= lengthBonus;
 
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
-            if (countMiss > 0)
-                aimValue *= 0.97 * Math.Pow(1 - Math.Pow((double)countMiss / totalHits, 0.775), countMiss);
+            if (effectiveMissCount > 0)
+                aimValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), effectiveMissCount);
 
             // Combo scaling.
             if (Attributes.MaxCombo > 0)
@@ -115,7 +118,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double approachRateBonus = 1.0 + (0.03 + 0.37 * approachRateTotalHitsFactor) * approachRateFactor;
 
             if (mods.Any(m => m is OsuModBlinds))
-                aimValue *= 1.3 + (totalHits * (0.0016 / (1 + 2 * countMiss)) * Math.Pow(accuracy, 16)) * (1 - 0.003 * Attributes.DrainRate * Attributes.DrainRate);
+                aimValue *= 1.3 + (totalHits * (0.0016 / (1 + 2 * effectiveMissCount)) * Math.Pow(accuracy, 16)) * (1 - 0.003 * Attributes.DrainRate * Attributes.DrainRate);
             else if (mods.Any(h => h is OsuModHidden))
             {
                 // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
@@ -142,8 +145,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             speedValue *= lengthBonus;
 
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
-            if (countMiss > 0)
-                speedValue *= 0.97 * Math.Pow(1 - Math.Pow((double)countMiss / totalHits, 0.775), Math.Pow(countMiss, .875));
+            if (effectiveMissCount > 0)
+                speedValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
 
             // Combo scaling.
             if (Attributes.MaxCombo > 0)
@@ -231,8 +234,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 flashlightValue *= 1.3;
 
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
-            if (countMiss > 0)
-                flashlightValue *= 0.97 * Math.Pow(1 - Math.Pow((double)countMiss / totalHits, 0.775), Math.Pow(countMiss, .875));
+            if (effectiveMissCount > 0)
+                flashlightValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
 
             // Combo scaling.
             if (Attributes.MaxCombo > 0)
@@ -250,6 +253,24 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             return flashlightValue;
         }
 
+        private int calculateEffectiveMissCount()
+        {
+            // guess the number of misses + slider breaks from combo
+            double comboBasedMissCount = 0.0;
+
+            if (Attributes.SliderCount > 0)
+            {
+                double fullComboThreshold = Attributes.MaxCombo - 0.1 * Attributes.SliderCount;
+                if (scoreMaxCombo < fullComboThreshold)
+                    comboBasedMissCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
+            }
+
+            // we're clamping misscount because since its derived from combo it can be higher than total hits and that breaks some calculations
+            comboBasedMissCount = Math.Min(comboBasedMissCount, totalHits);
+
+            return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
+        }
+
         private int totalHits => countGreat + countOk + countMeh + countMiss;
         private int totalSuccessfulHits => countGreat + countOk + countMeh;
     }

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -54,6 +54,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 
         private void setDistances()
         {
+            // We don't need to calculate either angle or distance when one of the last->curr objects is a spinner
+            if (BaseObject is Spinner || lastObject is Spinner)
+                return;
+
             // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
             float scalingFactor = normalized_radius / (float)BaseObject.Radius;
 
@@ -71,11 +75,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 
             Vector2 lastCursorPosition = getEndCursorPosition(lastObject);
 
-            // Don't need to jump to reach spinners
-            if (!(BaseObject is Spinner))
-                JumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;
+            JumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;
 
-            if (lastLastObject != null)
+            if (lastLastObject != null && !(lastLastObject is Spinner))
             {
                 Vector2 lastLastCursorPosition = getEndCursorPosition(lastLastObject);
 

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

@@ -8,12 +8,14 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osu.Game.Screens.Edit;
 using osuTK;
 using osuTK.Input;
 
@@ -67,6 +69,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             inputManager = GetContainingInputManager();
         }
 
+        [Resolved]
+        private EditorBeatmap editorBeatmap { get; set; }
+
         public override void UpdateTimeAndPosition(SnapResult result)
         {
             base.UpdateTimeAndPosition(result);
@@ -75,6 +80,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             {
                 case SliderPlacementState.Initial:
                     BeginPlacement();
+
+                    var nearestDifficultyPoint = editorBeatmap.HitObjects.LastOrDefault(h => h.GetEndTime() < HitObject.StartTime)?.DifficultyControlPoint?.DeepClone() as DifficultyControlPoint;
+
+                    HitObject.DifficultyControlPoint = nearestDifficultyPoint ?? new DifficultyControlPoint();
                     HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
                     break;
 
@@ -212,7 +221,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private void updateSlider()
         {
-            HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject.StartTime, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
+            HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
 
             bodyPiece.UpdateFrom(HitObject);
             headCirclePiece.UpdateFrom(HitObject.HeadCircle);

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

@@ -230,7 +230,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private void updatePath()
         {
-            HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject.StartTime, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
+            HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
             editorBeatmap?.Update(HitObject);
         }
 

osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapGrid.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Osu.Edit
     public class OsuDistanceSnapGrid : CircularDistanceSnapGrid
     {
         public OsuDistanceSnapGrid(OsuHitObject hitObject, [CanBeNull] OsuHitObject nextHitObject = null)
-            : base(hitObject.StackedEndPosition, hitObject.GetEndTime(), nextHitObject?.StartTime)
+            : base(hitObject, hitObject.StackedEndPosition, hitObject.GetEndTime(), nextHitObject?.StartTime)
         {
             Masking = true;
         }

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

@@ -0,0 +1,76 @@
+// 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.Rulesets.UI;
+using osu.Game.Rulesets.Mods;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Bindables;
+using osu.Framework.Localisation;
+using osu.Framework.Utils;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Configuration;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModNoScope : Mod, IUpdatableByPlayfield, IApplicableToScoreProcessor
+    {
+        /// <summary>
+        /// Slightly higher than the cutoff for <see cref="Drawable.IsPresent"/>.
+        /// </summary>
+        private const float min_alpha = 0.0002f;
+
+        private const float transition_duration = 100;
+
+        public override string Name => "No Scope";
+        public override string Acronym => "NS";
+        public override ModType Type => ModType.Fun;
+        public override IconUsage? Icon => FontAwesome.Solid.EyeSlash;
+        public override string Description => "Where's the cursor?";
+        public override double ScoreMultiplier => 1;
+
+        private BindableNumber<int> currentCombo;
+
+        private float targetAlpha;
+
+        [SettingSource(
+            "Hidden at combo",
+            "The combo count at which the cursor becomes completely hidden",
+            SettingControlType = typeof(SettingsSlider<int, HiddenComboSlider>)
+        )]
+        public BindableInt HiddenComboCount { get; } = new BindableInt
+        {
+            Default = 10,
+            Value = 10,
+            MinValue = 0,
+            MaxValue = 50,
+        };
+
+        public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
+
+        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+        {
+            if (HiddenComboCount.Value == 0) return;
+
+            currentCombo = scoreProcessor.Combo.GetBoundCopy();
+            currentCombo.BindValueChanged(combo =>
+            {
+                targetAlpha = Math.Max(min_alpha, 1 - (float)combo.NewValue / HiddenComboCount.Value);
+            }, true);
+        }
+
+        public virtual void Update(Playfield playfield)
+        {
+            playfield.Cursor.Alpha = (float)Interpolation.Lerp(playfield.Cursor.Alpha, targetAlpha, Math.Clamp(playfield.Time.Elapsed / transition_duration, 0, 1));
+        }
+    }
+
+    public class HiddenComboSlider : OsuSliderBar<int>
+    {
+        public override LocalisableString TooltipText => Current.Value == 0 ? "always hidden" : base.TooltipText;
+    }
+}

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

@@ -140,9 +140,8 @@ namespace osu.Game.Rulesets.Osu.Objects
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
-            DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
 
-            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
+            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * DifficultyControlPoint.SliderVelocity;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
             TickDistance = scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier;
@@ -175,7 +174,6 @@ namespace osu.Game.Rulesets.Osu.Objects
                             StartTime = e.Time,
                             Position = Position,
                             StackHeight = StackHeight,
-                            SampleControlPoint = SampleControlPoint,
                         });
                         break;
 

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -192,6 +192,7 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModBarrelRoll(),
                         new OsuModApproachDifferent(),
                         new OsuModMuted(),
+                        new OsuModNoScope(),
                     };
 
                 case ModType.System:

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -154,7 +154,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             double distance = distanceData.Distance * spans * LegacyBeatmapEncoder.LEGACY_TAIKO_VELOCITY_MULTIPLIER;
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(obj.StartTime);
-            DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(obj.StartTime);
+            DifficultyControlPoint difficultyPoint = obj.DifficultyControlPoint;
 
             double beatLength;
 #pragma warning disable 618
@@ -162,7 +162,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 #pragma warning restore 618
                 beatLength = timingPoint.BeatLength * legacyDifficultyPoint.BpmMultiplier;
             else
-                beatLength = timingPoint.BeatLength / difficultyPoint.SpeedMultiplier;
+                beatLength = timingPoint.BeatLength / difficultyPoint.SliderVelocity;
 
             double sliderScoringPointDistance = osu_base_scoring_distance * beatmap.Difficulty.SliderMultiplier / beatmap.Difficulty.SliderTickRate;
 

osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs

@@ -63,9 +63,8 @@ namespace osu.Game.Rulesets.Taiko.Objects
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
-            DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
 
-            double scoringDistance = base_distance * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
+            double scoringDistance = base_distance * difficulty.SliderMultiplier * DifficultyControlPoint.SliderVelocity;
             Velocity = scoringDistance / timingPoint.BeatLength;
 
             tickSpacing = timingPoint.BeatLength / TickRate;

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -192,15 +192,15 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 var difficultyPoint = controlPoints.DifficultyPointAt(0);
                 Assert.AreEqual(0, difficultyPoint.Time);
-                Assert.AreEqual(1.0, difficultyPoint.SpeedMultiplier);
+                Assert.AreEqual(1.0, difficultyPoint.SliderVelocity);
 
                 difficultyPoint = controlPoints.DifficultyPointAt(48428);
                 Assert.AreEqual(0, difficultyPoint.Time);
-                Assert.AreEqual(1.0, difficultyPoint.SpeedMultiplier);
+                Assert.AreEqual(1.0, difficultyPoint.SliderVelocity);
 
                 difficultyPoint = controlPoints.DifficultyPointAt(116999);
                 Assert.AreEqual(116999, difficultyPoint.Time);
-                Assert.AreEqual(0.75, difficultyPoint.SpeedMultiplier, 0.1);
+                Assert.AreEqual(0.75, difficultyPoint.SliderVelocity, 0.1);
 
                 var soundPoint = controlPoints.SamplePointAt(0);
                 Assert.AreEqual(956, soundPoint.Time);
@@ -227,7 +227,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.IsTrue(effectPoint.KiaiMode);
                 Assert.IsFalse(effectPoint.OmitFirstBarLine);
 
-                effectPoint = controlPoints.EffectPointAt(119637);
+                effectPoint = controlPoints.EffectPointAt(116637);
                 Assert.AreEqual(95901, effectPoint.Time);
                 Assert.IsFalse(effectPoint.KiaiMode);
                 Assert.IsFalse(effectPoint.OmitFirstBarLine);
@@ -249,10 +249,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.That(controlPoints.EffectPoints.Count, Is.EqualTo(3));
                 Assert.That(controlPoints.SamplePoints.Count, Is.EqualTo(3));
 
-                Assert.That(controlPoints.DifficultyPointAt(500).SpeedMultiplier, Is.EqualTo(1.5).Within(0.1));
-                Assert.That(controlPoints.DifficultyPointAt(1500).SpeedMultiplier, Is.EqualTo(1.5).Within(0.1));
-                Assert.That(controlPoints.DifficultyPointAt(2500).SpeedMultiplier, Is.EqualTo(0.75).Within(0.1));
-                Assert.That(controlPoints.DifficultyPointAt(3500).SpeedMultiplier, Is.EqualTo(1.5).Within(0.1));
+                Assert.That(controlPoints.DifficultyPointAt(500).SliderVelocity, Is.EqualTo(1.5).Within(0.1));
+                Assert.That(controlPoints.DifficultyPointAt(1500).SliderVelocity, Is.EqualTo(1.5).Within(0.1));
+                Assert.That(controlPoints.DifficultyPointAt(2500).SliderVelocity, Is.EqualTo(0.75).Within(0.1));
+                Assert.That(controlPoints.DifficultyPointAt(3500).SliderVelocity, Is.EqualTo(1.5).Within(0.1));
 
                 Assert.That(controlPoints.EffectPointAt(500).KiaiMode, Is.True);
                 Assert.That(controlPoints.EffectPointAt(1500).KiaiMode, Is.True);
@@ -279,10 +279,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var resStream = TestResources.OpenResource("timingpoint-speedmultiplier-reset.osu"))
             using (var stream = new LineBufferedReader(resStream))
             {
-                var controlPoints = decoder.Decode(stream).ControlPointInfo;
+                var controlPoints = (LegacyControlPointInfo)decoder.Decode(stream).ControlPointInfo;
 
-                Assert.That(controlPoints.DifficultyPointAt(0).SpeedMultiplier, Is.EqualTo(0.5).Within(0.1));
-                Assert.That(controlPoints.DifficultyPointAt(2000).SpeedMultiplier, Is.EqualTo(1).Within(0.1));
+                Assert.That(controlPoints.DifficultyPointAt(0).SliderVelocity, Is.EqualTo(0.5).Within(0.1));
+                Assert.That(controlPoints.DifficultyPointAt(2000).SliderVelocity, Is.EqualTo(1).Within(0.1));
             }
         }
 
@@ -394,12 +394,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var resStream = TestResources.OpenResource("controlpoint-difficulty-multiplier.osu"))
             using (var stream = new LineBufferedReader(resStream))
             {
-                var controlPointInfo = decoder.Decode(stream).ControlPointInfo;
+                var controlPointInfo = (LegacyControlPointInfo)decoder.Decode(stream).ControlPointInfo;
 
-                Assert.That(controlPointInfo.DifficultyPointAt(5).SpeedMultiplier, Is.EqualTo(1));
-                Assert.That(controlPointInfo.DifficultyPointAt(1000).SpeedMultiplier, Is.EqualTo(10));
-                Assert.That(controlPointInfo.DifficultyPointAt(2000).SpeedMultiplier, Is.EqualTo(1.8518518518518519d));
-                Assert.That(controlPointInfo.DifficultyPointAt(3000).SpeedMultiplier, Is.EqualTo(0.5));
+                Assert.That(controlPointInfo.DifficultyPointAt(5).SliderVelocity, Is.EqualTo(1));
+                Assert.That(controlPointInfo.DifficultyPointAt(1000).SliderVelocity, Is.EqualTo(10));
+                Assert.That(controlPointInfo.DifficultyPointAt(2000).SliderVelocity, Is.EqualTo(1.8518518518518519d));
+                Assert.That(controlPointInfo.DifficultyPointAt(3000).SliderVelocity, Is.EqualTo(0.5));
             }
         }
 

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs

@@ -46,8 +46,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             sort(decoded.beatmap);
             sort(decodedAfterEncode.beatmap);
 
-            Assert.That(decodedAfterEncode.beatmap.Serialize(), Is.EqualTo(decoded.beatmap.Serialize()));
-            Assert.IsTrue(areComboColoursEqual(decodedAfterEncode.beatmapSkin.Configuration, decoded.beatmapSkin.Configuration));
+            compareBeatmaps(decoded, decodedAfterEncode);
         }
 
         [TestCaseSource(nameof(allBeatmaps))]
@@ -62,8 +61,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             sort(decoded.beatmap);
             sort(decodedAfterEncode.beatmap);
 
-            Assert.That(decodedAfterEncode.beatmap.Serialize(), Is.EqualTo(decoded.beatmap.Serialize()));
-            Assert.IsTrue(areComboColoursEqual(decodedAfterEncode.beatmapSkin.Configuration, decoded.beatmapSkin.Configuration));
+            compareBeatmaps(decoded, decodedAfterEncode);
         }
 
         [TestCaseSource(nameof(allBeatmaps))]
@@ -77,12 +75,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
             var decodedAfterEncode = decodeFromLegacy(encodeToLegacy(decoded), name);
 
-            // in this process, we may lose some detail in the control points section.
-            // let's focus on only the hitobjects.
-            var originalHitObjects = decoded.beatmap.HitObjects.Serialize();
-            var newHitObjects = decodedAfterEncode.beatmap.HitObjects.Serialize();
-
-            Assert.That(newHitObjects, Is.EqualTo(originalHitObjects));
+            compareBeatmaps(decoded, decodedAfterEncode);
 
             ControlPointInfo removeLegacyControlPointTypes(ControlPointInfo controlPointInfo)
             {
@@ -97,7 +90,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                     // completely ignore "legacy" types, which have been moved to HitObjects.
                     // even though these would mostly be ignored by the Add call, they will still be available in groups,
                     // which isn't what we want to be testing here.
-                    if (point is SampleControlPoint)
+                    if (point is SampleControlPoint || point is DifficultyControlPoint)
                         continue;
 
                     newControlPoints.Add(point.Time, point.DeepClone());
@@ -107,6 +100,19 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        private void compareBeatmaps((IBeatmap beatmap, TestLegacySkin skin) expected, (IBeatmap beatmap, TestLegacySkin skin) actual)
+        {
+            // Check all control points that are still considered to be at a global level.
+            Assert.That(expected.beatmap.ControlPointInfo.TimingPoints.Serialize(), Is.EqualTo(actual.beatmap.ControlPointInfo.TimingPoints.Serialize()));
+            Assert.That(expected.beatmap.ControlPointInfo.EffectPoints.Serialize(), Is.EqualTo(actual.beatmap.ControlPointInfo.EffectPoints.Serialize()));
+
+            // Check all hitobjects.
+            Assert.That(expected.beatmap.HitObjects.Serialize(), Is.EqualTo(actual.beatmap.HitObjects.Serialize()));
+
+            // Check skin.
+            Assert.IsTrue(areComboColoursEqual(expected.skin.Configuration, actual.skin.Configuration));
+        }
+
         [Test]
         public void TestEncodeMultiSegmentSliderWithFloatingPointError()
         {
@@ -156,7 +162,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
-        private (IBeatmap beatmap, TestLegacySkin beatmapSkin) decodeFromLegacy(Stream stream, string name)
+        private (IBeatmap beatmap, TestLegacySkin skin) decodeFromLegacy(Stream stream, string name)
         {
             using (var reader = new LineBufferedReader(stream))
             {
@@ -174,7 +180,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
-        private MemoryStream encodeToLegacy((IBeatmap beatmap, ISkin beatmapSkin) fullBeatmap)
+        private MemoryStream encodeToLegacy((IBeatmap beatmap, ISkin skin) fullBeatmap)
         {
             var (beatmap, beatmapSkin) = fullBeatmap;
             var stream = new MemoryStream();

osu.Game.Tests/Database/BeatmapImporterTests.cs

@@ -0,0 +1,820 @@
+// 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.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Logging;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.IO.Archives;
+using osu.Game.Models;
+using osu.Game.Stores;
+using osu.Game.Tests.Resources;
+using Realms;
+using SharpCompress.Archives;
+using SharpCompress.Archives.Zip;
+using SharpCompress.Common;
+using SharpCompress.Writers.Zip;
+
+#nullable enable
+
+namespace osu.Game.Tests.Database
+{
+    [TestFixture]
+    public class BeatmapImporterTests : RealmTest
+    {
+        [Test]
+        public void TestImportBeatmapThenCleanup()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using (var importer = new BeatmapImporter(realmFactory, storage))
+                using (new RealmRulesetStore(realmFactory, storage))
+                {
+                    ILive<RealmBeatmapSet>? imported;
+
+                    using (var reader = new ZipArchiveReader(TestResources.GetTestBeatmapStream()))
+                        imported = await importer.Import(reader);
+
+                    Assert.AreEqual(1, realmFactory.Context.All<RealmBeatmapSet>().Count());
+
+                    Assert.NotNull(imported);
+                    Debug.Assert(imported != null);
+
+                    imported.PerformWrite(s => s.DeletePending = true);
+
+                    Assert.AreEqual(1, realmFactory.Context.All<RealmBeatmapSet>().Count(s => s.DeletePending));
+                }
+            });
+
+            Logger.Log("Running with no work to purge pending deletions");
+
+            RunTestWithRealm((realmFactory, _) => { Assert.AreEqual(0, realmFactory.Context.All<RealmBeatmapSet>().Count()); });
+        }
+
+        [Test]
+        public void TestImportWhenClosed()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                await LoadOszIntoStore(importer, realmFactory.Context);
+            });
+        }
+
+        [Test]
+        public void TestImportThenDelete()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                deleteBeatmapSet(imported, realmFactory.Context);
+            });
+        }
+
+        [Test]
+        public void TestImportThenDeleteFromStream()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var tempPath = TestResources.GetTestBeatmapForImport();
+
+                ILive<RealmBeatmapSet>? importedSet;
+
+                using (var stream = File.OpenRead(tempPath))
+                {
+                    importedSet = await importer.Import(new ImportTask(stream, Path.GetFileName(tempPath)));
+                    ensureLoaded(realmFactory.Context);
+                }
+
+                Assert.NotNull(importedSet);
+                Debug.Assert(importedSet != null);
+
+                Assert.IsTrue(File.Exists(tempPath), "Stream source file somehow went missing");
+                File.Delete(tempPath);
+
+                var imported = realmFactory.Context.All<RealmBeatmapSet>().First(beatmapSet => beatmapSet.ID == importedSet.ID);
+
+                deleteBeatmapSet(imported, realmFactory.Context);
+            });
+        }
+
+        [Test]
+        public void TestImportThenImport()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
+                Assert.IsTrue(imported.ID == importedSecondTime.ID);
+                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+
+                checkBeatmapSetCount(realmFactory.Context, 1);
+                checkSingleReferencedFileCount(realmFactory.Context, 18);
+            });
+        }
+
+        [Test]
+        public void TestImportThenImportWithReZip()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                try
+                {
+                    var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                    string hashBefore = hashFile(temp);
+
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(extractedFolder);
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    // zip files differ because different compression or encoder.
+                    Assert.AreNotEqual(hashBefore, hashFile(temp));
+
+                    var importedSecondTime = await importer.Import(new ImportTask(temp));
+
+                    ensureLoaded(realmFactory.Context);
+
+                    Assert.NotNull(importedSecondTime);
+                    Debug.Assert(importedSecondTime != null);
+
+                    // but contents doesn't, so existing should still be used.
+                    Assert.IsTrue(imported.ID == importedSecondTime.ID);
+                    Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
+        [Test]
+        public void TestImportThenImportWithChangedHashedFile()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                try
+                {
+                    var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                    await createScoreForBeatmap(realmFactory.Context, imported.Beatmaps.First());
+
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(extractedFolder);
+
+                    // arbitrary write to hashed file
+                    // this triggers the special BeatmapManager.PreImport deletion/replacement flow.
+                    using (var sw = new FileInfo(Directory.GetFiles(extractedFolder, "*.osu").First()).AppendText())
+                        await sw.WriteLineAsync("// changed");
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    var importedSecondTime = await importer.Import(new ImportTask(temp));
+
+                    ensureLoaded(realmFactory.Context);
+
+                    // check the newly "imported" beatmap is not the original.
+                    Assert.NotNull(importedSecondTime);
+                    Debug.Assert(importedSecondTime != null);
+
+                    Assert.IsTrue(imported.ID != importedSecondTime.ID);
+                    Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
+        [Test]
+        [Ignore("intentionally broken by import optimisations")]
+        public void TestImportThenImportWithChangedFile()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                try
+                {
+                    var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(extractedFolder);
+
+                    // arbitrary write to non-hashed file
+                    using (var sw = new FileInfo(Directory.GetFiles(extractedFolder, "*.mp3").First()).AppendText())
+                        await sw.WriteLineAsync("text");
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    var importedSecondTime = await importer.Import(new ImportTask(temp));
+
+                    ensureLoaded(realmFactory.Context);
+
+                    Assert.NotNull(importedSecondTime);
+                    Debug.Assert(importedSecondTime != null);
+
+                    // check the newly "imported" beatmap is not the original.
+                    Assert.IsTrue(imported.ID != importedSecondTime.ID);
+                    Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
+        [Test]
+        public void TestImportThenImportWithDifferentFilename()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                try
+                {
+                    var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(extractedFolder);
+
+                    // change filename
+                    var firstFile = new FileInfo(Directory.GetFiles(extractedFolder).First());
+                    firstFile.MoveTo(Path.Combine(firstFile.DirectoryName.AsNonNull(), $"{firstFile.Name}-changed{firstFile.Extension}"));
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    var importedSecondTime = await importer.Import(new ImportTask(temp));
+
+                    ensureLoaded(realmFactory.Context);
+
+                    Assert.NotNull(importedSecondTime);
+                    Debug.Assert(importedSecondTime != null);
+
+                    // check the newly "imported" beatmap is not the original.
+                    Assert.IsTrue(imported.ID != importedSecondTime.ID);
+                    Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
+        [Test]
+        [Ignore("intentionally broken by import optimisations")]
+        public void TestImportCorruptThenImport()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                var firstFile = imported.Files.First();
+
+                long originalLength;
+                using (var stream = storage.GetStream(firstFile.File.StoragePath))
+                    originalLength = stream.Length;
+
+                using (var stream = storage.GetStream(firstFile.File.StoragePath, FileAccess.Write, FileMode.Create))
+                    stream.WriteByte(0);
+
+                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                using (var stream = storage.GetStream(firstFile.File.StoragePath))
+                    Assert.AreEqual(stream.Length, originalLength, "Corruption was not fixed on second import");
+
+                // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
+                Assert.IsTrue(imported.ID == importedSecondTime.ID);
+                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+
+                checkBeatmapSetCount(realmFactory.Context, 1);
+                checkSingleReferencedFileCount(realmFactory.Context, 18);
+            });
+        }
+
+        [Test]
+        public void TestRollbackOnFailure()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                int loggedExceptionCount = 0;
+
+                Logger.NewEntry += l =>
+                {
+                    if (l.Target == LoggingTarget.Database && l.Exception != null)
+                        Interlocked.Increment(ref loggedExceptionCount);
+                };
+
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                realmFactory.Context.Write(() => imported.Hash += "-changed");
+
+                checkBeatmapSetCount(realmFactory.Context, 1);
+                checkBeatmapCount(realmFactory.Context, 12);
+                checkSingleReferencedFileCount(realmFactory.Context, 18);
+
+                var brokenTempFilename = TestResources.GetTestBeatmapForImport();
+
+                MemoryStream brokenOsu = new MemoryStream();
+                MemoryStream brokenOsz = new MemoryStream(await File.ReadAllBytesAsync(brokenTempFilename));
+
+                File.Delete(brokenTempFilename);
+
+                using (var outStream = File.Open(brokenTempFilename, FileMode.CreateNew))
+                using (var zip = ZipArchive.Open(brokenOsz))
+                {
+                    zip.AddEntry("broken.osu", brokenOsu, false);
+                    zip.SaveTo(outStream, CompressionType.Deflate);
+                }
+
+                // this will trigger purging of the existing beatmap (online set id match) but should rollback due to broken osu.
+                try
+                {
+                    await importer.Import(new ImportTask(brokenTempFilename));
+                }
+                catch
+                {
+                }
+
+                checkBeatmapSetCount(realmFactory.Context, 1);
+                checkBeatmapCount(realmFactory.Context, 12);
+
+                checkSingleReferencedFileCount(realmFactory.Context, 18);
+
+                Assert.AreEqual(1, loggedExceptionCount);
+
+                File.Delete(brokenTempFilename);
+            });
+        }
+
+        [Test]
+        public void TestImportThenDeleteThenImport()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                deleteBeatmapSet(imported, realmFactory.Context);
+
+                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
+                Assert.IsTrue(imported.ID == importedSecondTime.ID);
+                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+            });
+        }
+
+        [Test]
+        public void TestImportThenDeleteThenImportWithOnlineIDsMissing()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                realmFactory.Context.Write(() =>
+                {
+                    foreach (var b in imported.Beatmaps)
+                        b.OnlineID = -1;
+                });
+
+                deleteBeatmapSet(imported, realmFactory.Context);
+
+                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+
+                // check the newly "imported" beatmap has been reimported due to mismatch (even though hashes matched)
+                Assert.IsTrue(imported.ID != importedSecondTime.ID);
+                Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.Beatmaps.First().ID);
+            });
+        }
+
+        [Test]
+        public void TestImportWithDuplicateBeatmapIDs()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var metadata = new RealmBeatmapMetadata
+                {
+                    Artist = "SomeArtist",
+                    Author = "SomeAuthor"
+                };
+
+                var ruleset = realmFactory.Context.All<RealmRuleset>().First();
+
+                var toImport = new RealmBeatmapSet
+                {
+                    OnlineID = 1,
+                    Beatmaps =
+                    {
+                        new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), metadata)
+                        {
+                            OnlineID = 2,
+                        },
+                        new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), metadata)
+                        {
+                            OnlineID = 2,
+                            Status = BeatmapSetOnlineStatus.Loved,
+                        }
+                    }
+                };
+
+                var imported = await importer.Import(toImport);
+
+                Assert.NotNull(imported);
+                Debug.Assert(imported != null);
+
+                Assert.AreEqual(-1, imported.PerformRead(s => s.Beatmaps[0].OnlineID));
+                Assert.AreEqual(-1, imported.PerformRead(s => s.Beatmaps[1].OnlineID));
+            });
+        }
+
+        [Test]
+        public void TestImportWhenFileOpen()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+                using (File.OpenRead(temp))
+                    await importer.Import(temp);
+                ensureLoaded(realmFactory.Context);
+                File.Delete(temp);
+                Assert.IsFalse(File.Exists(temp), "We likely held a read lock on the file when we shouldn't");
+            });
+        }
+
+        [Test]
+        public void TestImportWithDuplicateHashes()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                try
+                {
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(extractedFolder);
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.AddEntry("duplicate.osu", Directory.GetFiles(extractedFolder, "*.osu").First());
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    await importer.Import(temp);
+
+                    ensureLoaded(realmFactory.Context);
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
+        [Test]
+        public void TestImportNestedStructure()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                string subfolder = Path.Combine(extractedFolder, "subfolder");
+
+                Directory.CreateDirectory(subfolder);
+
+                try
+                {
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(subfolder);
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    var imported = await importer.Import(new ImportTask(temp));
+
+                    Assert.NotNull(imported);
+                    Debug.Assert(imported != null);
+
+                    ensureLoaded(realmFactory.Context);
+
+                    Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("subfolder"))), "Files contain common subfolder");
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
+        [Test]
+        public void TestImportWithIgnoredDirectoryInArchive()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                string dataFolder = Path.Combine(extractedFolder, "actual_data");
+                string resourceForkFolder = Path.Combine(extractedFolder, "__MACOSX");
+                string resourceForkFilePath = Path.Combine(resourceForkFolder, ".extracted");
+
+                Directory.CreateDirectory(dataFolder);
+                Directory.CreateDirectory(resourceForkFolder);
+
+                using (var resourceForkFile = File.CreateText(resourceForkFilePath))
+                {
+                    await resourceForkFile.WriteLineAsync("adding content so that it's not empty");
+                }
+
+                try
+                {
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(dataFolder);
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    var imported = await importer.Import(new ImportTask(temp));
+
+                    Assert.NotNull(imported);
+                    Debug.Assert(imported != null);
+
+                    ensureLoaded(realmFactory.Context);
+
+                    Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("__MACOSX"))), "Files contain resource fork folder, which should be ignored");
+                    Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("actual_data"))), "Files contain common subfolder");
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
+        [Test]
+        public void TestUpdateBeatmapInfo()
+        {
+            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            {
+                using var importer = new BeatmapImporter(realmFactory, storage);
+                using var store = new RealmRulesetStore(realmFactory, storage);
+
+                var temp = TestResources.GetTestBeatmapForImport();
+                await importer.Import(temp);
+
+                // Update via the beatmap, not the beatmap info, to ensure correct linking
+                RealmBeatmapSet setToUpdate = realmFactory.Context.All<RealmBeatmapSet>().First();
+
+                var beatmapToUpdate = setToUpdate.Beatmaps.First();
+
+                realmFactory.Context.Write(() => beatmapToUpdate.DifficultyName = "updated");
+
+                RealmBeatmap updatedInfo = realmFactory.Context.All<RealmBeatmap>().First(b => b.ID == beatmapToUpdate.ID);
+                Assert.That(updatedInfo.DifficultyName, Is.EqualTo("updated"));
+            });
+        }
+
+        public static async Task<RealmBeatmapSet?> LoadQuickOszIntoOsu(BeatmapImporter importer, Realm realm)
+        {
+            var temp = TestResources.GetQuickTestBeatmapForImport();
+
+            var importedSet = await importer.Import(new ImportTask(temp));
+
+            Assert.NotNull(importedSet);
+
+            ensureLoaded(realm);
+
+            waitForOrAssert(() => !File.Exists(temp), "Temporary file still exists after standard import", 5000);
+
+            return realm.All<RealmBeatmapSet>().FirstOrDefault(beatmapSet => beatmapSet.ID == importedSet!.ID);
+        }
+
+        public static async Task<RealmBeatmapSet> LoadOszIntoStore(BeatmapImporter importer, Realm realm, string? path = null, bool virtualTrack = false)
+        {
+            var temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
+
+            var importedSet = await importer.Import(new ImportTask(temp));
+
+            Assert.NotNull(importedSet);
+            Debug.Assert(importedSet != null);
+
+            ensureLoaded(realm);
+
+            waitForOrAssert(() => !File.Exists(temp), "Temporary file still exists after standard import", 5000);
+
+            return realm.All<RealmBeatmapSet>().First(beatmapSet => beatmapSet.ID == importedSet.ID);
+        }
+
+        private void deleteBeatmapSet(RealmBeatmapSet imported, Realm realm)
+        {
+            realm.Write(() => imported.DeletePending = true);
+
+            checkBeatmapSetCount(realm, 0);
+            checkBeatmapSetCount(realm, 1, true);
+
+            Assert.IsTrue(realm.All<RealmBeatmapSet>().First(_ => true).DeletePending);
+        }
+
+        private static Task createScoreForBeatmap(Realm realm, RealmBeatmap beatmap)
+        {
+            // TODO: reimplement when we have score support in realm.
+            // return ImportScoreTest.LoadScoreIntoOsu(osu, new ScoreInfo
+            // {
+            //     OnlineScoreID = 2,
+            //     Beatmap = beatmap,
+            //     BeatmapInfoID = beatmap.ID
+            // }, new ImportScoreTest.TestArchiveReader());
+
+            return Task.CompletedTask;
+        }
+
+        private static void checkBeatmapSetCount(Realm realm, int expected, bool includeDeletePending = false)
+        {
+            Assert.AreEqual(expected, includeDeletePending
+                ? realm.All<RealmBeatmapSet>().Count()
+                : realm.All<RealmBeatmapSet>().Count(s => !s.DeletePending));
+        }
+
+        private static string hashFile(string filename)
+        {
+            using (var s = File.OpenRead(filename))
+                return s.ComputeMD5Hash();
+        }
+
+        private static void checkBeatmapCount(Realm realm, int expected)
+        {
+            Assert.AreEqual(expected, realm.All<RealmBeatmap>().Where(_ => true).ToList().Count);
+        }
+
+        private static void checkSingleReferencedFileCount(Realm realm, int expected)
+        {
+            int singleReferencedCount = 0;
+
+            foreach (var f in realm.All<RealmFile>())
+            {
+                if (f.BacklinksCount == 1)
+                    singleReferencedCount++;
+            }
+
+            Assert.AreEqual(expected, singleReferencedCount);
+        }
+
+        private static void ensureLoaded(Realm realm, int timeout = 60000)
+        {
+            IQueryable<RealmBeatmapSet>? resultSets = null;
+
+            waitForOrAssert(() => (resultSets = realm.All<RealmBeatmapSet>().Where(s => !s.DeletePending && s.OnlineID == 241526)).Any(),
+                @"BeatmapSet did not import to the database in allocated time.", timeout);
+
+            // ensure we were stored to beatmap database backing...
+            Assert.IsTrue(resultSets?.Count() == 1, $@"Incorrect result count found ({resultSets?.Count()} but should be 1).");
+
+            IEnumerable<RealmBeatmapSet> queryBeatmapSets() => realm.All<RealmBeatmapSet>().Where(s => !s.DeletePending && s.OnlineID == 241526);
+
+            var set = queryBeatmapSets().First();
+
+            // ReSharper disable once PossibleUnintendedReferenceComparison
+            IEnumerable<RealmBeatmap> queryBeatmaps() => realm.All<RealmBeatmap>().Where(s => s.BeatmapSet != null && s.BeatmapSet == set);
+
+            waitForOrAssert(() => queryBeatmaps().Count() == 12, @"Beatmaps did not import to the database in allocated time", timeout);
+            waitForOrAssert(() => queryBeatmapSets().Count() == 1, @"BeatmapSet did not import to the database in allocated time", timeout);
+
+            int countBeatmapSetBeatmaps = 0;
+            int countBeatmaps = 0;
+
+            waitForOrAssert(() =>
+                    (countBeatmapSetBeatmaps = queryBeatmapSets().First().Beatmaps.Count) ==
+                    (countBeatmaps = queryBeatmaps().Count()),
+                $@"Incorrect database beatmap count post-import ({countBeatmaps} but should be {countBeatmapSetBeatmaps}).", timeout);
+
+            foreach (RealmBeatmap b in set.Beatmaps)
+                Assert.IsTrue(set.Beatmaps.Any(c => c.OnlineID == b.OnlineID));
+            Assert.IsTrue(set.Beatmaps.Count > 0);
+        }
+
+        private static void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
+        {
+            const int sleep = 200;
+
+            while (timeout > 0)
+            {
+                Thread.Sleep(sleep);
+                timeout -= sleep;
+
+                if (result())
+                    return;
+            }
+
+            Assert.Fail(failureMessage);
+        }
+    }
+}

osu.Game.Tests/Database/RulesetStoreTests.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.Linq;
+using NUnit.Framework;
+using osu.Game.Models;
+using osu.Game.Stores;
+
+namespace osu.Game.Tests.Database
+{
+    public class RulesetStoreTests : RealmTest
+    {
+        [Test]
+        public void TestCreateStore()
+        {
+            RunTestWithRealm((realmFactory, storage) =>
+            {
+                var rulesets = new RealmRulesetStore(realmFactory, storage);
+
+                Assert.AreEqual(4, rulesets.AvailableRulesets.Count());
+                Assert.AreEqual(4, realmFactory.Context.All<RealmRuleset>().Count());
+            });
+        }
+
+        [Test]
+        public void TestCreateStoreTwiceDoesntAddRulesetsAgain()
+        {
+            RunTestWithRealm((realmFactory, storage) =>
+            {
+                var rulesets = new RealmRulesetStore(realmFactory, storage);
+                var rulesets2 = new RealmRulesetStore(realmFactory, storage);
+
+                Assert.AreEqual(4, rulesets.AvailableRulesets.Count());
+                Assert.AreEqual(4, rulesets2.AvailableRulesets.Count());
+
+                Assert.AreEqual(rulesets.AvailableRulesets.First(), rulesets2.AvailableRulesets.First());
+                Assert.AreEqual(4, realmFactory.Context.All<RealmRuleset>().Count());
+            });
+        }
+
+        [Test]
+        public void TestRetrievedRulesetsAreDetached()
+        {
+            RunTestWithRealm((realmFactory, storage) =>
+            {
+                var rulesets = new RealmRulesetStore(realmFactory, storage);
+
+                Assert.IsTrue((rulesets.AvailableRulesets.First() as RealmRuleset)?.IsManaged == false);
+                Assert.IsTrue((rulesets.GetRuleset(0) as RealmRuleset)?.IsManaged == false);
+                Assert.IsTrue((rulesets.GetRuleset("mania") as RealmRuleset)?.IsManaged == false);
+            });
+        }
+    }
+}

osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs

@@ -8,6 +8,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Edit;
@@ -55,8 +56,6 @@ namespace osu.Game.Tests.Editing
 
             composer.EditorBeatmap.Difficulty.SliderMultiplier = 1;
             composer.EditorBeatmap.ControlPointInfo.Clear();
-
-            composer.EditorBeatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 1 });
             composer.EditorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 1000 });
         });
 
@@ -73,13 +72,13 @@ namespace osu.Game.Tests.Editing
         [TestCase(2)]
         public void TestSpeedMultiplier(float multiplier)
         {
-            AddStep($"set multiplier = {multiplier}", () =>
+            assertSnapDistance(100 * multiplier, new HitObject
             {
-                composer.EditorBeatmap.ControlPointInfo.Clear();
-                composer.EditorBeatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = multiplier });
+                DifficultyControlPoint = new DifficultyControlPoint
+                {
+                    SliderVelocity = multiplier
+                }
             });
-
-            assertSnapDistance(100 * multiplier);
         }
 
         [TestCase(1)]
@@ -197,20 +196,20 @@ namespace osu.Game.Tests.Editing
             assertSnappedDistance(400, 400);
         }
 
-        private void assertSnapDistance(float expectedDistance)
-            => AddAssert($"distance is {expectedDistance}", () => composer.GetBeatSnapDistanceAt(0) == expectedDistance);
+        private void assertSnapDistance(float expectedDistance, HitObject hitObject = null)
+            => AddAssert($"distance is {expectedDistance}", () => composer.GetBeatSnapDistanceAt(hitObject ?? new HitObject()) == expectedDistance);
 
         private void assertDurationToDistance(double duration, float expectedDistance)
-            => AddAssert($"duration = {duration} -> distance = {expectedDistance}", () => composer.DurationToDistance(0, duration) == expectedDistance);
+            => AddAssert($"duration = {duration} -> distance = {expectedDistance}", () => composer.DurationToDistance(new HitObject(), duration) == expectedDistance);
 
         private void assertDistanceToDuration(float distance, double expectedDuration)
-            => AddAssert($"distance = {distance} -> duration = {expectedDuration}", () => composer.DistanceToDuration(0, distance) == expectedDuration);
+            => AddAssert($"distance = {distance} -> duration = {expectedDuration}", () => composer.DistanceToDuration(new HitObject(), distance) == expectedDuration);
 
         private void assertSnappedDuration(float distance, double expectedDuration)
-            => AddAssert($"distance = {distance} -> duration = {expectedDuration} (snapped)", () => composer.GetSnappedDurationFromDistance(0, distance) == expectedDuration);
+            => AddAssert($"distance = {distance} -> duration = {expectedDuration} (snapped)", () => composer.GetSnappedDurationFromDistance(new HitObject(), distance) == expectedDuration);
 
         private void assertSnappedDistance(float distance, float expectedDistance)
-            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)", () => composer.GetSnappedDistanceFromDistance(0, distance) == expectedDistance);
+            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)", () => composer.GetSnappedDistanceFromDistance(new HitObject(), distance) == expectedDistance);
 
         private class TestHitObjectComposer : OsuHitObjectComposer
         {

osu.Game.Tests/NonVisual/ControlPointInfoTest.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Tests.NonVisual
         [Test]
         public void TestAddRedundantDifficulty()
         {
-            var cpi = new ControlPointInfo();
+            var cpi = new LegacyControlPointInfo();
 
             cpi.Add(0, new DifficultyControlPoint()); // is redundant
             cpi.Add(1000, new DifficultyControlPoint()); // is redundant
@@ -55,7 +55,7 @@ namespace osu.Game.Tests.NonVisual
             Assert.That(cpi.DifficultyPoints.Count, Is.EqualTo(0));
             Assert.That(cpi.AllControlPoints.Count(), Is.EqualTo(0));
 
-            cpi.Add(1000, new DifficultyControlPoint { SpeedMultiplier = 2 }); // is not redundant
+            cpi.Add(1000, new DifficultyControlPoint { SliderVelocity = 2 }); // is not redundant
 
             Assert.That(cpi.Groups.Count, Is.EqualTo(1));
             Assert.That(cpi.DifficultyPoints.Count, Is.EqualTo(1));
@@ -159,7 +159,7 @@ namespace osu.Game.Tests.NonVisual
         [Test]
         public void TestAddControlPointToGroup()
         {
-            var cpi = new ControlPointInfo();
+            var cpi = new LegacyControlPointInfo();
 
             var group = cpi.GroupAt(1000, true);
             Assert.That(cpi.Groups.Count, Is.EqualTo(1));
@@ -174,23 +174,23 @@ namespace osu.Game.Tests.NonVisual
         [Test]
         public void TestAddDuplicateControlPointToGroup()
         {
-            var cpi = new ControlPointInfo();
+            var cpi = new LegacyControlPointInfo();
 
             var group = cpi.GroupAt(1000, true);
             Assert.That(cpi.Groups.Count, Is.EqualTo(1));
 
             group.Add(new DifficultyControlPoint());
-            group.Add(new DifficultyControlPoint { SpeedMultiplier = 2 });
+            group.Add(new DifficultyControlPoint { SliderVelocity = 2 });
 
             Assert.That(group.ControlPoints.Count, Is.EqualTo(1));
             Assert.That(cpi.DifficultyPoints.Count, Is.EqualTo(1));
-            Assert.That(cpi.DifficultyPoints.First().SpeedMultiplier, Is.EqualTo(2));
+            Assert.That(cpi.DifficultyPoints.First().SliderVelocity, Is.EqualTo(2));
         }
 
         [Test]
         public void TestRemoveControlPointFromGroup()
         {
-            var cpi = new ControlPointInfo();
+            var cpi = new LegacyControlPointInfo();
 
             var group = cpi.GroupAt(1000, true);
             Assert.That(cpi.Groups.Count, Is.EqualTo(1));
@@ -208,14 +208,14 @@ namespace osu.Game.Tests.NonVisual
         [Test]
         public void TestOrdering()
         {
-            var cpi = new ControlPointInfo();
+            var cpi = new LegacyControlPointInfo();
 
             cpi.Add(0, new TimingControlPoint());
             cpi.Add(1000, new TimingControlPoint { BeatLength = 500 });
             cpi.Add(10000, new TimingControlPoint { BeatLength = 200 });
             cpi.Add(5000, new TimingControlPoint { BeatLength = 100 });
-            cpi.Add(3000, new DifficultyControlPoint { SpeedMultiplier = 2 });
-            cpi.GroupAt(7000, true).Add(new DifficultyControlPoint { SpeedMultiplier = 4 });
+            cpi.Add(3000, new DifficultyControlPoint { SliderVelocity = 2 });
+            cpi.GroupAt(7000, true).Add(new DifficultyControlPoint { SliderVelocity = 4 });
             cpi.GroupAt(1000).Add(new SampleControlPoint { SampleVolume = 0 });
             cpi.GroupAt(8000, true).Add(new EffectControlPoint { KiaiMode = true });
 
@@ -230,14 +230,14 @@ namespace osu.Game.Tests.NonVisual
         [Test]
         public void TestClear()
         {
-            var cpi = new ControlPointInfo();
+            var cpi = new LegacyControlPointInfo();
 
             cpi.Add(0, new TimingControlPoint());
             cpi.Add(1000, new TimingControlPoint { BeatLength = 500 });
             cpi.Add(10000, new TimingControlPoint { BeatLength = 200 });
             cpi.Add(5000, new TimingControlPoint { BeatLength = 100 });
-            cpi.Add(3000, new DifficultyControlPoint { SpeedMultiplier = 2 });
-            cpi.GroupAt(7000, true).Add(new DifficultyControlPoint { SpeedMultiplier = 4 });
+            cpi.Add(3000, new DifficultyControlPoint { SliderVelocity = 2 });
+            cpi.GroupAt(7000, true).Add(new DifficultyControlPoint { SliderVelocity = 4 });
             cpi.GroupAt(1000).Add(new SampleControlPoint { SampleVolume = 0 });
             cpi.GroupAt(8000, true).Add(new EffectControlPoint { KiaiMode = true });
 

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

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components;
@@ -81,7 +82,7 @@ namespace osu.Game.Tests.Visual.Editing
             public new float DistanceSpacing => base.DistanceSpacing;
 
             public TestDistanceSnapGrid(double? endTime = null)
-                : base(grid_position, 0, endTime)
+                : base(new HitObject(), grid_position, 0, endTime)
             {
             }
 
@@ -158,15 +159,15 @@ namespace osu.Game.Tests.Visual.Editing
 
             public SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition) => new SnapResult(screenSpacePosition, 0);
 
-            public float GetBeatSnapDistanceAt(double referenceTime) => 10;
+            public float GetBeatSnapDistanceAt(HitObject referenceObject) => 10;
 
-            public float DurationToDistance(double referenceTime, double duration) => (float)duration;
+            public float DurationToDistance(HitObject referenceObject, double duration) => (float)duration;
 
-            public double DistanceToDuration(double referenceTime, float distance) => distance;
+            public double DistanceToDuration(HitObject referenceObject, float distance) => distance;
 
-            public double GetSnappedDurationFromDistance(double referenceTime, float distance) => 0;
+            public double GetSnappedDurationFromDistance(HitObject referenceObject, float distance) => 0;
 
-            public float GetSnappedDistanceFromDistance(double referenceTime, float distance) => 0;
+            public float GetSnappedDistanceFromDistance(HitObject referenceObject, float distance) => 0;
         }
     }
 }

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

@@ -8,6 +8,7 @@ using osu.Framework.Testing;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Select;
 using osuTK.Input;
@@ -30,23 +31,35 @@ namespace osu.Game.Tests.Visual.Editing
 
             PushAndConfirm(() => new EditorLoader());
 
-            AddUntilStep("wait for editor load", () => editor != null);
+            AddUntilStep("wait for editor load", () => editor?.IsLoaded == true);
 
-            AddStep("Set overall difficulty", () => editorBeatmap.Difficulty.OverallDifficulty = 7);
+            AddUntilStep("wait for metadata screen load", () => editor.ChildrenOfType<MetadataSection>().FirstOrDefault()?.IsLoaded == true);
 
-            AddStep("Add timing point", () => editorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint()));
+            // We intentionally switch away from the metadata screen, else there is a feedback loop with the textbox handling which causes metadata changes below to get overwritten.
 
             AddStep("Enter compose mode", () => InputManager.Key(Key.F1));
             AddUntilStep("Wait for compose mode load", () => editor.ChildrenOfType<HitObjectComposer>().FirstOrDefault()?.IsLoaded == true);
 
+            AddStep("Set overall difficulty", () => editorBeatmap.Difficulty.OverallDifficulty = 7);
+            AddStep("Set artist and title", () =>
+            {
+                editorBeatmap.BeatmapInfo.Metadata.Artist = "artist";
+                editorBeatmap.BeatmapInfo.Metadata.Title = "title";
+            });
+            AddStep("Set difficulty name", () => editorBeatmap.BeatmapInfo.Version = "difficulty");
+
+            AddStep("Add timing point", () => editorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint()));
+
             AddStep("Change to placement mode", () => InputManager.Key(Key.Number2));
             AddStep("Move to playfield", () => InputManager.MoveMouseTo(Game.ScreenSpaceDrawQuad.Centre));
             AddStep("Place single hitcircle", () => InputManager.Click(MouseButton.Left));
 
-            AddAssert("Beatmap contains single hitcircle", () => editorBeatmap.HitObjects.Count == 1);
+            checkMutations();
 
             AddStep("Save", () => InputManager.Keys(PlatformAction.Save));
 
+            checkMutations();
+
             AddStep("Exit", () => InputManager.Key(Key.Escape));
 
             AddUntilStep("Wait for main menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
@@ -58,8 +71,16 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("Enter editor", () => InputManager.Key(Key.Number5));
 
             AddUntilStep("Wait for editor load", () => editor != null);
+
+            checkMutations();
+        }
+
+        private void checkMutations()
+        {
             AddAssert("Beatmap contains single hitcircle", () => editorBeatmap.HitObjects.Count == 1);
             AddAssert("Beatmap has correct overall difficulty", () => editorBeatmap.Difficulty.OverallDifficulty == 7);
+            AddAssert("Beatmap has correct metadata", () => editorBeatmap.BeatmapInfo.Metadata.Artist == "artist" && editorBeatmap.BeatmapInfo.Metadata.Title == "title");
+            AddAssert("Beatmap has correct difficulty name", () => editorBeatmap.BeatmapInfo.Version == "difficulty");
         }
     }
 }

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

@@ -20,14 +20,15 @@ namespace osu.Game.Tests.Visual.Gameplay
     /// </summary>
     public abstract class TestSceneAllRulesetPlayers : RateAdjustedBeatmapTestScene
     {
-        protected Player Player;
+        protected Player Player { get; private set; }
+
+        protected OsuConfigManager Config { get; private set; }
 
         [BackgroundDependencyLoader]
         private void load(RulesetStore rulesets)
         {
-            OsuConfigManager manager;
-            Dependencies.Cache(manager = new OsuConfigManager(LocalStorage));
-            manager.GetBindable<double>(OsuSetting.DimLevel).Value = 1.0;
+            Dependencies.Cache(Config = new OsuConfigManager(LocalStorage));
+            Config.GetBindable<double>(OsuSetting.DimLevel).Value = 1.0;
         }
 
         [Test]

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

@@ -2,7 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using NUnit.Framework;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Configuration;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Play;
@@ -17,6 +19,14 @@ namespace osu.Game.Tests.Visual.Gameplay
             return new FailPlayer();
         }
 
+        [Test]
+        public void TestOsuWithoutRedTint()
+        {
+            AddStep("Disable red tint", () => Config.SetValue(OsuSetting.FadePlayfieldWhenHealthLow, false));
+            TestOsu();
+            AddStep("Enable red tint", () => Config.SetValue(OsuSetting.FadePlayfieldWhenHealthLow, true));
+        }
+
         protected override void AddCheckSteps()
         {
             AddUntilStep("wait for fail", () => Player.HasFailed);

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

@@ -291,7 +291,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
-            AddAssert($"epilepsy warning {(warning ? "present" : "absent")}", () => this.ChildrenOfType<EpilepsyWarning>().Any() == warning);
+            AddAssert($"epilepsy warning {(warning ? "present" : "absent")}", () => (getWarning() != null) == warning);
 
             if (warning)
             {
@@ -335,12 +335,17 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
-            AddUntilStep("wait for epilepsy warning", () => loader.ChildrenOfType<EpilepsyWarning>().Single().Alpha > 0);
+            AddUntilStep("wait for epilepsy warning", () => getWarning().Alpha > 0);
+            AddUntilStep("warning is shown", () => getWarning().State.Value == Visibility.Visible);
+
             AddStep("exit early", () => loader.Exit());
 
+            AddUntilStep("warning is hidden", () => getWarning().State.Value == Visibility.Hidden);
             AddUntilStep("sound volume restored", () => Beatmap.Value.Track.AggregateVolume.Value == 1);
         }
 
+        private EpilepsyWarning getWarning() => loader.ChildrenOfType<EpilepsyWarning>().SingleOrDefault();
+
         private class TestPlayerLoader : PlayerLoader
         {
             public new VisualSettings VisualSettings => base.VisualSettings;

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
@@ -10,10 +11,13 @@ using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Online.Solo;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko;
+using osu.Game.Scoring;
 using osu.Game.Screens.Ranking;
 using osu.Game.Tests.Beatmaps;
 
@@ -32,7 +36,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         protected override bool HasCustomSteps => true;
 
-        protected override TestPlayer CreatePlayer(Ruleset ruleset) => new TestPlayer(false);
+        protected override TestPlayer CreatePlayer(Ruleset ruleset) => new NonImportingPlayer(false);
 
         protected override Ruleset CreatePlayerRuleset() => createCustomRuleset?.Invoke() ?? new OsuRuleset();
 
@@ -86,6 +90,46 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("ensure passing submission", () => Player.SubmittedScore?.ScoreInfo.Passed == true);
         }
 
+        [Test]
+        public void TestSubmissionForDifferentRuleset()
+        {
+            prepareTokenResponse(true);
+
+            createPlayerTest(createRuleset: () => new TaikoRuleset());
+
+            AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
+
+            AddUntilStep("wait for track to start running", () => Beatmap.Value.Track.IsRunning);
+
+            addFakeHit();
+
+            AddStep("seek to completion", () => Player.GameplayClockContainer.Seek(Player.DrawableRuleset.Objects.Last().GetEndTime()));
+
+            AddUntilStep("results displayed", () => Player.GetChildScreen() is ResultsScreen);
+            AddAssert("ensure passing submission", () => Player.SubmittedScore?.ScoreInfo.Passed == true);
+            AddAssert("submitted score has correct ruleset ID", () => Player.SubmittedScore?.ScoreInfo.RulesetID == new TaikoRuleset().RulesetInfo.ID);
+        }
+
+        [Test]
+        public void TestSubmissionForConvertedBeatmap()
+        {
+            prepareTokenResponse(true);
+
+            createPlayerTest(createRuleset: () => new ManiaRuleset(), createBeatmap: _ => createTestBeatmap(new OsuRuleset().RulesetInfo));
+
+            AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
+
+            AddUntilStep("wait for track to start running", () => Beatmap.Value.Track.IsRunning);
+
+            addFakeHit();
+
+            AddStep("seek to completion", () => Player.GameplayClockContainer.Seek(Player.DrawableRuleset.Objects.Last().GetEndTime()));
+
+            AddUntilStep("results displayed", () => Player.GetChildScreen() is ResultsScreen);
+            AddAssert("ensure passing submission", () => Player.SubmittedScore?.ScoreInfo.Passed == true);
+            AddAssert("submitted score has correct ruleset ID", () => Player.SubmittedScore?.ScoreInfo.RulesetID == new ManiaRuleset().RulesetInfo.ID);
+        }
+
         [Test]
         public void TestNoSubmissionOnExitWithNoToken()
         {
@@ -183,12 +227,13 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("ensure no submission", () => Player.SubmittedScore == null);
         }
 
-        [Test]
-        public void TestNoSubmissionOnCustomRuleset()
+        [TestCase(null)]
+        [TestCase(10)]
+        public void TestNoSubmissionOnCustomRuleset(int? rulesetId)
         {
             prepareTokenResponse(true);
 
-            createPlayerTest(false, createRuleset: () => new OsuRuleset { RulesetInfo = { ID = 10 } });
+            createPlayerTest(false, createRuleset: () => new OsuRuleset { RulesetInfo = { ID = rulesetId } });
 
             AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
 
@@ -242,5 +287,33 @@ namespace osu.Game.Tests.Visual.Gameplay
                 });
             });
         }
+
+        private class NonImportingPlayer : TestPlayer
+        {
+            public NonImportingPlayer(bool allowPause = true, bool showResults = true, bool pauseOnFocusLost = false)
+                : base(allowPause, showResults, pauseOnFocusLost)
+            {
+            }
+
+            protected override Task ImportScore(Score score)
+            {
+                // It was discovered that Score members could sometimes be half-populated.
+                // In particular, the RulesetID property could be set to 0 even on non-osu! maps.
+                // We want to test that the state of that property is consistent in this test.
+                // EF makes this impossible.
+                //
+                // First off, because of the EF navigational property-explicit foreign key field duality,
+                // it can happen that - for example - the Ruleset navigational property is correctly initialised to mania,
+                // but the RulesetID foreign key property is not initialised and remains 0.
+                // EF silently bypasses this by prioritising the Ruleset navigational property over the RulesetID foreign key one.
+                //
+                // Additionally, adding an entity to an EF DbSet CAUSES SIDE EFFECTS with regard to the foreign key property.
+                // In the above instance, if a ScoreInfo with Ruleset = {mania} and RulesetID = 0 is attached to an EF context,
+                // RulesetID WILL BE SILENTLY SET TO THE CORRECT VALUE of 3.
+                //
+                // For the above reasons, importing is disabled in this test.
+                return Task.CompletedTask;
+            }
+        }
     }
 }

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

@@ -93,9 +93,9 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private IList<MultiplierControlPoint> testControlPoints => new List<MultiplierControlPoint>
         {
-            new MultiplierControlPoint(time_range) { DifficultyPoint = { SpeedMultiplier = 1.25 } },
-            new MultiplierControlPoint(1.5 * time_range) { DifficultyPoint = { SpeedMultiplier = 1 } },
-            new MultiplierControlPoint(2 * time_range) { DifficultyPoint = { SpeedMultiplier = 1.5 } }
+            new MultiplierControlPoint(time_range) { EffectPoint = { ScrollSpeed = 1.25 } },
+            new MultiplierControlPoint(1.5 * time_range) { EffectPoint = { ScrollSpeed = 1 } },
+            new MultiplierControlPoint(2 * time_range) { EffectPoint = { ScrollSpeed = 1.5 } }
         };
 
         [Test]

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

@@ -0,0 +1,51 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Game.Online.API;
+using osu.Game.Online.Spectator;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Tests.Visual.Spectator;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSpectatorHost : PlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
+
+        [Cached(typeof(SpectatorClient))]
+        private TestSpectatorClient spectatorClient { get; } = new TestSpectatorClient();
+
+        private DummyAPIAccess dummyAPIAccess => (DummyAPIAccess)API;
+        private const int dummy_user_id = 42;
+
+        public override void SetUpSteps()
+        {
+            AddStep("set dummy user", () => dummyAPIAccess.LocalUser.Value = new User
+            {
+                Id = dummy_user_id,
+                Username = "DummyUser"
+            });
+            AddStep("add test spectator client", () => Add(spectatorClient));
+            AddStep("add watching user", () => spectatorClient.WatchUser(dummy_user_id));
+            base.SetUpSteps();
+        }
+
+        [Test]
+        public void TestClientSendsCorrectRuleset()
+        {
+            AddUntilStep("spectator client sending frames", () => spectatorClient.PlayingUserStates.ContainsKey(dummy_user_id));
+            AddAssert("spectator client sent correct ruleset", () => spectatorClient.PlayingUserStates[dummy_user_id].RulesetID == Ruleset.Value.ID);
+        }
+
+        public override void TearDownSteps()
+        {
+            base.TearDownSteps();
+            AddStep("stop watching user", () => spectatorClient.StopWatchingUser(dummy_user_id));
+            AddStep("remove test spectator client", () => Remove(spectatorClient));
+        }
+    }
+}

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

@@ -564,11 +564,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 }
             });
 
-            AddRepeatStep("click spectate button", () =>
+            AddUntilStep("wait for ready button to be enabled", () => readyButton.ChildrenOfType<OsuButton>().Single().Enabled.Value);
+
+            AddStep("click ready button", () =>
             {
-                InputManager.MoveMouseTo(this.ChildrenOfType<MultiplayerReadyButton>().Single());
+                InputManager.MoveMouseTo(readyButton);
                 InputManager.Click(MouseButton.Left);
-            }, 2);
+            });
+
+            AddUntilStep("wait for player to be ready", () => client.Room?.Users[0].State == MultiplayerUserState.Ready);
+            AddUntilStep("wait for ready button to be enabled", () => readyButton.ChildrenOfType<OsuButton>().Single().Enabled.Value);
+
+            AddStep("click start button", () => InputManager.Click(MouseButton.Left));
 
             AddUntilStep("wait for player", () => Stack.CurrentScreen is Player);
 
@@ -582,6 +589,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for results", () => Stack.CurrentScreen is ResultsScreen);
         }
 
+        private MultiplayerReadyButton readyButton => this.ChildrenOfType<MultiplayerReadyButton>().Single();
+
         private void createRoom(Func<Room> room)
         {
             AddUntilStep("wait for lounge", () => multiplayerScreen.ChildrenOfType<LoungeSubScreen>().SingleOrDefault()?.IsLoaded == true);

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

@@ -275,6 +275,68 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 var state = i;
                 AddStep($"set state: {state}", () => Client.ChangeUserState(0, state));
             }
+
+            AddStep("set state: downloading", () => Client.ChangeUserBeatmapAvailability(0, BeatmapAvailability.Downloading(0)));
+
+            AddStep("set state: locally available", () => Client.ChangeUserBeatmapAvailability(0, BeatmapAvailability.LocallyAvailable()));
+        }
+
+        [Test]
+        public void TestModOverlap()
+        {
+            AddStep("add dummy mods", () =>
+            {
+                Client.ChangeUserMods(new Mod[]
+                {
+                    new OsuModNoFail(),
+                    new OsuModDoubleTime()
+                });
+            });
+
+            AddStep("add user with mods", () =>
+            {
+                Client.AddUser(new User
+                {
+                    Id = 0,
+                    Username = "Baka",
+                    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.ChangeUserMods(0, new Mod[]
+                {
+                    new OsuModHardRock(),
+                    new OsuModDoubleTime()
+                });
+            });
+
+            AddStep("set 0 ready", () => Client.ChangeState(MultiplayerUserState.Ready));
+
+            AddStep("set 1 spectate", () => Client.ChangeUserState(0, MultiplayerUserState.Spectating));
+
+            // Have to set back to idle due to status priority.
+            AddStep("set 0 no map, 1 ready", () =>
+            {
+                Client.ChangeState(MultiplayerUserState.Idle);
+                Client.ChangeBeatmapAvailability(BeatmapAvailability.NotDownloaded());
+                Client.ChangeUserState(0, MultiplayerUserState.Ready);
+            });
+
+            AddStep("set 0 downloading", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(0)));
+
+            AddStep("set 0 spectate", () => Client.ChangeUserState(0, MultiplayerUserState.Spectating));
+
+            AddStep("make both default", () =>
+            {
+                Client.ChangeBeatmapAvailability(BeatmapAvailability.LocallyAvailable());
+                Client.ChangeUserState(0, MultiplayerUserState.Idle);
+                Client.ChangeState(MultiplayerUserState.Idle);
+            });
         }
 
         private void createNewParticipantsList()

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

@@ -4,7 +4,7 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Database;
+using osu.Game.Overlays.Notifications;
 using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Visual.Navigation
@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestImportCreatedNotification()
         {
-            AddUntilStep("Import notification was presented", () => Game.Notifications.ChildrenOfType<ImportProgressNotification>().Count() == 1);
+            AddUntilStep("Import notification was presented", () => Game.Notifications.ChildrenOfType<ProgressCompletionNotification>().Count() == 1);
         }
     }
 }

osu.Game.Tests/Visual/Settings/TestSceneRestoreDefaultValueButton.cs

@@ -0,0 +1,63 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Overlays;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Settings
+{
+    public class TestSceneRestoreDefaultValueButton : OsuTestScene
+    {
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        private float scale = 1;
+
+        private readonly Bindable<float> current = new Bindable<float>
+        {
+            Default = default,
+            Value = 1,
+        };
+
+        [Test]
+        public void TestBasic()
+        {
+            RestoreDefaultValueButton<float> restoreDefaultValueButton = null;
+
+            AddStep("create button", () => Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colours.GreySeafoam
+                    },
+                    restoreDefaultValueButton = new RestoreDefaultValueButton<float>
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Scale = new Vector2(scale),
+                        Current = current,
+                    }
+                }
+            });
+            AddSliderStep("set scale", 1, 4, 1, scale =>
+            {
+                this.scale = scale;
+                if (restoreDefaultValueButton != null)
+                    restoreDefaultValueButton.Scale = new Vector2(scale);
+            });
+            AddToggleStep("toggle default state", state => current.Value = state ? default : 1);
+            AddToggleStep("toggle disabled state", state => current.Disabled = state);
+        }
+    }
+}

osu.Game.Tests/Visual/Settings/TestSceneSettingsItem.cs

@@ -5,6 +5,9 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Bindables;
 using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
 using osu.Game.Overlays;
 
@@ -29,9 +32,10 @@ namespace osu.Game.Tests.Visual.Settings
                         Value = "test"
                     }
                 };
-
-                restoreDefaultValueButton = textBox.ChildrenOfType<RestoreDefaultValueButton<string>>().Single();
             });
+            AddUntilStep("wait for loaded", () => textBox.IsLoaded);
+            AddStep("retrieve restore default button", () => restoreDefaultValueButton = textBox.ChildrenOfType<RestoreDefaultValueButton<string>>().Single());
+
             AddAssert("restore button hidden", () => restoreDefaultValueButton.Alpha == 0);
 
             AddStep("change value from default", () => textBox.Current.Value = "non-default");
@@ -41,6 +45,48 @@ namespace osu.Game.Tests.Visual.Settings
             AddUntilStep("restore button hidden", () => restoreDefaultValueButton.Alpha == 0);
         }
 
+        [Test]
+        public void TestSetAndClearLabelText()
+        {
+            SettingsTextBox textBox = null;
+            RestoreDefaultValueButton<string> restoreDefaultValueButton = null;
+            OsuTextBox control = null;
+
+            AddStep("create settings item", () =>
+            {
+                Child = textBox = new SettingsTextBox
+                {
+                    Current = new Bindable<string>
+                    {
+                        Default = "test",
+                        Value = "test"
+                    }
+                };
+            });
+            AddUntilStep("wait for loaded", () => textBox.IsLoaded);
+            AddStep("retrieve components", () =>
+            {
+                restoreDefaultValueButton = textBox.ChildrenOfType<RestoreDefaultValueButton<string>>().Single();
+                control = textBox.ChildrenOfType<OsuTextBox>().Single();
+            });
+
+            AddStep("set non-default value", () => restoreDefaultValueButton.Current.Value = "non-default");
+            AddAssert("default value button centre aligned to control size", () => Precision.AlmostEquals(restoreDefaultValueButton.Parent.DrawHeight, control.DrawHeight, 1));
+
+            AddStep("set label", () => textBox.LabelText = "label text");
+            AddAssert("default value button centre aligned to label size", () =>
+            {
+                var label = textBox.ChildrenOfType<OsuSpriteText>().Single(spriteText => spriteText.Text == "label text");
+                return Precision.AlmostEquals(restoreDefaultValueButton.Parent.DrawHeight, label.DrawHeight, 1);
+            });
+
+            AddStep("clear label", () => textBox.LabelText = default);
+            AddAssert("default value button centre aligned to control size", () => Precision.AlmostEquals(restoreDefaultValueButton.Parent.DrawHeight, control.DrawHeight, 1));
+
+            AddStep("set warning text", () => textBox.WarningText = "This is some very important warning text! Hopefully it doesn't break the alignment of the default value indicator...");
+            AddAssert("default value button centre aligned to control size", () => Precision.AlmostEquals(restoreDefaultValueButton.Parent.DrawHeight, control.DrawHeight, 1));
+        }
+
         /// <summary>
         /// Ensures that the reset to default button uses the correct implementation of IsDefault to determine whether it should be shown or not.
         /// Values have been chosen so that after being set, Value != Default (but they are close enough that the difference is negligible compared to Precision).
@@ -64,9 +110,9 @@ namespace osu.Game.Tests.Visual.Settings
                         Precision = 0.1f,
                     }
                 };
-
-                restoreDefaultValueButton = sliderBar.ChildrenOfType<RestoreDefaultValueButton<float>>().Single();
             });
+            AddUntilStep("wait for loaded", () => sliderBar.IsLoaded);
+            AddStep("retrieve restore default button", () => restoreDefaultValueButton = sliderBar.ChildrenOfType<RestoreDefaultValueButton<float>>().Single());
 
             AddAssert("restore button hidden", () => restoreDefaultValueButton.Alpha == 0);
 

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

@@ -1,11 +1,15 @@
 // 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 NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
@@ -19,28 +23,62 @@ namespace osu.Game.Tests.Visual.UserInterface
         {
             AddStep("create component", () =>
             {
-                LabelledSliderBar<double> component;
+                FillFlowContainer flow;
 
-                Child = new Container
+                Child = flow = new FillFlowContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Width = 500,
                     AutoSizeAxes = Axes.Y,
-                    Child = component = new LabelledSliderBar<double>
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
                     {
-                        Current = new BindableDouble(5)
+                        new LabelledSliderBar<double>
                         {
-                            MinValue = 0,
-                            MaxValue = 10,
-                            Precision = 1,
-                        }
-                    }
+                            Current = new BindableDouble(5)
+                            {
+                                MinValue = 0,
+                                MaxValue = 10,
+                                Precision = 1,
+                            },
+                            Label = "a sample component",
+                            Description = hasDescription ? "this text describes the component" : string.Empty,
+                        },
+                    },
                 };
 
-                component.Label = "a sample component";
-                component.Description = hasDescription ? "this text describes the component" : string.Empty;
+                foreach (var colour in Enum.GetValues(typeof(OverlayColourScheme)).OfType<OverlayColourScheme>())
+                {
+                    flow.Add(new OverlayColourContainer(colour)
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Child = new LabelledSliderBar<double>
+                        {
+                            Current = new BindableDouble(5)
+                            {
+                                MinValue = 0,
+                                MaxValue = 10,
+                                Precision = 1,
+                            },
+                            Label = "a sample component",
+                            Description = hasDescription ? "this text describes the component" : string.Empty,
+                        }
+                    });
+                }
             });
         }
+
+        private class OverlayColourContainer : Container
+        {
+            [Cached]
+            private OverlayColourProvider colourProvider;
+
+            public OverlayColourContainer(OverlayColourScheme scheme)
+            {
+                colourProvider = new OverlayColourProvider(scheme);
+            }
+        }
     }
 }

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

@@ -0,0 +1,20 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneOsuDropdown : ThemeComparisonTestScene
+    {
+        protected override Drawable CreateContent() =>
+            new OsuEnumDropdown<BeatmapSetOnlineStatus>
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Width = 150
+            };
+    }
+}

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

@@ -0,0 +1,68 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Settings;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneSettingsCheckbox : OsuTestScene
+    {
+        [TestCase]
+        public void TestCheckbox()
+        {
+            AddStep("create component", () =>
+            {
+                FillFlowContainer flow;
+
+                Child = flow = new FillFlowContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Width = 500,
+                    AutoSizeAxes = Axes.Y,
+                    Spacing = new Vector2(5),
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        new SettingsCheckbox
+                        {
+                            LabelText = "a sample component",
+                        },
+                    },
+                };
+
+                foreach (var colour1 in Enum.GetValues(typeof(OverlayColourScheme)).OfType<OverlayColourScheme>())
+                {
+                    flow.Add(new OverlayColourContainer(colour1)
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Child = new SettingsCheckbox
+                        {
+                            LabelText = "a sample component",
+                        }
+                    });
+                }
+            });
+        }
+
+        private class OverlayColourContainer : Container
+        {
+            [Cached]
+            private OverlayColourProvider colourProvider;
+
+            public OverlayColourContainer(OverlayColourScheme scheme)
+            {
+                colourProvider = new OverlayColourProvider(scheme);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Overlays;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public abstract class ThemeComparisonTestScene : OsuGridTestScene
+    {
+        protected ThemeComparisonTestScene()
+            : base(1, 2)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Cell(0, 0).AddRange(new[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colours.GreySeafoam
+                },
+                CreateContent()
+            });
+        }
+
+        private void createThemedContent(OverlayColourScheme colourScheme)
+        {
+            var colourProvider = new OverlayColourProvider(colourScheme);
+
+            Cell(0, 1).Clear();
+            Cell(0, 1).Add(new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies = new (Type, object)[]
+                {
+                    (typeof(OverlayColourProvider), colourProvider)
+                },
+                Children = new[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colourProvider.Background4
+                    },
+                    CreateContent()
+                }
+            });
+        }
+
+        protected abstract Drawable CreateContent();
+
+        [Test]
+        public void TestAllColourSchemes()
+        {
+            foreach (var scheme in Enum.GetValues(typeof(OverlayColourScheme)).Cast<OverlayColourScheme>())
+                AddStep($"set {scheme} scheme", () => createThemedContent(scheme));
+        }
+    }
+}

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -178,7 +178,7 @@ namespace osu.Game.Beatmaps
 
         #region Implementation of IHasOnlineID
 
-        public int? OnlineID => OnlineBeatmapID;
+        public int OnlineID => OnlineBeatmapID ?? -1;
 
         #endregion
 

osu.Game/Beatmaps/BeatmapManager.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Beatmaps
     /// Handles general operations related to global beatmap management.
     /// </summary>
     [ExcludeFromDynamicCompile]
-    public class BeatmapManager : IModelDownloader<BeatmapSetInfo>, IModelManager<BeatmapSetInfo>, IModelFileManager<BeatmapSetInfo, BeatmapSetFileInfo>, ICanAcceptFiles, IWorkingBeatmapCache, IDisposable
+    public class BeatmapManager : IModelDownloader<BeatmapSetInfo>, IModelManager<BeatmapSetInfo>, IModelFileManager<BeatmapSetInfo, BeatmapSetFileInfo>, IWorkingBeatmapCache, IDisposable
     {
         private readonly BeatmapModelManager beatmapModelManager;
         private readonly BeatmapModelDownloader beatmapModelDownloader;
@@ -176,11 +176,6 @@ namespace osu.Game.Beatmaps
             }
         }
 
-        /// <summary>
-        /// Fired when the user requests to view the resulting import.
-        /// </summary>
-        public Action<IEnumerable<ILive<BeatmapSetInfo>>> PresentImport { set => beatmapModelManager.PostImport = value; }
-
         /// <summary>
         /// Delete a beatmap difficulty.
         /// </summary>
@@ -338,5 +333,14 @@ namespace osu.Game.Beatmaps
         }
 
         #endregion
+
+        #region Implementation of IPostImports<out BeatmapSetInfo>
+
+        public Action<IEnumerable<ILive<BeatmapSetInfo>>> PostImport
+        {
+            set => beatmapModelManager.PostImport = value;
+        }
+
+        #endregion
     }
 }

osu.Game/Beatmaps/BeatmapModelManager.cs

@@ -123,15 +123,15 @@ namespace osu.Game.Beatmaps
             // check if a set already exists with the same online id, delete if it does.
             if (beatmapSet.OnlineBeatmapSetID != null)
             {
-                var existingOnlineId = beatmaps.ConsumableItems.FirstOrDefault(b => b.OnlineBeatmapSetID == beatmapSet.OnlineBeatmapSetID);
+                var existingSetWithSameOnlineID = beatmaps.ConsumableItems.FirstOrDefault(b => b.OnlineBeatmapSetID == beatmapSet.OnlineBeatmapSetID);
 
-                if (existingOnlineId != null)
+                if (existingSetWithSameOnlineID != null)
                 {
-                    Delete(existingOnlineId);
+                    Delete(existingSetWithSameOnlineID);
 
                     // in order to avoid a unique key constraint, immediately remove the online ID from the previous set.
-                    existingOnlineId.OnlineBeatmapSetID = null;
-                    foreach (var b in existingOnlineId.Beatmaps)
+                    existingSetWithSameOnlineID.OnlineBeatmapSetID = null;
+                    foreach (var b in existingSetWithSameOnlineID.Beatmaps)
                         b.OnlineBeatmapID = null;
 
                     LogForModel(beatmapSet, $"Found existing beatmap set with same OnlineBeatmapSetID ({beatmapSet.OnlineBeatmapSetID}). It has been deleted.");
@@ -192,6 +192,13 @@ namespace osu.Game.Beatmaps
         {
             var setInfo = beatmapInfo.BeatmapSet;
 
+            // Difficulty settings must be copied first due to the clone in `Beatmap<>.BeatmapInfo_Set`.
+            // This should hopefully be temporary, assuming said clone is eventually removed.
+            beatmapInfo.BaseDifficulty.CopyFrom(beatmapContent.Difficulty);
+
+            // All changes to metadata are made in the provided beatmapInfo, so this should be copied to the `IBeatmap` before encoding.
+            beatmapContent.BeatmapInfo = beatmapInfo;
+
             using (var stream = new MemoryStream())
             {
                 using (var sw = new StreamWriter(stream, Encoding.UTF8, 1024, true))
@@ -202,7 +209,6 @@ namespace osu.Game.Beatmaps
                 using (ContextFactory.GetForWrite())
                 {
                     beatmapInfo = setInfo.Beatmaps.Single(b => b.ID == beatmapInfo.ID);
-                    beatmapInfo.BaseDifficulty.CopyFrom(beatmapContent.Difficulty);
 
                     var metadata = beatmapInfo.Metadata ?? setInfo.Metadata;
 

osu.Game/Beatmaps/BeatmapSetInfo.cs

@@ -91,7 +91,7 @@ namespace osu.Game.Beatmaps
 
         #region Implementation of IHasOnlineID
 
-        public int? OnlineID => OnlineBeatmapSetID;
+        public int OnlineID => OnlineBeatmapSetID ?? -1;
 
         #endregion
 

osu.Game/Beatmaps/ControlPoints/ControlPoint.cs

@@ -15,11 +15,9 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// The time at which the control point takes effect.
         /// </summary>
         [JsonIgnore]
-        public double Time => controlPointGroup?.Time ?? 0;
+        public double Time { get; set; }
 
-        private ControlPointGroup controlPointGroup;
-
-        public void AttachGroup(ControlPointGroup pointGroup) => controlPointGroup = pointGroup;
+        public void AttachGroup(ControlPointGroup pointGroup) => Time = pointGroup.Time;
 
         public int CompareTo(ControlPoint other) => Time.CompareTo(other.Time);
 
@@ -46,6 +44,7 @@ namespace osu.Game.Beatmaps.ControlPoints
 
         public virtual void CopyFrom(ControlPoint other)
         {
+            Time = other.Time;
         }
     }
 }

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -33,14 +33,6 @@ namespace osu.Game.Beatmaps.ControlPoints
 
         private readonly SortedList<TimingControlPoint> timingPoints = new SortedList<TimingControlPoint>(Comparer<TimingControlPoint>.Default);
 
-        /// <summary>
-        /// All difficulty points.
-        /// </summary>
-        [JsonProperty]
-        public IReadOnlyList<DifficultyControlPoint> DifficultyPoints => difficultyPoints;
-
-        private readonly SortedList<DifficultyControlPoint> difficultyPoints = new SortedList<DifficultyControlPoint>(Comparer<DifficultyControlPoint>.Default);
-
         /// <summary>
         /// All effect points.
         /// </summary>
@@ -55,14 +47,6 @@ namespace osu.Game.Beatmaps.ControlPoints
         [JsonIgnore]
         public IEnumerable<ControlPoint> AllControlPoints => Groups.SelectMany(g => g.ControlPoints).ToArray();
 
-        /// <summary>
-        /// Finds the difficulty control point that is active at <paramref name="time"/>.
-        /// </summary>
-        /// <param name="time">The time to find the difficulty control point at.</param>
-        /// <returns>The difficulty control point.</returns>
-        [NotNull]
-        public DifficultyControlPoint DifficultyPointAt(double time) => BinarySearchWithFallback(DifficultyPoints, time, DifficultyControlPoint.DEFAULT);
-
         /// <summary>
         /// Finds the effect control point that is active at <paramref name="time"/>.
         /// </summary>
@@ -100,7 +84,6 @@ namespace osu.Game.Beatmaps.ControlPoints
         {
             groups.Clear();
             timingPoints.Clear();
-            difficultyPoints.Clear();
             effectPoints.Clear();
         }
 
@@ -277,10 +260,6 @@ namespace osu.Game.Beatmaps.ControlPoints
                 case EffectControlPoint _:
                     existing = EffectPointAt(time);
                     break;
-
-                case DifficultyControlPoint _:
-                    existing = DifficultyPointAt(time);
-                    break;
             }
 
             return newPoint?.IsRedundant(existing) == true;
@@ -298,9 +277,8 @@ namespace osu.Game.Beatmaps.ControlPoints
                     effectPoints.Add(typed);
                     break;
 
-                case DifficultyControlPoint typed:
-                    difficultyPoints.Add(typed);
-                    break;
+                default:
+                    throw new ArgumentException($"A control point of unexpected type {controlPoint.GetType()} was added to this {nameof(ControlPointInfo)}");
             }
         }
 
@@ -315,10 +293,6 @@ namespace osu.Game.Beatmaps.ControlPoints
                 case EffectControlPoint typed:
                     effectPoints.Remove(typed);
                     break;
-
-                case DifficultyControlPoint typed:
-                    difficultyPoints.Remove(typed);
-                    break;
             }
         }
 

osu.Game/Beatmaps/ControlPoints/DifficultyControlPoint.cs

@@ -7,17 +7,20 @@ using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
+    /// <remarks>
+    /// Note that going forward, this control point type should always be assigned directly to HitObjects.
+    /// </remarks>
     public class DifficultyControlPoint : ControlPoint
     {
         public static readonly DifficultyControlPoint DEFAULT = new DifficultyControlPoint
         {
-            SpeedMultiplierBindable = { Disabled = true },
+            SliderVelocityBindable = { Disabled = true },
         };
 
         /// <summary>
-        /// The speed multiplier at this control point.
+        /// The slider velocity at this control point.
         /// </summary>
-        public readonly BindableDouble SpeedMultiplierBindable = new BindableDouble(1)
+        public readonly BindableDouble SliderVelocityBindable = new BindableDouble(1)
         {
             Precision = 0.01,
             Default = 1,
@@ -28,21 +31,21 @@ namespace osu.Game.Beatmaps.ControlPoints
         public override Color4 GetRepresentingColour(OsuColour colours) => colours.Lime1;
 
         /// <summary>
-        /// The speed multiplier at this control point.
+        /// The slider velocity at this control point.
         /// </summary>
-        public double SpeedMultiplier
+        public double SliderVelocity
         {
-            get => SpeedMultiplierBindable.Value;
-            set => SpeedMultiplierBindable.Value = value;
+            get => SliderVelocityBindable.Value;
+            set => SliderVelocityBindable.Value = value;
         }
 
         public override bool IsRedundant(ControlPoint existing)
             => existing is DifficultyControlPoint existingDifficulty
-               && SpeedMultiplier == existingDifficulty.SpeedMultiplier;
+               && SliderVelocity == existingDifficulty.SliderVelocity;
 
         public override void CopyFrom(ControlPoint other)
         {
-            SpeedMultiplier = ((DifficultyControlPoint)other).SpeedMultiplier;
+            SliderVelocity = ((DifficultyControlPoint)other).SliderVelocity;
 
             base.CopyFrom(other);
         }

osu.Game/Beatmaps/ControlPoints/EffectControlPoint.cs

@@ -12,7 +12,8 @@ namespace osu.Game.Beatmaps.ControlPoints
         public static readonly EffectControlPoint DEFAULT = new EffectControlPoint
         {
             KiaiModeBindable = { Disabled = true },
-            OmitFirstBarLineBindable = { Disabled = true }
+            OmitFirstBarLineBindable = { Disabled = true },
+            ScrollSpeedBindable = { Disabled = true }
         };
 
         /// <summary>
@@ -20,6 +21,26 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         public readonly BindableBool OmitFirstBarLineBindable = new BindableBool();
 
+        /// <summary>
+        /// The relative scroll speed at this control point.
+        /// </summary>
+        public readonly BindableDouble ScrollSpeedBindable = new BindableDouble(1)
+        {
+            Precision = 0.01,
+            Default = 1,
+            MinValue = 0.01,
+            MaxValue = 10
+        };
+
+        /// <summary>
+        /// The relative scroll speed.
+        /// </summary>
+        public double ScrollSpeed
+        {
+            get => ScrollSpeedBindable.Value;
+            set => ScrollSpeedBindable.Value = value;
+        }
+
         public override Color4 GetRepresentingColour(OsuColour colours) => colours.Purple;
 
         /// <summary>
@@ -49,12 +70,14 @@ namespace osu.Game.Beatmaps.ControlPoints
             => !OmitFirstBarLine
                && existing is EffectControlPoint existingEffect
                && KiaiMode == existingEffect.KiaiMode
-               && OmitFirstBarLine == existingEffect.OmitFirstBarLine;
+               && OmitFirstBarLine == existingEffect.OmitFirstBarLine
+               && ScrollSpeed == existingEffect.ScrollSpeed;
 
         public override void CopyFrom(ControlPoint other)
         {
             KiaiMode = ((EffectControlPoint)other).KiaiMode;
             OmitFirstBarLine = ((EffectControlPoint)other).OmitFirstBarLine;
+            ScrollSpeed = ((EffectControlPoint)other).ScrollSpeed;
 
             base.CopyFrom(other);
         }

osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs

@@ -8,6 +8,9 @@ using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
+    /// <remarks>
+    /// Note that going forward, this control point type should always be assigned directly to HitObjects.
+    /// </remarks>
     public class SampleControlPoint : ControlPoint
     {
         public const string DEFAULT_BANK = "normal";

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -384,14 +384,21 @@ namespace osu.Game.Beatmaps.Formats
             addControlPoint(time, new LegacyDifficultyControlPoint(beatLength)
 #pragma warning restore 618
             {
-                SpeedMultiplier = speedMultiplier,
+                SliderVelocity = speedMultiplier,
             }, timingChange);
 
-            addControlPoint(time, new EffectControlPoint
+            var effectPoint = new EffectControlPoint
             {
                 KiaiMode = kiaiMode,
                 OmitFirstBarLine = omitFirstBarSignature,
-            }, timingChange);
+            };
+
+            bool isOsuRuleset = beatmap.BeatmapInfo.RulesetID == 0;
+            // scrolling rulesets use effect points rather than difficulty points for scroll speed adjustments.
+            if (!isOsuRuleset)
+                effectPoint.ScrollSpeed = speedMultiplier;
+
+            addControlPoint(time, effectPoint, timingChange);
 
             addControlPoint(time, new LegacySampleControlPoint
             {

osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs

@@ -170,33 +170,30 @@ namespace osu.Game.Beatmaps.Formats
             if (beatmap.ControlPointInfo.Groups.Count == 0)
                 return;
 
+            var legacyControlPoints = new LegacyControlPointInfo();
+            foreach (var point in beatmap.ControlPointInfo.AllControlPoints)
+                legacyControlPoints.Add(point.Time, point.DeepClone());
+
             writer.WriteLine("[TimingPoints]");
 
-            if (!(beatmap.ControlPointInfo is LegacyControlPointInfo))
+            SampleControlPoint lastRelevantSamplePoint = null;
+            DifficultyControlPoint lastRelevantDifficultyPoint = null;
+
+            bool isOsuRuleset = beatmap.BeatmapInfo.RulesetID == 0;
+
+            // iterate over hitobjects and pull out all required sample and difficulty changes
+            extractDifficultyControlPoints(beatmap.HitObjects);
+            extractSampleControlPoints(beatmap.HitObjects);
+
+            // handle scroll speed, which is stored as "slider velocity" in legacy formats.
+            // this is relevant for scrolling ruleset beatmaps.
+            if (!isOsuRuleset)
             {
-                var legacyControlPoints = new LegacyControlPointInfo();
-
-                foreach (var point in beatmap.ControlPointInfo.AllControlPoints)
-                    legacyControlPoints.Add(point.Time, point.DeepClone());
-
-                beatmap.ControlPointInfo = legacyControlPoints;
-
-                SampleControlPoint lastRelevantSamplePoint = null;
-
-                // iterate over hitobjects and pull out all required sample changes
-                foreach (var h in beatmap.HitObjects)
-                {
-                    var hSamplePoint = h.SampleControlPoint;
-
-                    if (!hSamplePoint.IsRedundant(lastRelevantSamplePoint))
-                    {
-                        legacyControlPoints.Add(hSamplePoint.Time, hSamplePoint);
-                        lastRelevantSamplePoint = hSamplePoint;
-                    }
-                }
+                foreach (var point in legacyControlPoints.EffectPoints)
+                    legacyControlPoints.Add(point.Time, new DifficultyControlPoint { SliderVelocity = point.ScrollSpeed });
             }
 
-            foreach (var group in beatmap.ControlPointInfo.Groups)
+            foreach (var group in legacyControlPoints.Groups)
             {
                 var groupTimingPoint = group.ControlPoints.OfType<TimingControlPoint>().FirstOrDefault();
 
@@ -209,16 +206,16 @@ namespace osu.Game.Beatmaps.Formats
                 }
 
                 // Output any remaining effects as secondary non-timing control point.
-                var difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(group.Time);
+                var difficultyPoint = legacyControlPoints.DifficultyPointAt(group.Time);
                 writer.Write(FormattableString.Invariant($"{group.Time},"));
-                writer.Write(FormattableString.Invariant($"{-100 / difficultyPoint.SpeedMultiplier},"));
+                writer.Write(FormattableString.Invariant($"{-100 / difficultyPoint.SliderVelocity},"));
                 outputControlPointAt(group.Time, false);
             }
 
             void outputControlPointAt(double time, bool isTimingPoint)
             {
-                var samplePoint = ((LegacyControlPointInfo)beatmap.ControlPointInfo).SamplePointAt(time);
-                var effectPoint = beatmap.ControlPointInfo.EffectPointAt(time);
+                var samplePoint = legacyControlPoints.SamplePointAt(time);
+                var effectPoint = legacyControlPoints.EffectPointAt(time);
 
                 // Apply the control point to a hit sample to uncover legacy properties (e.g. suffix)
                 HitSampleInfo tempHitSample = samplePoint.ApplyTo(new ConvertHitObjectParser.LegacyHitSampleInfo(string.Empty));
@@ -230,7 +227,7 @@ namespace osu.Game.Beatmaps.Formats
                 if (effectPoint.OmitFirstBarLine)
                     effectFlags |= LegacyEffectFlags.OmitFirstBarLine;
 
-                writer.Write(FormattableString.Invariant($"{(int)beatmap.ControlPointInfo.TimingPointAt(time).TimeSignature},"));
+                writer.Write(FormattableString.Invariant($"{(int)legacyControlPoints.TimingPointAt(time).TimeSignature},"));
                 writer.Write(FormattableString.Invariant($"{(int)toLegacySampleBank(tempHitSample.Bank)},"));
                 writer.Write(FormattableString.Invariant($"{toLegacyCustomSampleBank(tempHitSample)},"));
                 writer.Write(FormattableString.Invariant($"{tempHitSample.Volume},"));
@@ -238,6 +235,55 @@ namespace osu.Game.Beatmaps.Formats
                 writer.Write(FormattableString.Invariant($"{(int)effectFlags}"));
                 writer.WriteLine();
             }
+
+            IEnumerable<DifficultyControlPoint> collectDifficultyControlPoints(IEnumerable<HitObject> hitObjects)
+            {
+                if (!isOsuRuleset)
+                    yield break;
+
+                foreach (var hitObject in hitObjects)
+                {
+                    yield return hitObject.DifficultyControlPoint;
+
+                    foreach (var nested in collectDifficultyControlPoints(hitObject.NestedHitObjects))
+                        yield return nested;
+                }
+            }
+
+            void extractDifficultyControlPoints(IEnumerable<HitObject> hitObjects)
+            {
+                foreach (var hDifficultyPoint in collectDifficultyControlPoints(hitObjects).OrderBy(dp => dp.Time))
+                {
+                    if (!hDifficultyPoint.IsRedundant(lastRelevantDifficultyPoint))
+                    {
+                        legacyControlPoints.Add(hDifficultyPoint.Time, hDifficultyPoint);
+                        lastRelevantDifficultyPoint = hDifficultyPoint;
+                    }
+                }
+            }
+
+            IEnumerable<SampleControlPoint> collectSampleControlPoints(IEnumerable<HitObject> hitObjects)
+            {
+                foreach (var hitObject in hitObjects)
+                {
+                    yield return hitObject.SampleControlPoint;
+
+                    foreach (var nested in collectSampleControlPoints(hitObject.NestedHitObjects))
+                        yield return nested;
+                }
+            }
+
+            void extractSampleControlPoints(IEnumerable<HitObject> hitObject)
+            {
+                foreach (var hSamplePoint in collectSampleControlPoints(hitObject).OrderBy(sp => sp.Time))
+                {
+                    if (!hSamplePoint.IsRedundant(lastRelevantSamplePoint))
+                    {
+                        legacyControlPoints.Add(hSamplePoint.Time, hSamplePoint);
+                        lastRelevantSamplePoint = hSamplePoint;
+                    }
+                }
+            }
         }
 
         private void handleColours(TextWriter writer)

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -181,7 +181,7 @@ namespace osu.Game.Beatmaps.Formats
 
             public LegacyDifficultyControlPoint()
             {
-                SpeedMultiplierBindable.Precision = double.Epsilon;
+                SliderVelocityBindable.Precision = double.Epsilon;
             }
 
             public override void CopyFrom(ControlPoint other)

osu.Game/Beatmaps/Legacy/LegacyControlPointInfo.cs

@@ -1,9 +1,10 @@
 // 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 JetBrains.Annotations;
 using Newtonsoft.Json;
-using osu.Framework.Bindables;
+using osu.Framework.Lists;
 using osu.Game.Beatmaps.ControlPoints;
 
 namespace osu.Game.Beatmaps.Legacy
@@ -14,9 +15,9 @@ namespace osu.Game.Beatmaps.Legacy
         /// All sound points.
         /// </summary>
         [JsonProperty]
-        public IBindableList<SampleControlPoint> SamplePoints => samplePoints;
+        public IReadOnlyList<SampleControlPoint> SamplePoints => samplePoints;
 
-        private readonly BindableList<SampleControlPoint> samplePoints = new BindableList<SampleControlPoint>();
+        private readonly SortedList<SampleControlPoint> samplePoints = new SortedList<SampleControlPoint>(Comparer<SampleControlPoint>.Default);
 
         /// <summary>
         /// Finds the sound control point that is active at <paramref name="time"/>.
@@ -26,35 +27,76 @@ namespace osu.Game.Beatmaps.Legacy
         [NotNull]
         public SampleControlPoint SamplePointAt(double time) => BinarySearchWithFallback(SamplePoints, time, SamplePoints.Count > 0 ? SamplePoints[0] : SampleControlPoint.DEFAULT);
 
+        /// <summary>
+        /// All difficulty points.
+        /// </summary>
+        [JsonProperty]
+        public IReadOnlyList<DifficultyControlPoint> DifficultyPoints => difficultyPoints;
+
+        private readonly SortedList<DifficultyControlPoint> difficultyPoints = new SortedList<DifficultyControlPoint>(Comparer<DifficultyControlPoint>.Default);
+
+        /// <summary>
+        /// Finds the difficulty control point that is active at <paramref name="time"/>.
+        /// </summary>
+        /// <param name="time">The time to find the difficulty control point at.</param>
+        /// <returns>The difficulty control point.</returns>
+        [NotNull]
+        public DifficultyControlPoint DifficultyPointAt(double time) => BinarySearchWithFallback(DifficultyPoints, time, DifficultyControlPoint.DEFAULT);
+
         public override void Clear()
         {
             base.Clear();
             samplePoints.Clear();
+            difficultyPoints.Clear();
         }
 
         protected override bool CheckAlreadyExisting(double time, ControlPoint newPoint)
         {
-            if (newPoint is SampleControlPoint)
+            switch (newPoint)
             {
-                var existing = BinarySearch(SamplePoints, time);
-                return newPoint.IsRedundant(existing);
-            }
+                case SampleControlPoint _:
+                    // intentionally don't use SamplePointAt (we always need to consider the first sample point).
+                    var existing = BinarySearch(SamplePoints, time);
+                    return newPoint.IsRedundant(existing);
 
-            return base.CheckAlreadyExisting(time, newPoint);
+                case DifficultyControlPoint _:
+                    return newPoint.IsRedundant(DifficultyPointAt(time));
+
+                default:
+                    return base.CheckAlreadyExisting(time, newPoint);
+            }
         }
 
         protected override void GroupItemAdded(ControlPoint controlPoint)
         {
-            if (controlPoint is SampleControlPoint typed)
-                samplePoints.Add(typed);
+            switch (controlPoint)
+            {
+                case SampleControlPoint typed:
+                    samplePoints.Add(typed);
+                    return;
 
-            base.GroupItemAdded(controlPoint);
+                case DifficultyControlPoint typed:
+                    difficultyPoints.Add(typed);
+                    return;
+
+                default:
+                    base.GroupItemAdded(controlPoint);
+                    break;
+            }
         }
 
         protected override void GroupItemRemoved(ControlPoint controlPoint)
         {
-            if (controlPoint is SampleControlPoint typed)
-                samplePoints.Remove(typed);
+            switch (controlPoint)
+            {
+                case SampleControlPoint typed:
+                    samplePoints.Remove(typed);
+                    break;
+
+                case DifficultyControlPoint typed:
+                    difficultyPoints.Remove(typed);
+                    break;
+            }
 
             base.GroupItemRemoved(controlPoint);
         }

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -189,11 +189,14 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public void CancelAsyncLoad()
         {
-            loadCancellation?.Cancel();
-            loadCancellation = new CancellationTokenSource();
+            lock (beatmapFetchLock)
+            {
+                loadCancellation?.Cancel();
+                loadCancellation = new CancellationTokenSource();
 
-            if (beatmapLoadTask?.IsCompleted != true)
-                beatmapLoadTask = null;
+                if (beatmapLoadTask?.IsCompleted != true)
+                    beatmapLoadTask = null;
+            }
         }
 
         private CancellationTokenSource createCancellationTokenSource(TimeSpan? timeout)
@@ -205,19 +208,27 @@ namespace osu.Game.Beatmaps
             return new CancellationTokenSource(timeout ?? TimeSpan.FromSeconds(10));
         }
 
-        private Task<IBeatmap> loadBeatmapAsync() => beatmapLoadTask ??= Task.Factory.StartNew(() =>
+        private readonly object beatmapFetchLock = new object();
+
+        private Task<IBeatmap> loadBeatmapAsync()
         {
-            // Todo: Handle cancellation during beatmap parsing
-            var b = GetBeatmap() ?? new Beatmap();
+            lock (beatmapFetchLock)
+            {
+                return beatmapLoadTask ??= Task.Factory.StartNew(() =>
+                {
+                    // Todo: Handle cancellation during beatmap parsing
+                    var b = GetBeatmap() ?? new Beatmap();
 
-            // The original beatmap version needs to be preserved as the database doesn't contain it
-            BeatmapInfo.BeatmapVersion = b.BeatmapInfo.BeatmapVersion;
+                    // The original beatmap version needs to be preserved as the database doesn't contain it
+                    BeatmapInfo.BeatmapVersion = b.BeatmapInfo.BeatmapVersion;
 
-            // Use the database-backed info for more up-to-date values (beatmap id, ranked status, etc)
-            b.BeatmapInfo = BeatmapInfo;
+                    // Use the database-backed info for more up-to-date values (beatmap id, ranked status, etc)
+                    b.BeatmapInfo = BeatmapInfo;
 
-            return b;
-        }, loadCancellation.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+                    return b;
+                }, loadCancellation.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+            }
+        }
 
         public override string ToString() => BeatmapInfo.ToString();
 

osu.Game/Beatmaps/WorkingBeatmapCache.cs

@@ -66,8 +66,12 @@ namespace osu.Game.Beatmaps
             lock (workingCache)
             {
                 var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == info.ID);
+
                 if (working != null)
+                {
+                    Logger.Log($"Invalidating working beatmap cache for {info}");
                     workingCache.Remove(working);
+                }
             }
         }
 
@@ -86,6 +90,7 @@ namespace osu.Game.Beatmaps
             lock (workingCache)
             {
                 var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == beatmapInfo.ID);
+
                 if (working != null)
                     return working;
 

osu.Game/Collections/CollectionFilterDropdown.cs

@@ -181,7 +181,11 @@ namespace osu.Game.Collections
                 MaxHeight = 200;
             }
 
-            protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new CollectionDropdownMenuItem(item);
+            protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new CollectionDropdownMenuItem(item)
+            {
+                BackgroundColourHover = HoverColour,
+                BackgroundColourSelected = SelectionColour
+            };
         }
 
         protected class CollectionDropdownMenuItem : OsuDropdownMenu.DrawableOsuDropdownMenuItem

osu.Game/Configuration/OsuConfigManager.cs

@@ -6,10 +6,13 @@ using System.Diagnostics;
 using osu.Framework.Configuration;
 using osu.Framework.Configuration.Tracking;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Localisation;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Input;
 using osu.Game.Input.Bindings;
+using osu.Game.Localisation;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
@@ -185,20 +188,52 @@ namespace osu.Game.Configuration
 
             return new TrackedSettings
             {
-                new TrackedSetting<bool>(OsuSetting.MouseDisableButtons, v => new SettingDescription(!v, "gameplay mouse buttons", v ? "disabled" : "enabled", LookupKeyBindings(GlobalAction.ToggleGameplayMouseButtons))),
-                new TrackedSetting<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode, m => new SettingDescription(m, "HUD Visibility", m.GetDescription(), $"cycle: {LookupKeyBindings(GlobalAction.ToggleInGameInterface)} quick view: {LookupKeyBindings(GlobalAction.HoldForHUD)}")),
-                new TrackedSetting<ScalingMode>(OsuSetting.Scaling, m => new SettingDescription(m, "scaling", m.GetDescription())),
-                new TrackedSetting<int>(OsuSetting.Skin, m =>
+                new TrackedSetting<bool>(OsuSetting.MouseDisableButtons, disabledState => new SettingDescription(
+                    rawValue: !disabledState,
+                    name: GlobalActionKeyBindingStrings.ToggleGameplayMouseButtons,
+                    value: disabledState ? CommonStrings.Disabled.ToLower() : CommonStrings.Enabled.ToLower(),
+                    shortcut: LookupKeyBindings(GlobalAction.ToggleGameplayMouseButtons))
+                ),
+                new TrackedSetting<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode, visibilityMode => new SettingDescription(
+                    rawValue: visibilityMode,
+                    name: GameplaySettingsStrings.HUDVisibilityMode,
+                    value: visibilityMode.GetLocalisableDescription(),
+                    shortcut: new TranslatableString(@"_", @"{0}: {1} {2}: {3}",
+                        GlobalActionKeyBindingStrings.ToggleInGameInterface,
+                        LookupKeyBindings(GlobalAction.ToggleInGameInterface),
+                        GlobalActionKeyBindingStrings.HoldForHUD,
+                        LookupKeyBindings(GlobalAction.HoldForHUD)))
+                ),
+                new TrackedSetting<ScalingMode>(OsuSetting.Scaling, scalingMode => new SettingDescription(
+                        rawValue: scalingMode,
+                        name: GraphicsSettingsStrings.ScreenScaling,
+                        value: scalingMode.GetLocalisableDescription()
+                    )
+                ),
+                new TrackedSetting<int>(OsuSetting.Skin, skin =>
                 {
-                    string skinName = LookupSkinName(m) ?? string.Empty;
-                    return new SettingDescription(skinName, "skin", skinName, $"random: {LookupKeyBindings(GlobalAction.RandomSkin)}");
-                })
+                    string skinName = LookupSkinName(skin) ?? string.Empty;
+
+                    return new SettingDescription(
+                        rawValue: skinName,
+                        name: SkinSettingsStrings.SkinSectionHeader,
+                        value: skinName,
+                        shortcut: $"{GlobalActionKeyBindingStrings.RandomSkin}: {LookupKeyBindings(GlobalAction.RandomSkin)}"
+                    );
+                }),
+                new TrackedSetting<float>(OsuSetting.UIScale, scale => new SettingDescription(
+                        rawValue: scale,
+                        name: GraphicsSettingsStrings.UIScaling,
+                        value: $"{scale:N2}x"
+                        // TODO: implement lookup for framework platform key bindings
+                    )
+                ),
             };
         }
 
         public Func<int, string> LookupSkinName { private get; set; }
 
-        public Func<GlobalAction, string> LookupKeyBindings { get; set; }
+        public Func<GlobalAction, LocalisableString> LookupKeyBindings { get; set; }
     }
 
     // IMPORTANT: These are used in user configuration files.

osu.Game/Database/ArchiveModelManager.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Database
     /// </summary>
     /// <typeparam name="TModel">The model type.</typeparam>
     /// <typeparam name="TFileModel">The associated file join type.</typeparam>
-    public abstract class ArchiveModelManager<TModel, TFileModel> : ICanAcceptFiles, IModelManager<TModel>, IModelFileManager<TModel, TFileModel>, IPostImports<TModel>
+    public abstract class ArchiveModelManager<TModel, TFileModel> : IModelManager<TModel>, IModelFileManager<TModel, TFileModel>
         where TModel : class, IHasFiles<TFileModel>, IHasPrimaryKey, ISoftDelete
         where TFileModel : class, INamedFileInfo, new()
     {

osu.Game/Database/IHasOnlineID.cs

@@ -8,8 +8,12 @@ namespace osu.Game.Database
     public interface IHasOnlineID
     {
         /// <summary>
-        /// The server-side ID representing this instance, if one exists.
+        /// The server-side ID representing this instance, if one exists. Any value 0 or less denotes a missing ID.
         /// </summary>
-        int? OnlineID { get; }
+        /// <remarks>
+        /// Generally we use -1 when specifying "missing" in code, but values of 0 are also considered missing as the online source
+        /// is generally a MySQL autoincrement value, which can never be 0.
+        /// </remarks>
+        int OnlineID { get; }
     }
 }

osu.Game/Database/IModelImporter.cs

@@ -13,21 +13,9 @@ namespace osu.Game.Database
     /// A class which handles importing of associated models to the game store.
     /// </summary>
     /// <typeparam name="TModel">The model type.</typeparam>
-    public interface IModelImporter<TModel> : IPostNotifications
+    public interface IModelImporter<TModel> : IPostNotifications, IPostImports<TModel>, ICanAcceptFiles
         where TModel : class
     {
-        /// <summary>
-        /// Import one or more <typeparamref name="TModel"/> items from filesystem <paramref name="paths"/>.
-        /// </summary>
-        /// <remarks>
-        /// This will be treated as a low priority import if more than one path is specified; use <see cref="ArchiveModelManager{TModel,TFileModel}.Import(osu.Game.Database.ImportTask[])"/> to always import at standard priority.
-        /// This will post notifications tracking progress.
-        /// </remarks>
-        /// <param name="paths">One or more archive locations on disk.</param>
-        Task Import(params string[] paths);
-
-        Task Import(params ImportTask[] tasks);
-
         Task<IEnumerable<ILive<TModel>>> Import(ProgressNotification notification, params ImportTask[] tasks);
 
         /// <summary>

osu.Game/Database/IPostImports.cs

@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 
+#nullable enable
+
 namespace osu.Game.Database
 {
     public interface IPostImports<out TModel>
@@ -12,6 +14,6 @@ namespace osu.Game.Database
         /// <summary>
         /// Fired when the user requests to view the resulting import.
         /// </summary>
-        public Action<IEnumerable<ILive<TModel>>> PostImport { set; }
+        public Action<IEnumerable<ILive<TModel>>>? PostImport { set; }
     }
 }

osu.Game/Database/RealmContextFactory.cs

@@ -2,13 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Development;
-using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Framework.Statistics;
+using osu.Game.Models;
 using Realms;
 
 #nullable enable
@@ -18,7 +19,7 @@ namespace osu.Game.Database
     /// <summary>
     /// A factory which provides both the main (update thread bound) realm context and creates contexts for async usage.
     /// </summary>
-    public class RealmContextFactory : Component, IRealmFactory
+    public class RealmContextFactory : IDisposable, IRealmFactory
     {
         private readonly Storage storage;
 
@@ -27,7 +28,12 @@ namespace osu.Game.Database
         /// </summary>
         public readonly string Filename;
 
-        private const int schema_version = 6;
+        /// <summary>
+        /// Version history:
+        /// 6  First tracked version (~20211018)
+        /// 7  Changed OnlineID fields to non-nullable to add indexing support (20211018)
+        /// </summary>
+        private const int schema_version = 7;
 
         /// <summary>
         /// Lock object which is held during <see cref="BlockAllOperations"/> sections, blocking context creation during blocking periods.
@@ -71,6 +77,27 @@ namespace osu.Game.Database
 
             if (!Filename.EndsWith(realm_extension, StringComparison.Ordinal))
                 Filename += realm_extension;
+
+            cleanupPendingDeletions();
+        }
+
+        private void cleanupPendingDeletions()
+        {
+            using (var realm = CreateContext())
+            using (var transaction = realm.BeginWrite())
+            {
+                var pendingDeleteSets = realm.All<RealmBeatmapSet>().Where(s => s.DeletePending);
+
+                foreach (var s in pendingDeleteSets)
+                {
+                    foreach (var b in s.Beatmaps)
+                        realm.Remove(b);
+
+                    realm.Remove(s);
+                }
+
+                transaction.Commit();
+            }
         }
 
         /// <summary>
@@ -79,10 +106,11 @@ namespace osu.Game.Database
         /// <returns></returns>
         public bool Compact() => Realm.Compact(getConfiguration());
 
-        protected override void Update()
+        /// <summary>
+        /// Perform a blocking refresh on the main realm context.
+        /// </summary>
+        public void Refresh()
         {
-            base.Update();
-
             lock (contextLock)
             {
                 if (context?.Refresh() == true)
@@ -92,7 +120,7 @@ namespace osu.Game.Database
 
         public Realm CreateContext()
         {
-            if (IsDisposed)
+            if (isDisposed)
                 throw new ObjectDisposedException(nameof(RealmContextFactory));
 
             try
@@ -120,6 +148,36 @@ namespace osu.Game.Database
 
         private void onMigration(Migration migration, ulong lastSchemaVersion)
         {
+            if (lastSchemaVersion < 7)
+            {
+                convertOnlineIDs<RealmBeatmap>();
+                convertOnlineIDs<RealmBeatmapSet>();
+                convertOnlineIDs<RealmRuleset>();
+
+                void convertOnlineIDs<T>() where T : RealmObject
+                {
+                    var className = typeof(T).Name.Replace(@"Realm", string.Empty);
+
+                    // version was not bumped when the beatmap/ruleset models were added
+                    // therefore we must manually check for their presence to avoid throwing on the `DynamicApi` calls.
+                    if (!migration.OldRealm.Schema.TryFindObjectSchema(className, out _))
+                        return;
+
+                    var oldItems = migration.OldRealm.DynamicApi.All(className);
+                    var newItems = migration.NewRealm.DynamicApi.All(className);
+
+                    int itemCount = newItems.Count();
+
+                    for (int i = 0; i < itemCount; i++)
+                    {
+                        var oldItem = oldItems.ElementAt(i);
+                        var newItem = newItems.ElementAt(i);
+
+                        long? nullableOnlineID = oldItem?.OnlineID;
+                        newItem.OnlineID = (int)(nullableOnlineID ?? -1);
+                    }
+                }
+            }
         }
 
         /// <summary>
@@ -132,7 +190,7 @@ namespace osu.Game.Database
         /// <returns>An <see cref="IDisposable"/> which should be disposed to end the blocking section.</returns>
         public IDisposable BlockAllOperations()
         {
-            if (IsDisposed)
+            if (isDisposed)
                 throw new ObjectDisposedException(nameof(RealmContextFactory));
 
             if (!ThreadSafety.IsUpdateThread)
@@ -176,21 +234,23 @@ namespace osu.Game.Database
             });
         }
 
-        protected override void Dispose(bool isDisposing)
+        private bool isDisposed;
+
+        public void Dispose()
         {
             lock (contextLock)
             {
                 context?.Dispose();
             }
 
-            if (!IsDisposed)
+            if (!isDisposed)
             {
                 // intentionally block context creation indefinitely. this ensures that nothing can start consuming a new context after disposal.
                 contextCreationLock.Wait();
                 contextCreationLock.Dispose();
-            }
 
-            base.Dispose(isDisposing);
+                isDisposed = true;
+            }
         }
     }
 }

osu.Game/Graphics/OsuColour.cs

@@ -235,11 +235,18 @@ namespace osu.Game.Graphics
         /// </summary>
         public readonly Color4 Blue3 = Color4Extensions.FromHex(@"3399cc");
 
+        public readonly Color4 Lime0 = Color4Extensions.FromHex(@"ccff99");
+
         /// <summary>
         /// Equivalent to <see cref="OverlayColourProvider.Lime"/>'s <see cref="OverlayColourProvider.Colour1"/>.
         /// </summary>
         public readonly Color4 Lime1 = Color4Extensions.FromHex(@"b2ff66");
 
+        /// <summary>
+        /// Equivalent to <see cref="OverlayColourProvider.Lime"/>'s <see cref="OverlayColourProvider.Colour3"/>.
+        /// </summary>
+        public readonly Color4 Lime3 = Color4Extensions.FromHex(@"7fcc33");
+
         /// <summary>
         /// Equivalent to <see cref="OverlayColourProvider.Orange"/>'s <see cref="OverlayColourProvider.Colour1"/>.
         /// </summary>

osu.Game/Graphics/UserInterface/Nub.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using JetBrains.Annotations;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Allocation;
@@ -12,63 +13,74 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
+using osu.Game.Overlays;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class Nub : CircularContainer, IHasCurrentValue<bool>, IHasAccentColour
+    public class Nub : CompositeDrawable, IHasCurrentValue<bool>, IHasAccentColour
     {
-        public const float COLLAPSED_SIZE = 20;
-        public const float EXPANDED_SIZE = 40;
+        public const float HEIGHT = 15;
+
+        public const float EXPANDED_SIZE = 50;
 
         private const float border_width = 3;
 
-        private const double animate_in_duration = 150;
+        private const double animate_in_duration = 200;
         private const double animate_out_duration = 500;
 
+        private readonly Box fill;
+        private readonly Container main;
+
         public Nub()
         {
-            Box fill;
+            Size = new Vector2(EXPANDED_SIZE, HEIGHT);
 
-            Size = new Vector2(COLLAPSED_SIZE, 12);
-
-            BorderColour = Color4.White;
-            BorderThickness = border_width;
-
-            Masking = true;
-
-            Children = new[]
+            InternalChildren = new[]
             {
-                fill = new Box
+                main = new CircularContainer
                 {
+                    BorderColour = Color4.White,
+                    BorderThickness = border_width,
+                    Masking = true,
                     RelativeSizeAxes = Axes.Both,
-                    Alpha = 0,
-                    AlwaysPresent = true,
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    Children = new Drawable[]
+                    {
+                        fill = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true,
+                        },
+                    }
                 },
             };
-
-            Current.ValueChanged += filled =>
-            {
-                fill.FadeTo(filled.NewValue ? 1 : 0, 200, Easing.OutQuint);
-                this.TransformTo(nameof(BorderThickness), filled.NewValue ? 8.5f : border_width, 200, Easing.OutQuint);
-            };
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        [BackgroundDependencyLoader(true)]
+        private void load([CanBeNull] OverlayColourProvider colourProvider, OsuColour colours)
         {
-            AccentColour = colours.Pink;
-            GlowingAccentColour = colours.PinkLighter;
-            GlowColour = colours.PinkDarker;
+            AccentColour = colourProvider?.Highlight1 ?? colours.Pink;
+            GlowingAccentColour = colourProvider?.Highlight1.Lighten(0.2f) ?? colours.PinkLighter;
+            GlowColour = colourProvider?.Highlight1 ?? colours.PinkLighter;
 
-            EdgeEffect = new EdgeEffectParameters
+            main.EdgeEffect = new EdgeEffectParameters
             {
                 Colour = GlowColour.Opacity(0),
                 Type = EdgeEffectType.Glow,
-                Radius = 10,
-                Roundness = 8,
+                Radius = 8,
+                Roundness = 5,
             };
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Current.BindValueChanged(onCurrentValueChanged, true);
+        }
+
         private bool glowing;
 
         public bool Glowing
@@ -80,28 +92,17 @@ namespace osu.Game.Graphics.UserInterface
 
                 if (value)
                 {
-                    this.FadeColour(GlowingAccentColour, animate_in_duration, Easing.OutQuint);
-                    FadeEdgeEffectTo(1, animate_in_duration, Easing.OutQuint);
+                    main.FadeColour(GlowingAccentColour, animate_in_duration, Easing.OutQuint);
+                    main.FadeEdgeEffectTo(0.2f, animate_in_duration, Easing.OutQuint);
                 }
                 else
                 {
-                    FadeEdgeEffectTo(0, animate_out_duration);
-                    this.FadeColour(AccentColour, animate_out_duration);
+                    main.FadeEdgeEffectTo(0, animate_out_duration, Easing.OutQuint);
+                    main.FadeColour(AccentColour, animate_out_duration, Easing.OutQuint);
                 }
             }
         }
 
-        public bool Expanded
-        {
-            set
-            {
-                if (value)
-                    this.ResizeTo(new Vector2(EXPANDED_SIZE, 12), animate_in_duration, Easing.OutQuint);
-                else
-                    this.ResizeTo(new Vector2(COLLAPSED_SIZE, 12), animate_out_duration, Easing.OutQuint);
-            }
-        }
-
         private readonly Bindable<bool> current = new Bindable<bool>();
 
         public Bindable<bool> Current
@@ -126,7 +127,7 @@ namespace osu.Game.Graphics.UserInterface
             {
                 accentColour = value;
                 if (!Glowing)
-                    Colour = value;
+                    main.Colour = value;
             }
         }
 
@@ -139,7 +140,7 @@ namespace osu.Game.Graphics.UserInterface
             {
                 glowingAccentColour = value;
                 if (Glowing)
-                    Colour = value;
+                    main.Colour = value;
             }
         }
 
@@ -152,10 +153,22 @@ namespace osu.Game.Graphics.UserInterface
             {
                 glowColour = value;
 
-                var effect = EdgeEffect;
+                var effect = main.EdgeEffect;
                 effect.Colour = Glowing ? value : value.Opacity(0);
-                EdgeEffect = effect;
+                main.EdgeEffect = effect;
             }
         }
+
+        private void onCurrentValueChanged(ValueChangedEvent<bool> filled)
+        {
+            fill.FadeTo(filled.NewValue ? 1 : 0, 200, Easing.OutQuint);
+
+            if (filled.NewValue)
+                main.ResizeWidthTo(1, animate_in_duration, Easing.OutElasticHalf);
+            else
+                main.ResizeWidthTo(0.9f, animate_out_duration, Easing.OutElastic);
+
+            main.TransformTo(nameof(BorderThickness), filled.NewValue ? 8.5f : border_width, 200, Easing.OutQuint);
+        }
     }
 }

osu.Game/Graphics/UserInterface/OsuCheckbox.cs

@@ -9,16 +9,11 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
-using osuTK.Graphics;
 
 namespace osu.Game.Graphics.UserInterface
 {
     public class OsuCheckbox : Checkbox
     {
-        public Color4 CheckedColor { get; set; } = Color4.Cyan;
-        public Color4 UncheckedColor { get; set; } = Color4.White;
-        public int FadeDuration { get; set; }
-
         /// <summary>
         /// Whether to play sounds when the state changes as a result of user interaction.
         /// </summary>
@@ -104,14 +99,12 @@ namespace osu.Game.Graphics.UserInterface
         protected override bool OnHover(HoverEvent e)
         {
             Nub.Glowing = true;
-            Nub.Expanded = true;
             return base.OnHover(e);
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
         {
             Nub.Glowing = false;
-            Nub.Expanded = false;
             base.OnHoverLost(e);
         }
 

osu.Game/Graphics/UserInterface/OsuDropdown.cs

@@ -21,44 +21,17 @@ using osuTK.Graphics;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class OsuDropdown<T> : Dropdown<T>, IHasAccentColour
+    public class OsuDropdown<T> : Dropdown<T>
     {
         private const float corner_radius = 5;
 
-        private Color4 accentColour;
-
-        public Color4 AccentColour
-        {
-            get => accentColour;
-            set
-            {
-                accentColour = value;
-                updateAccentColour();
-            }
-        }
-
-        [BackgroundDependencyLoader(true)]
-        private void load(OverlayColourProvider? colourProvider, OsuColour colours)
-        {
-            if (accentColour == default)
-                accentColour = colourProvider?.Light4 ?? colours.PinkDarker;
-            updateAccentColour();
-        }
-
-        private void updateAccentColour()
-        {
-            if (Header is IHasAccentColour header) header.AccentColour = accentColour;
-
-            if (Menu is IHasAccentColour menu) menu.AccentColour = accentColour;
-        }
-
         protected override DropdownHeader CreateHeader() => new OsuDropdownHeader();
 
         protected override DropdownMenu CreateMenu() => new OsuDropdownMenu();
 
         #region OsuDropdownMenu
 
-        protected class OsuDropdownMenu : DropdownMenu, IHasAccentColour
+        protected class OsuDropdownMenu : DropdownMenu
         {
             public override bool HandleNonPositionalInput => State == MenuState.Open;
 
@@ -78,9 +51,11 @@ namespace osu.Game.Graphics.UserInterface
             }
 
             [BackgroundDependencyLoader(true)]
-            private void load(OverlayColourProvider? colourProvider, AudioManager audio)
+            private void load(OverlayColourProvider? colourProvider, OsuColour colours, AudioManager audio)
             {
                 BackgroundColour = colourProvider?.Background5 ?? Color4.Black.Opacity(0.5f);
+                HoverColour = colourProvider?.Light4 ?? colours.PinkDarker;
+                SelectionColour = colourProvider?.Background3 ?? colours.PinkDarker.Opacity(0.5f);
 
                 sampleOpen = audio.Samples.Get(@"UI/dropdown-open");
                 sampleClose = audio.Samples.Get(@"UI/dropdown-close");
@@ -121,57 +96,77 @@ namespace osu.Game.Graphics.UserInterface
                 }
             }
 
-            private Color4 accentColour;
+            private Color4 hoverColour;
 
-            public Color4 AccentColour
+            public Color4 HoverColour
             {
-                get => accentColour;
+                get => hoverColour;
                 set
                 {
-                    accentColour = value;
-                    foreach (var c in Children.OfType<IHasAccentColour>())
-                        c.AccentColour = value;
+                    hoverColour = value;
+                    foreach (var c in Children.OfType<DrawableOsuDropdownMenuItem>())
+                        c.BackgroundColourHover = value;
+                }
+            }
+
+            private Color4 selectionColour;
+
+            public Color4 SelectionColour
+            {
+                get => selectionColour;
+                set
+                {
+                    selectionColour = value;
+                    foreach (var c in Children.OfType<DrawableOsuDropdownMenuItem>())
+                        c.BackgroundColourSelected = value;
                 }
             }
 
             protected override Menu CreateSubMenu() => new OsuMenu(Direction.Vertical);
 
-            protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new DrawableOsuDropdownMenuItem(item) { AccentColour = accentColour };
+            protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new DrawableOsuDropdownMenuItem(item)
+            {
+                BackgroundColourHover = HoverColour,
+                BackgroundColourSelected = SelectionColour
+            };
 
             protected override ScrollContainer<Drawable> CreateScrollContainer(Direction direction) => new OsuScrollContainer(direction);
 
             #region DrawableOsuDropdownMenuItem
 
-            public class DrawableOsuDropdownMenuItem : DrawableDropdownMenuItem, IHasAccentColour
+            public class DrawableOsuDropdownMenuItem : DrawableDropdownMenuItem
             {
                 // IsHovered is used
                 public override bool HandlePositionalInput => true;
 
-                private Color4? accentColour;
-
-                public Color4 AccentColour
+                public new Color4 BackgroundColourHover
                 {
-                    get => accentColour ?? nonAccentSelectedColour;
+                    get => base.BackgroundColourHover;
                     set
                     {
-                        accentColour = value;
+                        base.BackgroundColourHover = value;
+                        updateColours();
+                    }
+                }
+
+                public new Color4 BackgroundColourSelected
+                {
+                    get => base.BackgroundColourSelected;
+                    set
+                    {
+                        base.BackgroundColourSelected = value;
                         updateColours();
                     }
                 }
 
                 private void updateColours()
                 {
-                    BackgroundColourHover = accentColour ?? nonAccentHoverColour;
-                    BackgroundColourSelected = accentColour ?? nonAccentSelectedColour;
                     BackgroundColour = BackgroundColourHover.Opacity(0);
 
                     UpdateBackgroundColour();
                     UpdateForegroundColour();
                 }
 
-                private Color4 nonAccentHoverColour;
-                private Color4 nonAccentSelectedColour;
-
                 public DrawableOsuDropdownMenuItem(MenuItem item)
                     : base(item)
                 {
@@ -182,12 +177,8 @@ namespace osu.Game.Graphics.UserInterface
                 }
 
                 [BackgroundDependencyLoader]
-                private void load(OsuColour colours)
+                private void load()
                 {
-                    nonAccentHoverColour = colours.PinkDarker;
-                    nonAccentSelectedColour = Color4.Black.Opacity(0.5f);
-                    updateColours();
-
                     AddInternal(new HoverSounds());
                 }
 
@@ -290,7 +281,7 @@ namespace osu.Game.Graphics.UserInterface
 
         #endregion
 
-        public class OsuDropdownHeader : DropdownHeader, IHasAccentColour
+        public class OsuDropdownHeader : DropdownHeader
         {
             protected readonly SpriteText Text;
 
@@ -302,18 +293,6 @@ namespace osu.Game.Graphics.UserInterface
 
             protected readonly SpriteIcon Icon;
 
-            private Color4 accentColour;
-
-            public virtual Color4 AccentColour
-            {
-                get => accentColour;
-                set
-                {
-                    accentColour = value;
-                    BackgroundColourHover = accentColour;
-                }
-            }
-
             public OsuDropdownHeader()
             {
                 Foreground.Padding = new MarginPadding(10);

osu.Game/Graphics/UserInterface/OsuSliderBar.cs

@@ -3,11 +3,13 @@
 
 using System;
 using System.Globalization;
+using JetBrains.Annotations;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
@@ -16,6 +18,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
+using osu.Game.Overlays;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -52,34 +55,63 @@ namespace osu.Game.Graphics.UserInterface
             {
                 accentColour = value;
                 leftBox.Colour = value;
+            }
+        }
+
+        private Colour4 backgroundColour;
+
+        public Color4 BackgroundColour
+        {
+            get => backgroundColour;
+            set
+            {
+                backgroundColour = value;
                 rightBox.Colour = value;
             }
         }
 
         public OsuSliderBar()
         {
-            Height = 12;
-            RangePadding = 20;
+            Height = Nub.HEIGHT;
+            RangePadding = Nub.EXPANDED_SIZE / 2;
             Children = new Drawable[]
             {
-                leftBox = new Box
+                new Container
                 {
-                    Height = 2,
-                    EdgeSmoothness = new Vector2(0, 0.5f),
-                    Position = new Vector2(2, 0),
-                    RelativeSizeAxes = Axes.None,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.CentreLeft,
-                },
-                rightBox = new Box
-                {
-                    Height = 2,
-                    EdgeSmoothness = new Vector2(0, 0.5f),
-                    Position = new Vector2(-2, 0),
-                    RelativeSizeAxes = Axes.None,
-                    Anchor = Anchor.CentreRight,
-                    Origin = Anchor.CentreRight,
-                    Alpha = 0.5f,
+                    Padding = new MarginPadding { Horizontal = 2 },
+                    Child = new CircularContainer
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                        Masking = true,
+                        CornerRadius = 5f,
+                        Children = new Drawable[]
+                        {
+                            leftBox = new Box
+                            {
+                                Height = 5,
+                                EdgeSmoothness = new Vector2(0, 0.5f),
+                                RelativeSizeAxes = Axes.None,
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                            },
+                            rightBox = new Box
+                            {
+                                Height = 5,
+                                EdgeSmoothness = new Vector2(0, 0.5f),
+                                RelativeSizeAxes = Axes.None,
+                                Anchor = Anchor.CentreRight,
+                                Origin = Anchor.CentreRight,
+                                Alpha = 0.5f,
+                            },
+                        },
+                    },
                 },
                 nubContainer = new Container
                 {
@@ -88,7 +120,7 @@ namespace osu.Game.Graphics.UserInterface
                     {
                         Origin = Anchor.TopCentre,
                         RelativePositionAxes = Axes.X,
-                        Expanded = true,
+                        Current = { Value = true }
                     },
                 },
                 new HoverClickSounds()
@@ -97,11 +129,12 @@ namespace osu.Game.Graphics.UserInterface
             Current.DisabledChanged += disabled => { Alpha = disabled ? 0.3f : 1; };
         }
 
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio, OsuColour colours)
+        [BackgroundDependencyLoader(true)]
+        private void load(AudioManager audio, [CanBeNull] OverlayColourProvider colourProvider, OsuColour colours)
         {
             sample = audio.Samples.Get(@"UI/notch-tick");
-            AccentColour = colours.Pink;
+            AccentColour = colourProvider?.Highlight1 ?? colours.Pink;
+            BackgroundColour = colourProvider?.Background5 ?? colours.Pink.Opacity(0.5f);
         }
 
         protected override void Update()
@@ -119,26 +152,25 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override bool OnHover(HoverEvent e)
         {
-            Nub.Glowing = true;
+            updateGlow();
             return base.OnHover(e);
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
         {
-            Nub.Glowing = false;
+            updateGlow();
             base.OnHoverLost(e);
         }
 
-        protected override bool OnMouseDown(MouseDownEvent e)
+        protected override void OnDragEnd(DragEndEvent e)
         {
-            Nub.Current.Value = true;
-            return base.OnMouseDown(e);
+            updateGlow();
+            base.OnDragEnd(e);
         }
 
-        protected override void OnMouseUp(MouseUpEvent e)
+        private void updateGlow()
         {
-            Nub.Current.Value = false;
-            base.OnMouseUp(e);
+            Nub.Glowing = IsHovered || IsDragged;
         }
 
         protected override void OnUserChange(T value)

osu.Game/Graphics/UserInterface/OsuTabDropdown.cs

@@ -11,13 +11,33 @@ using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class OsuTabDropdown<T> : OsuDropdown<T>
+    public class OsuTabDropdown<T> : OsuDropdown<T>, IHasAccentColour
     {
+        private Color4 accentColour;
+
+        public Color4 AccentColour
+        {
+            get => accentColour;
+            set
+            {
+                accentColour = value;
+
+                if (IsLoaded)
+                    propagateAccentColour();
+            }
+        }
+
         public OsuTabDropdown()
         {
             RelativeSizeAxes = Axes.X;
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            propagateAccentColour();
+        }
+
         protected override DropdownMenu CreateMenu() => new OsuTabDropdownMenu();
 
         protected override DropdownHeader CreateHeader() => new OsuTabDropdownHeader
@@ -26,6 +46,18 @@ namespace osu.Game.Graphics.UserInterface
             Origin = Anchor.TopRight
         };
 
+        private void propagateAccentColour()
+        {
+            if (Menu is OsuDropdownMenu dropdownMenu)
+            {
+                dropdownMenu.HoverColour = accentColour;
+                dropdownMenu.SelectionColour = accentColour.Opacity(0.5f);
+            }
+
+            if (Header is OsuTabDropdownHeader tabDropdownHeader)
+                tabDropdownHeader.AccentColour = accentColour;
+        }
+
         private class OsuTabDropdownMenu : OsuDropdownMenu
         {
             public OsuTabDropdownMenu()
@@ -37,7 +69,7 @@ namespace osu.Game.Graphics.UserInterface
                 MaxHeight = 400;
             }
 
-            protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new DrawableOsuTabDropdownMenuItem(item) { AccentColour = AccentColour };
+            protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new DrawableOsuTabDropdownMenuItem(item);
 
             private class DrawableOsuTabDropdownMenuItem : DrawableOsuDropdownMenuItem
             {
@@ -49,15 +81,18 @@ namespace osu.Game.Graphics.UserInterface
             }
         }
 
-        protected class OsuTabDropdownHeader : OsuDropdownHeader
+        protected class OsuTabDropdownHeader : OsuDropdownHeader, IHasAccentColour
         {
-            public override Color4 AccentColour
+            private Color4 accentColour;
+
+            public Color4 AccentColour
             {
-                get => base.AccentColour;
+                get => accentColour;
                 set
                 {
-                    base.AccentColour = value;
-                    Foreground.Colour = value;
+                    accentColour = value;
+                    BackgroundColourHover = value;
+                    updateColour();
                 }
             }
 
@@ -93,15 +128,20 @@ namespace osu.Game.Graphics.UserInterface
 
             protected override bool OnHover(HoverEvent e)
             {
-                Foreground.Colour = BackgroundColour;
+                updateColour();
                 return base.OnHover(e);
             }
 
             protected override void OnHoverLost(HoverLostEvent e)
             {
-                Foreground.Colour = BackgroundColourHover;
+                updateColour();
                 base.OnHoverLost(e);
             }
+
+            private void updateColour()
+            {
+                Foreground.Colour = IsHovered ? BackgroundColour : BackgroundColourHover;
+            }
         }
     }
 }

osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs

@@ -2,10 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
 
 namespace osu.Game.Graphics.UserInterfaceV2
 {
@@ -23,10 +25,10 @@ namespace osu.Game.Graphics.UserInterfaceV2
             }
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        [BackgroundDependencyLoader(true)]
+        private void load([CanBeNull] OverlayColourProvider overlayColourProvider, OsuColour colours)
         {
-            BackgroundColour = colours.Blue3;
+            BackgroundColour = overlayColourProvider?.Highlight1 ?? colours.Blue3;
         }
 
         protected override void LoadComplete()

osu.Game/Localisation/CommonStrings.cs

@@ -24,6 +24,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString Enabled => new TranslatableString(getKey(@"enabled"), @"Enabled");
 
+        /// <summary>
+        /// "Disabled"
+        /// </summary>
+        public static LocalisableString Disabled => new TranslatableString(getKey(@"disabled"), @"Disabled");
+
         /// <summary>
         /// "Default"
         /// </summary>

osu.Game/Localisation/ResourceManagerLocalisationStore.cs

@@ -29,6 +29,9 @@ namespace osu.Game.Localisation
         {
             var split = lookup.Split(':');
 
+            if (split.Length < 2)
+                return null;
+
             string ns = split[0];
             string key = split[1];
 

osu.Game/Localisation/ToastStrings.cs

@@ -0,0 +1,39 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Localisation;
+
+namespace osu.Game.Localisation
+{
+    public static class ToastStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.Toast";
+
+        /// <summary>
+        /// "no key bound"
+        /// </summary>
+        public static LocalisableString NoKeyBound => new TranslatableString(getKey(@"no_key_bound"), @"no key bound");
+
+        /// <summary>
+        /// "Music Playback"
+        /// </summary>
+        public static LocalisableString MusicPlayback => new TranslatableString(getKey(@"music_playback"), @"Music Playback");
+
+        /// <summary>
+        /// "Pause track"
+        /// </summary>
+        public static LocalisableString PauseTrack => new TranslatableString(getKey(@"pause_track"), @"Pause track");
+
+        /// <summary>
+        /// "Play track"
+        /// </summary>
+        public static LocalisableString PlayTrack => new TranslatableString(getKey(@"play_track"), @"Play track");
+
+        /// <summary>
+        /// "Restart track"
+        /// </summary>
+        public static LocalisableString RestartTrack => new TranslatableString(getKey(@"restart_track"), @"Restart track");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}

osu.Game/Models/RealmBeatmap.cs

@@ -44,7 +44,8 @@ namespace osu.Game.Models
         [MapTo(nameof(Status))]
         public int StatusInt { get; set; }
 
-        public int? OnlineID { get; set; }
+        [Indexed]
+        public int OnlineID { get; set; } = -1;
 
         public double Length { get; set; }
 

osu.Game/Models/RealmBeatmapSet.cs

@@ -20,7 +20,8 @@ namespace osu.Game.Models
         [PrimaryKey]
         public Guid ID { get; set; } = Guid.NewGuid();
 
-        public int? OnlineID { get; set; }
+        [Indexed]
+        public int OnlineID { get; set; } = -1;
 
         public DateTimeOffset DateAdded { get; set; }
 
@@ -62,7 +63,7 @@ namespace osu.Game.Models
             if (IsManaged && other.IsManaged)
                 return ID == other.ID;
 
-            if (OnlineID.HasValue && other.OnlineID.HasValue)
+            if (OnlineID > 0 && other.OnlineID > 0)
                 return OnlineID == other.OnlineID;
 
             if (!string.IsNullOrEmpty(Hash) && !string.IsNullOrEmpty(other.Hash))

osu.Game/Models/RealmRuleset.cs

@@ -18,7 +18,8 @@ namespace osu.Game.Models
         [PrimaryKey]
         public string ShortName { get; set; } = string.Empty;
 
-        public int? OnlineID { get; set; }
+        [Indexed]
+        public int OnlineID { get; set; } = -1;
 
         public string Name { get; set; } = string.Empty;
 
@@ -29,7 +30,7 @@ namespace osu.Game.Models
             ShortName = shortName;
             Name = name;
             InstantiationInfo = instantiationInfo;
-            OnlineID = onlineID;
+            OnlineID = onlineID ?? -1;
         }
 
         [UsedImplicitly]
@@ -39,7 +40,7 @@ namespace osu.Game.Models
 
         public RealmRuleset(int? onlineID, string name, string shortName, bool available)
         {
-            OnlineID = onlineID;
+            OnlineID = onlineID ?? -1;
             Name = name;
             ShortName = shortName;
             Available = available;

osu.Game/Online/API/OAuth.cs

@@ -39,17 +39,19 @@ namespace osu.Game.Online.API
             if (string.IsNullOrEmpty(username)) throw new ArgumentException("Missing username.");
             if (string.IsNullOrEmpty(password)) throw new ArgumentException("Missing password.");
 
-            using (var req = new AccessTokenRequestPassword(username, password)
+            var accessTokenRequest = new AccessTokenRequestPassword(username, password)
             {
                 Url = $@"{endpoint}/oauth/token",
                 Method = HttpMethod.Post,
                 ClientId = clientId,
                 ClientSecret = clientSecret
-            })
+            };
+
+            using (accessTokenRequest)
             {
                 try
                 {
-                    req.Perform();
+                    accessTokenRequest.Perform();
                 }
                 catch (Exception ex)
                 {
@@ -60,7 +62,7 @@ namespace osu.Game.Online.API
                     try
                     {
                         // attempt to decode a displayable error string.
-                        var error = JsonConvert.DeserializeObject<OAuthError>(req.GetResponseString() ?? string.Empty);
+                        var error = JsonConvert.DeserializeObject<OAuthError>(accessTokenRequest.GetResponseString() ?? string.Empty);
                         if (error != null)
                             throwableException = new APIException(error.UserDisplayableError, ex);
                     }
@@ -71,7 +73,7 @@ namespace osu.Game.Online.API
                     throw throwableException;
                 }
 
-                Token.Value = req.ResponseObject;
+                Token.Value = accessTokenRequest.ResponseObject;
             }
         }
 
@@ -79,17 +81,19 @@ namespace osu.Game.Online.API
         {
             try
             {
-                using (var req = new AccessTokenRequestRefresh(refresh)
+                var refreshRequest = new AccessTokenRequestRefresh(refresh)
                 {
                     Url = $@"{endpoint}/oauth/token",
                     Method = HttpMethod.Post,
                     ClientId = clientId,
                     ClientSecret = clientSecret
-                })
-                {
-                    req.Perform();
+                };
 
-                    Token.Value = req.ResponseObject;
+                using (refreshRequest)
+                {
+                    refreshRequest.Perform();
+
+                    Token.Value = refreshRequest.ResponseObject;
                     return true;
                 }
             }

osu.Game/Online/Multiplayer/MultiplayerClient.cs

@@ -374,7 +374,7 @@ namespace osu.Game.Online.Multiplayer
 
                 UserJoined?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
         }
 
         Task IMultiplayerClient.UserLeft(MultiplayerRoomUser user) =>

osu.Game/OsuGame.cs

@@ -554,6 +554,7 @@ namespace osu.Game
         {
             beatmap.OldValue?.CancelAsyncLoad();
             beatmap.NewValue?.BeginAsyncLoad();
+            Logger.Log($"Game-wide working beatmap updated to {beatmap.NewValue}");
         }
 
         private void modsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
@@ -642,7 +643,7 @@ namespace osu.Game
             SkinManager.PostNotification = n => Notifications.Post(n);
 
             BeatmapManager.PostNotification = n => Notifications.Post(n);
-            BeatmapManager.PresentImport = items => PresentBeatmap(items.First().Value);
+            BeatmapManager.PostImport = items => PresentBeatmap(items.First().Value);
 
             ScoreManager.PostNotification = n => Notifications.Post(n);
             ScoreManager.PostImport = items => PresentScore(items.First().Value);
@@ -656,9 +657,9 @@ namespace osu.Game
                 var combinations = KeyBindingStore.GetReadableKeyCombinationsFor(l);
 
                 if (combinations.Count == 0)
-                    return "none";
+                    return ToastStrings.NoKeyBound;
 
-                return string.Join(" or ", combinations);
+                return string.Join(" / ", combinations);
             };
 
             Container logoContainer;

osu.Game/OsuGameBase.cs

@@ -187,8 +187,6 @@ namespace osu.Game
 
             dependencies.Cache(realmFactory = new RealmContextFactory(Storage, "client"));
 
-            AddInternal(realmFactory);
-
             dependencies.CacheAs(Storage);
 
             var largeStore = new LargeTextureStore(Host.CreateTextureLoaderStore(new NamespacedResourceStore<byte[]>(Resources, @"Textures")));
@@ -529,6 +527,7 @@ namespace osu.Game
             LocalConfig?.Dispose();
 
             contextFactory?.FlushConnections();
+            realmFactory?.Dispose();
         }
     }
 }

osu.Game/Overlays/Login/UserDropdown.cs

@@ -29,12 +29,6 @@ namespace osu.Game.Overlays.Login
             }
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            AccentColour = colours.Gray5;
-        }
-
         protected class UserDropdownMenu : OsuDropdownMenu
         {
             public UserDropdownMenu()
@@ -56,6 +50,8 @@ namespace osu.Game.Overlays.Login
             private void load(OsuColour colours)
             {
                 BackgroundColour = colours.Gray3;
+                SelectionColour = colours.Gray4;
+                HoverColour = colours.Gray5;
             }
 
             protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new DrawableUserDropdownMenuItem(item);
@@ -118,6 +114,7 @@ namespace osu.Game.Overlays.Login
             private void load(OsuColour colours)
             {
                 BackgroundColour = colours.Gray3;
+                BackgroundColourHover = colours.Gray5;
             }
         }
     }

osu.Game/Overlays/Music/CollectionDropdown.cs

@@ -19,12 +19,6 @@ namespace osu.Game.Overlays.Music
     {
         protected override bool ShowManageCollectionsItem => false;
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            AccentColour = colours.Gray6;
-        }
-
         protected override CollectionDropdownHeader CreateCollectionHeader() => new CollectionsHeader();
 
         protected override CollectionDropdownMenu CreateCollectionMenu() => new CollectionsMenu();
@@ -41,6 +35,8 @@ namespace osu.Game.Overlays.Music
             private void load(OsuColour colours)
             {
                 BackgroundColour = colours.Gray4;
+                SelectionColour = colours.Gray5;
+                HoverColour = colours.Gray6;
             }
         }
 
@@ -50,6 +46,7 @@ namespace osu.Game.Overlays.Music
             private void load(OsuColour colours)
             {
                 BackgroundColour = colours.Gray4;
+                BackgroundColourHover = colours.Gray6;
             }
 
             public CollectionsHeader()

osu.Game/Overlays/Music/MusicKeyBindingHandler.cs

@@ -3,12 +3,15 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
+using osu.Game.Localisation;
 using osu.Game.Overlays.OSD;
 
 namespace osu.Game.Overlays.Music
@@ -39,11 +42,11 @@ namespace osu.Game.Overlays.Music
                     bool wasPlaying = musicController.IsPlaying;
 
                     if (musicController.TogglePause())
-                        onScreenDisplay?.Display(new MusicActionToast(wasPlaying ? "Pause track" : "Play track", e.Action));
+                        onScreenDisplay?.Display(new MusicActionToast(wasPlaying ? ToastStrings.PauseTrack : ToastStrings.PlayTrack, e.Action));
                     return true;
 
                 case GlobalAction.MusicNext:
-                    musicController.NextTrack(() => onScreenDisplay?.Display(new MusicActionToast("Next track", e.Action)));
+                    musicController.NextTrack(() => onScreenDisplay?.Display(new MusicActionToast(GlobalActionKeyBindingStrings.MusicNext, e.Action)));
 
                     return true;
 
@@ -53,11 +56,11 @@ namespace osu.Game.Overlays.Music
                         switch (res)
                         {
                             case PreviousTrackResult.Restart:
-                                onScreenDisplay?.Display(new MusicActionToast("Restart track", e.Action));
+                                onScreenDisplay?.Display(new MusicActionToast(ToastStrings.RestartTrack, e.Action));
                                 break;
 
                             case PreviousTrackResult.Previous:
-                                onScreenDisplay?.Display(new MusicActionToast("Previous track", e.Action));
+                                onScreenDisplay?.Display(new MusicActionToast(GlobalActionKeyBindingStrings.MusicPrev, e.Action));
                                 break;
                         }
                     });
@@ -76,8 +79,8 @@ namespace osu.Game.Overlays.Music
         {
             private readonly GlobalAction action;
 
-            public MusicActionToast(string value, GlobalAction action)
-                : base("Music Playback", value, string.Empty)
+            public MusicActionToast(LocalisableString value, GlobalAction action)
+                : base(ToastStrings.MusicPlayback, value, string.Empty)
             {
                 this.action = action;
             }
@@ -85,7 +88,7 @@ namespace osu.Game.Overlays.Music
             [BackgroundDependencyLoader]
             private void load(OsuConfigManager config)
             {
-                ShortcutText.Text = config.LookupKeyBindings(action).ToUpperInvariant();
+                ShortcutText.Text = config.LookupKeyBindings(action).ToUpper();
             }
         }
     }

osu.Game/Overlays/Notifications/ProgressNotification.cs

@@ -31,10 +31,12 @@ namespace osu.Game.Overlays.Notifications
             set
             {
                 progress = value;
-                Scheduler.AddOnce(() => progressBar.Progress = progress);
+                Scheduler.AddOnce(updateProgress, progress);
             }
         }
 
+        private void updateProgress(float progress) => progressBar.Progress = progress;
+
         protected override void LoadComplete()
         {
             base.LoadComplete();

osu.Game/Overlays/OSD/Toast.cs

@@ -1,13 +1,16 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osuTK;
 using osuTK.Graphics;
+using osu.Game.Localisation;
 
 namespace osu.Game.Overlays.OSD
 {
@@ -23,7 +26,7 @@ namespace osu.Game.Overlays.OSD
 
         protected readonly OsuSpriteText ShortcutText;
 
-        protected Toast(string description, string value, string shortcut)
+        protected Toast(LocalisableString description, LocalisableString value, LocalisableString shortcut)
         {
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
@@ -60,12 +63,12 @@ namespace osu.Game.Overlays.OSD
                     Spacing = new Vector2(1, 0),
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre,
-                    Text = description.ToUpperInvariant()
+                    Text = description.ToUpper()
                 },
                 ValueText = new OsuSpriteText
                 {
                     Font = OsuFont.GetFont(size: 24, weight: FontWeight.Light),
-                    Padding = new MarginPadding { Left = 10, Right = 10 },
+                    Padding = new MarginPadding { Horizontal = 10 },
                     Name = "Value",
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -77,9 +80,9 @@ namespace osu.Game.Overlays.OSD
                     Origin = Anchor.BottomCentre,
                     Name = "Shortcut",
                     Alpha = 0.3f,
-                    Margin = new MarginPadding { Bottom = 15 },
+                    Margin = new MarginPadding { Bottom = 15, Horizontal = 10 },
                     Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold),
-                    Text = string.IsNullOrEmpty(shortcut) ? "NO KEY BOUND" : shortcut.ToUpperInvariant()
+                    Text = string.IsNullOrEmpty(shortcut.ToString()) ? ToastStrings.NoKeyBound.ToUpper() : shortcut.ToUpper()
                 },
             };
         }

osu.Game/Overlays/OSD/TrackedSettingToast.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Overlays.OSD
         private Sample sampleChange;
 
         public TrackedSettingToast(SettingDescription description)
-            : base(description.Name.ToString(), description.Value.ToString(), description.Shortcut.ToString())
+            : base(description.Name, description.Value, description.Shortcut)
         {
             FillFlowContainer<OptionLight> optionLights;
 

osu.Game/Overlays/Rankings/SpotlightSelector.cs

@@ -175,18 +175,18 @@ namespace osu.Game.Overlays.Rankings
 
         private class SpotlightsDropdown : OsuDropdown<APISpotlight>
         {
-            private DropdownMenu menu;
+            private OsuDropdownMenu menu;
 
-            protected override DropdownMenu CreateMenu() => menu = base.CreateMenu().With(m => m.MaxHeight = 400);
+            protected override DropdownMenu CreateMenu() => menu = (OsuDropdownMenu)base.CreateMenu().With(m => m.MaxHeight = 400);
 
             protected override DropdownHeader CreateHeader() => new SpotlightsDropdownHeader();
 
             [BackgroundDependencyLoader]
             private void load(OverlayColourProvider colourProvider)
             {
-                // osu-web adds a 0.6 opacity container on top of the 0.5 base one when hovering, 0.8 on a single container here matches the resulting colour
-                AccentColour = colourProvider.Background6.Opacity(0.8f);
                 menu.BackgroundColour = colourProvider.Background5;
+                menu.HoverColour = colourProvider.Background4;
+                menu.SelectionColour = colourProvider.Background3;
                 Padding = new MarginPadding { Vertical = 20 };
             }
 
@@ -205,7 +205,8 @@ namespace osu.Game.Overlays.Rankings
                 private void load(OverlayColourProvider colourProvider)
                 {
                     BackgroundColour = colourProvider.Background6.Opacity(0.5f);
-                    BackgroundColourHover = colourProvider.Background5;
+                    // osu-web adds a 0.6 opacity container on top of the 0.5 base one when hovering, 0.8 on a single container here matches the resulting colour
+                    BackgroundColourHover = colourProvider.Background6.Opacity(0.8f);
                 }
             }
         }

osu.Game/Overlays/RestoreDefaultValueButton.cs

@@ -3,10 +3,8 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.UserInterface;
@@ -14,6 +12,7 @@ using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
+using osuTK;
 
 namespace osu.Game.Overlays
 {
@@ -45,30 +44,21 @@ namespace osu.Game.Overlays
             }
         }
 
-        private bool hovering;
+        [Resolved]
+        private OsuColour colours { get; set; }
 
-        public RestoreDefaultValueButton()
-        {
-            Height = 1;
-
-            RelativeSizeAxes = Axes.Y;
-            Width = SettingsPanel.CONTENT_MARGINS;
-        }
+        private const float size = 4;
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colour)
         {
-            BackgroundColour = colour.Yellow;
-            Content.Width = 0.33f;
-            Content.CornerRadius = 3;
-            Content.EdgeEffect = new EdgeEffectParameters
-            {
-                Colour = BackgroundColour.Opacity(0.1f),
-                Type = EdgeEffectType.Glow,
-                Radius = 2,
-            };
+            BackgroundColour = colour.Lime1;
+            Size = new Vector2(3 * size);
+
+            Content.RelativeSizeAxes = Axes.None;
+            Content.Size = new Vector2(size);
+            Content.CornerRadius = size / 2;
 
-            Padding = new MarginPadding { Vertical = 1.5f };
             Alpha = 0f;
 
             Action += () =>
@@ -81,39 +71,55 @@ namespace osu.Game.Overlays
         protected override void LoadComplete()
         {
             base.LoadComplete();
-
-            // avoid unnecessary transforms on first display.
-            Alpha = currentAlpha;
-            Background.Colour = currentColour;
+            updateState();
+            FinishTransforms(true);
         }
 
         public LocalisableString TooltipText => "revert to default";
 
         protected override bool OnHover(HoverEvent e)
         {
-            hovering = true;
             UpdateState();
             return false;
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
         {
-            hovering = false;
             UpdateState();
         }
 
         public void UpdateState() => Scheduler.AddOnce(updateState);
 
-        private float currentAlpha => current.IsDefault ? 0f : hovering && !current.Disabled ? 1f : 0.65f;
-        private ColourInfo currentColour => current.Disabled ? Color4.Gray : BackgroundColour;
+        private const double fade_duration = 200;
 
         private void updateState()
         {
             if (current == null)
                 return;
 
-            this.FadeTo(currentAlpha, 200, Easing.OutQuint);
-            Background.FadeColour(currentColour, 200, Easing.OutQuint);
+            Enabled.Value = !Current.Disabled;
+
+            if (!Current.Disabled)
+            {
+                this.FadeTo(Current.IsDefault ? 0 : 1, fade_duration, Easing.OutQuint);
+                Background.FadeColour(IsHovered ? colours.Lime0 : colours.Lime1, fade_duration, Easing.OutQuint);
+                Content.TweenEdgeEffectTo(new EdgeEffectParameters
+                {
+                    Colour = (IsHovered ? colours.Lime1 : colours.Lime3).Opacity(0.4f),
+                    Radius = IsHovered ? 8 : 4,
+                    Type = EdgeEffectType.Glow
+                }, fade_duration, Easing.OutQuint);
+            }
+            else
+            {
+                Background.FadeColour(colours.Lime3, fade_duration, Easing.OutQuint);
+                Content.TweenEdgeEffectTo(new EdgeEffectParameters
+                {
+                    Colour = colours.Lime3.Opacity(0.1f),
+                    Radius = 2,
+                    Type = EdgeEffectType.Glow
+                }, fade_duration, Easing.OutQuint);
+            }
         }
     }
 }

osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.cs

@@ -82,60 +82,75 @@ namespace osu.Game.Overlays.Settings.Sections.Input
         {
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
-            Padding = new MarginPadding { Horizontal = SettingsPanel.CONTENT_MARGINS };
+            Padding = new MarginPadding { Right = SettingsPanel.CONTENT_MARGINS };
 
             InternalChildren = new Drawable[]
             {
-                new RestoreDefaultValueButton<bool>
+                new Container
                 {
-                    Current = isDefault,
-                    Action = RestoreDefaults,
-                    Origin = Anchor.TopRight,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = SettingsPanel.CONTENT_MARGINS,
+                    Child = new RestoreDefaultValueButton<bool>
+                    {
+                        Current = isDefault,
+                        Action = RestoreDefaults,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
                 },
-                content = new Container
+                new Container
                 {
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
-                    Masking = true,
-                    CornerRadius = padding,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Radius = 2,
-                        Colour = colourProvider.Highlight1.Opacity(0),
-                        Type = EdgeEffectType.Shadow,
-                        Hollow = true,
-                    },
+                    Padding = new MarginPadding { Left = SettingsPanel.CONTENT_MARGINS },
                     Children = new Drawable[]
                     {
-                        new Box
+                        content = new Container
                         {
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = colourProvider.Background5,
-                        },
-                        text = new OsuSpriteText
-                        {
-                            Text = action.GetLocalisableDescription(),
-                            Margin = new MarginPadding(1.5f * padding),
-                        },
-                        buttons = new FillFlowContainer<KeyButton>
-                        {
-                            AutoSizeAxes = Axes.Both,
-                            Anchor = Anchor.TopRight,
-                            Origin = Anchor.TopRight
-                        },
-                        cancelAndClearButtons = new FillFlowContainer
-                        {
-                            AutoSizeAxes = Axes.Both,
-                            Padding = new MarginPadding(padding) { Top = height + padding * 2 },
-                            Anchor = Anchor.TopRight,
-                            Origin = Anchor.TopRight,
-                            Alpha = 0,
-                            Spacing = new Vector2(5),
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Masking = true,
+                            CornerRadius = padding,
+                            EdgeEffect = new EdgeEffectParameters
+                            {
+                                Radius = 2,
+                                Colour = colourProvider.Highlight1.Opacity(0),
+                                Type = EdgeEffectType.Shadow,
+                                Hollow = true,
+                            },
                             Children = new Drawable[]
                             {
-                                new CancelButton { Action = finalise },
-                                new ClearButton { Action = clear },
-                            },
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = colourProvider.Background5,
+                                },
+                                text = new OsuSpriteText
+                                {
+                                    Text = action.GetLocalisableDescription(),
+                                    Margin = new MarginPadding(1.5f * padding),
+                                },
+                                buttons = new FillFlowContainer<KeyButton>
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight
+                                },
+                                cancelAndClearButtons = new FillFlowContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding(padding) { Top = height + padding * 2 },
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                    Alpha = 0,
+                                    Spacing = new Vector2(5),
+                                    Children = new Drawable[]
+                                    {
+                                        new CancelButton { Action = finalise },
+                                        new ClearButton { Action = clear },
+                                    },
+                                }
+                            }
                         }
                     }
                 },