Merge branch 'master' of https://github.com/ppy/osu

osu.Game.Rulesets.Catch.Tests/TestCaseHyperDash.cs

@@ -1,9 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -17,13 +19,30 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         protected override IBeatmap CreateBeatmap(Ruleset ruleset)
         {
-            var beatmap = new Beatmap { BeatmapInfo = { Ruleset = ruleset.RulesetInfo } };
+            var beatmap = new Beatmap
+            {
+                BeatmapInfo =
+                {
+                    Ruleset = ruleset.RulesetInfo,
+                    BaseDifficulty = new BeatmapDifficulty { CircleSize = 3.6f }
+                }
+            };
+
+            // Should produce a hperdash
+            beatmap.HitObjects.Add(new Fruit { StartTime = 816, X = 308 / 512f, NewCombo = true });
+            beatmap.HitObjects.Add(new Fruit { StartTime = 1008, X = 56 / 512f, });
 
             for (int i = 0; i < 512; i++)
                 if (i % 5 < 3)
-                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = i * 100, NewCombo = i % 8 == 0 });
+                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = 2000 + i * 100, NewCombo = i % 8 == 0 });
 
             return beatmap;
         }
+
+        protected override void AddCheckSteps(Func<Player> player)
+        {
+            base.AddCheckSteps(player);
+            AddAssert("First note is hyperdash", () => Beatmap.Value.Beatmap.HitObjects[0] is Fruit f && f.HyperDash);
+        }
     }
 }

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapProcessor.cs

@@ -100,7 +100,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 CatchHitObject nextObject = objectWithDroplets[i + 1];
 
                 int thisDirection = nextObject.X > currentObject.X ? 1 : -1;
-                double timeToNext = nextObject.StartTime - currentObject.StartTime;
+                double timeToNext = nextObject.StartTime - currentObject.StartTime - 1000f / 60f / 4; // 1/4th of a frame of grace time, taken from osu-stable
                 double distanceToNext = Math.Abs(nextObject.X - currentObject.X) - (lastDirection == thisDirection ? lastExcess : halfCatcherWidth);
                 float distanceToHyper = (float)(timeToNext * CatcherArea.Catcher.BASE_SPEED - distanceToNext);
                 if (distanceToHyper < 0)

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

@@ -25,8 +25,8 @@ namespace osu.Game.Rulesets.Mania.Tests
         [BackgroundDependencyLoader]
         private void load(RulesetConfigCache configCache)
         {
-            var config = (ManiaConfigManager)configCache.GetConfigFor(Ruleset.Value.CreateInstance());
+            var config = (ManiaRulesetConfigManager)configCache.GetConfigFor(Ruleset.Value.CreateInstance());
-            config.BindWith(ManiaSetting.ScrollDirection, direction);
+            config.BindWith(ManiaRulesetSetting.ScrollDirection, direction);
         }
     }
 }

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

@@ -8,9 +8,9 @@ using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Configuration
 {
-    public class ManiaConfigManager : RulesetConfigManager<ManiaSetting>
+    public class ManiaRulesetConfigManager : RulesetConfigManager<ManiaRulesetSetting>
     {
-        public ManiaConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
+        public ManiaRulesetConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
             : base(settings, ruleset, variant)
         {
         }
@@ -19,17 +19,17 @@ namespace osu.Game.Rulesets.Mania.Configuration
         {
             base.InitialiseDefaults();
 
-            Set(ManiaSetting.ScrollTime, 2250.0, 50.0, 10000.0, 50.0);
+            Set(ManiaRulesetSetting.ScrollTime, 2250.0, 50.0, 10000.0, 50.0);
-            Set(ManiaSetting.ScrollDirection, ManiaScrollingDirection.Down);
+            Set(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
         {
-            new TrackedSetting<double>(ManiaSetting.ScrollTime, v => new SettingDescription(v, "Scroll Time", $"{v}ms"))
+            new TrackedSetting<double>(ManiaRulesetSetting.ScrollTime, v => new SettingDescription(v, "Scroll Time", $"{v}ms"))
         };
     }
 
-    public enum ManiaSetting
+    public enum ManiaRulesetSetting
     {
         ScrollTime,
         ScrollDirection

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -162,7 +162,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new ManiaReplayFrame();
 
-        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new ManiaConfigManager(settings, RulesetInfo);
+        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new ManiaRulesetConfigManager(settings, RulesetInfo);
 
         public override RulesetSettingsSubsection CreateSettings() => new ManiaSettingsSubsection(this);
 

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -22,19 +22,19 @@ namespace osu.Game.Rulesets.Mania
         [BackgroundDependencyLoader]
         private void load()
         {
-            var config = (ManiaConfigManager)Config;
+            var config = (ManiaRulesetConfigManager)Config;
 
             Children = new Drawable[]
             {
                 new SettingsEnumDropdown<ManiaScrollingDirection>
                 {
                     LabelText = "Scrolling direction",
-                    Bindable = config.GetBindable<ManiaScrollingDirection>(ManiaSetting.ScrollDirection)
+                    Bindable = config.GetBindable<ManiaScrollingDirection>(ManiaRulesetSetting.ScrollDirection)
                 },
                 new SettingsSlider<double, TimeSlider>
                 {
                     LabelText = "Scroll speed",
-                    Bindable = config.GetBindable<double>(ManiaSetting.ScrollTime)
+                    Bindable = config.GetBindable<double>(ManiaRulesetSetting.ScrollTime)
                 },
             };
         }

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

@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public IEnumerable<BarLine> BarLines;
 
-        protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
+        protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;
 
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
 
@@ -74,10 +74,10 @@ namespace osu.Game.Rulesets.Mania.UI
         {
             BarLines.ForEach(Playfield.Add);
 
-            Config.BindWith(ManiaSetting.ScrollDirection, configDirection);
+            Config.BindWith(ManiaRulesetSetting.ScrollDirection, configDirection);
             configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);
 
-            Config.BindWith(ManiaSetting.ScrollTime, TimeRange);
+            Config.BindWith(ManiaRulesetSetting.ScrollTime, TimeRange);
         }
 
         /// <summary>

osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs

@@ -0,0 +1,30 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Configuration;
+
+namespace osu.Game.Rulesets.Osu.Configuration
+{
+    public class OsuRulesetConfigManager : RulesetConfigManager<OsuRulesetSetting>
+    {
+        public OsuRulesetConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
+            : base(settings, ruleset, variant)
+        {
+        }
+
+        protected override void InitialiseDefaults()
+        {
+            base.InitialiseDefaults();
+
+            Set(OsuRulesetSetting.SnakingInSliders, true);
+            Set(OsuRulesetSetting.SnakingOutSliders, true);
+        }
+    }
+
+    public enum OsuRulesetSetting
+    {
+        SnakingInSliders,
+        SnakingOutSliders
+    }
+}

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

@@ -10,8 +10,8 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
 using osu.Game.Skinning;
@@ -33,6 +33,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private readonly IBindable<float> scaleBindable = new Bindable<float>();
         private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
 
+        [Resolved(CanBeNull = true)]
+        private OsuRulesetConfigManager config { get; set; }
+
         public DrawableSlider(Slider s)
             : base(s)
         {
@@ -94,10 +97,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load()
         {
-            config.BindWith(OsuSetting.SnakingInSliders, Body.SnakingIn);
+            config?.BindWith(OsuRulesetSetting.SnakingInSliders, Body.SnakingIn);
-            config.BindWith(OsuSetting.SnakingOutSliders, Body.SnakingOut);
+            config?.BindWith(OsuRulesetSetting.SnakingOutSliders, Body.SnakingOut);
 
             positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
             scaleBindable.BindValueChanged(scale =>

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -16,8 +16,11 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Difficulty;
 using osu.Game.Scoring;
 
@@ -144,12 +147,14 @@ namespace osu.Game.Rulesets.Osu
 
         public override string ShortName => "osu";
 
-        public override RulesetSettingsSubsection CreateSettings() => new OsuSettings(this);
+        public override RulesetSettingsSubsection CreateSettings() => new OsuSettingsSubsection(this);
 
         public override int? LegacyID => 0;
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new OsuReplayFrame();
 
+        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new OsuRulesetConfigManager(settings, RulesetInfo);
+
         public OsuRuleset(RulesetInfo rulesetInfo = null)
             : base(rulesetInfo)
         {

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

@@ -8,6 +8,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Replays;
@@ -20,6 +21,8 @@ namespace osu.Game.Rulesets.Osu.UI
 {
     public class OsuRulesetContainer : RulesetContainer<OsuPlayfield, OsuHitObject>
     {
+        protected new OsuRulesetConfigManager Config => (OsuRulesetConfigManager)base.Config;
+
         public OsuRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {

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

@@ -3,34 +3,36 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Game.Configuration;
 using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Osu.Configuration;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
-    public class OsuSettings : RulesetSettingsSubsection
+    public class OsuSettingsSubsection : RulesetSettingsSubsection
     {
         protected override string Header => "osu!";
 
-        public OsuSettings(Ruleset ruleset)
+        public OsuSettingsSubsection(Ruleset ruleset)
             : base(ruleset)
         {
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load()
         {
+            var config = (OsuRulesetConfigManager)Config;
+
             Children = new Drawable[]
             {
                 new SettingsCheckbox
                 {
                     LabelText = "Snaking in sliders",
-                    Bindable = config.GetBindable<bool>(OsuSetting.SnakingInSliders)
+                    Bindable = config.GetBindable<bool>(OsuRulesetSetting.SnakingInSliders)
                 },
                 new SettingsCheckbox
                 {
                     LabelText = "Snaking out sliders",
-                    Bindable = config.GetBindable<bool>(OsuSetting.SnakingOutSliders)
+                    Bindable = config.GetBindable<bool>(OsuRulesetSetting.SnakingOutSliders)
                 },
             };
         }

osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs

@@ -101,7 +101,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                     int fireCount = 0;
 
                     // ReSharper disable once AccessToModifiedClosure
-                    manager.ItemAdded += (_, __, ___) => fireCount++;
+                    manager.ItemAdded += (_, __) => fireCount++;
                     manager.ItemRemoved += _ => fireCount++;
 
                     var imported = LoadOszIntoOsu(osu);

osu.Game/Beatmaps/BeatmapManager.cs

@@ -11,7 +11,6 @@ using Microsoft.EntityFrameworkCore;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
@@ -50,11 +49,6 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public event Action<DownloadBeatmapSetRequest> BeatmapDownloadFailed;
 
-        /// <summary>
-        /// Fired when a beatmap load is requested (into the interactive game UI).
-        /// </summary>
-        public Action<BeatmapSetInfo> PresentBeatmap;
-
         /// <summary>
         /// A default representation of a WorkingBeatmap to use when no beatmap is available.
         /// </summary>
@@ -151,8 +145,7 @@ namespace osu.Game.Beatmaps
 
             var downloadNotification = new DownloadNotification
             {
-                CompletionText = $"Imported {beatmapSetInfo.Metadata.Artist} - {beatmapSetInfo.Metadata.Title}!",
+                Text = $"Downloading {beatmapSetInfo}",
-                Text = $"Downloading {beatmapSetInfo.Metadata.Artist} - {beatmapSetInfo.Metadata.Title}",
             };
 
             var request = new DownloadBeatmapSetRequest(beatmapSetInfo, noVideo);
@@ -165,20 +158,10 @@ namespace osu.Game.Beatmaps
 
             request.Success += filename =>
             {
-                downloadNotification.Text = $"Importing {beatmapSetInfo.Metadata.Artist} - {beatmapSetInfo.Metadata.Title}";
-
                 Task.Factory.StartNew(() =>
                 {
                     // This gets scheduled back to the update thread, but we want the import to run in the background.
-                    var importedBeatmap = Import(filename);
+                    Import(downloadNotification, filename);
-
-                    downloadNotification.CompletionClickAction = () =>
-                    {
-                        PresentCompletedImport(importedBeatmap.Yield());
-                        return true;
-                    };
-                    downloadNotification.State = ProgressNotificationState.Completed;
-
                     currentDownloads.Remove(request);
                 }, TaskCreationOptions.LongRunning);
             };
@@ -221,12 +204,6 @@ namespace osu.Game.Beatmaps
             return true;
         }
 
-        protected override void PresentCompletedImport(IEnumerable<BeatmapSetInfo> imported)
-        {
-            base.PresentCompletedImport(imported);
-            PresentBeatmap?.Invoke(imported.LastOrDefault());
-        }
-
         /// <summary>
         /// Get an existing download request if it exists.
         /// </summary>

osu.Game/Beatmaps/Drawables/DifficultyColouredContainer.cs

@@ -48,11 +48,11 @@ namespace osu.Game.Beatmaps.Drawables
 
             var rating = beatmap.StarDifficulty;
 
-            if (rating < 1.5) return DifficultyRating.Easy;
+            if (rating < 2.0) return DifficultyRating.Easy;
-            if (rating < 2.25) return DifficultyRating.Normal;
+            if (rating < 2.7) return DifficultyRating.Normal;
-            if (rating < 3.75) return DifficultyRating.Hard;
+            if (rating < 4.0) return DifficultyRating.Hard;
-            if (rating < 5.25) return DifficultyRating.Insane;
+            if (rating < 5.3) return DifficultyRating.Insane;
-            if (rating < 6.75) return DifficultyRating.Expert;
+            if (rating < 6.5) return DifficultyRating.Expert;
 
             return DifficultyRating.ExpertPlus;
         }

osu.Game/Configuration/OsuConfigManager.cs

@@ -72,9 +72,6 @@ namespace osu.Game.Configuration
 
             Set(OsuSetting.MenuParallax, true);
 
-            Set(OsuSetting.SnakingInSliders, true);
-            Set(OsuSetting.SnakingOutSliders, true);
-
             // Gameplay
             Set(OsuSetting.DimLevel, 0.3, 0, 1, 0.01);
             Set(OsuSetting.BlurLevel, 0, 0, 1, 0.01);
@@ -150,8 +147,6 @@ namespace osu.Game.Configuration
         DisplayStarsMinimum,
         DisplayStarsMaximum,
         RandomSelectAlgorithm,
-        SnakingInSliders,
-        SnakingOutSliders,
         ShowFpsDisplay,
         ChatDisplayHeight,
         Version,

osu.Game/Database/ArchiveModelManager.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Database
         where TModel : class, IHasFiles<TFileModel>, IHasPrimaryKey, ISoftDelete
         where TFileModel : INamedFileInfo, new()
     {
-        public delegate void ItemAddedDelegate(TModel model, bool existing, bool silent);
+        public delegate void ItemAddedDelegate(TModel model, bool existing);
 
         /// <summary>
         /// Set an endpoint for notifications to be posted to.
@@ -113,7 +113,7 @@ namespace osu.Game.Database
             ContextFactory = contextFactory;
 
             ModelStore = modelStore;
-            ModelStore.ItemAdded += (item, silent) => handleEvent(() => ItemAdded?.Invoke(item, false, silent));
+            ModelStore.ItemAdded += item => handleEvent(() => ItemAdded?.Invoke(item, false));
             ModelStore.ItemRemoved += s => handleEvent(() => ItemRemoved?.Invoke(s));
 
             Files = new FileStore(contextFactory, storage);
@@ -131,14 +131,18 @@ namespace osu.Game.Database
         /// <param name="paths">One or more archive locations on disk.</param>
         public void Import(params string[] paths)
         {
-            var notification = new ProgressNotification
+            var notification = new ProgressNotification { State = ProgressNotificationState.Active };
-            {
-                Text = "Import is initialising...",
-                Progress = 0,
-                State = ProgressNotificationState.Active,
-            };
 
             PostNotification?.Invoke(notification);
+            Import(notification, paths);
+        }
+
+        protected void Import(ProgressNotification notification, params string[] paths)
+        {
+            notification.Progress = 0;
+            notification.Text = "Import is initialising...";
+
+            var term = $"{typeof(TModel).Name.Replace("Info", "").ToLower()}";
 
             List<TModel> imported = new List<TModel>();
 
@@ -151,7 +155,18 @@ namespace osu.Game.Database
 
                 try
                 {
-                    notification.Text = $"Importing ({++current} of {paths.Length})\n{Path.GetFileName(path)}";
+                    var text = "Importing ";
+
+                    if (path.Length > 1)
+                        text += $"{++current} of {paths.Length} {term}s..";
+                    else
+                        text += $"{term}..";
+
+                    // only show the filename if it isn't a temporary one (as those look ugly).
+                    if (!path.Contains(Path.GetTempPath()))
+                        text += $"\n{Path.GetFileName(path)}";
+
+                    notification.Text = text;
 
                     imported.Add(Import(path));
 
@@ -171,13 +186,20 @@ namespace osu.Game.Database
             }
             else
             {
-                notification.CompletionText = $"Imported {current} {typeof(TModel).Name.Replace("Info", "").ToLower()}s!";
+                notification.CompletionText = imported.Count == 1
-                notification.CompletionClickAction += () =>
+                    ? $"Imported {imported.First()}!"
+                    : $"Imported {current} {term}s!";
+
+                if (imported.Count > 0 && PresentImport != null)
                 {
-                    if (imported.Count > 0)
+                    notification.CompletionText += " Click to view.";
-                        PresentCompletedImport(imported);
+                    notification.CompletionClickAction = () =>
+                    {
+                        PresentImport?.Invoke(imported);
                         return true;
                     };
+                }
+
                 notification.State = ProgressNotificationState.Completed;
             }
         }
@@ -210,9 +232,10 @@ namespace osu.Game.Database
             return import;
         }
 
-        protected virtual void PresentCompletedImport(IEnumerable<TModel> imported)
+        /// <summary>
-        {
+        /// Fired when the user requests to view the resulting import.
-        }
+        /// </summary>
+        public Action<IEnumerable<TModel>> PresentImport;
 
         /// <summary>
         /// Import an item from an <see cref="ArchiveReader"/>.
@@ -228,7 +251,7 @@ namespace osu.Game.Database
 
                 model.Hash = computeHash(archive);
 
-                return Import(model, false, archive);
+                return Import(model, archive);
             }
             catch (Exception e)
             {
@@ -262,9 +285,8 @@ namespace osu.Game.Database
         /// Import an item from a <see cref="TModel"/>.
         /// </summary>
         /// <param name="item">The model to be imported.</param>
-        /// <param name="silent">Whether the user should be notified fo the import.</param>
         /// <param name="archive">An optional archive to use for model population.</param>
-        public TModel Import(TModel item, bool silent = false, ArchiveReader archive = null)
+        public TModel Import(TModel item, ArchiveReader archive = null)
         {
             delayEvents();
 
@@ -284,7 +306,7 @@ namespace osu.Game.Database
                         {
                             Undelete(existing);
                             Logger.Log($"Found existing {typeof(TModel)} for {item} (ID {existing.ID}). Skipping import.", LoggingTarget.Database);
-                            handleEvent(() => ItemAdded?.Invoke(existing, true, silent));
+                            handleEvent(() => ItemAdded?.Invoke(existing, true));
                             return existing;
                         }
 
@@ -294,7 +316,7 @@ namespace osu.Game.Database
                         Populate(item, archive);
 
                         // import to store
-                        ModelStore.Add(item, silent);
+                        ModelStore.Add(item);
                     }
                     catch (Exception e)
                     {

osu.Game/Database/MutableDatabaseBackedStore.cs

@@ -16,9 +16,7 @@ namespace osu.Game.Database
     public abstract class MutableDatabaseBackedStore<T> : DatabaseBackedStore
         where T : class, IHasPrimaryKey, ISoftDelete
     {
-        public delegate void ItemAddedDelegate(T model, bool silent);
+        public event Action<T> ItemAdded;
-
-        public event ItemAddedDelegate ItemAdded;
         public event Action<T> ItemRemoved;
 
         protected MutableDatabaseBackedStore(IDatabaseContextFactory contextFactory, Storage storage = null)
@@ -35,8 +33,7 @@ namespace osu.Game.Database
         /// Add a <see cref="T"/> to the database.
         /// </summary>
         /// <param name="item">The item to add.</param>
-        /// <param name="silent">Whether the user should be notified of the addition.</param>
+        public void Add(T item)
-        public void Add(T item, bool silent)
         {
             using (var usage = ContextFactory.GetForWrite())
             {
@@ -44,7 +41,7 @@ namespace osu.Game.Database
                 context.Attach(item);
             }
 
-            ItemAdded?.Invoke(item, silent);
+            ItemAdded?.Invoke(item);
         }
 
         /// <summary>
@@ -57,7 +54,7 @@ namespace osu.Game.Database
                 usage.Context.Update(item);
 
             ItemRemoved?.Invoke(item);
-            ItemAdded?.Invoke(item, true);
+            ItemAdded?.Invoke(item);
         }
 
         /// <summary>
@@ -94,7 +91,7 @@ namespace osu.Game.Database
                 item.DeletePending = false;
             }
 
-            ItemAdded?.Invoke(item, true);
+            ItemAdded?.Invoke(item);
             return true;
         }
 

osu.Game/Graphics/UserInterface/RollingCounter.cs

@@ -59,7 +59,6 @@ namespace osu.Game.Graphics.UserInterface
 
         public abstract void Increment(T amount);
 
-
         public float TextSize
         {
             get => DisplayedCountSpriteText.Font.Size;

osu.Game/Online/API/Requests/SearchBeatmapSetsRequest.cs

@@ -36,11 +36,12 @@ namespace osu.Game.Online.API.Requests
 
         [Description("Ranked & Approved")]
         RankedApproved = 0,
-        Approved = 1,
+        Qualified = 3,
         Loved = 8,
         Favourites = 2,
-        Qualified = 3,
+
-        Pending = 4,
+        [Description("Pending & WIP")]
+        PendingWIP = 4,
         Graveyard = 5,
 
         [Description("My Maps")]

osu.Game/OsuGame.cs

@@ -167,8 +167,6 @@ namespace osu.Game
         {
             this.frameworkConfig = frameworkConfig;
 
-            ScoreManager.ItemAdded += (score, _, silent) => Schedule(() => LoadScore(score, silent));
-
             if (!Host.IsPrimaryInstance)
             {
                 Logger.Log(@"osu! does not support multiple running instances.", LoggingTarget.Runtime, LogLevel.Error);
@@ -217,63 +215,12 @@ namespace osu.Game
             externalLinkOpener.OpenUrlExternally(url);
         }
 
-        private ScheduledDelegate scoreLoad;
-
         /// <summary>
         /// Show a beatmap set as an overlay.
         /// </summary>
         /// <param name="setId">The set to display.</param>
         public void ShowBeatmapSet(int setId) => beatmapSetOverlay.FetchAndShowBeatmapSet(setId);
 
-        /// <summary>
-        /// Present a beatmap at song select.
-        /// </summary>
-        /// <param name="beatmap">The beatmap to select.</param>
-        public void PresentBeatmap(BeatmapSetInfo beatmap)
-        {
-            if (menuScreen == null)
-            {
-                Schedule(() => PresentBeatmap(beatmap));
-                return;
-            }
-
-            CloseAllOverlays(false);
-
-            void setBeatmap()
-            {
-                if (Beatmap.Disabled)
-                {
-                    Schedule(setBeatmap);
-                    return;
-                }
-
-                var databasedSet = beatmap.OnlineBeatmapSetID != null ? BeatmapManager.QueryBeatmapSet(s => s.OnlineBeatmapSetID == beatmap.OnlineBeatmapSetID) : BeatmapManager.QueryBeatmapSet(s => s.Hash == beatmap.Hash);
-
-                if (databasedSet != null)
-                {
-                    // Use first beatmap available for current ruleset, else switch ruleset.
-                    var first = databasedSet.Beatmaps.Find(b => b.Ruleset == ruleset.Value) ?? databasedSet.Beatmaps.First();
-
-                    ruleset.Value = first.Ruleset;
-                    Beatmap.Value = BeatmapManager.GetWorkingBeatmap(first);
-                }
-            }
-
-            switch (screenStack.CurrentScreen)
-            {
-                case SongSelect _:
-                    break;
-                default:
-                    // navigate to song select if we are not already there.
-
-                    menuScreen.MakeCurrent();
-                    menuScreen.LoadToSolo();
-                    break;
-            }
-
-            setBeatmap();
-        }
-
         /// <summary>
         /// Show a user's profile as an overlay.
         /// </summary>
@@ -286,19 +233,44 @@ namespace osu.Game
         /// <param name="beatmapId">The beatmap to show.</param>
         public void ShowBeatmap(int beatmapId) => beatmapSetOverlay.FetchAndShowBeatmap(beatmapId);
 
-        protected void LoadScore(ScoreInfo score, bool silent)
+        /// <summary>
+        /// Present a beatmap at song select immediately.
+        /// The user should have already requested this interactively.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to select.</param>
+        public void PresentBeatmap(BeatmapSetInfo beatmap)
         {
-            if (silent)
+            var databasedSet = beatmap.OnlineBeatmapSetID != null
-                return;
+                ? BeatmapManager.QueryBeatmapSet(s => s.OnlineBeatmapSetID == beatmap.OnlineBeatmapSetID)
+                : BeatmapManager.QueryBeatmapSet(s => s.Hash == beatmap.Hash);
 
-            scoreLoad?.Cancel();
+            if (databasedSet == null)
-
-            if (menuScreen == null)
             {
-                scoreLoad = Schedule(() => LoadScore(score, false));
+                Logger.Log("The requested beatmap could not be loaded.", LoggingTarget.Information);
                 return;
             }
 
+            performFromMainMenu(() =>
+            {
+                // we might already be at song select, so a check is required before performing the load to solo.
+                if (menuScreen.IsCurrentScreen())
+                    menuScreen.LoadToSolo();
+
+                // Use first beatmap available for current ruleset, else switch ruleset.
+                var first = databasedSet.Beatmaps.Find(b => b.Ruleset == ruleset.Value) ?? databasedSet.Beatmaps.First();
+
+                ruleset.Value = first.Ruleset;
+                Beatmap.Value = BeatmapManager.GetWorkingBeatmap(first);
+            }, $"load {beatmap}", bypassScreenAllowChecks: true, targetScreen: typeof(PlaySongSelect));
+        }
+
+        /// <summary>
+        /// Present a score's replay immediately.
+        /// The user should have already requested this interactively.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to select.</param>
+        public void PresentScore(ScoreInfo score)
+        {
             var databasedScore = ScoreManager.GetScore(score);
             var databasedScoreInfo = databasedScore.ScoreInfo;
             if (databasedScore.Replay == null)
@@ -314,14 +286,40 @@ namespace osu.Game
                 return;
             }
 
-            if ((screenStack.CurrentScreen as IOsuScreen)?.AllowExternalScreenChange == false)
+            performFromMainMenu(() =>
+            {
+                ruleset.Value = databasedScoreInfo.Ruleset;
+
+                Beatmap.Value = BeatmapManager.GetWorkingBeatmap(databasedBeatmap);
+                Beatmap.Value.Mods.Value = databasedScoreInfo.Mods;
+
+                menuScreen.Push(new PlayerLoader(() => new ReplayPlayer(databasedScore)));
+            }, $"watch {databasedScoreInfo}", bypassScreenAllowChecks: true);
+        }
+
+        private ScheduledDelegate performFromMainMenuTask;
+
+        /// <summary>
+        /// Perform an action only after returning to the main menu.
+        /// Eagerly tries to exit the current screen until it succeeds.
+        /// </summary>
+        /// <param name="action">The action to perform once we are in the correct state.</param>
+        /// <param name="taskName">The task name to display in a notification (if we can't immediately reach the main menu state).</param>
+        /// <param name="targetScreen">An optional target screen type. If this screen is already current we can immediately perform the action without returning to the menu.</param>
+        /// <param name="bypassScreenAllowChecks">Whether checking <see cref="IOsuScreen.AllowExternalScreenChange"/> should be bypassed.</param>
+        private void performFromMainMenu(Action action, string taskName, Type targetScreen = null, bool bypassScreenAllowChecks = false)
+        {
+            performFromMainMenuTask?.Cancel();
+
+            // if the current screen does not allow screen changing, give the user an option to try again later.
+            if (!bypassScreenAllowChecks && (screenStack.CurrentScreen as IOsuScreen)?.AllowExternalScreenChange == false)
             {
                 notifications.Post(new SimpleNotification
                 {
-                    Text = $"Click here to watch {databasedScoreInfo.User.Username} on {databasedScoreInfo.Beatmap}",
+                    Text = $"Click here to {taskName}",
                     Activated = () =>
                     {
-                        loadScore();
+                        performFromMainMenu(action, taskName, targetScreen, true);
                         return true;
                     }
                 });
@@ -329,24 +327,26 @@ namespace osu.Game
                 return;
             }
 
-            loadScore();
+            CloseAllOverlays(false);
 
-            void loadScore()
+            // we may already be at the target screen type.
+            if (targetScreen != null && screenStack.CurrentScreen?.GetType() == targetScreen)
             {
-                if (!menuScreen.IsCurrentScreen() || Beatmap.Disabled)
+                action();
-                {
-                    menuScreen.MakeCurrent();
-                    this.Delay(500).Schedule(loadScore, out scoreLoad);
                 return;
             }
 
-                ruleset.Value = databasedScoreInfo.Ruleset;
+            // all conditions have been met to continue with the action.
-
+            if (menuScreen?.IsCurrentScreen() == true && !Beatmap.Disabled)
-                Beatmap.Value = BeatmapManager.GetWorkingBeatmap(databasedBeatmap);
+            {
-                Beatmap.Value.Mods.Value = databasedScoreInfo.Mods;
+                action();
-
+                return;
-                menuScreen.Push(new PlayerLoader(() => new ReplayPlayer(databasedScore)));
             }
+
+            // menuScreen may not be initialised yet (null check required).
+            menuScreen?.MakeCurrent();
+
+            performFromMainMenuTask = Schedule(() => performFromMainMenu(action, taskName));
         }
 
         protected override void Dispose(bool isDisposing)
@@ -370,8 +370,10 @@ namespace osu.Game
 
             BeatmapManager.PostNotification = n => notifications?.Post(n);
             BeatmapManager.GetStableStorage = GetStorageForStableInstall;
+            BeatmapManager.PresentImport = items => PresentBeatmap(items.First());
 
-            BeatmapManager.PresentBeatmap = PresentBeatmap;
+            ScoreManager.PostNotification = n => notifications?.Post(n);
+            ScoreManager.PresentImport = items => PresentScore(items.First());
 
             Container logoContainer;
 

osu.Game/Overlays/Direct/DownloadTrackingComposite.cs

@@ -118,7 +118,7 @@ namespace osu.Game.Overlays.Direct
 
         private void onRequestFailure(Exception e) => Schedule(() => attachDownload(null));
 
-        private void setAdded(BeatmapSetInfo s, bool existing, bool silent) => setDownloadStateFromManager(s, DownloadState.LocallyAvailable);
+        private void setAdded(BeatmapSetInfo s, bool existing) => setDownloadStateFromManager(s, DownloadState.LocallyAvailable);
 
         private void setRemoved(BeatmapSetInfo s) => setDownloadStateFromManager(s, DownloadState.NotDownloaded);
 

osu.Game/Overlays/Music/PlaylistList.cs

@@ -75,7 +75,7 @@ namespace osu.Game.Overlays.Music
             [BackgroundDependencyLoader]
             private void load(BeatmapManager beatmaps, IBindable<WorkingBeatmap> beatmap)
             {
-                beatmaps.GetAllUsableBeatmapSets().ForEach(b => addBeatmapSet(b, false, false));
+                beatmaps.GetAllUsableBeatmapSets().ForEach(b => addBeatmapSet(b, false));
                 beatmaps.ItemAdded += addBeatmapSet;
                 beatmaps.ItemRemoved += removeBeatmapSet;
 
@@ -83,7 +83,7 @@ namespace osu.Game.Overlays.Music
                 beatmapBacking.ValueChanged += _ => updateSelectedSet();
             }
 
-            private void addBeatmapSet(BeatmapSetInfo obj, bool existing, bool silent) => Schedule(() =>
+            private void addBeatmapSet(BeatmapSetInfo obj, bool existing) => Schedule(() =>
             {
                 if (existing)
                     return;

osu.Game/Overlays/MusicController.cs

@@ -212,7 +212,7 @@ namespace osu.Game.Overlays
             beatmapSets.Insert(index, beatmapSetInfo);
         }
 
-        private void handleBeatmapAdded(BeatmapSetInfo obj, bool existing, bool silent)
+        private void handleBeatmapAdded(BeatmapSetInfo obj, bool existing)
         {
             if (existing)
                 return;

osu.Game/Overlays/Settings/Sections/SkinSection.cs

@@ -82,7 +82,7 @@ namespace osu.Game.Overlays.Settings.Sections
 
         private void itemRemoved(SkinInfo s) => Schedule(() => skinDropdown.Items = skinDropdown.Items.Where(i => i.ID != s.ID).ToArray());
 
-        private void itemAdded(SkinInfo s, bool existing, bool silent)
+        private void itemAdded(SkinInfo s, bool existing)
         {
             if (existing)
                 return;

osu.Game/Scoring/ScoreInfo.cs

@@ -178,5 +178,7 @@ namespace osu.Game.Scoring
         {
             public string Acronym { get; set; }
         }
+
+        public override string ToString() => $"{User} playing {Beatmap}";
     }
 }

osu.Game/Screens/IOsuScreen.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Screens
 
         /// <summary>
         /// Whether a top-level component should be allowed to exit the current screen to, for example,
-        /// complete an import.
+        /// complete an import. Note that this can be overridden by a user if they specifically request.
         /// </summary>
         bool AllowExternalScreenChange { get; }
 

osu.Game/Screens/Menu/Disclaimer.cs

@@ -5,14 +5,17 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Screens;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
+using osu.Game.Online.API;
 using osuTK;
 using osuTK.Graphics;
 using osu.Game.Overlays;
+using osu.Game.Users;
 
 namespace osu.Game.Screens.Menu
 {
@@ -33,13 +36,15 @@ namespace osu.Game.Screens.Menu
 
         private const float icon_y = -85;
 
+        private readonly Bindable<User> currentUser = new Bindable<User>();
+
         public Disclaimer()
         {
             ValidForResume = false;
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load(OsuColour colours, APIAccess api)
         {
             InternalChildren = new Drawable[]
             {
@@ -96,6 +101,13 @@ namespace osu.Game.Screens.Menu
             }).First());
 
             iconColour = colours.Yellow;
+
+            currentUser.BindTo(api.LocalUser);
+            currentUser.BindValueChanged(e =>
+            {
+                if (e.NewValue.IsSupporter)
+                    supporterDrawables.ForEach(d => d.FadeOut(500, Easing.OutQuint).Expire());
+            }, true);
         }
 
         protected override void LoadComplete()

osu.Game/Screens/Multi/Match/Components/ReadyButton.cs

@@ -54,7 +54,7 @@ namespace osu.Game.Screens.Multi.Match.Components
             hasBeatmap = beatmaps.QueryBeatmap(b => b.OnlineBeatmapID == beatmap.OnlineBeatmapID) != null;
         }
 
-        private void beatmapAdded(BeatmapSetInfo model, bool existing, bool silent)
+        private void beatmapAdded(BeatmapSetInfo model, bool existing)
         {
             if (Beatmap.Value == null)
                 return;

osu.Game/Screens/Multi/Match/MatchSubScreen.cs

@@ -202,7 +202,7 @@ namespace osu.Game.Screens.Multi.Match
         /// <summary>
         /// Handle the case where a beatmap is imported (and can be used by this match).
         /// </summary>
-        private void beatmapAdded(BeatmapSetInfo model, bool existing, bool silent) => Schedule(() =>
+        private void beatmapAdded(BeatmapSetInfo model, bool existing) => Schedule(() =>
         {
             if (Beatmap.Value != beatmapManager.DefaultBeatmap)
                 return;

osu.Game/Screens/Play/Player.cs

@@ -298,7 +298,7 @@ namespace osu.Game.Screens.Play
 
                     var score = CreateScore();
                     if (RulesetContainer.ReplayScore == null)
-                        scoreManager.Import(score, true);
+                        scoreManager.Import(score);
 
                     this.Push(CreateResults(score));
 

osu.Game/Screens/Play/SquareGraph.cs

@@ -242,7 +242,11 @@ namespace osu.Game.Screens.Play
 
                 // Reverse drawableRows so when iterating through them they start at the bottom
                 drawableRows.Reverse();
+            }
 
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
                 fillActive();
             }
 

osu.Game/Screens/Select/SongSelect.cs

@@ -582,7 +582,7 @@ namespace osu.Game.Screens.Select
             }
         }
 
-        private void onBeatmapSetAdded(BeatmapSetInfo s, bool existing, bool silent) => Carousel.UpdateBeatmapSet(s);
+        private void onBeatmapSetAdded(BeatmapSetInfo s, bool existing) => Carousel.UpdateBeatmapSet(s);
         private void onBeatmapSetRemoved(BeatmapSetInfo s) => Carousel.RemoveBeatmapSet(s);
         private void onBeatmapRestored(BeatmapInfo b) => Carousel.UpdateBeatmapSet(beatmaps.QueryBeatmapSet(s => s.ID == b.BeatmapSetInfoID));
         private void onBeatmapHidden(BeatmapInfo b) => Carousel.UpdateBeatmapSet(beatmaps.QueryBeatmapSet(s => s.ID == b.BeatmapSetInfoID));

osu.sln.DotSettings

@@ -230,6 +230,8 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTLINE_TYPE_PARAMETER_LIST/@EntryValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ANONYMOUS_METHOD_DECLARATION_BRACES/@EntryValue">NEXT_LINE</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INITIALIZER_BRACES/@EntryValue">NEXT_LINE</s:String>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_CODE/@EntryValue">1</s:Int64>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue">1</s:Int64>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/LINE_FEED_AT_FILE_END/@EntryValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_ACCESSORHOLDER_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_ACCESSOR_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>