Merge branch 'master' into adjust-rankings-overlay

osu.Game/Audio/HitSampleInfo.cs

@@ -1,8 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable enable
+
 using System;
 using System.Collections.Generic;
+using Newtonsoft.Json;
+using osu.Game.Utils;
 
 namespace osu.Game.Audio
 {
@@ -10,7 +14,7 @@ namespace osu.Game.Audio
     /// Describes a gameplay hit sample.
     /// </summary>
     [Serializable]
-    public class HitSampleInfo : ISampleInfo
+    public class HitSampleInfo : ISampleInfo, IEquatable<HitSampleInfo>
     {
         public const string HIT_WHISTLE = @"hitwhistle";
         public const string HIT_FINISH = @"hitfinish";
@@ -18,39 +22,70 @@ namespace osu.Game.Audio
         public const string HIT_CLAP = @"hitclap";
 
         /// <summary>
-        /// The bank to load the sample from.
+        /// All valid sample addition constants.
         /// </summary>
-        public string Bank;
+        public static IEnumerable<string> AllAdditions => new[] { HIT_WHISTLE, HIT_CLAP, HIT_FINISH };
 
         /// <summary>
         /// The name of the sample to load.
         /// </summary>
-        public string Name;
+        public readonly string Name;
+
+        /// <summary>
+        /// The bank to load the sample from.
+        /// </summary>
+        public readonly string? Bank;
 
         /// <summary>
         /// An optional suffix to provide priority lookup. Falls back to non-suffixed <see cref="Name"/>.
         /// </summary>
-        public string Suffix;
+        public readonly string? Suffix;
 
         /// <summary>
         /// The sample volume.
         /// </summary>
-        public int Volume { get; set; }
+        public int Volume { get; }
+
+        public HitSampleInfo(string name, string? bank = null, string? suffix = null, int volume = 0)
+        {
+            Name = name;
+            Bank = bank;
+            Suffix = suffix;
+            Volume = volume;
+        }
 
         /// <summary>
         /// Retrieve all possible filenames that can be used as a source, returned in order of preference (highest first).
         /// </summary>
+        [JsonIgnore]
         public virtual IEnumerable<string> LookupNames
         {
             get
             {
                 if (!string.IsNullOrEmpty(Suffix))
-                    yield return $"{Bank}-{Name}{Suffix}";
+                    yield return $"Gameplay/{Bank}-{Name}{Suffix}";
 
-                yield return $"{Bank}-{Name}";
+                yield return $"Gameplay/{Bank}-{Name}";
             }
         }
 
-        public HitSampleInfo Clone() => (HitSampleInfo)MemberwiseClone();
+        /// <summary>
+        /// Creates a new <see cref="HitSampleInfo"/> with overridden values.
+        /// </summary>
+        /// <param name="newName">An optional new sample name.</param>
+        /// <param name="newBank">An optional new sample bank.</param>
+        /// <param name="newSuffix">An optional new lookup suffix.</param>
+        /// <param name="newVolume">An optional new volume.</param>
+        /// <returns>The new <see cref="HitSampleInfo"/>.</returns>
+        public virtual HitSampleInfo With(Optional<string> newName = default, Optional<string?> newBank = default, Optional<string?> newSuffix = default, Optional<int> newVolume = default)
+            => new HitSampleInfo(newName.GetOr(Name), newBank.GetOr(Bank), newSuffix.GetOr(Suffix), newVolume.GetOr(Volume));
+
+        public bool Equals(HitSampleInfo? other)
+            => other != null && Name == other.Name && Bank == other.Bank && Suffix == other.Suffix;
+
+        public override bool Equals(object? obj)
+            => obj is HitSampleInfo other && Equals(other);
+
+        public override int GetHashCode() => HashCode.Combine(Name, Bank, Suffix);
     }
 }

osu.Game/Audio/PreviewTrackManager.cs

@@ -11,6 +11,7 @@ using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.IO.Stores;
+using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 
 namespace osu.Game.Audio
@@ -26,6 +27,8 @@ namespace osu.Game.Audio
 
         protected TrackManagerPreviewTrack CurrentTrack;
 
+        private readonly BindableNumber<double> globalTrackVolumeAdjust = new BindableNumber<double>(OsuGameBase.GLOBAL_TRACK_VOLUME_ADJUST);
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -34,6 +37,7 @@ namespace osu.Game.Audio
             trackStore = new PreviewTrackStore(new OnlineStore());
 
             audio.AddItem(trackStore);
+            trackStore.AddAdjustment(AdjustableProperty.Volume, globalTrackVolumeAdjust);
             trackStore.AddAdjustment(AdjustableProperty.Volume, audio.VolumeTrack);
         }
 
@@ -76,7 +80,7 @@ namespace osu.Game.Audio
         /// <param name="source">The <see cref="IPreviewTrackOwner"/> which may be the owner of the <see cref="PreviewTrack"/>.</param>
         public void StopAnyPlaying(IPreviewTrackOwner source)
         {
-            if (CurrentTrack == null || CurrentTrack.Owner != source)
+            if (CurrentTrack == null || (CurrentTrack.Owner != null && CurrentTrack.Owner != source))
                 return;
 
             CurrentTrack.Stop();
@@ -86,11 +90,12 @@ namespace osu.Game.Audio
         /// <summary>
         /// Creates the <see cref="TrackManagerPreviewTrack"/>.
         /// </summary>
-        protected virtual TrackManagerPreviewTrack CreatePreviewTrack(BeatmapSetInfo beatmapSetInfo, ITrackStore trackStore) => new TrackManagerPreviewTrack(beatmapSetInfo, trackStore);
+        protected virtual TrackManagerPreviewTrack CreatePreviewTrack(BeatmapSetInfo beatmapSetInfo, ITrackStore trackStore) =>
+            new TrackManagerPreviewTrack(beatmapSetInfo, trackStore);
 
         public class TrackManagerPreviewTrack : PreviewTrack
         {
-            [Resolved]
+            [Resolved(canBeNull: true)]
             public IPreviewTrackOwner Owner { get; private set; }
 
             private readonly BeatmapSetInfo beatmapSetInfo;
@@ -102,6 +107,12 @@ namespace osu.Game.Audio
                 this.trackManager = trackManager;
             }
 
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                Logger.Log($"A {nameof(PreviewTrack)} was created without a containing {nameof(IPreviewTrackOwner)}. An owner should be added for correct behaviour.");
+            }
+
             protected override Track GetTrack() => trackManager.Get($"https://b.ppy.sh/preview/{beatmapSetInfo?.OnlineBeatmapSetID}.mp3");
         }
 

osu.Game/Audio/SampleInfo.cs

@@ -1,24 +1,41 @@
 // 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;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace osu.Game.Audio
 {
     /// <summary>
     /// Describes a gameplay sample.
     /// </summary>
-    public class SampleInfo : ISampleInfo
+    public class SampleInfo : ISampleInfo, IEquatable<SampleInfo>
     {
-        private readonly string sampleName;
+        private readonly string[] sampleNames;
 
-        public SampleInfo(string sampleName)
+        public SampleInfo(params string[] sampleNames)
         {
-            this.sampleName = sampleName;
+            this.sampleNames = sampleNames;
+            Array.Sort(sampleNames);
         }
 
-        public IEnumerable<string> LookupNames => new[] { sampleName };
+        public IEnumerable<string> LookupNames => sampleNames;
 
         public int Volume { get; } = 100;
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                StructuralComparisons.StructuralEqualityComparer.GetHashCode(sampleNames),
+                Volume);
+        }
+
+        public bool Equals(SampleInfo other)
+            => other != null && sampleNames.SequenceEqual(other.sampleNames);
+
+        public override bool Equals(object obj)
+            => obj is SampleInfo other && Equals(other);
     }
 }

osu.Game/Beatmaps/Beatmap.cs

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

osu.Game/Beatmaps/BeatmapConverter.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
 
@@ -16,12 +17,12 @@ namespace osu.Game.Beatmaps
     public abstract class BeatmapConverter<T> : IBeatmapConverter
         where T : HitObject
     {
-        private event Action<HitObject, IEnumerable<HitObject>> ObjectConverted;
+        private event Action<HitObject, IEnumerable<HitObject>> objectConverted;
 
         event Action<HitObject, IEnumerable<HitObject>> IBeatmapConverter.ObjectConverted
         {
-            add => ObjectConverted += value;
-            remove => ObjectConverted -= value;
+            add => objectConverted += value;
+            remove => objectConverted -= value;
         }
 
         public IBeatmap Beatmap { get; }
@@ -36,34 +37,31 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public abstract bool CanConvert();
 
-        /// <summary>
-        /// Converts <see cref="Beatmap"/>.
-        /// </summary>
-        /// <returns>The converted Beatmap.</returns>
-        public IBeatmap Convert()
+        public IBeatmap Convert(CancellationToken cancellationToken = default)
         {
             // We always operate on a clone of the original beatmap, to not modify it game-wide
-            return ConvertBeatmap(Beatmap.Clone());
+            return ConvertBeatmap(Beatmap.Clone(), cancellationToken);
         }
 
         /// <summary>
         /// Performs the conversion of a Beatmap using this Beatmap Converter.
         /// </summary>
         /// <param name="original">The un-converted Beatmap.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>The converted Beatmap.</returns>
-        protected virtual Beatmap<T> ConvertBeatmap(IBeatmap original)
+        protected virtual Beatmap<T> ConvertBeatmap(IBeatmap original, CancellationToken cancellationToken)
         {
             var beatmap = CreateBeatmap();
 
             beatmap.BeatmapInfo = original.BeatmapInfo;
             beatmap.ControlPointInfo = original.ControlPointInfo;
-            beatmap.HitObjects = convertHitObjects(original.HitObjects, original);
+            beatmap.HitObjects = convertHitObjects(original.HitObjects, original, cancellationToken).OrderBy(s => s.StartTime).ToList();
             beatmap.Breaks = original.Breaks;
 
             return beatmap;
         }
 
-        private List<T> convertHitObjects(IReadOnlyList<HitObject> hitObjects, IBeatmap beatmap)
+        private List<T> convertHitObjects(IReadOnlyList<HitObject> hitObjects, IBeatmap beatmap, CancellationToken cancellationToken)
         {
             var result = new List<T>(hitObjects.Count);
 
@@ -75,12 +73,12 @@ namespace osu.Game.Beatmaps
                     continue;
                 }
 
-                var converted = ConvertHitObject(obj, beatmap);
+                var converted = ConvertHitObject(obj, beatmap, cancellationToken);
 
-                if (ObjectConverted != null)
+                if (objectConverted != null)
                 {
                     converted = converted.ToList();
-                    ObjectConverted.Invoke(obj, converted);
+                    objectConverted.Invoke(obj, converted);
                 }
 
                 foreach (var c in converted)
@@ -104,7 +102,8 @@ namespace osu.Game.Beatmaps
         /// </summary>
         /// <param name="original">The hit object to convert.</param>
         /// <param name="beatmap">The un-converted Beatmap.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>The converted hit object.</returns>
-        protected abstract IEnumerable<T> ConvertHitObject(HitObject original, IBeatmap beatmap);
+        protected virtual IEnumerable<T> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken) => Enumerable.Empty<T>();
     }
 }

osu.Game/Beatmaps/BeatmapDifficultyCache.cs

@@ -0,0 +1,328 @@
+// 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.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Lists;
+using osu.Framework.Logging;
+using osu.Framework.Threading;
+using osu.Framework.Utils;
+using osu.Game.Database;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// A component which performs and acts as a central cache for difficulty calculations of beatmap/ruleset/mod combinations.
+    /// Currently not persisted between game sessions.
+    /// </summary>
+    public class BeatmapDifficultyCache : MemoryCachingComponent<BeatmapDifficultyCache.DifficultyCacheLookup, StarDifficulty>
+    {
+        // Too many simultaneous updates can lead to stutters. One thread seems to work fine for song select display purposes.
+        private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(1, nameof(BeatmapDifficultyCache));
+
+        /// <summary>
+        /// All bindables that should be updated along with the current ruleset + mods.
+        /// </summary>
+        private readonly WeakList<BindableStarDifficulty> trackedBindables = new WeakList<BindableStarDifficulty>();
+
+        /// <summary>
+        /// Cancellation sources used by tracked bindables.
+        /// </summary>
+        private readonly List<CancellationTokenSource> linkedCancellationSources = new List<CancellationTokenSource>();
+
+        /// <summary>
+        /// Lock to be held when operating on <see cref="trackedBindables"/> or <see cref="linkedCancellationSources"/>.
+        /// </summary>
+        private readonly object bindableUpdateLock = new object();
+
+        private CancellationTokenSource trackedUpdateCancellationSource;
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; }
+
+        [Resolved]
+        private Bindable<RulesetInfo> currentRuleset { get; set; }
+
+        [Resolved]
+        private Bindable<IReadOnlyList<Mod>> currentMods { get; set; }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            currentRuleset.BindValueChanged(_ => updateTrackedBindables());
+            currentMods.BindValueChanged(_ => updateTrackedBindables(), true);
+        }
+
+        /// <summary>
+        /// Retrieves a bindable containing the star difficulty of a <see cref="BeatmapInfo"/> that follows the currently-selected ruleset and mods.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> to get the difficulty of.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops updating the star difficulty for the given <see cref="BeatmapInfo"/>.</param>
+        /// <returns>A bindable that is updated to contain the star difficulty when it becomes available. Will be null while in an initial calculating state (but not during updates to ruleset and mods if a stale value is already propagated).</returns>
+        public IBindable<StarDifficulty?> GetBindableDifficulty([NotNull] BeatmapInfo beatmapInfo, CancellationToken cancellationToken = default)
+        {
+            var bindable = createBindable(beatmapInfo, currentRuleset.Value, currentMods.Value, cancellationToken);
+
+            lock (bindableUpdateLock)
+                trackedBindables.Add(bindable);
+
+            return bindable;
+        }
+
+        /// <summary>
+        /// Retrieves a bindable containing the star difficulty of a <see cref="BeatmapInfo"/> with a given <see cref="RulesetInfo"/> and <see cref="Mod"/> combination.
+        /// </summary>
+        /// <remarks>
+        /// The bindable will not update to follow the currently-selected ruleset and mods.
+        /// </remarks>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> to get the difficulty of.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/> to get the difficulty with. If <c>null</c>, the <paramref name="beatmapInfo"/>'s ruleset is used.</param>
+        /// <param name="mods">The <see cref="Mod"/>s to get the difficulty with. If <c>null</c>, no mods will be assumed.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops updating the star difficulty for the given <see cref="BeatmapInfo"/>.</param>
+        /// <returns>A bindable that is updated to contain the star difficulty when it becomes available. Will be null while in an initial calculating state.</returns>
+        public IBindable<StarDifficulty?> GetBindableDifficulty([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo rulesetInfo, [CanBeNull] IEnumerable<Mod> mods,
+                                                                CancellationToken cancellationToken = default)
+            => createBindable(beatmapInfo, rulesetInfo, mods, cancellationToken);
+
+        /// <summary>
+        /// Retrieves the difficulty of a <see cref="BeatmapInfo"/>.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> to get the difficulty of.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/> to get the difficulty with.</param>
+        /// <param name="mods">The <see cref="Mod"/>s to get the difficulty with.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops computing the star difficulty.</param>
+        /// <returns>The <see cref="StarDifficulty"/>.</returns>
+        public virtual Task<StarDifficulty> GetDifficultyAsync([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo rulesetInfo = null,
+                                                               [CanBeNull] IEnumerable<Mod> mods = null, CancellationToken cancellationToken = default)
+        {
+            // In the case that the user hasn't given us a ruleset, use the beatmap's default ruleset.
+            rulesetInfo ??= beatmapInfo.Ruleset;
+
+            // Difficulty can only be computed if the beatmap and ruleset are locally available.
+            if (beatmapInfo.ID == 0 || rulesetInfo.ID == null)
+            {
+                // If not, fall back to the existing star difficulty (e.g. from an online source).
+                return Task.FromResult(new StarDifficulty(beatmapInfo.StarDifficulty, beatmapInfo.MaxCombo ?? 0));
+            }
+
+            return GetAsync(new DifficultyCacheLookup(beatmapInfo, rulesetInfo, mods), cancellationToken);
+        }
+
+        protected override Task<StarDifficulty> ComputeValueAsync(DifficultyCacheLookup lookup, CancellationToken token = default)
+        {
+            return Task.Factory.StartNew(() =>
+            {
+                if (CheckExists(lookup, out var existing))
+                    return existing;
+
+                return computeDifficulty(lookup);
+            }, token, TaskCreationOptions.HideScheduler | TaskCreationOptions.RunContinuationsAsynchronously, updateScheduler);
+        }
+
+        /// <summary>
+        /// Retrieves the <see cref="DifficultyRating"/> that describes a star rating.
+        /// </summary>
+        /// <remarks>
+        /// For more information, see: https://osu.ppy.sh/help/wiki/Difficulties
+        /// </remarks>
+        /// <param name="starRating">The star rating.</param>
+        /// <returns>The <see cref="DifficultyRating"/> that best describes <paramref name="starRating"/>.</returns>
+        public static DifficultyRating GetDifficultyRating(double starRating)
+        {
+            if (Precision.AlmostBigger(starRating, 6.5, 0.005))
+                return DifficultyRating.ExpertPlus;
+
+            if (Precision.AlmostBigger(starRating, 5.3, 0.005))
+                return DifficultyRating.Expert;
+
+            if (Precision.AlmostBigger(starRating, 4.0, 0.005))
+                return DifficultyRating.Insane;
+
+            if (Precision.AlmostBigger(starRating, 2.7, 0.005))
+                return DifficultyRating.Hard;
+
+            if (Precision.AlmostBigger(starRating, 2.0, 0.005))
+                return DifficultyRating.Normal;
+
+            return DifficultyRating.Easy;
+        }
+
+        /// <summary>
+        /// Updates all tracked <see cref="BindableStarDifficulty"/> using the current ruleset and mods.
+        /// </summary>
+        private void updateTrackedBindables()
+        {
+            lock (bindableUpdateLock)
+            {
+                cancelTrackedBindableUpdate();
+                trackedUpdateCancellationSource = new CancellationTokenSource();
+
+                foreach (var b in trackedBindables)
+                {
+                    var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(trackedUpdateCancellationSource.Token, b.CancellationToken);
+                    linkedCancellationSources.Add(linkedSource);
+
+                    updateBindable(b, currentRuleset.Value, currentMods.Value, linkedSource.Token);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Cancels the existing update of all tracked <see cref="BindableStarDifficulty"/> via <see cref="updateTrackedBindables"/>.
+        /// </summary>
+        private void cancelTrackedBindableUpdate()
+        {
+            lock (bindableUpdateLock)
+            {
+                trackedUpdateCancellationSource?.Cancel();
+                trackedUpdateCancellationSource = null;
+
+                if (linkedCancellationSources != null)
+                {
+                    foreach (var c in linkedCancellationSources)
+                        c.Dispose();
+
+                    linkedCancellationSources.Clear();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="BindableStarDifficulty"/> and triggers an initial value update.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> that star difficulty should correspond to.</param>
+        /// <param name="initialRulesetInfo">The initial <see cref="RulesetInfo"/> to get the difficulty with.</param>
+        /// <param name="initialMods">The initial <see cref="Mod"/>s to get the difficulty with.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops updating the star difficulty for the given <see cref="BeatmapInfo"/>.</param>
+        /// <returns>The <see cref="BindableStarDifficulty"/>.</returns>
+        private BindableStarDifficulty createBindable([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo initialRulesetInfo, [CanBeNull] IEnumerable<Mod> initialMods,
+                                                      CancellationToken cancellationToken)
+        {
+            var bindable = new BindableStarDifficulty(beatmapInfo, cancellationToken);
+            updateBindable(bindable, initialRulesetInfo, initialMods, cancellationToken);
+            return bindable;
+        }
+
+        /// <summary>
+        /// Updates the value of a <see cref="BindableStarDifficulty"/> with a given ruleset + mods.
+        /// </summary>
+        /// <param name="bindable">The <see cref="BindableStarDifficulty"/> to update.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/> to update with.</param>
+        /// <param name="mods">The <see cref="Mod"/>s to update with.</param>
+        /// <param name="cancellationToken">A token that may be used to cancel this update.</param>
+        private void updateBindable([NotNull] BindableStarDifficulty bindable, [CanBeNull] RulesetInfo rulesetInfo, [CanBeNull] IEnumerable<Mod> mods, CancellationToken cancellationToken = default)
+        {
+            // GetDifficultyAsync will fall back to existing data from BeatmapInfo if not locally available
+            // (contrary to GetAsync)
+            GetDifficultyAsync(bindable.Beatmap, rulesetInfo, mods, cancellationToken)
+                .ContinueWith(t =>
+                {
+                    // We're on a threadpool thread, but we should exit back to the update thread so consumers can safely handle value-changed events.
+                    Schedule(() =>
+                    {
+                        if (!cancellationToken.IsCancellationRequested)
+                            bindable.Value = t.Result;
+                    });
+                }, cancellationToken);
+        }
+
+        /// <summary>
+        /// Computes the difficulty defined by a <see cref="DifficultyCacheLookup"/> key, and stores it to the timed cache.
+        /// </summary>
+        /// <param name="key">The <see cref="DifficultyCacheLookup"/> that defines the computation parameters.</param>
+        /// <returns>The <see cref="StarDifficulty"/>.</returns>
+        private StarDifficulty computeDifficulty(in DifficultyCacheLookup key)
+        {
+            // In the case that the user hasn't given us a ruleset, use the beatmap's default ruleset.
+            var beatmapInfo = key.Beatmap;
+            var rulesetInfo = key.Ruleset;
+
+            try
+            {
+                var ruleset = rulesetInfo.CreateInstance();
+                Debug.Assert(ruleset != null);
+
+                var calculator = ruleset.CreateDifficultyCalculator(beatmapManager.GetWorkingBeatmap(key.Beatmap));
+                var attributes = calculator.Calculate(key.OrderedMods);
+
+                return new StarDifficulty(attributes);
+            }
+            catch (BeatmapInvalidForRulesetException e)
+            {
+                if (rulesetInfo.Equals(beatmapInfo.Ruleset))
+                    Logger.Error(e, $"Failed to convert {beatmapInfo.OnlineBeatmapID} to the beatmap's default ruleset ({beatmapInfo.Ruleset}).");
+
+                return new StarDifficulty();
+            }
+            catch
+            {
+                return new StarDifficulty();
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            cancelTrackedBindableUpdate();
+            updateScheduler?.Dispose();
+        }
+
+        public readonly struct DifficultyCacheLookup : IEquatable<DifficultyCacheLookup>
+        {
+            public readonly BeatmapInfo Beatmap;
+            public readonly RulesetInfo Ruleset;
+
+            public readonly Mod[] OrderedMods;
+
+            public DifficultyCacheLookup([NotNull] BeatmapInfo beatmap, [CanBeNull] RulesetInfo ruleset, IEnumerable<Mod> mods)
+            {
+                Beatmap = beatmap;
+                // In the case that the user hasn't given us a ruleset, use the beatmap's default ruleset.
+                Ruleset = ruleset ?? Beatmap.Ruleset;
+                OrderedMods = mods?.OrderBy(m => m.Acronym).ToArray() ?? Array.Empty<Mod>();
+            }
+
+            public bool Equals(DifficultyCacheLookup other)
+                => Beatmap.ID == other.Beatmap.ID
+                   && Ruleset.ID == other.Ruleset.ID
+                   && OrderedMods.Select(m => m.Acronym).SequenceEqual(other.OrderedMods.Select(m => m.Acronym));
+
+            public override int GetHashCode()
+            {
+                var hashCode = new HashCode();
+
+                hashCode.Add(Beatmap.ID);
+                hashCode.Add(Ruleset.ID);
+
+                foreach (var mod in OrderedMods)
+                    hashCode.Add(mod.Acronym);
+
+                return hashCode.ToHashCode();
+            }
+        }
+
+        private class BindableStarDifficulty : Bindable<StarDifficulty?>
+        {
+            public readonly BeatmapInfo Beatmap;
+            public readonly CancellationToken CancellationToken;
+
+            public BindableStarDifficulty(BeatmapInfo beatmap, CancellationToken cancellationToken)
+            {
+                Beatmap = beatmap;
+                CancellationToken = cancellationToken;
+            }
+        }
+    }
+}

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -7,6 +7,8 @@ using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using Newtonsoft.Json;
+using osu.Framework.Localisation;
+using osu.Framework.Testing;
 using osu.Game.Database;
 using osu.Game.IO.Serialization;
 using osu.Game.Rulesets;
@@ -14,6 +16,7 @@ using osu.Game.Scoring;
 
 namespace osu.Game.Beatmaps
 {
+    [ExcludeFromDynamicCompile]
     [Serializable]
     public class BeatmapInfo : IEquatable<BeatmapInfo>, IJsonSerializable, IHasPrimaryKey
     {
@@ -90,13 +93,14 @@ namespace osu.Game.Beatmaps
 
         public bool LetterboxInBreaks { get; set; }
         public bool WidescreenStoryboard { get; set; }
+        public bool EpilepsyWarning { get; set; }
 
         // Editor
         // This bookmarks stuff is necessary because DB doesn't know how to store int[]
         [JsonIgnore]
         public string StoredBookmarks
         {
-            get => string.Join(",", Bookmarks);
+            get => string.Join(',', Bookmarks);
             set
             {
                 if (string.IsNullOrEmpty(value))
@@ -124,6 +128,8 @@ namespace osu.Game.Beatmaps
         // Metadata
         public string Version { get; set; }
 
+        private string versionString => string.IsNullOrEmpty(Version) ? string.Empty : $"[{Version}]";
+
         [JsonProperty("difficulty_rating")]
         public double StarDifficulty { get; set; }
 
@@ -133,24 +139,21 @@ namespace osu.Game.Beatmaps
         public List<ScoreInfo> Scores { get; set; }
 
         [JsonIgnore]
-        public DifficultyRating DifficultyRating
+        public DifficultyRating DifficultyRating => BeatmapDifficultyCache.GetDifficultyRating(StarDifficulty);
+
+        public string[] SearchableTerms => new[]
         {
-            get
-            {
-                var rating = StarDifficulty;
+            Version
+        }.Concat(Metadata?.SearchableTerms ?? Enumerable.Empty<string>()).Where(s => !string.IsNullOrEmpty(s)).ToArray();
 
-                if (rating < 2.0) return DifficultyRating.Easy;
-                if (rating < 2.7) return DifficultyRating.Normal;
-                if (rating < 4.0) return DifficultyRating.Hard;
-                if (rating < 5.3) return DifficultyRating.Insane;
-                if (rating < 6.5) return DifficultyRating.Expert;
+        public override string ToString() => $"{Metadata ?? BeatmapSet?.Metadata} {versionString}".Trim();
 
-                return DifficultyRating.ExpertPlus;
-            }
+        public RomanisableString ToRomanisableString()
+        {
+            var metadata = (Metadata ?? BeatmapSet?.Metadata)?.ToRomanisableString() ?? new RomanisableString(null, null);
+            return new RomanisableString($"{metadata.GetPreferred(true)} {versionString}".Trim(), $"{metadata.GetPreferred(false)} {versionString}".Trim());
         }
 
-        public override string ToString() => $"{Metadata} [{Version}]".Trim();
-
         public bool Equals(BeatmapInfo other)
         {
             if (ID == 0 || other?.ID == 0)

osu.Game/Beatmaps/BeatmapManager.cs

@@ -9,16 +9,19 @@ using System.Linq.Expressions;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
+using osu.Framework.IO.Stores;
 using osu.Framework.Lists;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
-using osu.Framework.Threading;
+using osu.Framework.Statistics;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Database;
 using osu.Game.IO;
@@ -27,60 +30,80 @@ using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Skinning;
+using osu.Game.Users;
 using Decoder = osu.Game.Beatmaps.Formats.Decoder;
-using ZipArchive = SharpCompress.Archives.Zip.ZipArchive;
 
 namespace osu.Game.Beatmaps
 {
     /// <summary>
     /// Handles the storage and retrieval of Beatmaps/WorkingBeatmaps.
     /// </summary>
-    public partial class BeatmapManager : DownloadableArchiveModelManager<BeatmapSetInfo, BeatmapSetFileInfo>
+    [ExcludeFromDynamicCompile]
+    public partial class BeatmapManager : DownloadableArchiveModelManager<BeatmapSetInfo, BeatmapSetFileInfo>, IDisposable, IBeatmapResourceProvider
     {
         /// <summary>
         /// Fired when a single difficulty has been hidden.
         /// </summary>
-        public event Action<BeatmapInfo> BeatmapHidden;
+        public IBindable<WeakReference<BeatmapInfo>> BeatmapHidden => beatmapHidden;
+
+        private readonly Bindable<WeakReference<BeatmapInfo>> beatmapHidden = new Bindable<WeakReference<BeatmapInfo>>();
 
         /// <summary>
         /// Fired when a single difficulty has been restored.
         /// </summary>
-        public event Action<BeatmapInfo> BeatmapRestored;
+        public IBindable<WeakReference<BeatmapInfo>> BeatmapRestored => beatmapRestored;
+
+        private readonly Bindable<WeakReference<BeatmapInfo>> beatmapRestored = new Bindable<WeakReference<BeatmapInfo>>();
 
         /// <summary>
         /// A default representation of a WorkingBeatmap to use when no beatmap is available.
         /// </summary>
         public readonly WorkingBeatmap DefaultBeatmap;
 
-        public override string[] HandledExtensions => new[] { ".osz" };
+        public override IEnumerable<string> HandledExtensions => new[] { ".osz" };
 
         protected override string[] HashableFileTypes => new[] { ".osu" };
 
-        protected override string ImportFromStablePath => "Songs";
+        protected override string ImportFromStablePath => ".";
+
+        protected override Storage PrepareStableStorage(StableStorage stableStorage) => stableStorage.GetSongStorage();
 
         private readonly RulesetStore rulesets;
         private readonly BeatmapStore beatmaps;
         private readonly AudioManager audioManager;
-        private readonly GameHost host;
-        private readonly BeatmapUpdateQueue updateQueue;
-        private readonly Storage exportStorage;
+        private readonly IResourceStore<byte[]> resources;
+        private readonly LargeTextureStore largeTextureStore;
+        private readonly ITrackStore trackStore;
 
-        public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, AudioManager audioManager, GameHost host = null,
-                              WorkingBeatmap defaultBeatmap = null)
+        [CanBeNull]
+        private readonly GameHost host;
+
+        [CanBeNull]
+        private readonly BeatmapOnlineLookupQueue onlineLookupQueue;
+
+        public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, IResourceStore<byte[]> resources, GameHost host = null,
+                              WorkingBeatmap defaultBeatmap = null, bool performOnlineLookups = false)
             : base(storage, contextFactory, api, new BeatmapStore(contextFactory), host)
         {
             this.rulesets = rulesets;
             this.audioManager = audioManager;
+            this.resources = resources;
             this.host = host;
 
             DefaultBeatmap = defaultBeatmap;
 
             beatmaps = (BeatmapStore)ModelStore;
-            beatmaps.BeatmapHidden += b => BeatmapHidden?.Invoke(b);
-            beatmaps.BeatmapRestored += b => BeatmapRestored?.Invoke(b);
+            beatmaps.BeatmapHidden += b => beatmapHidden.Value = new WeakReference<BeatmapInfo>(b);
+            beatmaps.BeatmapRestored += b => beatmapRestored.Value = new WeakReference<BeatmapInfo>(b);
+            beatmaps.ItemRemoved += removeWorkingCache;
+            beatmaps.ItemUpdated += removeWorkingCache;
 
-            updateQueue = new BeatmapUpdateQueue(api);
-            exportStorage = storage.GetStorageForDirectory("exports");
+            if (performOnlineLookups)
+                onlineLookupQueue = new BeatmapOnlineLookupQueue(api, storage);
+
+            largeTextureStore = new LargeTextureStore(host?.CreateTextureLoaderStore(Files.Store));
+            trackStore = audioManager.GetTrackStore(Files.Store);
         }
 
         protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize) =>
@@ -88,7 +111,32 @@ namespace osu.Game.Beatmaps
 
         protected override bool ShouldDeleteArchive(string path) => Path.GetExtension(path)?.ToLowerInvariant() == ".osz";
 
-        protected override Task Populate(BeatmapSetInfo beatmapSet, ArchiveReader archive, CancellationToken cancellationToken = default)
+        public WorkingBeatmap CreateNew(RulesetInfo ruleset, User user)
+        {
+            var metadata = new BeatmapMetadata
+            {
+                Author = user,
+            };
+
+            var set = new BeatmapSetInfo
+            {
+                Metadata = metadata,
+                Beatmaps = new List<BeatmapInfo>
+                {
+                    new BeatmapInfo
+                    {
+                        BaseDifficulty = new BeatmapDifficulty(),
+                        Ruleset = ruleset,
+                        Metadata = metadata,
+                    }
+                }
+            };
+
+            var working = Import(set).Result;
+            return GetWorkingBeatmap(working.Beatmaps.First());
+        }
+
+        protected override async Task Populate(BeatmapSetInfo beatmapSet, ArchiveReader archive, CancellationToken cancellationToken = default)
         {
             if (archive != null)
                 beatmapSet.Beatmaps = createBeatmapDifficulties(beatmapSet.Files);
@@ -104,7 +152,20 @@ namespace osu.Game.Beatmaps
 
             validateOnlineIds(beatmapSet);
 
-            return updateQueue.UpdateAsync(beatmapSet, cancellationToken);
+            bool hadOnlineBeatmapIDs = beatmapSet.Beatmaps.Any(b => b.OnlineBeatmapID > 0);
+
+            if (onlineLookupQueue != null)
+                await onlineLookupQueue.UpdateAsync(beatmapSet, cancellationToken).ConfigureAwait(false);
+
+            // ensure at least one beatmap was able to retrieve or keep an online ID, else drop the set ID.
+            if (hadOnlineBeatmapIDs && !beatmapSet.Beatmaps.Any(b => b.OnlineBeatmapID > 0))
+            {
+                if (beatmapSet.OnlineBeatmapSetID != null)
+                {
+                    beatmapSet.OnlineBeatmapSetID = null;
+                    LogForModel(beatmapSet, "Disassociating beatmap set ID due to loss of all beatmap IDs");
+                }
+            }
         }
 
         protected override void PreImport(BeatmapSetInfo beatmapSet)
@@ -120,8 +181,13 @@ namespace osu.Game.Beatmaps
                 if (existingOnlineId != null)
                 {
                     Delete(existingOnlineId);
-                    beatmaps.PurgeDeletable(s => s.ID == existingOnlineId.ID);
-                    LogForModel(beatmapSet, $"Found existing beatmap set with same OnlineBeatmapSetID ({beatmapSet.OnlineBeatmapSetID}). It has been purged.");
+
+                    // 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)
+                        b.OnlineBeatmapID = null;
+
+                    LogForModel(beatmapSet, $"Found existing beatmap set with same OnlineBeatmapSetID ({beatmapSet.OnlineBeatmapSetID}). It has been deleted.");
                 }
             }
         }
@@ -130,8 +196,6 @@ namespace osu.Game.Beatmaps
         {
             var beatmapIds = beatmapSet.Beatmaps.Where(b => b.OnlineBeatmapID.HasValue).Select(b => b.OnlineBeatmapID).ToList();
 
-            LogForModel(beatmapSet, "Validating online IDs...");
-
             // ensure all IDs are unique
             if (beatmapIds.GroupBy(b => b).Any(g => g.Count() > 1))
             {
@@ -180,75 +244,73 @@ namespace osu.Game.Beatmaps
         /// </summary>
         /// <param name="info">The <see cref="BeatmapInfo"/> to save the content against. The file referenced by <see cref="BeatmapInfo.Path"/> will be replaced.</param>
         /// <param name="beatmapContent">The <see cref="IBeatmap"/> content to write.</param>
-        public void Save(BeatmapInfo info, IBeatmap beatmapContent)
+        /// <param name="beatmapSkin">The beatmap <see cref="ISkin"/> content to write, null if to be omitted.</param>
+        public virtual void Save(BeatmapInfo info, IBeatmap beatmapContent, ISkin beatmapSkin = null)
         {
-            var setInfo = QueryBeatmapSet(s => s.Beatmaps.Any(b => b.ID == info.ID));
+            var setInfo = info.BeatmapSet;
 
             using (var stream = new MemoryStream())
             {
                 using (var sw = new StreamWriter(stream, Encoding.UTF8, 1024, true))
-                    new LegacyBeatmapEncoder(beatmapContent).Encode(sw);
+                    new LegacyBeatmapEncoder(beatmapContent, beatmapSkin).Encode(sw);
 
                 stream.Seek(0, SeekOrigin.Begin);
 
-                UpdateFile(setInfo, setInfo.Files.Single(f => string.Equals(f.Filename, info.Path, StringComparison.OrdinalIgnoreCase)), stream);
+                using (ContextFactory.GetForWrite())
+                {
+                    var beatmapInfo = setInfo.Beatmaps.Single(b => b.ID == info.ID);
+                    var metadata = beatmapInfo.Metadata ?? setInfo.Metadata;
+
+                    // grab the original file (or create a new one if not found).
+                    var fileInfo = setInfo.Files.SingleOrDefault(f => string.Equals(f.Filename, beatmapInfo.Path, StringComparison.OrdinalIgnoreCase)) ?? new BeatmapSetFileInfo();
+
+                    // metadata may have changed; update the path with the standard format.
+                    beatmapInfo.Path = $"{metadata.Artist} - {metadata.Title} ({metadata.Author}) [{beatmapInfo.Version}].osu";
+                    beatmapInfo.MD5Hash = stream.ComputeMD5Hash();
+
+                    // update existing or populate new file's filename.
+                    fileInfo.Filename = beatmapInfo.Path;
+
+                    stream.Seek(0, SeekOrigin.Begin);
+                    ReplaceFile(setInfo, fileInfo, stream);
+                }
             }
 
-            var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == info.ID);
-            if (working != null)
-                workingCache.Remove(working);
+            removeWorkingCache(info);
         }
 
-        /// <summary>
-        /// Exports a <see cref="BeatmapSetInfo"/> to an .osz package.
-        /// </summary>
-        /// <param name="set">The <see cref="BeatmapSetInfo"/> to export.</param>
-        public void Export(BeatmapSetInfo set)
-        {
-            var localSet = QueryBeatmapSet(s => s.ID == set.ID);
-
-            using (var archive = ZipArchive.Create())
-            {
-                foreach (var file in localSet.Files)
-                    archive.AddEntry(file.Filename, Files.Storage.GetStream(file.FileInfo.StoragePath));
-
-                using (var outputStream = exportStorage.GetStream($"{set}.osz", FileAccess.Write, FileMode.Create))
-                    archive.SaveTo(outputStream);
-
-                exportStorage.OpenInNativeExplorer();
-            }
-        }
-
-        private readonly WeakList<WorkingBeatmap> workingCache = new WeakList<WorkingBeatmap>();
+        private readonly WeakList<BeatmapManagerWorkingBeatmap> workingCache = new WeakList<BeatmapManagerWorkingBeatmap>();
 
         /// <summary>
         /// Retrieve a <see cref="WorkingBeatmap"/> instance for the provided <see cref="BeatmapInfo"/>
         /// </summary>
         /// <param name="beatmapInfo">The beatmap to lookup.</param>
-        /// <param name="previous">The currently loaded <see cref="WorkingBeatmap"/>. Allows for optimisation where elements are shared with the new beatmap. May be returned if beatmapInfo requested matches</param>
         /// <returns>A <see cref="WorkingBeatmap"/> instance correlating to the provided <see cref="BeatmapInfo"/>.</returns>
-        public WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo, WorkingBeatmap previous = null)
+        public virtual WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo)
         {
-            if (beatmapInfo?.ID > 0 && previous != null && previous.BeatmapInfo?.ID == beatmapInfo.ID)
-                return previous;
+            // if there are no files, presume the full beatmap info has not yet been fetched from the database.
+            if (beatmapInfo?.BeatmapSet?.Files.Count == 0)
+            {
+                int lookupId = beatmapInfo.ID;
+                beatmapInfo = QueryBeatmap(b => b.ID == lookupId);
+            }
 
-            if (beatmapInfo?.BeatmapSet == null || beatmapInfo == DefaultBeatmap?.BeatmapInfo)
+            if (beatmapInfo?.BeatmapSet == null)
                 return DefaultBeatmap;
 
             lock (workingCache)
             {
                 var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == beatmapInfo.ID);
+                if (working != null)
+                    return working;
 
-                if (working == null)
-                {
-                    if (beatmapInfo.Metadata == null)
-                        beatmapInfo.Metadata = beatmapInfo.BeatmapSet.Metadata;
+                beatmapInfo.Metadata ??= beatmapInfo.BeatmapSet.Metadata;
 
-                    workingCache.Add(working = new BeatmapManagerWorkingBeatmap(Files.Store,
-                        new LargeTextureStore(host?.CreateTextureLoaderStore(Files.Store)), beatmapInfo, audioManager));
-                }
+                workingCache.Add(working = new BeatmapManagerWorkingBeatmap(beatmapInfo, this));
+
+                // best effort; may be higher than expected.
+                GlobalStatistics.Get<int>(nameof(Beatmaps), $"Cached {nameof(WorkingBeatmap)}s").Value = workingCache.Count();
 
-                previous?.TransferTo(working);
                 return working;
             }
         }
@@ -260,9 +322,17 @@ namespace osu.Game.Beatmaps
         /// <returns>The first result for the provided query, or null if no results were found.</returns>
         public BeatmapSetInfo QueryBeatmapSet(Expression<Func<BeatmapSetInfo, bool>> query) => beatmaps.ConsumableItems.AsNoTracking().FirstOrDefault(query);
 
-        protected override bool CanUndelete(BeatmapSetInfo existing, BeatmapSetInfo import)
+        protected override bool CanSkipImport(BeatmapSetInfo existing, BeatmapSetInfo import)
         {
-            if (!base.CanUndelete(existing, import))
+            if (!base.CanReuseExisting(existing, import))
+                return false;
+
+            return existing.Beatmaps.Any(b => b.OnlineBeatmapID != null);
+        }
+
+        protected override bool CanReuseExisting(BeatmapSetInfo existing, BeatmapSetInfo import)
+        {
+            if (!base.CanReuseExisting(existing, import))
                 return false;
 
             var existingIds = existing.Beatmaps.Select(b => b.OnlineBeatmapID).OrderBy(i => i);
@@ -276,13 +346,39 @@ namespace osu.Game.Beatmaps
         /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
         /// </summary>
         /// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
-        public List<BeatmapSetInfo> GetAllUsableBeatmapSets() => GetAllUsableBeatmapSetsEnumerable().ToList();
+        public List<BeatmapSetInfo> GetAllUsableBeatmapSets(IncludedDetails includes = IncludedDetails.All, bool includeProtected = false) =>
+            GetAllUsableBeatmapSetsEnumerable(includes, includeProtected).ToList();
 
         /// <summary>
-        /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
+        /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s. Note that files are not populated.
         /// </summary>
+        /// <param name="includes">The level of detail to include in the returned objects.</param>
+        /// <param name="includeProtected">Whether to include protected (system) beatmaps. These should not be included for gameplay playable use cases.</param>
         /// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
-        public IQueryable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable() => beatmaps.ConsumableItems.Where(s => !s.DeletePending && !s.Protected);
+        public IEnumerable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable(IncludedDetails includes, bool includeProtected = false)
+        {
+            IQueryable<BeatmapSetInfo> queryable;
+
+            switch (includes)
+            {
+                case IncludedDetails.Minimal:
+                    queryable = beatmaps.BeatmapSetsOverview;
+                    break;
+
+                case IncludedDetails.AllButFiles:
+                    queryable = beatmaps.BeatmapSetsWithoutFiles;
+                    break;
+
+                default:
+                    queryable = beatmaps.ConsumableItems;
+                    break;
+            }
+
+            // AsEnumerable used here to avoid applying the WHERE in sql. When done so, ef core 2.x uses an incorrect ORDER BY
+            // clause which causes queries to take 5-10x longer.
+            // TODO: remove if upgrading to EF core 3.x.
+            return queryable.AsEnumerable().Where(s => !s.DeletePending && (includeProtected || !s.Protected));
+        }
 
         /// <summary>
         /// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
@@ -310,7 +406,7 @@ namespace osu.Game.Beatmaps
         protected override BeatmapSetInfo CreateModel(ArchiveReader reader)
         {
             // let's make sure there are actually .osu files to import.
-            string mapName = reader.Filenames.FirstOrDefault(f => f.EndsWith(".osu"));
+            string mapName = reader.Filenames.FirstOrDefault(f => f.EndsWith(".osu", StringComparison.OrdinalIgnoreCase));
 
             if (string.IsNullOrEmpty(mapName))
             {
@@ -338,10 +434,10 @@ namespace osu.Game.Beatmaps
         {
             var beatmapInfos = new List<BeatmapInfo>();
 
-            foreach (var file in files.Where(f => f.Filename.EndsWith(".osu")))
+            foreach (var file in files.Where(f => f.Filename.EndsWith(".osu", StringComparison.OrdinalIgnoreCase)))
             {
                 using (var raw = Files.Store.GetStream(file.FileInfo.StoragePath))
-                using (var ms = new MemoryStream()) //we need a memory stream so we can seek
+                using (var ms = new MemoryStream()) // we need a memory stream so we can seek
                 using (var sr = new LineBufferedReader(ms))
                 {
                     raw.CopyTo(ms);
@@ -365,7 +461,7 @@ namespace osu.Game.Beatmaps
                     // TODO: this should be done in a better place once we actually need to dynamically update it.
                     beatmap.BeatmapInfo.StarDifficulty = ruleset?.CreateInstance().CreateDifficultyCalculator(new DummyConversionBeatmap(beatmap)).Calculate().StarRating ?? 0;
                     beatmap.BeatmapInfo.Length = calculateLength(beatmap);
-                    beatmap.BeatmapInfo.BPM = beatmap.ControlPointInfo.BPMMode;
+                    beatmap.BeatmapInfo.BPM = 60000 / beatmap.GetMostCommonBeatLength();
 
                     beatmapInfos.Add(beatmap.BeatmapInfo);
                 }
@@ -388,6 +484,40 @@ namespace osu.Game.Beatmaps
             return endTime - startTime;
         }
 
+        private void removeWorkingCache(BeatmapSetInfo info)
+        {
+            if (info.Beatmaps == null) return;
+
+            foreach (var b in info.Beatmaps)
+                removeWorkingCache(b);
+        }
+
+        private void removeWorkingCache(BeatmapInfo info)
+        {
+            lock (workingCache)
+            {
+                var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == info.ID);
+                if (working != null)
+                    workingCache.Remove(working);
+            }
+        }
+
+        public void Dispose()
+        {
+            onlineLookupQueue?.Dispose();
+        }
+
+        #region IResourceStorageProvider
+
+        TextureStore IBeatmapResourceProvider.LargeTextureStore => largeTextureStore;
+        ITrackStore IBeatmapResourceProvider.Tracks => trackStore;
+        AudioManager IStorageResourceProvider.AudioManager => audioManager;
+        IResourceStore<byte[]> IStorageResourceProvider.Files => Files.Store;
+        IResourceStore<byte[]> IStorageResourceProvider.Resources => resources;
+        IResourceStore<TextureUpload> IStorageResourceProvider.CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => host?.CreateTextureLoaderStore(underlyingStore);
+
+        #endregion
+
         /// <summary>
         /// A dummy WorkingBeatmap for the purpose of retrieving a beatmap for star difficulty calculation.
         /// </summary>
@@ -403,70 +533,30 @@ namespace osu.Game.Beatmaps
 
             protected override IBeatmap GetBeatmap() => beatmap;
             protected override Texture GetBackground() => null;
-            protected override VideoSprite GetVideo() => null;
-            protected override Track GetTrack() => null;
-        }
-
-        private class BeatmapUpdateQueue
-        {
-            private readonly IAPIProvider api;
-
-            private const int update_queue_request_concurrency = 4;
-
-            private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(update_queue_request_concurrency, nameof(BeatmapUpdateQueue));
-
-            public BeatmapUpdateQueue(IAPIProvider api)
-            {
-                this.api = api;
-            }
-
-            public Task UpdateAsync(BeatmapSetInfo beatmapSet, CancellationToken cancellationToken)
-            {
-                if (api?.State != APIState.Online)
-                    return Task.CompletedTask;
-
-                LogForModel(beatmapSet, "Performing online lookups...");
-                return Task.WhenAll(beatmapSet.Beatmaps.Select(b => UpdateAsync(beatmapSet, b, cancellationToken)).ToArray());
-            }
-
-            // todo: expose this when we need to do individual difficulty lookups.
-            protected Task UpdateAsync(BeatmapSetInfo beatmapSet, BeatmapInfo beatmap, CancellationToken cancellationToken)
-                => Task.Factory.StartNew(() => update(beatmapSet, beatmap), cancellationToken, TaskCreationOptions.HideScheduler, updateScheduler);
-
-            private void update(BeatmapSetInfo set, BeatmapInfo beatmap)
-            {
-                if (api?.State != APIState.Online)
-                    return;
-
-                var req = new GetBeatmapRequest(beatmap);
-
-                req.Failure += fail;
-
-                try
-                {
-                    // intentionally blocking to limit web request concurrency
-                    api.Perform(req);
-
-                    var res = req.Result;
-
-                    beatmap.Status = res.Status;
-                    beatmap.BeatmapSet.Status = res.BeatmapSet.Status;
-                    beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
-                    beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
-
-                    LogForModel(set, $"Online retrieval mapped {beatmap} to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.");
-                }
-                catch (Exception e)
-                {
-                    fail(e);
-                }
-
-                void fail(Exception e)
-                {
-                    beatmap.OnlineBeatmapID = null;
-                    LogForModel(set, $"Online retrieval failed for {beatmap} ({e.Message})");
-                }
-            }
+            protected override Track GetBeatmapTrack() => null;
+            protected override ISkin GetSkin() => null;
+            public override Stream GetStream(string storagePath) => null;
         }
     }
+
+    /// <summary>
+    /// The level of detail to include in database results.
+    /// </summary>
+    public enum IncludedDetails
+    {
+        /// <summary>
+        /// Only include beatmap difficulties and set level metadata.
+        /// </summary>
+        Minimal,
+
+        /// <summary>
+        /// Include all difficulties, rulesets, difficulty metadata but no files.
+        /// </summary>
+        AllButFiles,
+
+        /// <summary>
+        /// Include everything.
+        /// </summary>
+        All
+    }
 }

osu.Game/Beatmaps/BeatmapManager_BeatmapOnlineLookupQueue.cs

@@ -0,0 +1,209 @@
+// 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.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Data.Sqlite;
+using osu.Framework.Development;
+using osu.Framework.IO.Network;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Framework.Threading;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using SharpCompress.Compressors;
+using SharpCompress.Compressors.BZip2;
+
+namespace osu.Game.Beatmaps
+{
+    public partial class BeatmapManager
+    {
+        [ExcludeFromDynamicCompile]
+        private class BeatmapOnlineLookupQueue : IDisposable
+        {
+            private readonly IAPIProvider api;
+            private readonly Storage storage;
+
+            private const int update_queue_request_concurrency = 4;
+
+            private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(update_queue_request_concurrency, nameof(BeatmapOnlineLookupQueue));
+
+            private FileWebRequest cacheDownloadRequest;
+
+            private const string cache_database_name = "online.db";
+
+            public BeatmapOnlineLookupQueue(IAPIProvider api, Storage storage)
+            {
+                this.api = api;
+                this.storage = storage;
+
+                // avoid downloading / using cache for unit tests.
+                if (!DebugUtils.IsNUnitRunning && !storage.Exists(cache_database_name))
+                    prepareLocalCache();
+            }
+
+            public Task UpdateAsync(BeatmapSetInfo beatmapSet, CancellationToken cancellationToken)
+            {
+                return Task.WhenAll(beatmapSet.Beatmaps.Select(b => UpdateAsync(beatmapSet, b, cancellationToken)).ToArray());
+            }
+
+            // todo: expose this when we need to do individual difficulty lookups.
+            protected Task UpdateAsync(BeatmapSetInfo beatmapSet, BeatmapInfo beatmap, CancellationToken cancellationToken)
+                => Task.Factory.StartNew(() => lookup(beatmapSet, beatmap), cancellationToken, TaskCreationOptions.HideScheduler | TaskCreationOptions.RunContinuationsAsynchronously, updateScheduler);
+
+            private void lookup(BeatmapSetInfo set, BeatmapInfo beatmap)
+            {
+                if (checkLocalCache(set, beatmap))
+                    return;
+
+                if (api?.State.Value != APIState.Online)
+                    return;
+
+                var req = new GetBeatmapRequest(beatmap);
+
+                req.Failure += fail;
+
+                try
+                {
+                    // intentionally blocking to limit web request concurrency
+                    api.Perform(req);
+
+                    var res = req.Result;
+
+                    if (res != null)
+                    {
+                        beatmap.Status = res.Status;
+                        beatmap.BeatmapSet.Status = res.BeatmapSet.Status;
+                        beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
+                        beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
+
+                        if (beatmap.Metadata != null)
+                            beatmap.Metadata.AuthorID = res.AuthorID;
+
+                        if (beatmap.BeatmapSet.Metadata != null)
+                            beatmap.BeatmapSet.Metadata.AuthorID = res.AuthorID;
+
+                        LogForModel(set, $"Online retrieval mapped {beatmap} to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.");
+                    }
+                }
+                catch (Exception e)
+                {
+                    fail(e);
+                }
+
+                void fail(Exception e)
+                {
+                    beatmap.OnlineBeatmapID = null;
+                    LogForModel(set, $"Online retrieval failed for {beatmap} ({e.Message})");
+                }
+            }
+
+            private void prepareLocalCache()
+            {
+                string cacheFilePath = storage.GetFullPath(cache_database_name);
+                string compressedCacheFilePath = $"{cacheFilePath}.bz2";
+
+                cacheDownloadRequest = new FileWebRequest(compressedCacheFilePath, $"https://assets.ppy.sh/client-resources/{cache_database_name}.bz2?{DateTimeOffset.UtcNow:yyyyMMdd}");
+
+                cacheDownloadRequest.Failed += ex =>
+                {
+                    File.Delete(compressedCacheFilePath);
+                    File.Delete(cacheFilePath);
+
+                    Logger.Log($"{nameof(BeatmapOnlineLookupQueue)}'s online cache download failed: {ex}", LoggingTarget.Database);
+                };
+
+                cacheDownloadRequest.Finished += () =>
+                {
+                    try
+                    {
+                        using (var stream = File.OpenRead(cacheDownloadRequest.Filename))
+                        using (var outStream = File.OpenWrite(cacheFilePath))
+                        using (var bz2 = new BZip2Stream(stream, CompressionMode.Decompress, false))
+                            bz2.CopyTo(outStream);
+
+                        // set to null on completion to allow lookups to begin using the new source
+                        cacheDownloadRequest = null;
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.Log($"{nameof(BeatmapOnlineLookupQueue)}'s online cache extraction failed: {ex}", LoggingTarget.Database);
+                        File.Delete(cacheFilePath);
+                    }
+                    finally
+                    {
+                        File.Delete(compressedCacheFilePath);
+                    }
+                };
+
+                cacheDownloadRequest.PerformAsync();
+            }
+
+            private bool checkLocalCache(BeatmapSetInfo set, BeatmapInfo beatmap)
+            {
+                // download is in progress (or was, and failed).
+                if (cacheDownloadRequest != null)
+                    return false;
+
+                // database is unavailable.
+                if (!storage.Exists(cache_database_name))
+                    return false;
+
+                try
+                {
+                    using (var db = new SqliteConnection(storage.GetDatabaseConnectionString("online")))
+                    {
+                        db.Open();
+
+                        using (var cmd = db.CreateCommand())
+                        {
+                            cmd.CommandText = "SELECT beatmapset_id, beatmap_id, approved, user_id FROM osu_beatmaps WHERE checksum = @MD5Hash OR beatmap_id = @OnlineBeatmapID OR filename = @Path";
+
+                            cmd.Parameters.Add(new SqliteParameter("@MD5Hash", beatmap.MD5Hash));
+                            cmd.Parameters.Add(new SqliteParameter("@OnlineBeatmapID", beatmap.OnlineBeatmapID ?? (object)DBNull.Value));
+                            cmd.Parameters.Add(new SqliteParameter("@Path", beatmap.Path));
+
+                            using (var reader = cmd.ExecuteReader())
+                            {
+                                if (reader.Read())
+                                {
+                                    var status = (BeatmapSetOnlineStatus)reader.GetByte(2);
+
+                                    beatmap.Status = status;
+                                    beatmap.BeatmapSet.Status = status;
+                                    beatmap.BeatmapSet.OnlineBeatmapSetID = reader.GetInt32(0);
+                                    beatmap.OnlineBeatmapID = reader.GetInt32(1);
+
+                                    if (beatmap.Metadata != null)
+                                        beatmap.Metadata.AuthorID = reader.GetInt32(3);
+
+                                    if (beatmap.BeatmapSet.Metadata != null)
+                                        beatmap.BeatmapSet.Metadata.AuthorID = reader.GetInt32(3);
+
+                                    LogForModel(set, $"Cached local retrieval for {beatmap}.");
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    LogForModel(set, $"Cached local retrieval for {beatmap} failed with {ex}.");
+                }
+
+                return false;
+            }
+
+            public void Dispose()
+            {
+                cacheDownloadRequest?.Dispose();
+                updateScheduler?.Dispose();
+            }
+        }
+    }
+}

osu.Game/Beatmaps/BeatmapManager_WorkingBeatmap.cs

@@ -2,13 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Linq;
-using osu.Framework.Audio;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
-using osu.Framework.IO.Stores;
 using osu.Framework.Logging;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
 using osu.Game.Skinning;
@@ -18,22 +17,26 @@ namespace osu.Game.Beatmaps
 {
     public partial class BeatmapManager
     {
-        protected class BeatmapManagerWorkingBeatmap : WorkingBeatmap
+        [ExcludeFromDynamicCompile]
+        private class BeatmapManagerWorkingBeatmap : WorkingBeatmap
         {
-            private readonly IResourceStore<byte[]> store;
+            [NotNull]
+            private readonly IBeatmapResourceProvider resources;
 
-            public BeatmapManagerWorkingBeatmap(IResourceStore<byte[]> store, TextureStore textureStore, BeatmapInfo beatmapInfo, AudioManager audioManager)
-                : base(beatmapInfo, audioManager)
+            public BeatmapManagerWorkingBeatmap(BeatmapInfo beatmapInfo, [NotNull] IBeatmapResourceProvider resources)
+                : base(beatmapInfo, resources.AudioManager)
             {
-                this.store = store;
-                this.textureStore = textureStore;
+                this.resources = resources;
             }
 
             protected override IBeatmap GetBeatmap()
             {
+                if (BeatmapInfo.Path == null)
+                    return new Beatmap { BeatmapInfo = BeatmapInfo };
+
                 try
                 {
-                    using (var stream = new LineBufferedReader(store.GetStream(getPathForFile(BeatmapInfo.Path))))
+                    using (var stream = new LineBufferedReader(GetStream(BeatmapSetInfo.GetPathForFile(BeatmapInfo.Path))))
                         return Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
                 }
                 catch (Exception e)
@@ -43,12 +46,6 @@ namespace osu.Game.Beatmaps
                 }
             }
 
-            private string getPathForFile(string filename) => BeatmapSetInfo.Files.FirstOrDefault(f => string.Equals(f.Filename, filename, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
-
-            private TextureStore textureStore;
-
-            private ITrackStore trackStore;
-
             protected override bool BackgroundStillValid(Texture b) => false; // bypass lazy logic. we want to return a new background each time for refcounting purposes.
 
             protected override Texture GetBackground()
@@ -58,7 +55,7 @@ namespace osu.Game.Beatmaps
 
                 try
                 {
-                    return textureStore.Get(getPathForFile(Metadata.BackgroundFile));
+                    return resources.LargeTextureStore.Get(BeatmapSetInfo.GetPathForFile(Metadata.BackgroundFile));
                 }
                 catch (Exception e)
                 {
@@ -67,29 +64,14 @@ namespace osu.Game.Beatmaps
                 }
             }
 
-            protected override VideoSprite GetVideo()
+            protected override Track GetBeatmapTrack()
             {
-                if (Metadata?.VideoFile == null)
+                if (Metadata?.AudioFile == null)
                     return null;
 
                 try
                 {
-                    var stream = textureStore.GetStream(getPathForFile(Metadata.VideoFile));
-
-                    return stream == null ? null : new VideoSprite(stream);
-                }
-                catch (Exception e)
-                {
-                    Logger.Error(e, "Video failed to load");
-                    return null;
-                }
-            }
-
-            protected override Track GetTrack()
-            {
-                try
-                {
-                    return (trackStore ??= AudioManager.GetTrackStore(store)).Get(getPathForFile(Metadata.AudioFile));
+                    return resources.Tracks.Get(BeatmapSetInfo.GetPathForFile(Metadata.AudioFile));
                 }
                 catch (Exception e)
                 {
@@ -98,27 +80,14 @@ namespace osu.Game.Beatmaps
                 }
             }
 
-            public override void RecycleTrack()
-            {
-                base.RecycleTrack();
-
-                trackStore?.Dispose();
-                trackStore = null;
-            }
-
-            public override void TransferTo(WorkingBeatmap other)
-            {
-                base.TransferTo(other);
-
-                if (other is BeatmapManagerWorkingBeatmap owb && textureStore != null && BeatmapInfo.BackgroundEquals(other.BeatmapInfo))
-                    owb.textureStore = textureStore;
-            }
-
             protected override Waveform GetWaveform()
             {
+                if (Metadata?.AudioFile == null)
+                    return null;
+
                 try
                 {
-                    var trackData = store.GetStream(getPathForFile(Metadata.AudioFile));
+                    var trackData = GetStream(BeatmapSetInfo.GetPathForFile(Metadata.AudioFile));
                     return trackData == null ? null : new Waveform(trackData);
                 }
                 catch (Exception e)
@@ -134,7 +103,7 @@ namespace osu.Game.Beatmaps
 
                 try
                 {
-                    using (var stream = new LineBufferedReader(store.GetStream(getPathForFile(BeatmapInfo.Path))))
+                    using (var stream = new LineBufferedReader(GetStream(BeatmapSetInfo.GetPathForFile(BeatmapInfo.Path))))
                     {
                         var decoder = Decoder.GetDecoder<Storyboard>(stream);
 
@@ -143,7 +112,7 @@ namespace osu.Game.Beatmaps
                             storyboard = decoder.Decode(stream);
                         else
                         {
-                            using (var secondaryStream = new LineBufferedReader(store.GetStream(getPathForFile(BeatmapSetInfo.StoryboardFile))))
+                            using (var secondaryStream = new LineBufferedReader(GetStream(BeatmapSetInfo.GetPathForFile(BeatmapSetInfo.StoryboardFile))))
                                 storyboard = decoder.Decode(stream, secondaryStream);
                         }
                     }
@@ -163,7 +132,7 @@ namespace osu.Game.Beatmaps
             {
                 try
                 {
-                    return new LegacyBeatmapSkin(BeatmapInfo, store, AudioManager);
+                    return new LegacyBeatmapSkin(BeatmapInfo, resources.Files, resources);
                 }
                 catch (Exception e)
                 {
@@ -171,6 +140,8 @@ namespace osu.Game.Beatmaps
                     return null;
                 }
             }
+
+            public override Stream GetStream(string storagePath) => resources.Files.GetStream(storagePath);
         }
     }
 }

osu.Game/Beatmaps/BeatmapMetadata.cs

@@ -6,19 +6,27 @@ using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using Newtonsoft.Json;
+using osu.Framework.Localisation;
+using osu.Framework.Testing;
 using osu.Game.Database;
 using osu.Game.Users;
 
 namespace osu.Game.Beatmaps
 {
+    [ExcludeFromDynamicCompile]
     [Serializable]
     public class BeatmapMetadata : IEquatable<BeatmapMetadata>, IHasPrimaryKey
     {
         public int ID { get; set; }
 
         public string Title { get; set; }
+
+        [JsonProperty("title_unicode")]
         public string TitleUnicode { get; set; }
+
         public string Artist { get; set; }
+
+        [JsonProperty("artist_unicode")]
         public string ArtistUnicode { get; set; }
 
         [JsonIgnore]
@@ -27,6 +35,21 @@ namespace osu.Game.Beatmaps
         [JsonIgnore]
         public List<BeatmapSetInfo> BeatmapSets { get; set; }
 
+        /// <summary>
+        /// Helper property to deserialize a username to <see cref="User"/>.
+        /// </summary>
+        [JsonProperty(@"user_id")]
+        [Column("AuthorID")]
+        public int AuthorID
+        {
+            get => Author?.Id ?? 1;
+            set
+            {
+                Author ??= new User();
+                Author.Id = value;
+            }
+        }
+
         /// <summary>
         /// Helper property to deserialize a username to <see cref="User"/>.
         /// </summary>
@@ -35,7 +58,11 @@ namespace osu.Game.Beatmaps
         public string AuthorString
         {
             get => Author?.Username;
-            set => Author = new User { Username = value };
+            set
+            {
+                Author ??= new User();
+                Author.Username = value;
+            }
         }
 
         /// <summary>
@@ -49,12 +76,26 @@ namespace osu.Game.Beatmaps
         [JsonProperty(@"tags")]
         public string Tags { get; set; }
 
+        /// <summary>
+        /// The time in milliseconds to begin playing the track for preview purposes.
+        /// If -1, the track should begin playing at 40% of its length.
+        /// </summary>
         public int PreviewTime { get; set; }
+
         public string AudioFile { get; set; }
         public string BackgroundFile { get; set; }
-        public string VideoFile { get; set; }
 
-        public override string ToString() => $"{Artist} - {Title} ({Author})";
+        public override string ToString()
+        {
+            string author = Author == null ? string.Empty : $"({Author})";
+            return $"{Artist} - {Title} {author}".Trim();
+        }
+
+        public RomanisableString ToRomanisableString()
+        {
+            string author = Author == null ? string.Empty : $"({Author})";
+            return new RomanisableString($"{ArtistUnicode} - {TitleUnicode} {author}".Trim(), $"{Artist} - {Title} {author}".Trim());
+        }
 
         [JsonIgnore]
         public string[] SearchableTerms => new[]
@@ -82,8 +123,7 @@ namespace osu.Game.Beatmaps
                    && Tags == other.Tags
                    && PreviewTime == other.PreviewTime
                    && AudioFile == other.AudioFile
-                   && BackgroundFile == other.BackgroundFile
-                   && VideoFile == other.VideoFile;
+                   && BackgroundFile == other.BackgroundFile;
         }
     }
 }

osu.Game/Beatmaps/BeatmapProcessor.cs

@@ -22,8 +22,18 @@ namespace osu.Game.Beatmaps
         {
             IHasComboInformation lastObj = null;
 
+            bool isFirst = true;
+
             foreach (var obj in Beatmap.HitObjects.OfType<IHasComboInformation>())
             {
+                if (isFirst)
+                {
+                    obj.NewCombo = true;
+
+                    // first hitobject should always be marked as a new combo for sanity.
+                    isFirst = false;
+                }
+
                 if (obj.NewCombo)
                 {
                     obj.IndexInCurrentCombo = 0;

osu.Game/Beatmaps/BeatmapSetInfo.cs

@@ -5,10 +5,13 @@ using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
+using JetBrains.Annotations;
+using osu.Framework.Testing;
 using osu.Game.Database;
 
 namespace osu.Game.Beatmaps
 {
+    [ExcludeFromDynamicCompile]
     public class BeatmapSetInfo : IHasPrimaryKey, IHasFiles<BeatmapSetFileInfo>, ISoftDelete, IEquatable<BeatmapSetInfo>
     {
         public int ID { get; set; }
@@ -29,6 +32,9 @@ namespace osu.Game.Beatmaps
 
         public List<BeatmapInfo> Beatmaps { get; set; }
 
+        [NotNull]
+        public List<BeatmapSetFileInfo> Files { get; set; } = new List<BeatmapSetFileInfo>();
+
         [NotMapped]
         public BeatmapSetOnlineInfo OnlineInfo { get; set; }
 
@@ -55,9 +61,14 @@ namespace osu.Game.Beatmaps
 
         public string Hash { get; set; }
 
-        public string StoryboardFile => Files?.Find(f => f.Filename.EndsWith(".osb"))?.Filename;
+        public string StoryboardFile => Files.Find(f => f.Filename.EndsWith(".osb", StringComparison.OrdinalIgnoreCase))?.Filename;
 
-        public List<BeatmapSetFileInfo> Files { get; set; }
+        /// <summary>
+        /// Returns the storage path for the file in this beatmapset with the given filename, if any exists, otherwise null.
+        /// The path returned is relative to the user file storage.
+        /// </summary>
+        /// <param name="filename">The name of the file to get the storage path of.</param>
+        public string GetPathForFile(string filename) => Files.SingleOrDefault(f => string.Equals(f.Filename, filename, StringComparison.OrdinalIgnoreCase))?.FileInfo.StoragePath;
 
         public override string ToString() => Metadata?.ToString() ?? base.ToString();
 

osu.Game/Beatmaps/BeatmapSetOnlineInfo.cs

@@ -31,6 +31,11 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public BeatmapSetOnlineStatus Status { get; set; }
 
+        /// <summary>
+        /// Whether or not this beatmap set has explicit content.
+        /// </summary>
+        public bool HasExplicitContent { get; set; }
+
         /// <summary>
         /// Whether or not this beatmap set has a background video.
         /// </summary>

osu.Game/Beatmaps/BeatmapSetOnlineStatus.cs

@@ -14,4 +14,10 @@ namespace osu.Game.Beatmaps
         Qualified = 3,
         Loved = 4,
     }
+
+    public static class BeatmapSetOnlineStatusExtensions
+    {
+        public static bool GrantsPerformancePoints(this BeatmapSetOnlineStatus status)
+            => status == BeatmapSetOnlineStatus.Ranked || status == BeatmapSetOnlineStatus.Approved;
+    }
 }

osu.Game/Beatmaps/BeatmapStatistic.cs

@@ -1,13 +1,18 @@
 // 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.Sprites;
+using System;
+using osu.Framework.Graphics;
 
 namespace osu.Game.Beatmaps
 {
     public class BeatmapStatistic
     {
-        public IconUsage Icon;
+        /// <summary>
+        /// A function to create the icon for display purposes. Use default icons available via <see cref="BeatmapStatisticIcon"/> whenever possible for conformity.
+        /// </summary>
+        public Func<Drawable> CreateIcon;
+
         public string Content;
         public string Name;
     }

osu.Game/Beatmaps/BeatmapStatisticIcon.cs

@@ -0,0 +1,43 @@
+// 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 Humanizer;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// A default implementation of an icon used to represent beatmap statistics.
+    /// </summary>
+    public class BeatmapStatisticIcon : Sprite
+    {
+        private readonly BeatmapStatisticsIconType iconType;
+
+        public BeatmapStatisticIcon(BeatmapStatisticsIconType iconType)
+        {
+            this.iconType = iconType;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
+        {
+            Texture = textures.Get($"Icons/BeatmapDetails/{iconType.ToString().Kebaberize()}");
+        }
+    }
+
+    public enum BeatmapStatisticsIconType
+    {
+        Accuracy,
+        ApproachRate,
+        Bpm,
+        Circles,
+        HpDrain,
+        Length,
+        OverallDifficulty,
+        Size,
+        Sliders,
+        Spinners,
+    }
+}

osu.Game/Beatmaps/BeatmapStore.cs

@@ -87,6 +87,18 @@ namespace osu.Game.Beatmaps
             base.Purge(items, context);
         }
 
+        public IQueryable<BeatmapSetInfo> BeatmapSetsOverview => ContextFactory.Get().BeatmapSetInfo
+                                                                               .Include(s => s.Metadata)
+                                                                               .Include(s => s.Beatmaps)
+                                                                               .AsNoTracking();
+
+        public IQueryable<BeatmapSetInfo> BeatmapSetsWithoutFiles => ContextFactory.Get().BeatmapSetInfo
+                                                                                   .Include(s => s.Metadata)
+                                                                                   .Include(s => s.Beatmaps).ThenInclude(s => s.Ruleset)
+                                                                                   .Include(s => s.Beatmaps).ThenInclude(b => b.BaseDifficulty)
+                                                                                   .Include(s => s.Beatmaps).ThenInclude(b => b.Metadata)
+                                                                                   .AsNoTracking();
+
         public IQueryable<BeatmapInfo> Beatmaps =>
             ContextFactory.Get().BeatmapInfo
                           .Include(b => b.BeatmapSet).ThenInclude(s => s.Metadata)

osu.Game/Beatmaps/ControlPoints/ControlPoint.cs

@@ -2,10 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Game.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
-    public abstract class ControlPoint : IComparable<ControlPoint>, IEquatable<ControlPoint>
+    public abstract class ControlPoint : IComparable<ControlPoint>
     {
         /// <summary>
         /// The time at which the control point takes effect.
@@ -18,13 +20,29 @@ namespace osu.Game.Beatmaps.ControlPoints
 
         public int CompareTo(ControlPoint other) => Time.CompareTo(other.Time);
 
-        /// <summary>
-        /// Whether this control point is equivalent to another, ignoring time.
-        /// </summary>
-        /// <param name="other">Another control point to compare with.</param>
-        /// <returns>Whether equivalent.</returns>
-        public abstract bool EquivalentTo(ControlPoint other);
+        public virtual Color4 GetRepresentingColour(OsuColour colours) => colours.Yellow;
 
-        public bool Equals(ControlPoint other) => Time == other?.Time && EquivalentTo(other);
+        /// <summary>
+        /// Determines whether this <see cref="ControlPoint"/> results in a meaningful change when placed alongside another.
+        /// </summary>
+        /// <param name="existing">An existing control point to compare with.</param>
+        /// <returns>Whether this <see cref="ControlPoint"/> is redundant when placed alongside <paramref name="existing"/>.</returns>
+        public abstract bool IsRedundant(ControlPoint existing);
+
+        /// <summary>
+        /// Create an unbound copy of this control point.
+        /// </summary>
+        public ControlPoint CreateCopy()
+        {
+            var copy = (ControlPoint)Activator.CreateInstance(GetType());
+
+            copy.CopyFrom(this);
+
+            return copy;
+        }
+
+        public virtual void CopyFrom(ControlPoint other)
+        {
+        }
     }
 }

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -4,9 +4,12 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Bindables;
 using osu.Framework.Lists;
+using osu.Framework.Utils;
+using osu.Game.Screens.Edit;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
@@ -41,9 +44,9 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// All sound points.
         /// </summary>
         [JsonProperty]
-        public IReadOnlyList<SampleControlPoint> SamplePoints => samplePoints;
+        public IBindableList<SampleControlPoint> SamplePoints => samplePoints;
 
-        private readonly SortedList<SampleControlPoint> samplePoints = new SortedList<SampleControlPoint>(Comparer<SampleControlPoint>.Default);
+        private readonly BindableList<SampleControlPoint> samplePoints = new BindableList<SampleControlPoint>();
 
         /// <summary>
         /// All effect points.
@@ -56,6 +59,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// <summary>
         /// All control points, of all types.
         /// </summary>
+        [JsonIgnore]
         public IEnumerable<ControlPoint> AllControlPoints => Groups.SelectMany(g => g.ControlPoints).ToArray();
 
         /// <summary>
@@ -63,49 +67,46 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="time">The time to find the difficulty control point at.</param>
         /// <returns>The difficulty control point.</returns>
-        public DifficultyControlPoint DifficultyPointAt(double time) => binarySearchWithFallback(DifficultyPoints, time);
+        [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>
         /// <param name="time">The time to find the effect control point at.</param>
         /// <returns>The effect control point.</returns>
-        public EffectControlPoint EffectPointAt(double time) => binarySearchWithFallback(EffectPoints, time);
+        [NotNull]
+        public EffectControlPoint EffectPointAt(double time) => binarySearchWithFallback(EffectPoints, time, EffectControlPoint.DEFAULT);
 
         /// <summary>
         /// Finds the sound control point that is active at <paramref name="time"/>.
         /// </summary>
         /// <param name="time">The time to find the sound control point at.</param>
         /// <returns>The sound control point.</returns>
-        public SampleControlPoint SamplePointAt(double time) => binarySearchWithFallback(SamplePoints, time, SamplePoints.Count > 0 ? SamplePoints[0] : null);
+        [NotNull]
+        public SampleControlPoint SamplePointAt(double time) => binarySearchWithFallback(SamplePoints, time, SamplePoints.Count > 0 ? SamplePoints[0] : SampleControlPoint.DEFAULT);
 
         /// <summary>
         /// Finds the timing control point that is active at <paramref name="time"/>.
         /// </summary>
         /// <param name="time">The time to find the timing control point at.</param>
         /// <returns>The timing control point.</returns>
-        public TimingControlPoint TimingPointAt(double time) => binarySearchWithFallback(TimingPoints, time, TimingPoints.Count > 0 ? TimingPoints[0] : null);
+        [NotNull]
+        public TimingControlPoint TimingPointAt(double time) => binarySearchWithFallback(TimingPoints, time, TimingPoints.Count > 0 ? TimingPoints[0] : TimingControlPoint.DEFAULT);
 
         /// <summary>
         /// Finds the maximum BPM represented by any timing control point.
         /// </summary>
         [JsonIgnore]
         public double BPMMaximum =>
-            60000 / (TimingPoints.OrderBy(c => c.BeatLength).FirstOrDefault() ?? new TimingControlPoint()).BeatLength;
+            60000 / (TimingPoints.OrderBy(c => c.BeatLength).FirstOrDefault() ?? TimingControlPoint.DEFAULT).BeatLength;
 
         /// <summary>
         /// Finds the minimum BPM represented by any timing control point.
         /// </summary>
         [JsonIgnore]
         public double BPMMinimum =>
-            60000 / (TimingPoints.OrderByDescending(c => c.BeatLength).FirstOrDefault() ?? new TimingControlPoint()).BeatLength;
-
-        /// <summary>
-        /// Finds the mode BPM (most common BPM) represented by the control points.
-        /// </summary>
-        [JsonIgnore]
-        public double BPMMode =>
-            60000 / (TimingPoints.GroupBy(c => c.BeatLength).OrderByDescending(grp => grp.Count()).FirstOrDefault()?.FirstOrDefault() ?? new TimingControlPoint()).BeatLength;
+            60000 / (TimingPoints.OrderByDescending(c => c.BeatLength).FirstOrDefault() ?? TimingControlPoint.DEFAULT).BeatLength;
 
         /// <summary>
         /// Remove all <see cref="ControlPointGroup"/>s and return to a pristine state.
@@ -157,24 +158,79 @@ namespace osu.Game.Beatmaps.ControlPoints
 
         public void RemoveGroup(ControlPointGroup group)
         {
+            foreach (var item in group.ControlPoints.ToArray())
+                group.Remove(item);
+
             group.ItemAdded -= groupItemAdded;
             group.ItemRemoved -= groupItemRemoved;
 
             groups.Remove(group);
         }
 
+        /// <summary>
+        /// Returns the time on the given beat divisor closest to the given time.
+        /// </summary>
+        /// <param name="time">The time to find the closest snapped time to.</param>
+        /// <param name="beatDivisor">The beat divisor to snap to.</param>
+        /// <param name="referenceTime">An optional reference point to use for timing point lookup.</param>
+        public double GetClosestSnappedTime(double time, int beatDivisor, double? referenceTime = null)
+        {
+            var timingPoint = TimingPointAt(referenceTime ?? time);
+            return getClosestSnappedTime(timingPoint, time, beatDivisor);
+        }
+
+        /// <summary>
+        /// Returns the time on *ANY* valid beat divisor, favouring the divisor closest to the given time.
+        /// </summary>
+        /// <param name="time">The time to find the closest snapped time to.</param>
+        public double GetClosestSnappedTime(double time) => GetClosestSnappedTime(time, GetClosestBeatDivisor(time));
+
+        /// <summary>
+        /// Returns the beat snap divisor closest to the given time. If two are equally close, the smallest divisor is returned.
+        /// </summary>
+        /// <param name="time">The time to find the closest beat snap divisor to.</param>
+        /// <param name="referenceTime">An optional reference point to use for timing point lookup.</param>
+        public int GetClosestBeatDivisor(double time, double? referenceTime = null)
+        {
+            TimingControlPoint timingPoint = TimingPointAt(referenceTime ?? time);
+
+            int closestDivisor = 0;
+            double closestTime = double.MaxValue;
+
+            foreach (int divisor in BindableBeatDivisor.VALID_DIVISORS)
+            {
+                double distanceFromSnap = Math.Abs(time - getClosestSnappedTime(timingPoint, time, divisor));
+
+                if (Precision.DefinitelyBigger(closestTime, distanceFromSnap))
+                {
+                    closestDivisor = divisor;
+                    closestTime = distanceFromSnap;
+                }
+            }
+
+            return closestDivisor;
+        }
+
+        private static double getClosestSnappedTime(TimingControlPoint timingPoint, double time, int beatDivisor)
+        {
+            var beatLength = timingPoint.BeatLength / beatDivisor;
+            var beatLengths = (int)Math.Round((time - timingPoint.Time) / beatLength, MidpointRounding.AwayFromZero);
+
+            return timingPoint.Time + beatLengths * beatLength;
+        }
+
         /// <summary>
         /// Binary searches one of the control point lists to find the active control point at <paramref name="time"/>.
         /// Includes logic for returning a specific point when no matching point is found.
         /// </summary>
         /// <param name="list">The list to search.</param>
         /// <param name="time">The time to find the control point at.</param>
-        /// <param name="prePoint">The control point to use when <paramref name="time"/> is before any control points. If null, a new control point will be constructed.</param>
+        /// <param name="fallback">The control point to use when <paramref name="time"/> is before any control points.</param>
         /// <returns>The active control point at <paramref name="time"/>, or a fallback <see cref="ControlPoint"/> if none found.</returns>
-        private T binarySearchWithFallback<T>(IReadOnlyList<T> list, double time, T prePoint = null)
-            where T : ControlPoint, new()
+        private T binarySearchWithFallback<T>(IReadOnlyList<T> list, double time, T fallback)
+            where T : ControlPoint
         {
-            return binarySearch(list, time) ?? prePoint ?? new T();
+            return binarySearch(list, time) ?? fallback;
         }
 
         /// <summary>
@@ -247,7 +303,7 @@ namespace osu.Game.Beatmaps.ControlPoints
                     break;
             }
 
-            return existing?.EquivalentTo(newPoint) == true;
+            return newPoint?.IsRedundant(existing) == true;
         }
 
         private void groupItemAdded(ControlPoint controlPoint)
@@ -293,5 +349,15 @@ namespace osu.Game.Beatmaps.ControlPoints
                     break;
             }
         }
+
+        public ControlPointInfo CreateCopy()
+        {
+            var controlPointInfo = new ControlPointInfo();
+
+            foreach (var point in AllControlPoints)
+                controlPointInfo.Add(point.Time, point.CreateCopy());
+
+            return controlPointInfo;
+        }
     }
 }

osu.Game/Beatmaps/ControlPoints/DifficultyControlPoint.cs

@@ -2,22 +2,31 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Bindables;
+using osu.Game.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
     public class DifficultyControlPoint : ControlPoint
     {
+        public static readonly DifficultyControlPoint DEFAULT = new DifficultyControlPoint
+        {
+            SpeedMultiplierBindable = { Disabled = true },
+        };
+
         /// <summary>
         /// The speed multiplier at this control point.
         /// </summary>
         public readonly BindableDouble SpeedMultiplierBindable = new BindableDouble(1)
         {
-            Precision = 0.1,
+            Precision = 0.01,
             Default = 1,
             MinValue = 0.1,
             MaxValue = 10
         };
 
+        public override Color4 GetRepresentingColour(OsuColour colours) => colours.Lime1;
+
         /// <summary>
         /// The speed multiplier at this control point.
         /// </summary>
@@ -27,7 +36,15 @@ namespace osu.Game.Beatmaps.ControlPoints
             set => SpeedMultiplierBindable.Value = value;
         }
 
-        public override bool EquivalentTo(ControlPoint other) =>
-            other is DifficultyControlPoint otherTyped && otherTyped.SpeedMultiplier.Equals(SpeedMultiplier);
+        public override bool IsRedundant(ControlPoint existing)
+            => existing is DifficultyControlPoint existingDifficulty
+               && SpeedMultiplier == existingDifficulty.SpeedMultiplier;
+
+        public override void CopyFrom(ControlPoint other)
+        {
+            SpeedMultiplier = ((DifficultyControlPoint)other).SpeedMultiplier;
+
+            base.CopyFrom(other);
+        }
     }
 }

osu.Game/Beatmaps/ControlPoints/EffectControlPoint.cs

@@ -2,16 +2,26 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Bindables;
+using osu.Game.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
     public class EffectControlPoint : ControlPoint
     {
+        public static readonly EffectControlPoint DEFAULT = new EffectControlPoint
+        {
+            KiaiModeBindable = { Disabled = true },
+            OmitFirstBarLineBindable = { Disabled = true }
+        };
+
         /// <summary>
         /// Whether the first bar line of this control point is ignored.
         /// </summary>
         public readonly BindableBool OmitFirstBarLineBindable = new BindableBool();
 
+        public override Color4 GetRepresentingColour(OsuColour colours) => colours.Purple;
+
         /// <summary>
         /// Whether the first bar line of this control point is ignored.
         /// </summary>
@@ -35,8 +45,18 @@ namespace osu.Game.Beatmaps.ControlPoints
             set => KiaiModeBindable.Value = value;
         }
 
-        public override bool EquivalentTo(ControlPoint other) =>
-            other is EffectControlPoint otherTyped &&
-            KiaiMode == otherTyped.KiaiMode && OmitFirstBarLine == otherTyped.OmitFirstBarLine;
+        public override bool IsRedundant(ControlPoint existing)
+            => !OmitFirstBarLine
+               && existing is EffectControlPoint existingEffect
+               && KiaiMode == existingEffect.KiaiMode
+               && OmitFirstBarLine == existingEffect.OmitFirstBarLine;
+
+        public override void CopyFrom(ControlPoint other)
+        {
+            KiaiMode = ((EffectControlPoint)other).KiaiMode;
+            OmitFirstBarLine = ((EffectControlPoint)other).OmitFirstBarLine;
+
+            base.CopyFrom(other);
+        }
     }
 }

osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs

@@ -3,6 +3,8 @@
 
 using osu.Framework.Bindables;
 using osu.Game.Audio;
+using osu.Game.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
@@ -10,6 +12,14 @@ namespace osu.Game.Beatmaps.ControlPoints
     {
         public const string DEFAULT_BANK = "normal";
 
+        public static readonly SampleControlPoint DEFAULT = new SampleControlPoint
+        {
+            SampleBankBindable = { Disabled = true },
+            SampleVolumeBindable = { Disabled = true }
+        };
+
+        public override Color4 GetRepresentingColour(OsuColour colours) => colours.Pink;
+
         /// <summary>
         /// The default sample bank at this control point.
         /// </summary>
@@ -48,12 +58,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="sampleName">The name of the same.</param>
         /// <returns>A populated <see cref="HitSampleInfo"/>.</returns>
-        public HitSampleInfo GetSampleInfo(string sampleName = HitSampleInfo.HIT_NORMAL) => new HitSampleInfo
-        {
-            Bank = SampleBank,
-            Name = sampleName,
-            Volume = SampleVolume,
-        };
+        public HitSampleInfo GetSampleInfo(string sampleName = HitSampleInfo.HIT_NORMAL) => new HitSampleInfo(sampleName, SampleBank, volume: SampleVolume);
 
         /// <summary>
         /// Applies <see cref="SampleBank"/> and <see cref="SampleVolume"/> to a <see cref="HitSampleInfo"/> if necessary, returning the modified <see cref="HitSampleInfo"/>.
@@ -61,15 +66,19 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// <param name="hitSampleInfo">The <see cref="HitSampleInfo"/>. This will not be modified.</param>
         /// <returns>The modified <see cref="HitSampleInfo"/>. This does not share a reference with <paramref name="hitSampleInfo"/>.</returns>
         public virtual HitSampleInfo ApplyTo(HitSampleInfo hitSampleInfo)
-        {
-            var newSampleInfo = hitSampleInfo.Clone();
-            newSampleInfo.Bank = hitSampleInfo.Bank ?? SampleBank;
-            newSampleInfo.Volume = hitSampleInfo.Volume > 0 ? hitSampleInfo.Volume : SampleVolume;
-            return newSampleInfo;
-        }
+            => hitSampleInfo.With(newBank: hitSampleInfo.Bank ?? SampleBank, newVolume: hitSampleInfo.Volume > 0 ? hitSampleInfo.Volume : SampleVolume);
 
-        public override bool EquivalentTo(ControlPoint other) =>
-            other is SampleControlPoint otherTyped &&
-            SampleBank == otherTyped.SampleBank && SampleVolume == otherTyped.SampleVolume;
+        public override bool IsRedundant(ControlPoint existing)
+            => existing is SampleControlPoint existingSample
+               && SampleBank == existingSample.SampleBank
+               && SampleVolume == existingSample.SampleVolume;
+
+        public override void CopyFrom(ControlPoint other)
+        {
+            SampleVolume = ((SampleControlPoint)other).SampleVolume;
+            SampleBank = ((SampleControlPoint)other).SampleBank;
+
+            base.CopyFrom(other);
+        }
     }
 }

osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs

@@ -3,6 +3,8 @@
 
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
@@ -13,6 +15,23 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         public readonly Bindable<TimeSignatures> TimeSignatureBindable = new Bindable<TimeSignatures>(TimeSignatures.SimpleQuadruple) { Default = TimeSignatures.SimpleQuadruple };
 
+        /// <summary>
+        /// Default length of a beat in milliseconds. Used whenever there is no beatmap or track playing.
+        /// </summary>
+        private const double default_beat_length = 60000.0 / 60.0;
+
+        public override Color4 GetRepresentingColour(OsuColour colours) => colours.Orange1;
+
+        public static readonly TimingControlPoint DEFAULT = new TimingControlPoint
+        {
+            BeatLengthBindable =
+            {
+                Value = default_beat_length,
+                Disabled = true
+            },
+            TimeSignatureBindable = { Disabled = true }
+        };
+
         /// <summary>
         /// The time signature at this control point.
         /// </summary>
@@ -48,8 +67,15 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         public double BPM => 60000 / BeatLength;
 
-        public override bool EquivalentTo(ControlPoint other) =>
-            other is TimingControlPoint otherTyped
-            && TimeSignature == otherTyped.TimeSignature && BeatLength.Equals(otherTyped.BeatLength);
+        // Timing points are never redundant as they can change the time signature.
+        public override bool IsRedundant(ControlPoint existing) => false;
+
+        public override void CopyFrom(ControlPoint other)
+        {
+            TimeSignature = ((TimingControlPoint)other).TimeSignature;
+            BeatLength = ((TimingControlPoint)other).BeatLength;
+
+            base.CopyFrom(other);
+        }
     }
 }

osu.Game/Beatmaps/DifficultyRecommender.cs

@@ -0,0 +1,129 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// A class which will recommend the most suitable difficulty for the local user from a beatmap set.
+    /// This requires the user to be logged in, as it sources from the user's online profile.
+    /// </summary>
+    public class DifficultyRecommender : Component
+    {
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
+        [Resolved]
+        private Bindable<RulesetInfo> ruleset { get; set; }
+
+        /// <summary>
+        /// The user for which the last requests were run.
+        /// </summary>
+        private int? requestedUserId;
+
+        private readonly Dictionary<RulesetInfo, double> recommendedDifficultyMapping = new Dictionary<RulesetInfo, double>();
+
+        private readonly IBindable<APIState> apiState = new Bindable<APIState>();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            apiState.BindTo(api.State);
+            apiState.BindValueChanged(onlineStateChanged, true);
+        }
+
+        /// <summary>
+        /// Find the recommended difficulty from a selection of available difficulties for the current local user.
+        /// </summary>
+        /// <remarks>
+        /// This requires the user to be online for now.
+        /// </remarks>
+        /// <param name="beatmaps">A collection of beatmaps to select a difficulty from.</param>
+        /// <returns>The recommended difficulty, or null if a recommendation could not be provided.</returns>
+        [CanBeNull]
+        public BeatmapInfo GetRecommendedBeatmap(IEnumerable<BeatmapInfo> beatmaps)
+        {
+            foreach (var r in orderedRulesets)
+            {
+                if (!recommendedDifficultyMapping.TryGetValue(r, out var recommendation))
+                    continue;
+
+                BeatmapInfo beatmap = beatmaps.Where(b => b.Ruleset.Equals(r)).OrderBy(b =>
+                {
+                    var difference = b.StarDifficulty - recommendation;
+                    return difference >= 0 ? difference * 2 : difference * -1; // prefer easier over harder
+                }).FirstOrDefault();
+
+                if (beatmap != null)
+                    return beatmap;
+            }
+
+            return null;
+        }
+
+        private void fetchRecommendedValues()
+        {
+            if (recommendedDifficultyMapping.Count > 0 && api.LocalUser.Value.Id == requestedUserId)
+                return;
+
+            requestedUserId = api.LocalUser.Value.Id;
+
+            // only query API for built-in rulesets
+            rulesets.AvailableRulesets.Where(ruleset => ruleset.ID <= ILegacyRuleset.MAX_LEGACY_RULESET_ID).ForEach(rulesetInfo =>
+            {
+                var req = new GetUserRequest(api.LocalUser.Value.Id, rulesetInfo);
+
+                req.Success += result =>
+                {
+                    // algorithm taken from https://github.com/ppy/osu-web/blob/e6e2825516449e3d0f3f5e1852c6bdd3428c3437/app/Models/User.php#L1505
+                    recommendedDifficultyMapping[rulesetInfo] = Math.Pow((double)(result.Statistics.PP ?? 0), 0.4) * 0.195;
+                };
+
+                api.Queue(req);
+            });
+        }
+
+        /// <returns>
+        /// Rulesets ordered descending by their respective recommended difficulties.
+        /// The currently selected ruleset will always be first.
+        /// </returns>
+        private IEnumerable<RulesetInfo> orderedRulesets
+        {
+            get
+            {
+                if (LoadState < LoadState.Ready || ruleset.Value == null)
+                    return Enumerable.Empty<RulesetInfo>();
+
+                return recommendedDifficultyMapping
+                       .OrderByDescending(pair => pair.Value)
+                       .Select(pair => pair.Key)
+                       .Where(r => !r.Equals(ruleset.Value))
+                       .Prepend(ruleset.Value);
+            }
+        }
+
+        private void onlineStateChanged(ValueChangedEvent<APIState> state) => Schedule(() =>
+        {
+            switch (state.NewValue)
+            {
+                case APIState.Online:
+                    fetchRecommendedValues();
+                    break;
+            }
+        });
+    }
+}

osu.Game/Beatmaps/Drawables/DifficultyIcon.cs

@@ -2,7 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Threading;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -14,6 +18,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osuTK;
 using osuTK.Graphics;
 
@@ -21,9 +26,6 @@ namespace osu.Game.Beatmaps.Drawables
 {
     public class DifficultyIcon : CompositeDrawable, IHasCustomTooltip
     {
-        private readonly BeatmapInfo beatmap;
-        private readonly RulesetInfo ruleset;
-
         private readonly Container iconContainer;
 
         /// <summary>
@@ -35,23 +37,54 @@ namespace osu.Game.Beatmaps.Drawables
             set => iconContainer.Size = value;
         }
 
-        public DifficultyIcon(BeatmapInfo beatmap, RulesetInfo ruleset = null, bool shouldShowTooltip = true)
+        [NotNull]
+        private readonly BeatmapInfo beatmap;
+
+        [CanBeNull]
+        private readonly RulesetInfo ruleset;
+
+        [CanBeNull]
+        private readonly IReadOnlyList<Mod> mods;
+
+        private readonly bool shouldShowTooltip;
+
+        private readonly bool performBackgroundDifficultyLookup;
+
+        private readonly Bindable<StarDifficulty> difficultyBindable = new Bindable<StarDifficulty>();
+
+        private Drawable background;
+
+        /// <summary>
+        /// Creates a new <see cref="DifficultyIcon"/> with a given <see cref="RulesetInfo"/> and <see cref="Mod"/> combination.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to show the difficulty of.</param>
+        /// <param name="ruleset">The ruleset to show the difficulty with.</param>
+        /// <param name="mods">The mods to show the difficulty with.</param>
+        /// <param name="shouldShowTooltip">Whether to display a tooltip when hovered.</param>
+        public DifficultyIcon([NotNull] BeatmapInfo beatmap, [CanBeNull] RulesetInfo ruleset, [CanBeNull] IReadOnlyList<Mod> mods, bool shouldShowTooltip = true)
+            : this(beatmap, shouldShowTooltip)
+        {
+            this.ruleset = ruleset ?? beatmap.Ruleset;
+            this.mods = mods ?? Array.Empty<Mod>();
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="DifficultyIcon"/> that follows the currently-selected ruleset and mods.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to show the difficulty of.</param>
+        /// <param name="shouldShowTooltip">Whether to display a tooltip when hovered.</param>
+        /// <param name="performBackgroundDifficultyLookup">Whether to perform difficulty lookup (including calculation if necessary).</param>
+        public DifficultyIcon([NotNull] BeatmapInfo beatmap, bool shouldShowTooltip = true, bool performBackgroundDifficultyLookup = true)
         {
             this.beatmap = beatmap ?? throw new ArgumentNullException(nameof(beatmap));
-
-            this.ruleset = ruleset ?? beatmap.Ruleset;
-            if (shouldShowTooltip)
-                TooltipContent = beatmap;
+            this.shouldShowTooltip = shouldShowTooltip;
+            this.performBackgroundDifficultyLookup = performBackgroundDifficultyLookup;
 
             AutoSizeAxes = Axes.Both;
 
             InternalChild = iconContainer = new Container { Size = new Vector2(20f) };
         }
 
-        public ITooltip GetCustomTooltip() => new DifficultyIconTooltip();
-
-        public object TooltipContent { get; }
-
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
@@ -70,10 +103,10 @@ namespace osu.Game.Beatmaps.Drawables
                         Type = EdgeEffectType.Shadow,
                         Radius = 5,
                     },
-                    Child = new Box
+                    Child = background = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Colour = colours.ForDifficultyRating(beatmap.DifficultyRating),
+                        Colour = colours.ForDifficultyRating(beatmap.DifficultyRating) // Default value that will be re-populated once difficulty calculation completes
                     },
                 },
                 new ConstrainedIconContainer
@@ -82,16 +115,81 @@ namespace osu.Game.Beatmaps.Drawables
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                     // the null coalesce here is only present to make unit tests work (ruleset dlls aren't copied correctly for testing at the moment)
-                    Icon = ruleset?.CreateInstance()?.CreateIcon() ?? new SpriteIcon { Icon = FontAwesome.Regular.QuestionCircle }
-                }
+                    Icon = (ruleset ?? beatmap.Ruleset)?.CreateInstance()?.CreateIcon() ?? new SpriteIcon { Icon = FontAwesome.Regular.QuestionCircle }
+                },
             };
+
+            if (performBackgroundDifficultyLookup)
+                iconContainer.Add(new DelayedLoadUnloadWrapper(() => new DifficultyRetriever(beatmap, ruleset, mods) { StarDifficulty = { BindTarget = difficultyBindable } }, 0));
+            else
+                difficultyBindable.Value = new StarDifficulty(beatmap.StarDifficulty, 0);
+
+            difficultyBindable.BindValueChanged(difficulty => background.Colour = colours.ForDifficultyRating(difficulty.NewValue.DifficultyRating));
+        }
+
+        public ITooltip GetCustomTooltip() => new DifficultyIconTooltip();
+
+        public object TooltipContent => shouldShowTooltip ? new DifficultyIconTooltipContent(beatmap, difficultyBindable) : null;
+
+        private class DifficultyRetriever : Component
+        {
+            public readonly Bindable<StarDifficulty> StarDifficulty = new Bindable<StarDifficulty>();
+
+            private readonly BeatmapInfo beatmap;
+            private readonly RulesetInfo ruleset;
+            private readonly IReadOnlyList<Mod> mods;
+
+            private CancellationTokenSource difficultyCancellation;
+
+            [Resolved]
+            private BeatmapDifficultyCache difficultyCache { get; set; }
+
+            public DifficultyRetriever(BeatmapInfo beatmap, RulesetInfo ruleset, IReadOnlyList<Mod> mods)
+            {
+                this.beatmap = beatmap;
+                this.ruleset = ruleset;
+                this.mods = mods;
+            }
+
+            private IBindable<StarDifficulty?> localStarDifficulty;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                difficultyCancellation = new CancellationTokenSource();
+                localStarDifficulty = ruleset != null
+                    ? difficultyCache.GetBindableDifficulty(beatmap, ruleset, mods, difficultyCancellation.Token)
+                    : difficultyCache.GetBindableDifficulty(beatmap, difficultyCancellation.Token);
+                localStarDifficulty.BindValueChanged(d =>
+                {
+                    if (d.NewValue is StarDifficulty diff)
+                        StarDifficulty.Value = diff;
+                });
+            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+                difficultyCancellation?.Cancel();
+            }
+        }
+
+        private class DifficultyIconTooltipContent
+        {
+            public readonly BeatmapInfo Beatmap;
+            public readonly IBindable<StarDifficulty> Difficulty;
+
+            public DifficultyIconTooltipContent(BeatmapInfo beatmap, IBindable<StarDifficulty> difficulty)
+            {
+                Beatmap = beatmap;
+                Difficulty = difficulty;
+            }
         }
 
         private class DifficultyIconTooltip : VisibilityContainer, ITooltip
         {
             private readonly OsuSpriteText difficultyName, starRating;
             private readonly Box background;
-
             private readonly FillFlowContainer difficultyFlow;
 
             public DifficultyIconTooltip()
@@ -159,14 +257,22 @@ namespace osu.Game.Beatmaps.Drawables
                 background.Colour = colours.Gray3;
             }
 
+            private readonly IBindable<StarDifficulty> starDifficulty = new Bindable<StarDifficulty>();
+
             public bool SetContent(object content)
             {
-                if (!(content is BeatmapInfo beatmap))
+                if (!(content is DifficultyIconTooltipContent iconContent))
                     return false;
 
-                difficultyName.Text = beatmap.Version;
-                starRating.Text = $"{beatmap.StarDifficulty:0.##}";
-                difficultyFlow.Colour = colours.ForDifficultyRating(beatmap.DifficultyRating, true);
+                difficultyName.Text = iconContent.Beatmap.Version;
+
+                starDifficulty.UnbindAll();
+                starDifficulty.BindTo(iconContent.Difficulty);
+                starDifficulty.BindValueChanged(difficulty =>
+                {
+                    starRating.Text = $"{difficulty.NewValue.Stars:0.##}";
+                    difficultyFlow.Colour = colours.ForDifficultyRating(difficulty.NewValue.DifficultyRating, true);
+                }, true);
 
                 return true;
             }

osu.Game/Beatmaps/Drawables/GroupedDifficultyIcon.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Beatmaps.Drawables
     public class GroupedDifficultyIcon : DifficultyIcon
     {
         public GroupedDifficultyIcon(List<BeatmapInfo> beatmaps, RulesetInfo ruleset, Color4 counterColour)
-            : base(beatmaps.OrderBy(b => b.StarDifficulty).Last(), ruleset, false)
+            : base(beatmaps.OrderBy(b => b.StarDifficulty).Last(), ruleset, null, false)
         {
             AddInternal(new OsuSpriteText
             {

osu.Game/Beatmaps/Drawables/UpdateableBeatmapBackgroundSprite.cs

@@ -16,6 +16,8 @@ namespace osu.Game.Beatmaps.Drawables
     {
         public readonly Bindable<BeatmapInfo> Beatmap = new Bindable<BeatmapInfo>();
 
+        protected override double LoadDelay => 500;
+
         [Resolved]
         private BeatmapManager beatmaps { get; set; }
 
@@ -32,8 +34,8 @@ namespace osu.Game.Beatmaps.Drawables
         /// </summary>
         protected virtual double UnloadDelay => 10000;
 
-        protected override DelayedLoadWrapper CreateDelayedLoadWrapper(Func<Drawable> createContentFunc, double timeBeforeLoad)
-            => new DelayedLoadUnloadWrapper(createContentFunc, timeBeforeLoad, UnloadDelay);
+        protected override DelayedLoadWrapper CreateDelayedLoadWrapper(Func<Drawable> createContentFunc, double timeBeforeLoad) =>
+            new DelayedLoadUnloadWrapper(createContentFunc, timeBeforeLoad, UnloadDelay) { RelativeSizeAxes = Axes.Both };
 
         protected override double TransformDuration => 400;
 

osu.Game/Beatmaps/Drawables/UpdateableBeatmapSetCover.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -8,79 +9,52 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Beatmaps.Drawables
 {
-    public class UpdateableBeatmapSetCover : Container
+    public class UpdateableBeatmapSetCover : ModelBackedDrawable<BeatmapSetInfo>
     {
-        private Drawable displayedCover;
-
-        private BeatmapSetInfo beatmapSet;
+        private readonly BeatmapSetCoverType coverType;
 
         public BeatmapSetInfo BeatmapSet
         {
-            get => beatmapSet;
-            set
-            {
-                if (value == beatmapSet) return;
-
-                beatmapSet = value;
-
-                if (IsLoaded)
-                    updateCover();
-            }
+            get => Model;
+            set => Model = value;
         }
 
-        private BeatmapSetCoverType coverType = BeatmapSetCoverType.Cover;
-
-        public BeatmapSetCoverType CoverType
+        public new bool Masking
         {
-            get => coverType;
-            set
-            {
-                if (value == coverType) return;
-
-                coverType = value;
-
-                if (IsLoaded)
-                    updateCover();
-            }
+            get => base.Masking;
+            set => base.Masking = value;
         }
 
-        public UpdateableBeatmapSetCover()
+        public UpdateableBeatmapSetCover(BeatmapSetCoverType coverType = BeatmapSetCoverType.Cover)
         {
-            Child = new Box
+            this.coverType = coverType;
+
+            InternalChild = new Box
             {
                 RelativeSizeAxes = Axes.Both,
                 Colour = OsuColour.Gray(0.2f),
             };
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            updateCover();
-        }
+        protected override double LoadDelay => 500;
 
-        private void updateCover()
-        {
-            displayedCover?.FadeOut(400);
-            displayedCover?.Expire();
-            displayedCover = null;
+        protected override double TransformDuration => 400;
 
-            if (beatmapSet != null)
+        protected override DelayedLoadWrapper CreateDelayedLoadWrapper(Func<Drawable> createContentFunc, double timeBeforeLoad)
+            => new DelayedLoadUnloadWrapper(createContentFunc, timeBeforeLoad);
+
+        protected override Drawable CreateDrawable(BeatmapSetInfo model)
+        {
+            if (model == null)
+                return null;
+
+            return new BeatmapSetCover(model, coverType)
             {
-                BeatmapSetCover cover;
-
-                Add(displayedCover = new DelayedLoadWrapper(
-                    cover = new BeatmapSetCover(beatmapSet, coverType)
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Both,
-                        FillMode = FillMode.Fill,
-                    })
-                );
-
-                cover.OnLoadComplete += d => d.FadeInFromZero(400, Easing.Out);
-            }
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                FillMode = FillMode.Fill,
+            };
         }
     }
 }

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -3,16 +3,19 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using JetBrains.Annotations;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
+using osu.Game.Skinning;
 
 namespace osu.Game.Beatmaps
 {
@@ -20,7 +23,7 @@ namespace osu.Game.Beatmaps
     {
         private readonly TextureStore textures;
 
-        public DummyWorkingBeatmap(AudioManager audio, TextureStore textures)
+        public DummyWorkingBeatmap([NotNull] AudioManager audio, TextureStore textures)
             : base(new BeatmapInfo
             {
                 Metadata = new BeatmapMetadata
@@ -45,9 +48,11 @@ namespace osu.Game.Beatmaps
 
         protected override Texture GetBackground() => textures?.Get(@"Backgrounds/bg4");
 
-        protected override VideoSprite GetVideo() => null;
+        protected override Track GetBeatmapTrack() => GetVirtualTrack();
 
-        protected override Track GetTrack() => GetVirtualTrack();
+        protected override ISkin GetSkin() => null;
+
+        public override Stream GetStream(string storagePath) => null;
 
         private class DummyRulesetInfo : RulesetInfo
         {
@@ -78,7 +83,7 @@ namespace osu.Game.Beatmaps
 
                     public bool CanConvert() => true;
 
-                    public IBeatmap Convert()
+                    public IBeatmap Convert(CancellationToken cancellationToken = default)
                     {
                         foreach (var obj in Beatmap.HitObjects)
                             ObjectConverted?.Invoke(obj, obj.Yield());

osu.Game/Beatmaps/Formats/Decoder.cs

@@ -63,7 +63,7 @@ namespace osu.Game.Beatmaps.Formats
             if (line == null)
                 throw new IOException("Unknown file format (null)");
 
-            var decoder = typedDecoders.Select(d => line.StartsWith(d.Key, StringComparison.InvariantCulture) ? d.Value : null).FirstOrDefault();
+            var decoder = typedDecoders.Where(d => line.StartsWith(d.Key, StringComparison.InvariantCulture)).Select(d => d.Value).FirstOrDefault();
 
             // it's important the magic does NOT get consumed here, since sometimes it's part of the structure
             // (see JsonBeatmapDecoder - the magic string is the opening brace)

osu.Game/Beatmaps/Formats/IHasCustomColours.cs

@@ -8,6 +8,6 @@ namespace osu.Game.Beatmaps.Formats
 {
     public interface IHasCustomColours
     {
-        Dictionary<string, Color4> CustomColours { get; set; }
+        Dictionary<string, Color4> CustomColours { get; }
     }
 }

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -6,18 +6,17 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using osu.Framework.Extensions;
-using osu.Game.Beatmaps.Timing;
-using osu.Game.Rulesets.Objects.Legacy;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.IO;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.IO;
+using osu.Game.Rulesets.Objects.Legacy;
 
 namespace osu.Game.Beatmaps.Formats
 {
     public class LegacyBeatmapDecoder : LegacyDecoder<Beatmap>
     {
-        public const int LATEST_VERSION = 14;
-
         private Beatmap beatmap;
 
         private ConvertHitObjectParser parser;
@@ -68,16 +67,14 @@ namespace osu.Game.Beatmaps.Formats
 
         protected override void ParseLine(Beatmap beatmap, Section section, string line)
         {
-            var strippedLine = StripComments(line);
-
             switch (section)
             {
                 case Section.General:
-                    handleGeneral(strippedLine);
+                    handleGeneral(line);
                     return;
 
                 case Section.Editor:
-                    handleEditor(strippedLine);
+                    handleEditor(line);
                     return;
 
                 case Section.Metadata:
@@ -85,19 +82,19 @@ namespace osu.Game.Beatmaps.Formats
                     return;
 
                 case Section.Difficulty:
-                    handleDifficulty(strippedLine);
+                    handleDifficulty(line);
                     return;
 
                 case Section.Events:
-                    handleEvent(strippedLine);
+                    handleEvent(line);
                     return;
 
                 case Section.TimingPoints:
-                    handleTimingPoint(strippedLine);
+                    handleTimingPoint(line);
                     return;
 
                 case Section.HitObjects:
-                    handleHitObject(strippedLine);
+                    handleHitObject(line);
                     return;
             }
 
@@ -175,6 +172,10 @@ namespace osu.Game.Beatmaps.Formats
                 case @"WidescreenStoryboard":
                     beatmap.BeatmapInfo.WidescreenStoryboard = Parsing.ParseInt(pair.Value) == 1;
                     break;
+
+                case @"EpilepsyWarning":
+                    beatmap.BeatmapInfo.EpilepsyWarning = Parsing.ParseInt(pair.Value) == 1;
+                    break;
             }
         }
 
@@ -303,23 +304,11 @@ namespace osu.Game.Beatmaps.Formats
                     beatmap.BeatmapInfo.Metadata.BackgroundFile = CleanFilename(split[2]);
                     break;
 
-                case LegacyEventType.Video:
-                    beatmap.BeatmapInfo.Metadata.VideoFile = CleanFilename(split[2]);
-                    break;
-
                 case LegacyEventType.Break:
                     double start = getOffsetTime(Parsing.ParseDouble(split[1]));
+                    double end = Math.Max(start, getOffsetTime(Parsing.ParseDouble(split[2])));
 
-                    var breakEvent = new BreakPeriod
-                    {
-                        StartTime = start,
-                        EndTime = Math.Max(start, getOffsetTime(Parsing.ParseDouble(split[2])))
-                    };
-
-                    if (!breakEvent.HasEffect)
-                        return;
-
-                    beatmap.Breaks.Add(breakEvent);
+                    beatmap.Breaks.Add(new BreakPeriod(start, end));
                     break;
             }
         }
@@ -358,8 +347,8 @@ namespace osu.Game.Beatmaps.Formats
             if (split.Length >= 8)
             {
                 LegacyEffectFlags effectFlags = (LegacyEffectFlags)Parsing.ParseInt(split[7]);
-                kiaiMode = effectFlags.HasFlag(LegacyEffectFlags.Kiai);
-                omitFirstBarSignature = effectFlags.HasFlag(LegacyEffectFlags.OmitFirstBarLine);
+                kiaiMode = effectFlags.HasFlagFast(LegacyEffectFlags.Kiai);
+                omitFirstBarSignature = effectFlags.HasFlagFast(LegacyEffectFlags.OmitFirstBarLine);
             }
 
             string stringSampleSet = sampleSet.ToString().ToLowerInvariant();
@@ -376,7 +365,9 @@ namespace osu.Game.Beatmaps.Formats
                 addControlPoint(time, controlPoint, true);
             }
 
-            addControlPoint(time, new LegacyDifficultyControlPoint
+#pragma warning disable 618
+            addControlPoint(time, new LegacyDifficultyControlPoint(beatLength)
+#pragma warning restore 618
             {
                 SpeedMultiplier = speedMultiplier,
             }, timingChange);
@@ -393,17 +384,10 @@ namespace osu.Game.Beatmaps.Formats
                 SampleVolume = sampleVolume,
                 CustomSampleBank = customSampleBank,
             }, timingChange);
-
-            // To handle the scenario where a non-timing line shares the same time value as a subsequent timing line but
-            // appears earlier in the file, we buffer non-timing control points and rewrite them *after* control points from the timing line
-            // with the same time value (allowing them to overwrite as necessary).
-            //
-            // The expected outcome is that we prefer the non-timing line's adjustments over the timing line's adjustments when time is equal.
-            if (timingChange)
-                flushPendingPoints();
         }
 
         private readonly List<ControlPoint> pendingControlPoints = new List<ControlPoint>();
+        private readonly HashSet<Type> pendingControlPointTypes = new HashSet<Type>();
         private double pendingControlPointsTime;
 
         private void addControlPoint(double time, ControlPoint point, bool timingChange)
@@ -412,28 +396,34 @@ namespace osu.Game.Beatmaps.Formats
                 flushPendingPoints();
 
             if (timingChange)
-            {
-                beatmap.ControlPointInfo.Add(time, point);
-                return;
-            }
+                pendingControlPoints.Insert(0, point);
+            else
+                pendingControlPoints.Add(point);
 
-            pendingControlPoints.Add(point);
             pendingControlPointsTime = time;
         }
 
         private void flushPendingPoints()
         {
-            foreach (var p in pendingControlPoints)
-                beatmap.ControlPointInfo.Add(pendingControlPointsTime, p);
+            // Changes from non-timing-points are added to the end of the list (see addControlPoint()) and should override any changes from timing-points (added to the start of the list).
+            for (int i = pendingControlPoints.Count - 1; i >= 0; i--)
+            {
+                var type = pendingControlPoints[i].GetType();
+                if (pendingControlPointTypes.Contains(type))
+                    continue;
+
+                pendingControlPointTypes.Add(type);
+                beatmap.ControlPointInfo.Add(pendingControlPointsTime, pendingControlPoints[i]);
+            }
 
             pendingControlPoints.Clear();
+            pendingControlPointTypes.Clear();
         }
 
         private void handleHitObject(string line)
         {
             // If the ruleset wasn't specified, assume the osu!standard ruleset.
-            if (parser == null)
-                parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser(getOffsetTime(), FormatVersion);
+            parser ??= new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser(getOffsetTime(), FormatVersion);
 
             var obj = parser.Parse(line);
             if (obj != null)

osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs

@@ -3,14 +3,20 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text;
+using JetBrains.Annotations;
 using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -20,9 +26,18 @@ namespace osu.Game.Beatmaps.Formats
 
         private readonly IBeatmap beatmap;
 
-        public LegacyBeatmapEncoder(IBeatmap beatmap)
+        [CanBeNull]
+        private readonly ISkin skin;
+
+        /// <summary>
+        /// Creates a new <see cref="LegacyBeatmapEncoder"/>.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to encode.</param>
+        /// <param name="skin">The beatmap's skin, used for encoding combo colours.</param>
+        public LegacyBeatmapEncoder(IBeatmap beatmap, [CanBeNull] ISkin skin)
         {
             this.beatmap = beatmap;
+            this.skin = skin;
 
             if (beatmap.BeatmapInfo.RulesetID < 0 || beatmap.BeatmapInfo.RulesetID > 3)
                 throw new ArgumentException("Only beatmaps in the osu, taiko, catch, or mania rulesets can be encoded to the legacy beatmap format.", nameof(beatmap));
@@ -48,7 +63,10 @@ namespace osu.Game.Beatmaps.Formats
             handleEvents(writer);
 
             writer.WriteLine();
-            handleTimingPoints(writer);
+            handleControlPoints(writer);
+
+            writer.WriteLine();
+            handleColours(writer);
 
             writer.WriteLine();
             handleHitObjects(writer);
@@ -58,7 +76,7 @@ namespace osu.Game.Beatmaps.Formats
         {
             writer.WriteLine("[General]");
 
-            writer.WriteLine(FormattableString.Invariant($"AudioFilename: {Path.GetFileName(beatmap.Metadata.AudioFile)}"));
+            if (beatmap.Metadata.AudioFile != null) writer.WriteLine(FormattableString.Invariant($"AudioFilename: {Path.GetFileName(beatmap.Metadata.AudioFile)}"));
             writer.WriteLine(FormattableString.Invariant($"AudioLeadIn: {beatmap.BeatmapInfo.AudioLeadIn}"));
             writer.WriteLine(FormattableString.Invariant($"PreviewTime: {beatmap.Metadata.PreviewTime}"));
             // Todo: Not all countdown types are supported by lazer yet
@@ -103,15 +121,15 @@ namespace osu.Game.Beatmaps.Formats
             writer.WriteLine("[Metadata]");
 
             writer.WriteLine(FormattableString.Invariant($"Title: {beatmap.Metadata.Title}"));
-            writer.WriteLine(FormattableString.Invariant($"TitleUnicode: {beatmap.Metadata.TitleUnicode}"));
+            if (beatmap.Metadata.TitleUnicode != null) writer.WriteLine(FormattableString.Invariant($"TitleUnicode: {beatmap.Metadata.TitleUnicode}"));
             writer.WriteLine(FormattableString.Invariant($"Artist: {beatmap.Metadata.Artist}"));
-            writer.WriteLine(FormattableString.Invariant($"ArtistUnicode: {beatmap.Metadata.ArtistUnicode}"));
+            if (beatmap.Metadata.ArtistUnicode != null) writer.WriteLine(FormattableString.Invariant($"ArtistUnicode: {beatmap.Metadata.ArtistUnicode}"));
             writer.WriteLine(FormattableString.Invariant($"Creator: {beatmap.Metadata.AuthorString}"));
             writer.WriteLine(FormattableString.Invariant($"Version: {beatmap.BeatmapInfo.Version}"));
-            writer.WriteLine(FormattableString.Invariant($"Source: {beatmap.Metadata.Source}"));
-            writer.WriteLine(FormattableString.Invariant($"Tags: {beatmap.Metadata.Tags}"));
-            writer.WriteLine(FormattableString.Invariant($"BeatmapID: {beatmap.BeatmapInfo.OnlineBeatmapID ?? 0}"));
-            writer.WriteLine(FormattableString.Invariant($"BeatmapSetID: {beatmap.BeatmapInfo.BeatmapSet.OnlineBeatmapSetID ?? -1}"));
+            if (beatmap.Metadata.Source != null) writer.WriteLine(FormattableString.Invariant($"Source: {beatmap.Metadata.Source}"));
+            if (beatmap.Metadata.Tags != null) writer.WriteLine(FormattableString.Invariant($"Tags: {beatmap.Metadata.Tags}"));
+            if (beatmap.BeatmapInfo.OnlineBeatmapID != null) writer.WriteLine(FormattableString.Invariant($"BeatmapID: {beatmap.BeatmapInfo.OnlineBeatmapID}"));
+            if (beatmap.BeatmapInfo.BeatmapSet?.OnlineBeatmapSetID != null) writer.WriteLine(FormattableString.Invariant($"BeatmapSetID: {beatmap.BeatmapInfo.BeatmapSet.OnlineBeatmapSetID}"));
         }
 
         private void handleDifficulty(TextWriter writer)
@@ -122,7 +140,12 @@ namespace osu.Game.Beatmaps.Formats
             writer.WriteLine(FormattableString.Invariant($"CircleSize: {beatmap.BeatmapInfo.BaseDifficulty.CircleSize}"));
             writer.WriteLine(FormattableString.Invariant($"OverallDifficulty: {beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty}"));
             writer.WriteLine(FormattableString.Invariant($"ApproachRate: {beatmap.BeatmapInfo.BaseDifficulty.ApproachRate}"));
-            writer.WriteLine(FormattableString.Invariant($"SliderMultiplier: {beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier}"));
+
+            // Taiko adjusts the slider multiplier (see: TaikoBeatmapConverter.LEGACY_VELOCITY_MULTIPLIER)
+            writer.WriteLine(beatmap.BeatmapInfo.RulesetID == 1
+                ? FormattableString.Invariant($"SliderMultiplier: {beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier / 1.4f}")
+                : FormattableString.Invariant($"SliderMultiplier: {beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier}"));
+
             writer.WriteLine(FormattableString.Invariant($"SliderTickRate: {beatmap.BeatmapInfo.BaseDifficulty.SliderTickRate}"));
         }
 
@@ -133,14 +156,11 @@ namespace osu.Game.Beatmaps.Formats
             if (!string.IsNullOrEmpty(beatmap.BeatmapInfo.Metadata.BackgroundFile))
                 writer.WriteLine(FormattableString.Invariant($"{(int)LegacyEventType.Background},0,\"{beatmap.BeatmapInfo.Metadata.BackgroundFile}\",0,0"));
 
-            if (!string.IsNullOrEmpty(beatmap.BeatmapInfo.Metadata.VideoFile))
-                writer.WriteLine(FormattableString.Invariant($"{(int)LegacyEventType.Video},0,\"{beatmap.BeatmapInfo.Metadata.VideoFile}\",0,0"));
-
             foreach (var b in beatmap.Breaks)
                 writer.WriteLine(FormattableString.Invariant($"{(int)LegacyEventType.Break},{b.StartTime},{b.EndTime}"));
         }
 
-        private void handleTimingPoints(TextWriter writer)
+        private void handleControlPoints(TextWriter writer)
         {
             if (beatmap.ControlPointInfo.Groups.Count == 0)
                 return;
@@ -149,20 +169,30 @@ namespace osu.Game.Beatmaps.Formats
 
             foreach (var group in beatmap.ControlPointInfo.Groups)
             {
-                var timingPoint = group.ControlPoints.OfType<TimingControlPoint>().FirstOrDefault();
-                var difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(group.Time);
-                var samplePoint = beatmap.ControlPointInfo.SamplePointAt(group.Time);
-                var effectPoint = beatmap.ControlPointInfo.EffectPointAt(group.Time);
+                var groupTimingPoint = group.ControlPoints.OfType<TimingControlPoint>().FirstOrDefault();
 
-                // Convert beat length the legacy format
-                double beatLength;
-                if (timingPoint != null)
-                    beatLength = timingPoint.BeatLength;
-                else
-                    beatLength = -100 / difficultyPoint.SpeedMultiplier;
+                // If the group contains a timing control point, it needs to be output separately.
+                if (groupTimingPoint != null)
+                {
+                    writer.Write(FormattableString.Invariant($"{groupTimingPoint.Time},"));
+                    writer.Write(FormattableString.Invariant($"{groupTimingPoint.BeatLength},"));
+                    outputControlPointEffectsAt(groupTimingPoint.Time, true);
+                }
+
+                // Output any remaining effects as secondary non-timing control point.
+                var difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(group.Time);
+                writer.Write(FormattableString.Invariant($"{group.Time},"));
+                writer.Write(FormattableString.Invariant($"{-100 / difficultyPoint.SpeedMultiplier},"));
+                outputControlPointEffectsAt(group.Time, false);
+            }
+
+            void outputControlPointEffectsAt(double time, bool isTimingPoint)
+            {
+                var samplePoint = beatmap.ControlPointInfo.SamplePointAt(time);
+                var effectPoint = beatmap.ControlPointInfo.EffectPointAt(time);
 
                 // Apply the control point to a hit sample to uncover legacy properties (e.g. suffix)
-                HitSampleInfo tempHitSample = samplePoint.ApplyTo(new HitSampleInfo());
+                HitSampleInfo tempHitSample = samplePoint.ApplyTo(new ConvertHitObjectParser.LegacyHitSampleInfo(string.Empty));
 
                 // Convert effect flags to the legacy format
                 LegacyEffectFlags effectFlags = LegacyEffectFlags.None;
@@ -171,93 +201,114 @@ namespace osu.Game.Beatmaps.Formats
                 if (effectPoint.OmitFirstBarLine)
                     effectFlags |= LegacyEffectFlags.OmitFirstBarLine;
 
-                writer.Write(FormattableString.Invariant($"{group.Time},"));
-                writer.Write(FormattableString.Invariant($"{beatLength},"));
-                writer.Write(FormattableString.Invariant($"{(int)beatmap.ControlPointInfo.TimingPointAt(group.Time).TimeSignature},"));
+                writer.Write(FormattableString.Invariant($"{(int)beatmap.ControlPointInfo.TimingPointAt(time).TimeSignature},"));
                 writer.Write(FormattableString.Invariant($"{(int)toLegacySampleBank(tempHitSample.Bank)},"));
-                writer.Write(FormattableString.Invariant($"{toLegacyCustomSampleBank(tempHitSample.Suffix)},"));
+                writer.Write(FormattableString.Invariant($"{toLegacyCustomSampleBank(tempHitSample)},"));
                 writer.Write(FormattableString.Invariant($"{tempHitSample.Volume},"));
-                writer.Write(FormattableString.Invariant($"{(timingPoint != null ? '1' : '0')},"));
+                writer.Write(FormattableString.Invariant($"{(isTimingPoint ? '1' : '0')},"));
                 writer.Write(FormattableString.Invariant($"{(int)effectFlags}"));
                 writer.WriteLine();
             }
         }
 
+        private void handleColours(TextWriter writer)
+        {
+            var colours = skin?.GetConfig<GlobalSkinColours, IReadOnlyList<Color4>>(GlobalSkinColours.ComboColours)?.Value;
+
+            if (colours == null || colours.Count == 0)
+                return;
+
+            writer.WriteLine("[Colours]");
+
+            for (var i = 0; i < colours.Count; i++)
+            {
+                var comboColour = colours[i];
+
+                writer.Write(FormattableString.Invariant($"Combo{i}: "));
+                writer.Write(FormattableString.Invariant($"{(byte)(comboColour.R * byte.MaxValue)},"));
+                writer.Write(FormattableString.Invariant($"{(byte)(comboColour.G * byte.MaxValue)},"));
+                writer.Write(FormattableString.Invariant($"{(byte)(comboColour.B * byte.MaxValue)},"));
+                writer.Write(FormattableString.Invariant($"{(byte)(comboColour.A * byte.MaxValue)}"));
+                writer.WriteLine();
+            }
+        }
+
         private void handleHitObjects(TextWriter writer)
         {
+            writer.WriteLine("[HitObjects]");
+
             if (beatmap.HitObjects.Count == 0)
                 return;
 
-            writer.WriteLine("[HitObjects]");
+            foreach (var h in beatmap.HitObjects)
+                handleHitObject(writer, h);
+        }
+
+        private void handleHitObject(TextWriter writer, HitObject hitObject)
+        {
+            Vector2 position = new Vector2(256, 192);
 
             switch (beatmap.BeatmapInfo.RulesetID)
             {
                 case 0:
-                    foreach (var h in beatmap.HitObjects)
-                        handleOsuHitObject(writer, h);
-                    break;
-
-                case 1:
-                    foreach (var h in beatmap.HitObjects)
-                        handleTaikoHitObject(writer, h);
+                    position = ((IHasPosition)hitObject).Position;
                     break;
 
                 case 2:
-                    foreach (var h in beatmap.HitObjects)
-                        handleCatchHitObject(writer, h);
+                    position.X = ((IHasXPosition)hitObject).X;
                     break;
 
                 case 3:
-                    foreach (var h in beatmap.HitObjects)
-                        handleManiaHitObject(writer, h);
+                    int totalColumns = (int)Math.Max(1, beatmap.BeatmapInfo.BaseDifficulty.CircleSize);
+                    position.X = (int)Math.Ceiling(((IHasXPosition)hitObject).X * (512f / totalColumns));
                     break;
             }
-        }
 
-        private void handleOsuHitObject(TextWriter writer, HitObject hitObject)
-        {
-            var positionData = (IHasPosition)hitObject;
-
-            writer.Write(FormattableString.Invariant($"{positionData.X},"));
-            writer.Write(FormattableString.Invariant($"{positionData.Y},"));
+            writer.Write(FormattableString.Invariant($"{position.X},"));
+            writer.Write(FormattableString.Invariant($"{position.Y},"));
             writer.Write(FormattableString.Invariant($"{hitObject.StartTime},"));
             writer.Write(FormattableString.Invariant($"{(int)getObjectType(hitObject)},"));
+            writer.Write(FormattableString.Invariant($"{(int)toLegacyHitSoundType(hitObject.Samples)},"));
 
-            writer.Write(hitObject is IHasCurve
-                ? FormattableString.Invariant($"0,")
-                : FormattableString.Invariant($"{(int)toLegacyHitSoundType(hitObject.Samples)},"));
-
-            if (hitObject is IHasCurve curveData)
+            if (hitObject is IHasPath path)
             {
-                addCurveData(writer, curveData, positionData);
-                writer.Write(getSampleBank(hitObject.Samples, zeroBanks: true));
+                addPathData(writer, path, position);
+                writer.Write(getSampleBank(hitObject.Samples));
             }
             else
             {
-                if (hitObject is IHasEndTime endTimeData)
-                    writer.Write(FormattableString.Invariant($"{endTimeData.EndTime},"));
+                if (hitObject is IHasDuration)
+                    addEndTimeData(writer, hitObject);
+
                 writer.Write(getSampleBank(hitObject.Samples));
             }
 
             writer.WriteLine();
         }
 
-        private static LegacyHitObjectType getObjectType(HitObject hitObject)
+        private LegacyHitObjectType getObjectType(HitObject hitObject)
         {
-            var comboData = (IHasCombo)hitObject;
+            LegacyHitObjectType type = 0;
 
-            var type = (LegacyHitObjectType)(comboData.ComboOffset << 4);
+            if (hitObject is IHasCombo combo)
+            {
+                type = (LegacyHitObjectType)(combo.ComboOffset << 4);
 
-            if (comboData.NewCombo) type |= LegacyHitObjectType.NewCombo;
+                if (combo.NewCombo)
+                    type |= LegacyHitObjectType.NewCombo;
+            }
 
             switch (hitObject)
             {
-                case IHasCurve _:
+                case IHasPath _:
                     type |= LegacyHitObjectType.Slider;
                     break;
 
-                case IHasEndTime _:
-                    type |= LegacyHitObjectType.Spinner | LegacyHitObjectType.NewCombo;
+                case IHasDuration _:
+                    if (beatmap.BeatmapInfo.RulesetID == 3)
+                        type |= LegacyHitObjectType.Hold;
+                    else
+                        type |= LegacyHitObjectType.Spinner;
                     break;
 
                 default:
@@ -268,17 +319,36 @@ namespace osu.Game.Beatmaps.Formats
             return type;
         }
 
-        private void addCurveData(TextWriter writer, IHasCurve curveData, IHasPosition positionData)
+        private void addPathData(TextWriter writer, IHasPath pathData, Vector2 position)
         {
             PathType? lastType = null;
 
-            for (int i = 0; i < curveData.Path.ControlPoints.Count; i++)
+            for (int i = 0; i < pathData.Path.ControlPoints.Count; i++)
             {
-                PathControlPoint point = curveData.Path.ControlPoints[i];
+                PathControlPoint point = pathData.Path.ControlPoints[i];
 
                 if (point.Type.Value != null)
                 {
-                    if (point.Type.Value != lastType)
+                    // We've reached a new (explicit) segment!
+
+                    // Explicit segments have a new format in which the type is injected into the middle of the control point string.
+                    // To preserve compatibility with osu-stable as much as possible, explicit segments with the same type are converted to use implicit segments by duplicating the control point.
+                    // One exception are consecutive perfect curves, which aren't supported in osu!stable and can lead to decoding issues if encoded as implicit segments
+                    bool needsExplicitSegment = point.Type.Value != lastType || point.Type.Value == PathType.PerfectCurve;
+
+                    // Another exception to this is when the last two control points of the last segment were duplicated. This is not a scenario supported by osu!stable.
+                    // Lazer does not add implicit segments for the last two control points of _any_ explicit segment, so an explicit segment is forced in order to maintain consistency with the decoder.
+                    if (i > 1)
+                    {
+                        // We need to use the absolute control point position to determine equality, otherwise floating point issues may arise.
+                        Vector2 p1 = position + pathData.Path.ControlPoints[i - 1].Position.Value;
+                        Vector2 p2 = position + pathData.Path.ControlPoints[i - 2].Position.Value;
+
+                        if ((int)p1.X == (int)p2.X && (int)p1.Y == (int)p2.Y)
+                            needsExplicitSegment = true;
+                    }
+
+                    if (needsExplicitSegment)
                     {
                         switch (point.Type.Value)
                         {
@@ -304,56 +374,69 @@ namespace osu.Game.Beatmaps.Formats
                     else
                     {
                         // New segment with the same type - duplicate the control point
-                        writer.Write(FormattableString.Invariant($"{positionData.X + point.Position.Value.X}:{positionData.Y + point.Position.Value.Y}|"));
+                        writer.Write(FormattableString.Invariant($"{position.X + point.Position.Value.X}:{position.Y + point.Position.Value.Y}|"));
                     }
                 }
 
                 if (i != 0)
                 {
-                    writer.Write(FormattableString.Invariant($"{positionData.X + point.Position.Value.X}:{positionData.Y + point.Position.Value.Y}"));
-                    writer.Write(i != curveData.Path.ControlPoints.Count - 1 ? "|" : ",");
+                    writer.Write(FormattableString.Invariant($"{position.X + point.Position.Value.X}:{position.Y + point.Position.Value.Y}"));
+                    writer.Write(i != pathData.Path.ControlPoints.Count - 1 ? "|" : ",");
                 }
             }
 
-            writer.Write(FormattableString.Invariant($"{curveData.RepeatCount + 1},"));
-            writer.Write(FormattableString.Invariant($"{curveData.Path.Distance},"));
+            var curveData = pathData as IHasPathWithRepeats;
 
-            for (int i = 0; i < curveData.NodeSamples.Count; i++)
-            {
-                writer.Write(FormattableString.Invariant($"{(int)toLegacyHitSoundType(curveData.NodeSamples[i])}"));
-                writer.Write(i != curveData.NodeSamples.Count - 1 ? "|" : ",");
-            }
+            writer.Write(FormattableString.Invariant($"{(curveData?.RepeatCount ?? 0) + 1},"));
+            writer.Write(FormattableString.Invariant($"{pathData.Path.Distance},"));
 
-            for (int i = 0; i < curveData.NodeSamples.Count; i++)
+            if (curveData != null)
             {
-                writer.Write(getSampleBank(curveData.NodeSamples[i], true));
-                writer.Write(i != curveData.NodeSamples.Count - 1 ? "|" : ",");
+                for (int i = 0; i < curveData.NodeSamples.Count; i++)
+                {
+                    writer.Write(FormattableString.Invariant($"{(int)toLegacyHitSoundType(curveData.NodeSamples[i])}"));
+                    writer.Write(i != curveData.NodeSamples.Count - 1 ? "|" : ",");
+                }
+
+                for (int i = 0; i < curveData.NodeSamples.Count; i++)
+                {
+                    writer.Write(getSampleBank(curveData.NodeSamples[i], true));
+                    writer.Write(i != curveData.NodeSamples.Count - 1 ? "|" : ",");
+                }
             }
         }
 
-        private void handleTaikoHitObject(TextWriter writer, HitObject hitObject) => throw new NotImplementedException();
+        private void addEndTimeData(TextWriter writer, HitObject hitObject)
+        {
+            var endTimeData = (IHasDuration)hitObject;
+            var type = getObjectType(hitObject);
 
-        private void handleCatchHitObject(TextWriter writer, HitObject hitObject) => throw new NotImplementedException();
+            char suffix = ',';
 
-        private void handleManiaHitObject(TextWriter writer, HitObject hitObject) => throw new NotImplementedException();
+            // Holds write the end time as if it's part of sample data.
+            if (type == LegacyHitObjectType.Hold)
+                suffix = ':';
 
-        private string getSampleBank(IList<HitSampleInfo> samples, bool banksOnly = false, bool zeroBanks = false)
+            writer.Write(FormattableString.Invariant($"{endTimeData.EndTime}{suffix}"));
+        }
+
+        private string getSampleBank(IList<HitSampleInfo> samples, bool banksOnly = false)
         {
             LegacySampleBank normalBank = toLegacySampleBank(samples.SingleOrDefault(s => s.Name == HitSampleInfo.HIT_NORMAL)?.Bank);
             LegacySampleBank addBank = toLegacySampleBank(samples.FirstOrDefault(s => !string.IsNullOrEmpty(s.Name) && s.Name != HitSampleInfo.HIT_NORMAL)?.Bank);
 
             StringBuilder sb = new StringBuilder();
 
-            sb.Append(FormattableString.Invariant($"{(zeroBanks ? 0 : (int)normalBank)}:"));
-            sb.Append(FormattableString.Invariant($"{(zeroBanks ? 0 : (int)addBank)}"));
+            sb.Append(FormattableString.Invariant($"{(int)normalBank}:"));
+            sb.Append(FormattableString.Invariant($"{(int)addBank}"));
 
             if (!banksOnly)
             {
-                string customSampleBank = toLegacyCustomSampleBank(samples.FirstOrDefault(s => !string.IsNullOrEmpty(s.Name))?.Suffix);
+                string customSampleBank = toLegacyCustomSampleBank(samples.FirstOrDefault(s => !string.IsNullOrEmpty(s.Name)));
                 string sampleFilename = samples.FirstOrDefault(s => string.IsNullOrEmpty(s.Name))?.LookupNames.First() ?? string.Empty;
                 int volume = samples.FirstOrDefault()?.Volume ?? 100;
 
-                sb.Append(":");
+                sb.Append(':');
                 sb.Append(FormattableString.Invariant($"{customSampleBank}:"));
                 sb.Append(FormattableString.Invariant($"{volume}:"));
                 sb.Append(FormattableString.Invariant($"{sampleFilename}"));
@@ -405,6 +488,12 @@ namespace osu.Game.Beatmaps.Formats
             }
         }
 
-        private string toLegacyCustomSampleBank(string sampleSuffix) => string.IsNullOrEmpty(sampleSuffix) ? "0" : sampleSuffix;
+        private string toLegacyCustomSampleBank(HitSampleInfo hitSampleInfo)
+        {
+            if (hitSampleInfo is ConvertHitObjectParser.LegacyHitSampleInfo legacy)
+                return legacy.CustomSampleBank.ToString(CultureInfo.InvariantCulture);
+
+            return "0";
+        }
     }
 }

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -8,6 +8,7 @@ using osu.Framework.Logging;
 using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.IO;
+using osu.Game.Rulesets.Objects.Legacy;
 using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.Formats
@@ -15,6 +16,8 @@ namespace osu.Game.Beatmaps.Formats
     public abstract class LegacyDecoder<T> : Decoder<T>
         where T : new()
     {
+        public const int LATEST_VERSION = 14;
+
         protected readonly int FormatVersion;
 
         protected LegacyDecoder(int version)
@@ -33,6 +36,14 @@ namespace osu.Game.Beatmaps.Formats
                 if (ShouldSkipLine(line))
                     continue;
 
+                if (section != Section.Metadata)
+                {
+                    // comments should not be stripped from metadata lines, as the song metadata may contain "//" as valid data.
+                    line = StripComments(line);
+                }
+
+                line = line.TrimEnd();
+
                 if (line.StartsWith('[') && line.EndsWith(']'))
                 {
                     if (!Enum.TryParse(line[1..^1], out section))
@@ -41,6 +52,7 @@ namespace osu.Game.Beatmaps.Formats
                         section = Section.None;
                     }
 
+                    OnBeginNewSection(section);
                     continue;
                 }
 
@@ -57,14 +69,20 @@ namespace osu.Game.Beatmaps.Formats
 
         protected virtual bool ShouldSkipLine(string line) => string.IsNullOrWhiteSpace(line) || line.AsSpan().TrimStart().StartsWith("//".AsSpan(), StringComparison.Ordinal);
 
+        /// <summary>
+        /// Invoked when a new <see cref="Section"/> has been entered.
+        /// </summary>
+        /// <param name="section">The entered <see cref="Section"/>.</param>
+        protected virtual void OnBeginNewSection(Section section)
+        {
+        }
+
         protected virtual void ParseLine(T output, Section section, string line)
         {
-            line = StripComments(line);
-
             switch (section)
             {
                 case Section.Colours:
-                    handleColours(output, line);
+                    HandleColours(output, line);
                     return;
             }
         }
@@ -78,11 +96,11 @@ namespace osu.Game.Beatmaps.Formats
             return line;
         }
 
-        private void handleColours(T output, string line)
+        protected void HandleColours<TModel>(TModel output, string line)
         {
             var pair = SplitKeyVal(line);
 
-            bool isCombo = pair.Key.StartsWith(@"Combo");
+            bool isCombo = pair.Key.StartsWith(@"Combo", StringComparison.Ordinal);
 
             string[] split = pair.Value.Split(',');
 
@@ -93,7 +111,8 @@ namespace osu.Game.Beatmaps.Formats
 
             try
             {
-                colour = new Color4(byte.Parse(split[0]), byte.Parse(split[1]), byte.Parse(split[2]), split.Length == 4 ? byte.Parse(split[3]) : (byte)255);
+                byte alpha = split.Length == 4 ? byte.Parse(split[3]) : (byte)255;
+                colour = new Color4(byte.Parse(split[0]), byte.Parse(split[1]), byte.Parse(split[2]), alpha);
             }
             catch
             {
@@ -139,15 +158,38 @@ namespace osu.Game.Beatmaps.Formats
             Colours,
             HitObjects,
             Variables,
-            Fonts
+            Fonts,
+            CatchTheBeat,
+            Mania,
         }
 
-        internal class LegacyDifficultyControlPoint : DifficultyControlPoint
+        [Obsolete("Do not use unless you're a legacy ruleset and 100% sure.")]
+        public class LegacyDifficultyControlPoint : DifficultyControlPoint
         {
+            /// <summary>
+            /// Legacy BPM multiplier that introduces floating-point errors for rulesets that depend on it.
+            /// DO NOT USE THIS UNLESS 100% SURE.
+            /// </summary>
+            public double BpmMultiplier { get; private set; }
+
+            public LegacyDifficultyControlPoint(double beatLength)
+                : this()
+            {
+                // Note: In stable, the division occurs on floats, but with compiler optimisations turned on actually seems to occur on doubles via some .NET black magic (possibly inlining?).
+                BpmMultiplier = beatLength < 0 ? Math.Clamp((float)-beatLength, 10, 10000) / 100.0 : 1;
+            }
+
             public LegacyDifficultyControlPoint()
             {
                 SpeedMultiplierBindable.Precision = double.Epsilon;
             }
+
+            public override void CopyFrom(ControlPoint other)
+            {
+                base.CopyFrom(other);
+
+                BpmMultiplier = ((LegacyDifficultyControlPoint)other).BpmMultiplier;
+            }
         }
 
         internal class LegacySampleControlPoint : SampleControlPoint
@@ -158,15 +200,23 @@ namespace osu.Game.Beatmaps.Formats
             {
                 var baseInfo = base.ApplyTo(hitSampleInfo);
 
-                if (string.IsNullOrEmpty(baseInfo.Suffix) && CustomSampleBank > 1)
-                    baseInfo.Suffix = CustomSampleBank.ToString();
+                if (baseInfo is ConvertHitObjectParser.LegacyHitSampleInfo legacy && legacy.CustomSampleBank == 0)
+                    return legacy.With(newCustomSampleBank: CustomSampleBank);
 
                 return baseInfo;
             }
 
-            public override bool EquivalentTo(ControlPoint other) =>
-                base.EquivalentTo(other) && other is LegacySampleControlPoint otherTyped &&
-                CustomSampleBank == otherTyped.CustomSampleBank;
+            public override bool IsRedundant(ControlPoint existing)
+                => base.IsRedundant(existing)
+                   && existing is LegacySampleControlPoint existingSample
+                   && CustomSampleBank == existingSample.CustomSampleBank;
+
+            public override void CopyFrom(ControlPoint other)
+            {
+                base.CopyFrom(other);
+
+                CustomSampleBank = ((LegacySampleControlPoint)other).CustomSampleBank;
+            }
         }
     }
 }

osu.Game/Beatmaps/Formats/LegacyDifficultyCalculatorBeatmapDecoder.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
-using osu.Game.Beatmaps.ControlPoints;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -26,17 +25,5 @@ namespace osu.Game.Beatmaps.Formats
             AddDecoder<Beatmap>(@"osu file format v", m => new LegacyDifficultyCalculatorBeatmapDecoder(int.Parse(m.Split('v').Last())));
             SetFallbackDecoder<Beatmap>(() => new LegacyDifficultyCalculatorBeatmapDecoder());
         }
-
-        protected override TimingControlPoint CreateTimingControlPoint()
-            => new LegacyDifficultyCalculatorTimingControlPoint();
-
-        private class LegacyDifficultyCalculatorTimingControlPoint : TimingControlPoint
-        {
-            public LegacyDifficultyCalculatorTimingControlPoint()
-            {
-                BeatLengthBindable.MinValue = double.MinValue;
-                BeatLengthBindable.MaxValue = double.MaxValue;
-            }
-        }
     }
 }

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -3,15 +3,15 @@
 
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.IO;
-using osuTK;
-using osuTK.Graphics;
+using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps.Legacy;
 using osu.Game.IO;
 using osu.Game.Storyboards;
-using osu.Game.Beatmaps.Legacy;
-using osu.Framework.Utils;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -24,15 +24,15 @@ namespace osu.Game.Beatmaps.Formats
 
         private readonly Dictionary<string, string> variables = new Dictionary<string, string>();
 
-        public LegacyStoryboardDecoder()
-            : base(0)
+        public LegacyStoryboardDecoder(int version = LATEST_VERSION)
+            : base(version)
         {
         }
 
         public static void Register()
         {
             // note that this isn't completely correct
-            AddDecoder<Storyboard>(@"osu file format v", m => new LegacyStoryboardDecoder());
+            AddDecoder<Storyboard>(@"osu file format v", m => new LegacyStoryboardDecoder(Parsing.ParseInt(m.Split('v').Last())));
             AddDecoder<Storyboard>(@"[Events]", m => new LegacyStoryboardDecoder());
             SetFallbackDecoder<Storyboard>(() => new LegacyStoryboardDecoder());
         }
@@ -45,10 +45,12 @@ namespace osu.Game.Beatmaps.Formats
 
         protected override void ParseLine(Storyboard storyboard, Section section, string line)
         {
-            line = StripComments(line);
-
             switch (section)
             {
+                case Section.General:
+                    handleGeneral(storyboard, line);
+                    return;
+
                 case Section.Events:
                     handleEvents(line);
                     return;
@@ -61,6 +63,18 @@ namespace osu.Game.Beatmaps.Formats
             base.ParseLine(storyboard, section, line);
         }
 
+        private void handleGeneral(Storyboard storyboard, string line)
+        {
+            var pair = SplitKeyVal(line);
+
+            switch (pair.Key)
+            {
+                case "UseSkinSprites":
+                    storyboard.UseSkinSprites = pair.Value == "1";
+                    break;
+            }
+        }
+
         private void handleEvents(string line)
         {
             var depth = 0;
@@ -88,13 +102,22 @@ namespace osu.Game.Beatmaps.Formats
 
                 switch (type)
                 {
+                    case LegacyEventType.Video:
+                    {
+                        var offset = Parsing.ParseInt(split[1]);
+                        var path = CleanFilename(split[2]);
+
+                        storyboard.GetLayer("Video").Add(new StoryboardVideo(path, offset));
+                        break;
+                    }
+
                     case LegacyEventType.Sprite:
                     {
                         var layer = parseLayer(split[1]);
                         var origin = parseOrigin(split[2]);
                         var path = CleanFilename(split[3]);
-                        var x = float.Parse(split[4], NumberFormatInfo.InvariantInfo);
-                        var y = float.Parse(split[5], NumberFormatInfo.InvariantInfo);
+                        var x = Parsing.ParseFloat(split[4], Parsing.MAX_COORDINATE_VALUE);
+                        var y = Parsing.ParseFloat(split[5], Parsing.MAX_COORDINATE_VALUE);
                         storyboardSprite = new StoryboardSprite(path, origin, new Vector2(x, y));
                         storyboard.GetLayer(layer).Add(storyboardSprite);
                         break;
@@ -105,11 +128,16 @@ namespace osu.Game.Beatmaps.Formats
                         var layer = parseLayer(split[1]);
                         var origin = parseOrigin(split[2]);
                         var path = CleanFilename(split[3]);
-                        var x = float.Parse(split[4], NumberFormatInfo.InvariantInfo);
-                        var y = float.Parse(split[5], NumberFormatInfo.InvariantInfo);
-                        var frameCount = int.Parse(split[6]);
-                        var frameDelay = double.Parse(split[7], NumberFormatInfo.InvariantInfo);
-                        var loopType = split.Length > 8 ? (AnimationLoopType)Enum.Parse(typeof(AnimationLoopType), split[8]) : AnimationLoopType.LoopForever;
+                        var x = Parsing.ParseFloat(split[4], Parsing.MAX_COORDINATE_VALUE);
+                        var y = Parsing.ParseFloat(split[5], Parsing.MAX_COORDINATE_VALUE);
+                        var frameCount = Parsing.ParseInt(split[6]);
+                        var frameDelay = Parsing.ParseDouble(split[7]);
+
+                        if (FormatVersion < 6)
+                            // this is random as hell but taken straight from osu-stable.
+                            frameDelay = Math.Round(0.015 * frameDelay) * 1.186 * (1000 / 60f);
+
+                        var loopType = split.Length > 8 ? parseAnimationLoopType(split[8]) : AnimationLoopType.LoopForever;
                         storyboardSprite = new StoryboardAnimation(path, origin, new Vector2(x, y), frameCount, frameDelay, loopType);
                         storyboard.GetLayer(layer).Add(storyboardSprite);
                         break;
@@ -117,10 +145,10 @@ namespace osu.Game.Beatmaps.Formats
 
                     case LegacyEventType.Sample:
                     {
-                        var time = double.Parse(split[1], CultureInfo.InvariantCulture);
+                        var time = Parsing.ParseDouble(split[1]);
                         var layer = parseLayer(split[2]);
                         var path = CleanFilename(split[3]);
-                        var volume = split.Length > 4 ? float.Parse(split[4], CultureInfo.InvariantCulture) : 100;
+                        var volume = split.Length > 4 ? Parsing.ParseFloat(split[4]) : 100;
                         storyboard.GetLayer(layer).Add(new StoryboardSampleInfo(path, time, (int)volume));
                         break;
                     }
@@ -138,17 +166,17 @@ namespace osu.Game.Beatmaps.Formats
                     case "T":
                     {
                         var triggerName = split[1];
-                        var startTime = split.Length > 2 ? double.Parse(split[2], CultureInfo.InvariantCulture) : double.MinValue;
-                        var endTime = split.Length > 3 ? double.Parse(split[3], CultureInfo.InvariantCulture) : double.MaxValue;
-                        var groupNumber = split.Length > 4 ? int.Parse(split[4]) : 0;
+                        var startTime = split.Length > 2 ? Parsing.ParseDouble(split[2]) : double.MinValue;
+                        var endTime = split.Length > 3 ? Parsing.ParseDouble(split[3]) : double.MaxValue;
+                        var groupNumber = split.Length > 4 ? Parsing.ParseInt(split[4]) : 0;
                         timelineGroup = storyboardSprite?.AddTrigger(triggerName, startTime, endTime, groupNumber);
                         break;
                     }
 
                     case "L":
                     {
-                        var startTime = double.Parse(split[1], CultureInfo.InvariantCulture);
-                        var loopCount = int.Parse(split[2]);
+                        var startTime = Parsing.ParseDouble(split[1]);
+                        var loopCount = Parsing.ParseInt(split[2]);
                         timelineGroup = storyboardSprite?.AddLoop(startTime, loopCount);
                         break;
                     }
@@ -158,52 +186,52 @@ namespace osu.Game.Beatmaps.Formats
                         if (string.IsNullOrEmpty(split[3]))
                             split[3] = split[2];
 
-                        var easing = (Easing)int.Parse(split[1]);
-                        var startTime = double.Parse(split[2], CultureInfo.InvariantCulture);
-                        var endTime = double.Parse(split[3], CultureInfo.InvariantCulture);
+                        var easing = (Easing)Parsing.ParseInt(split[1]);
+                        var startTime = Parsing.ParseDouble(split[2]);
+                        var endTime = Parsing.ParseDouble(split[3]);
 
                         switch (commandType)
                         {
                             case "F":
                             {
-                                var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                var startValue = Parsing.ParseFloat(split[4]);
+                                var endValue = split.Length > 5 ? Parsing.ParseFloat(split[5]) : startValue;
                                 timelineGroup?.Alpha.Add(easing, startTime, endTime, startValue, endValue);
                                 break;
                             }
 
                             case "S":
                             {
-                                var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                var startValue = Parsing.ParseFloat(split[4]);
+                                var endValue = split.Length > 5 ? Parsing.ParseFloat(split[5]) : startValue;
                                 timelineGroup?.Scale.Add(easing, startTime, endTime, startValue, endValue);
                                 break;
                             }
 
                             case "V":
                             {
-                                var startX = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                var startY = float.Parse(split[5], CultureInfo.InvariantCulture);
-                                var endX = split.Length > 6 ? float.Parse(split[6], CultureInfo.InvariantCulture) : startX;
-                                var endY = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startY;
+                                var startX = Parsing.ParseFloat(split[4]);
+                                var startY = Parsing.ParseFloat(split[5]);
+                                var endX = split.Length > 6 ? Parsing.ParseFloat(split[6]) : startX;
+                                var endY = split.Length > 7 ? Parsing.ParseFloat(split[7]) : startY;
                                 timelineGroup?.VectorScale.Add(easing, startTime, endTime, new Vector2(startX, startY), new Vector2(endX, endY));
                                 break;
                             }
 
                             case "R":
                             {
-                                var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                var startValue = Parsing.ParseFloat(split[4]);
+                                var endValue = split.Length > 5 ? Parsing.ParseFloat(split[5]) : startValue;
                                 timelineGroup?.Rotation.Add(easing, startTime, endTime, MathUtils.RadiansToDegrees(startValue), MathUtils.RadiansToDegrees(endValue));
                                 break;
                             }
 
                             case "M":
                             {
-                                var startX = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                var startY = float.Parse(split[5], CultureInfo.InvariantCulture);
-                                var endX = split.Length > 6 ? float.Parse(split[6], CultureInfo.InvariantCulture) : startX;
-                                var endY = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startY;
+                                var startX = Parsing.ParseFloat(split[4]);
+                                var startY = Parsing.ParseFloat(split[5]);
+                                var endX = split.Length > 6 ? Parsing.ParseFloat(split[6]) : startX;
+                                var endY = split.Length > 7 ? Parsing.ParseFloat(split[7]) : startY;
                                 timelineGroup?.X.Add(easing, startTime, endTime, startX, endX);
                                 timelineGroup?.Y.Add(easing, startTime, endTime, startY, endY);
                                 break;
@@ -211,28 +239,28 @@ namespace osu.Game.Beatmaps.Formats
 
                             case "MX":
                             {
-                                var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                var startValue = Parsing.ParseFloat(split[4]);
+                                var endValue = split.Length > 5 ? Parsing.ParseFloat(split[5]) : startValue;
                                 timelineGroup?.X.Add(easing, startTime, endTime, startValue, endValue);
                                 break;
                             }
 
                             case "MY":
                             {
-                                var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                var startValue = Parsing.ParseFloat(split[4]);
+                                var endValue = split.Length > 5 ? Parsing.ParseFloat(split[5]) : startValue;
                                 timelineGroup?.Y.Add(easing, startTime, endTime, startValue, endValue);
                                 break;
                             }
 
                             case "C":
                             {
-                                var startRed = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                var startGreen = float.Parse(split[5], CultureInfo.InvariantCulture);
-                                var startBlue = float.Parse(split[6], CultureInfo.InvariantCulture);
-                                var endRed = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startRed;
-                                var endGreen = split.Length > 8 ? float.Parse(split[8], CultureInfo.InvariantCulture) : startGreen;
-                                var endBlue = split.Length > 9 ? float.Parse(split[9], CultureInfo.InvariantCulture) : startBlue;
+                                var startRed = Parsing.ParseFloat(split[4]);
+                                var startGreen = Parsing.ParseFloat(split[5]);
+                                var startBlue = Parsing.ParseFloat(split[6]);
+                                var endRed = split.Length > 7 ? Parsing.ParseFloat(split[7]) : startRed;
+                                var endGreen = split.Length > 8 ? Parsing.ParseFloat(split[8]) : startGreen;
+                                var endBlue = split.Length > 9 ? Parsing.ParseFloat(split[9]) : startBlue;
                                 timelineGroup?.Colour.Add(easing, startTime, endTime,
                                     new Color4(startRed / 255f, startGreen / 255f, startBlue / 255f, 1),
                                     new Color4(endRed / 255f, endGreen / 255f, endBlue / 255f, 1));
@@ -311,6 +339,12 @@ namespace osu.Game.Beatmaps.Formats
             }
         }
 
+        private AnimationLoopType parseAnimationLoopType(string value)
+        {
+            var parsed = (AnimationLoopType)Enum.Parse(typeof(AnimationLoopType), value);
+            return Enum.IsDefined(typeof(AnimationLoopType), parsed) ? parsed : AnimationLoopType.LoopForever;
+        }
+
         private void handleVariables(string line)
         {
             var pair = SplitKeyVal(line, '=');
@@ -323,7 +357,7 @@ namespace osu.Game.Beatmaps.Formats
         /// <param name="line">The line which may contains variables.</param>
         private void decodeVariables(ref string line)
         {
-            while (line.IndexOf('$') >= 0)
+            while (line.Contains('$'))
             {
                 string origLine = line;
 

osu.Game/Beatmaps/Formats/Parsing.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Beatmaps.Formats
     /// </summary>
     public static class Parsing
     {
-        public const int MAX_COORDINATE_VALUE = 65536;
+        public const int MAX_COORDINATE_VALUE = 131072;
 
         public const double MAX_PARSE_VALUE = int.MaxValue;
 

osu.Game/Beatmaps/IBeatmap.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// The control points in this beatmap.
         /// </summary>
-        ControlPointInfo ControlPointInfo { get; }
+        ControlPointInfo ControlPointInfo { get; set; }
 
         /// <summary>
         /// The breaks in this beatmap.
@@ -44,9 +44,13 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// Returns statistics for the <see cref="HitObjects"/> contained in this beatmap.
         /// </summary>
-        /// <returns></returns>
         IEnumerable<BeatmapStatistic> GetStatistics();
 
+        /// <summary>
+        /// Finds the most common beat length represented by the control points in this beatmap.
+        /// </summary>
+        double GetMostCommonBeatLength();
+
         /// <summary>
         /// Creates a shallow-clone of this beatmap and returns it.
         /// </summary>

osu.Game/Beatmaps/IBeatmapConverter.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
 
@@ -30,6 +31,8 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// Converts <see cref="Beatmap"/>.
         /// </summary>
-        IBeatmap Convert();
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The converted Beatmap.</returns>
+        IBeatmap Convert(CancellationToken cancellationToken = default);
     }
 }

osu.Game/Beatmaps/IBeatmapResourceProvider.cs

@@ -0,0 +1,22 @@
+// 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.Audio.Track;
+using osu.Framework.Graphics.Textures;
+using osu.Game.IO;
+
+namespace osu.Game.Beatmaps
+{
+    public interface IBeatmapResourceProvider : IStorageResourceProvider
+    {
+        /// <summary>
+        /// Retrieve a global large texture store, used for loading beatmap backgrounds.
+        /// </summary>
+        TextureStore LargeTextureStore { get; }
+
+        /// <summary>
+        /// Access a global track store for retrieving beatmap tracks from.
+        /// </summary>
+        ITrackStore Tracks { get; }
+    }
+}

osu.Game/Beatmaps/IWorkingBeatmap.cs

@@ -1,10 +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 System.Collections.Generic;
+using System.IO;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -26,16 +27,6 @@ namespace osu.Game.Beatmaps
         /// </summary>
         Texture Background { get; }
 
-        /// <summary>
-        /// Retrieves the video background file for this <see cref="WorkingBeatmap"/>.
-        /// </summary>
-        VideoSprite Video { get; }
-
-        /// <summary>
-        /// Retrieves the audio track for this <see cref="WorkingBeatmap"/>.
-        /// </summary>
-        Track Track { get; }
-
         /// <summary>
         /// Retrieves the <see cref="Waveform"/> for the <see cref="Track"/> of this <see cref="WorkingBeatmap"/>.
         /// </summary>
@@ -51,6 +42,11 @@ namespace osu.Game.Beatmaps
         /// </summary>
         ISkin Skin { get; }
 
+        /// <summary>
+        /// Retrieves the <see cref="Track"/> which this <see cref="WorkingBeatmap"/> has loaded.
+        /// </summary>
+        Track Track { get; }
+
         /// <summary>
         /// Constructs a playable <see cref="IBeatmap"/> from <see cref="Beatmap"/> using the applicable converters for a specific <see cref="RulesetInfo"/>.
         /// <para>
@@ -60,8 +56,28 @@ namespace osu.Game.Beatmaps
         /// </summary>
         /// <param name="ruleset">The <see cref="RulesetInfo"/> to create a playable <see cref="IBeatmap"/> for.</param>
         /// <param name="mods">The <see cref="Mod"/>s to apply to the <see cref="IBeatmap"/>.</param>
+        /// <param name="timeout">The maximum length in milliseconds to wait for load to complete. Defaults to 10,000ms.</param>
         /// <returns>The converted <see cref="IBeatmap"/>.</returns>
         /// <exception cref="BeatmapInvalidForRulesetException">If <see cref="Beatmap"/> could not be converted to <paramref name="ruleset"/>.</exception>
-        IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods = null);
+        IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods = null, TimeSpan? timeout = null);
+
+        /// <summary>
+        /// Load a new audio track instance for this beatmap. This should be called once before accessing <see cref="Track"/>.
+        /// The caller of this method is responsible for the lifetime of the track.
+        /// </summary>
+        /// <remarks>
+        /// In a standard game context, the loading of the track is managed solely by MusicController, which will
+        /// automatically load the track of the current global IBindable WorkingBeatmap.
+        /// As such, this method should only be called in very special scenarios, such as external tests or apps which are
+        /// outside of the game context.
+        /// </remarks>
+        /// <returns>A fresh track instance, which will also be available via <see cref="Track"/>.</returns>
+        Track LoadTrack();
+
+        /// <summary>
+        /// Returns the stream of the file from the given storage path.
+        /// </summary>
+        /// <param name="storagePath">The storage path to the file.</param>
+        Stream GetStream(string storagePath);
     }
 }

osu.Game/Beatmaps/Legacy/LegacyMods.cs

@@ -38,5 +38,6 @@ namespace osu.Game.Beatmaps.Legacy
         Key1 = 1 << 26,
         Key3 = 1 << 27,
         Key2 = 1 << 28,
+        Mirror = 1 << 30,
     }
 }

osu.Game/Beatmaps/Legacy/LegacyStoryLayer.cs

@@ -8,6 +8,8 @@ namespace osu.Game.Beatmaps.Legacy
         Background = 0,
         Fail = 1,
         Pass = 2,
-        Foreground = 3
+        Foreground = 3,
+        Overlay = 4,
+        Video = 5
     }
 }

osu.Game/Beatmaps/MetadataUtils.cs

@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System.Linq;
+using System.Text;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// Groups utility methods used to handle beatmap metadata.
+    /// </summary>
+    public static class MetadataUtils
+    {
+        /// <summary>
+        /// Returns <see langword="true"/> if the character <paramref name="c"/> can be used in <see cref="BeatmapMetadata.Artist"/> and <see cref="BeatmapMetadata.Title"/> fields.
+        /// Characters not matched by this method can be placed in <see cref="BeatmapMetadata.ArtistUnicode"/> and <see cref="BeatmapMetadata.TitleUnicode"/>.
+        /// </summary>
+        public static bool IsRomanised(char c) => c <= 0xFF;
+
+        /// <summary>
+        /// Returns <see langword="true"/> if the string <paramref name="str"/> can be used in <see cref="BeatmapMetadata.Artist"/> and <see cref="BeatmapMetadata.Title"/> fields.
+        /// Strings not matched by this method can be placed in <see cref="BeatmapMetadata.ArtistUnicode"/> and <see cref="BeatmapMetadata.TitleUnicode"/>.
+        /// </summary>
+        public static bool IsRomanised(string? str) => string.IsNullOrEmpty(str) || str.All(IsRomanised);
+
+        /// <summary>
+        /// Returns a copy of <paramref name="str"/> with all characters that do not match <see cref="IsRomanised(char)"/> removed.
+        /// </summary>
+        public static string StripNonRomanisedCharacters(string? str)
+        {
+            if (string.IsNullOrEmpty(str))
+                return string.Empty;
+
+            var stringBuilder = new StringBuilder(str.Length);
+
+            foreach (var c in str)
+            {
+                if (IsRomanised(c))
+                    stringBuilder.Append(c);
+            }
+
+            return stringBuilder.ToString().Trim();
+        }
+    }
+}

osu.Game/Beatmaps/StarDifficulty.cs

@@ -0,0 +1,53 @@
+// 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 JetBrains.Annotations;
+using osu.Game.Rulesets.Difficulty;
+
+namespace osu.Game.Beatmaps
+{
+    public readonly struct StarDifficulty
+    {
+        /// <summary>
+        /// The star difficulty rating for the given beatmap.
+        /// </summary>
+        public readonly double Stars;
+
+        /// <summary>
+        /// The maximum combo achievable on the given beatmap.
+        /// </summary>
+        public readonly int MaxCombo;
+
+        /// <summary>
+        /// The difficulty attributes computed for the given beatmap.
+        /// Might not be available if the star difficulty is associated with a beatmap that's not locally available.
+        /// </summary>
+        [CanBeNull]
+        public readonly DifficultyAttributes Attributes;
+
+        /// <summary>
+        /// Creates a <see cref="StarDifficulty"/> structure based on <see cref="DifficultyAttributes"/> computed
+        /// by a <see cref="DifficultyCalculator"/>.
+        /// </summary>
+        public StarDifficulty([NotNull] DifficultyAttributes attributes)
+        {
+            Stars = attributes.StarRating;
+            MaxCombo = attributes.MaxCombo;
+            Attributes = attributes;
+            // Todo: Add more members (BeatmapInfo.DifficultyRating? Attributes? Etc...)
+        }
+
+        /// <summary>
+        /// Creates a <see cref="StarDifficulty"/> structure with a pre-populated star difficulty and max combo
+        /// in scenarios where computing <see cref="DifficultyAttributes"/> is not feasible (i.e. when working with online sources).
+        /// </summary>
+        public StarDifficulty(double starDifficulty, int maxCombo)
+        {
+            Stars = starDifficulty;
+            MaxCombo = maxCombo;
+            Attributes = null;
+        }
+
+        public DifficultyRating DifficultyRating => BeatmapDifficultyCache.GetDifficultyRating(Stars);
+    }
+}

osu.Game/Beatmaps/Timing/BreakPeriod.cs

@@ -28,10 +28,21 @@ namespace osu.Game.Beatmaps.Timing
         public double Duration => EndTime - StartTime;
 
         /// <summary>
-        /// Whether the break has any effect. Breaks that are too short are culled before they are added to the beatmap.
+        /// Whether the break has any effect.
         /// </summary>
         public bool HasEffect => Duration >= MIN_BREAK_DURATION;
 
+        /// <summary>
+        /// Constructs a new break period.
+        /// </summary>
+        /// <param name="startTime">The start time of the break period.</param>
+        /// <param name="endTime">The end time of the break period.</param>
+        public BreakPeriod(double startTime, double endTime)
+        {
+            StartTime = startTime;
+            EndTime = endTime;
+        }
+
         /// <summary>
         /// Whether this break contains a specified time.
         /// </summary>

osu.Game/Beatmaps/Timing/TimeSignatures.cs

@@ -1,11 +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 System.ComponentModel;
+
 namespace osu.Game.Beatmaps.Timing
 {
     public enum TimeSignatures
     {
+        [Description("4/4")]
         SimpleQuadruple = 4,
+
+        [Description("3/4")]
         SimpleTriple = 3
     }
 }

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -1,26 +1,29 @@
 // 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.Audio.Track;
-using osu.Framework.Graphics.Textures;
-using osu.Game.Rulesets.Mods;
 using System;
 using System.Collections.Generic;
-using osu.Game.Storyboards;
+using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 using osu.Framework.Audio;
-using osu.Framework.Statistics;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Logging;
+using osu.Framework.Testing;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.UI;
 using osu.Game.Skinning;
-using osu.Framework.Graphics.Video;
-using osu.Framework.Logging;
+using osu.Game.Storyboards;
 
 namespace osu.Game.Beatmaps
 {
+    [ExcludeFromDynamicCompile]
     public abstract class WorkingBeatmap : IWorkingBeatmap
     {
         public readonly BeatmapInfo BeatmapInfo;
@@ -31,8 +34,6 @@ namespace osu.Game.Beatmaps
 
         protected AudioManager AudioManager { get; }
 
-        private static readonly GlobalStatistic<int> total_count = GlobalStatistics.Get<int>(nameof(Beatmaps), $"Total {nameof(WorkingBeatmap)}s");
-
         protected WorkingBeatmap(BeatmapInfo beatmapInfo, AudioManager audioManager)
         {
             AudioManager = audioManager;
@@ -40,20 +41,17 @@ namespace osu.Game.Beatmaps
             BeatmapSetInfo = beatmapInfo.BeatmapSet;
             Metadata = beatmapInfo.Metadata ?? BeatmapSetInfo?.Metadata ?? new BeatmapMetadata();
 
-            track = new RecyclableLazy<Track>(() => GetTrack() ?? GetVirtualTrack(1000));
             background = new RecyclableLazy<Texture>(GetBackground, BackgroundStillValid);
             waveform = new RecyclableLazy<Waveform>(GetWaveform);
             storyboard = new RecyclableLazy<Storyboard>(GetStoryboard);
             skin = new RecyclableLazy<ISkin>(GetSkin);
-
-            total_count.Value++;
         }
 
         protected virtual Track GetVirtualTrack(double emptyLength = 0)
         {
             const double excess_length = 1000;
 
-            var lastObject = Beatmap.HitObjects.LastOrDefault();
+            var lastObject = Beatmap?.HitObjects.LastOrDefault();
 
             double length;
 
@@ -63,7 +61,7 @@ namespace osu.Game.Beatmaps
                     length = emptyLength;
                     break;
 
-                case IHasEndTime endTime:
+                case IHasDuration endTime:
                     length = endTime.EndTime + excess_length;
                     break;
 
@@ -83,55 +81,100 @@ namespace osu.Game.Beatmaps
         /// <returns>The applicable <see cref="IBeatmapConverter"/>.</returns>
         protected virtual IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap, Ruleset ruleset) => ruleset.CreateBeatmapConverter(beatmap);
 
-        public IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods = null)
+        public IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods = null, TimeSpan? timeout = null)
         {
-            mods ??= Array.Empty<Mod>();
-
-            var rulesetInstance = ruleset.CreateInstance();
-
-            IBeatmapConverter converter = CreateBeatmapConverter(Beatmap, rulesetInstance);
-
-            // Check if the beatmap can be converted
-            if (Beatmap.HitObjects.Count > 0 && !converter.CanConvert())
-                throw new BeatmapInvalidForRulesetException($"{nameof(Beatmaps.Beatmap)} can not be converted for the ruleset (ruleset: {ruleset.InstantiationInfo}, converter: {converter}).");
-
-            // Apply conversion mods
-            foreach (var mod in mods.OfType<IApplicableToBeatmapConverter>())
-                mod.ApplyToBeatmapConverter(converter);
-
-            // Convert
-            IBeatmap converted = converter.Convert();
-
-            // Apply difficulty mods
-            if (mods.Any(m => m is IApplicableToDifficulty))
+            using (var cancellationSource = createCancellationTokenSource(timeout))
             {
-                converted.BeatmapInfo = converted.BeatmapInfo.Clone();
-                converted.BeatmapInfo.BaseDifficulty = converted.BeatmapInfo.BaseDifficulty.Clone();
+                mods ??= Array.Empty<Mod>();
 
-                foreach (var mod in mods.OfType<IApplicableToDifficulty>())
-                    mod.ApplyToDifficulty(converted.BeatmapInfo.BaseDifficulty);
+                var rulesetInstance = ruleset.CreateInstance();
+
+                IBeatmapConverter converter = CreateBeatmapConverter(Beatmap, rulesetInstance);
+
+                // Check if the beatmap can be converted
+                if (Beatmap.HitObjects.Count > 0 && !converter.CanConvert())
+                    throw new BeatmapInvalidForRulesetException($"{nameof(Beatmaps.Beatmap)} can not be converted for the ruleset (ruleset: {ruleset.InstantiationInfo}, converter: {converter}).");
+
+                // Apply conversion mods
+                foreach (var mod in mods.OfType<IApplicableToBeatmapConverter>())
+                {
+                    if (cancellationSource.IsCancellationRequested)
+                        throw new BeatmapLoadTimeoutException(BeatmapInfo);
+
+                    mod.ApplyToBeatmapConverter(converter);
+                }
+
+                // Convert
+                IBeatmap converted = converter.Convert(cancellationSource.Token);
+
+                // Apply conversion mods to the result
+                foreach (var mod in mods.OfType<IApplicableAfterBeatmapConversion>())
+                {
+                    if (cancellationSource.IsCancellationRequested)
+                        throw new BeatmapLoadTimeoutException(BeatmapInfo);
+
+                    mod.ApplyToBeatmap(converted);
+                }
+
+                // Apply difficulty mods
+                if (mods.Any(m => m is IApplicableToDifficulty))
+                {
+                    converted.BeatmapInfo = converted.BeatmapInfo.Clone();
+                    converted.BeatmapInfo.BaseDifficulty = converted.BeatmapInfo.BaseDifficulty.Clone();
+
+                    foreach (var mod in mods.OfType<IApplicableToDifficulty>())
+                    {
+                        if (cancellationSource.IsCancellationRequested)
+                            throw new BeatmapLoadTimeoutException(BeatmapInfo);
+
+                        mod.ApplyToDifficulty(converted.BeatmapInfo.BaseDifficulty);
+                    }
+                }
+
+                IBeatmapProcessor processor = rulesetInstance.CreateBeatmapProcessor(converted);
+
+                foreach (var mod in mods.OfType<IApplicableToBeatmapProcessor>())
+                    mod.ApplyToBeatmapProcessor(processor);
+
+                processor?.PreProcess();
+
+                // Compute default values for hitobjects, including creating nested hitobjects in-case they're needed
+                try
+                {
+                    foreach (var obj in converted.HitObjects)
+                    {
+                        if (cancellationSource.IsCancellationRequested)
+                            throw new BeatmapLoadTimeoutException(BeatmapInfo);
+
+                        obj.ApplyDefaults(converted.ControlPointInfo, converted.BeatmapInfo.BaseDifficulty, cancellationSource.Token);
+                    }
+                }
+                catch (OperationCanceledException)
+                {
+                    throw new BeatmapLoadTimeoutException(BeatmapInfo);
+                }
+
+                foreach (var mod in mods.OfType<IApplicableToHitObject>())
+                {
+                    foreach (var obj in converted.HitObjects)
+                    {
+                        if (cancellationSource.IsCancellationRequested)
+                            throw new BeatmapLoadTimeoutException(BeatmapInfo);
+
+                        mod.ApplyToHitObject(obj);
+                    }
+                }
+
+                processor?.PostProcess();
+
+                foreach (var mod in mods.OfType<IApplicableToBeatmap>())
+                {
+                    cancellationSource.Token.ThrowIfCancellationRequested();
+                    mod.ApplyToBeatmap(converted);
+                }
+
+                return converted;
             }
-
-            IBeatmapProcessor processor = rulesetInstance.CreateBeatmapProcessor(converted);
-
-            processor?.PreProcess();
-
-            // Compute default values for hitobjects, including creating nested hitobjects in-case they're needed
-            foreach (var obj in converted.HitObjects)
-                obj.ApplyDefaults(converted.ControlPointInfo, converted.BeatmapInfo.BaseDifficulty);
-
-            foreach (var mod in mods.OfType<IApplicableToHitObject>())
-            {
-                foreach (var obj in converted.HitObjects)
-                    mod.ApplyToHitObject(obj);
-            }
-
-            processor?.PostProcess();
-
-            foreach (var mod in mods.OfType<IApplicableToBeatmap>())
-                mod.ApplyToBeatmap(converted);
-
-            return converted;
         }
 
         private CancellationTokenSource loadCancellation = new CancellationTokenSource();
@@ -156,6 +199,15 @@ namespace osu.Game.Beatmaps
                 beatmapLoadTask = null;
         }
 
+        private CancellationTokenSource createCancellationTokenSource(TimeSpan? timeout)
+        {
+            if (Debugger.IsAttached)
+                // ignore timeout when debugger is attached (may be breakpointing / debugging).
+                return new CancellationTokenSource();
+
+            return new CancellationTokenSource(timeout ?? TimeSpan.FromSeconds(10));
+        }
+
         private Task<IBeatmap> loadBeatmapAsync() => beatmapLoadTask ??= Task.Factory.StartNew(() =>
         {
             // Todo: Handle cancellation during beatmap parsing
@@ -172,7 +224,7 @@ namespace osu.Game.Beatmaps
 
         public override string ToString() => BeatmapInfo.ToString();
 
-        public bool BeatmapLoaded => beatmapLoadTask?.IsCompleted ?? false;
+        public virtual bool BeatmapLoaded => beatmapLoadTask?.IsCompleted ?? false;
 
         public IBeatmap Beatmap
         {
@@ -208,14 +260,59 @@ namespace osu.Game.Beatmaps
         protected abstract Texture GetBackground();
         private readonly RecyclableLazy<Texture> background;
 
-        public VideoSprite Video => GetVideo();
+        private Track loadedTrack;
 
-        protected abstract VideoSprite GetVideo();
+        [NotNull]
+        public Track LoadTrack() => loadedTrack = GetBeatmapTrack() ?? GetVirtualTrack(1000);
 
-        public bool TrackLoaded => track.IsResultAvailable;
-        public Track Track => track.Value;
-        protected abstract Track GetTrack();
-        private RecyclableLazy<Track> track;
+        /// <summary>
+        /// Reads the correct track restart point from beatmap metadata and sets looping to enabled.
+        /// </summary>
+        public void PrepareTrackForPreviewLooping()
+        {
+            Track.Looping = true;
+            Track.RestartPoint = Metadata.PreviewTime;
+
+            if (Track.RestartPoint == -1)
+            {
+                if (!Track.IsLoaded)
+                {
+                    // force length to be populated (https://github.com/ppy/osu-framework/issues/4202)
+                    Track.Seek(Track.CurrentTime);
+                }
+
+                Track.RestartPoint = 0.4f * Track.Length;
+            }
+        }
+
+        /// <summary>
+        /// Transfer a valid audio track into this working beatmap. Used as an optimisation to avoid reload / track swap
+        /// across difficulties in the same beatmap set.
+        /// </summary>
+        /// <param name="track">The track to transfer.</param>
+        public void TransferTrack([NotNull] Track track) => loadedTrack = track ?? throw new ArgumentNullException(nameof(track));
+
+        /// <summary>
+        /// Whether this beatmap's track has been loaded via <see cref="LoadTrack"/>.
+        /// </summary>
+        public virtual bool TrackLoaded => loadedTrack != null;
+
+        /// <summary>
+        /// Get the loaded audio track instance. <see cref="LoadTrack"/> must have first been called.
+        /// This generally happens via MusicController when changing the global beatmap.
+        /// </summary>
+        public Track Track
+        {
+            get
+            {
+                if (!TrackLoaded)
+                    throw new InvalidOperationException($"Cannot access {nameof(Track)} without first calling {nameof(LoadTrack)}.");
+
+                return loadedTrack;
+            }
+        }
+
+        protected abstract Track GetBeatmapTrack();
 
         public bool WaveformLoaded => waveform.IsResultAvailable;
         public Waveform Waveform => waveform.Value;
@@ -230,29 +327,11 @@ namespace osu.Game.Beatmaps
         public bool SkinLoaded => skin.IsResultAvailable;
         public ISkin Skin => skin.Value;
 
-        protected virtual ISkin GetSkin() => new DefaultSkin();
+        protected abstract ISkin GetSkin();
+
         private readonly RecyclableLazy<ISkin> skin;
 
-        /// <summary>
-        /// Transfer pieces of a beatmap to a new one, where possible, to save on loading.
-        /// </summary>
-        /// <param name="other">The new beatmap which is being switched to.</param>
-        public virtual void TransferTo(WorkingBeatmap other)
-        {
-            if (track.IsResultAvailable && Track != null && BeatmapInfo.AudioEquals(other.BeatmapInfo))
-                other.track = track;
-        }
-
-        /// <summary>
-        /// Eagerly dispose of the audio track associated with this <see cref="WorkingBeatmap"/> (if any).
-        /// Accessing track again will load a fresh instance.
-        /// </summary>
-        public virtual void RecycleTrack() => track.Recycle();
-
-        ~WorkingBeatmap()
-        {
-            total_count.Value--;
-        }
+        public abstract Stream GetStream(string storagePath);
 
         public class RecyclableLazy<T>
         {
@@ -297,5 +376,13 @@ namespace osu.Game.Beatmaps
 
             private void recreate() => lazy = new Lazy<T>(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication);
         }
+
+        private class BeatmapLoadTimeoutException : TimeoutException
+        {
+            public BeatmapLoadTimeoutException(BeatmapInfo beatmapInfo)
+                : base($"Timed out while loading beatmap ({beatmapInfo}).")
+            {
+            }
+        }
     }
 }

osu.Game/Collections/BeatmapCollection.cs

@@ -0,0 +1,47 @@
+// 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.Framework.Bindables;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Collections
+{
+    /// <summary>
+    /// A collection of beatmaps grouped by a name.
+    /// </summary>
+    public class BeatmapCollection
+    {
+        /// <summary>
+        /// Invoked whenever any change occurs on this <see cref="BeatmapCollection"/>.
+        /// </summary>
+        public event Action Changed;
+
+        /// <summary>
+        /// The collection's name.
+        /// </summary>
+        public readonly Bindable<string> Name = new Bindable<string>();
+
+        /// <summary>
+        /// The beatmaps contained by the collection.
+        /// </summary>
+        public readonly BindableList<BeatmapInfo> Beatmaps = new BindableList<BeatmapInfo>();
+
+        /// <summary>
+        /// The date when this collection was last modified.
+        /// </summary>
+        public DateTimeOffset LastModifyDate { get; private set; } = DateTimeOffset.UtcNow;
+
+        public BeatmapCollection()
+        {
+            Beatmaps.CollectionChanged += (_, __) => onChange();
+            Name.ValueChanged += _ => onChange();
+        }
+
+        private void onChange()
+        {
+            LastModifyDate = DateTimeOffset.Now;
+            Changed?.Invoke();
+        }
+    }
+}

osu.Game/Collections/CollectionFilterDropdown.cs

@@ -0,0 +1,295 @@
+// 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.Specialized;
+using System.Diagnostics;
+using System.Linq;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osuTK;
+
+namespace osu.Game.Collections
+{
+    /// <summary>
+    /// A dropdown to select the <see cref="CollectionFilterMenuItem"/> to filter beatmaps using.
+    /// </summary>
+    public class CollectionFilterDropdown : OsuDropdown<CollectionFilterMenuItem>
+    {
+        /// <summary>
+        /// Whether to show the "manage collections..." menu item in the dropdown.
+        /// </summary>
+        protected virtual bool ShowManageCollectionsItem => true;
+
+        private readonly BindableWithCurrent<CollectionFilterMenuItem> current = new BindableWithCurrent<CollectionFilterMenuItem>();
+
+        public new Bindable<CollectionFilterMenuItem> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
+        private readonly IBindableList<BeatmapCollection> collections = new BindableList<BeatmapCollection>();
+        private readonly IBindableList<BeatmapInfo> beatmaps = new BindableList<BeatmapInfo>();
+        private readonly BindableList<CollectionFilterMenuItem> filters = new BindableList<CollectionFilterMenuItem>();
+
+        [Resolved(CanBeNull = true)]
+        private ManageCollectionsDialog manageCollectionsDialog { get; set; }
+
+        [Resolved(CanBeNull = true)]
+        private CollectionManager collectionManager { get; set; }
+
+        public CollectionFilterDropdown()
+        {
+            ItemSource = filters;
+            Current.Value = new AllBeatmapsCollectionFilterMenuItem();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            if (collectionManager != null)
+                collections.BindTo(collectionManager.Collections);
+
+            // Dropdown has logic which triggers a change on the bindable with every change to the contained items.
+            // This is not desirable here, as it leads to multiple filter operations running even though nothing has changed.
+            // An extra bindable is enough to subvert this behaviour.
+            base.Current = Current;
+
+            collections.BindCollectionChanged((_, __) => collectionsChanged(), true);
+            Current.BindValueChanged(filterChanged, true);
+        }
+
+        /// <summary>
+        /// Occurs when a collection has been added or removed.
+        /// </summary>
+        private void collectionsChanged()
+        {
+            var selectedItem = SelectedItem?.Value?.Collection;
+
+            filters.Clear();
+            filters.Add(new AllBeatmapsCollectionFilterMenuItem());
+            filters.AddRange(collections.Select(c => new CollectionFilterMenuItem(c)));
+
+            if (ShowManageCollectionsItem)
+                filters.Add(new ManageCollectionsFilterMenuItem());
+
+            Current.Value = filters.SingleOrDefault(f => f.Collection != null && f.Collection == selectedItem) ?? filters[0];
+        }
+
+        /// <summary>
+        /// Occurs when the <see cref="CollectionFilterMenuItem"/> selection has changed.
+        /// </summary>
+        private void filterChanged(ValueChangedEvent<CollectionFilterMenuItem> filter)
+        {
+            // Binding the beatmaps will trigger a collection change event, which results in an infinite-loop. This is rebound later, when it's safe to do so.
+            beatmaps.CollectionChanged -= filterBeatmapsChanged;
+
+            if (filter.OldValue?.Collection != null)
+                beatmaps.UnbindFrom(filter.OldValue.Collection.Beatmaps);
+
+            if (filter.NewValue?.Collection != null)
+                beatmaps.BindTo(filter.NewValue.Collection.Beatmaps);
+
+            beatmaps.CollectionChanged += filterBeatmapsChanged;
+
+            // Never select the manage collection filter - rollback to the previous filter.
+            // This is done after the above since it is important that bindable is unbound from OldValue, which is lost after forcing it back to the old value.
+            if (filter.NewValue is ManageCollectionsFilterMenuItem)
+            {
+                Current.Value = filter.OldValue;
+                manageCollectionsDialog?.Show();
+            }
+        }
+
+        /// <summary>
+        /// Occurs when the beatmaps contained by a <see cref="BeatmapCollection"/> have changed.
+        /// </summary>
+        private void filterBeatmapsChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            // The filtered beatmaps have changed, without the filter having changed itself. So a change in filter must be notified.
+            // Note that this does NOT propagate to bound bindables, so the FilterControl must bind directly to the value change event of this bindable.
+            Current.TriggerChange();
+        }
+
+        protected override LocalisableString GenerateItemText(CollectionFilterMenuItem item) => item.CollectionName.Value;
+
+        protected sealed override DropdownHeader CreateHeader() => CreateCollectionHeader().With(d =>
+        {
+            d.SelectedItem.BindTarget = Current;
+        });
+
+        protected sealed override DropdownMenu CreateMenu() => CreateCollectionMenu();
+
+        protected virtual CollectionDropdownHeader CreateCollectionHeader() => new CollectionDropdownHeader();
+
+        protected virtual CollectionDropdownMenu CreateCollectionMenu() => new CollectionDropdownMenu();
+
+        public class CollectionDropdownHeader : OsuDropdownHeader
+        {
+            public readonly Bindable<CollectionFilterMenuItem> SelectedItem = new Bindable<CollectionFilterMenuItem>();
+            private readonly Bindable<string> collectionName = new Bindable<string>();
+
+            protected override LocalisableString Label
+            {
+                get => base.Label;
+                set { } // See updateText().
+            }
+
+            public CollectionDropdownHeader()
+            {
+                Height = 25;
+                Icon.Size = new Vector2(16);
+                Foreground.Padding = new MarginPadding { Top = 4, Bottom = 4, Left = 8, Right = 4 };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                SelectedItem.BindValueChanged(_ => updateBindable(), true);
+            }
+
+            private void updateBindable()
+            {
+                collectionName.UnbindAll();
+
+                if (SelectedItem.Value != null)
+                    collectionName.BindTo(SelectedItem.Value.CollectionName);
+
+                collectionName.BindValueChanged(_ => updateText(), true);
+            }
+
+            // Dropdowns don't bind to value changes, so the real name is copied directly from the selected item here.
+            private void updateText() => base.Label = collectionName.Value;
+        }
+
+        protected class CollectionDropdownMenu : OsuDropdownMenu
+        {
+            public CollectionDropdownMenu()
+            {
+                MaxHeight = 200;
+            }
+
+            protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new CollectionDropdownMenuItem(item);
+        }
+
+        protected class CollectionDropdownMenuItem : OsuDropdownMenu.DrawableOsuDropdownMenuItem
+        {
+            [NotNull]
+            protected new CollectionFilterMenuItem Item => ((DropdownMenuItem<CollectionFilterMenuItem>)base.Item).Value;
+
+            [Resolved]
+            private OsuColour colours { get; set; }
+
+            [Resolved]
+            private IBindable<WorkingBeatmap> beatmap { get; set; }
+
+            [CanBeNull]
+            private readonly BindableList<BeatmapInfo> collectionBeatmaps;
+
+            [NotNull]
+            private readonly Bindable<string> collectionName;
+
+            private IconButton addOrRemoveButton;
+            private Content content;
+            private bool beatmapInCollection;
+
+            public CollectionDropdownMenuItem(MenuItem item)
+                : base(item)
+            {
+                collectionBeatmaps = Item.Collection?.Beatmaps.GetBoundCopy();
+                collectionName = Item.CollectionName.GetBoundCopy();
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AddInternal(addOrRemoveButton = new IconButton
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    X = -OsuScrollContainer.SCROLL_BAR_HEIGHT,
+                    Scale = new Vector2(0.65f),
+                    Action = addOrRemove,
+                });
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                if (collectionBeatmaps != null)
+                {
+                    collectionBeatmaps.CollectionChanged += (_, __) => collectionChanged();
+                    beatmap.BindValueChanged(_ => collectionChanged(), true);
+                }
+
+                // Although the DrawableMenuItem binds to value changes of the item's text, the item is an internal implementation detail of Dropdown that has no knowledge
+                // of the underlying CollectionFilter value and its accompanying name, so the real name has to be copied here. Without this, the collection name wouldn't update when changed.
+                collectionName.BindValueChanged(name => content.Text = name.NewValue, true);
+
+                updateButtonVisibility();
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateButtonVisibility();
+                return base.OnHover(e);
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                updateButtonVisibility();
+                base.OnHoverLost(e);
+            }
+
+            private void collectionChanged()
+            {
+                Debug.Assert(collectionBeatmaps != null);
+
+                beatmapInCollection = collectionBeatmaps.Contains(beatmap.Value.BeatmapInfo);
+
+                addOrRemoveButton.Enabled.Value = !beatmap.IsDefault;
+                addOrRemoveButton.Icon = beatmapInCollection ? FontAwesome.Solid.MinusSquare : FontAwesome.Solid.PlusSquare;
+                addOrRemoveButton.TooltipText = beatmapInCollection ? "Remove selected beatmap" : "Add selected beatmap";
+
+                updateButtonVisibility();
+            }
+
+            protected override void OnSelectChange()
+            {
+                base.OnSelectChange();
+                updateButtonVisibility();
+            }
+
+            private void updateButtonVisibility()
+            {
+                if (collectionBeatmaps == null)
+                    addOrRemoveButton.Alpha = 0;
+                else
+                    addOrRemoveButton.Alpha = IsHovered || IsPreSelected || beatmapInCollection ? 1 : 0;
+            }
+
+            private void addOrRemove()
+            {
+                Debug.Assert(collectionBeatmaps != null);
+
+                if (!collectionBeatmaps.Remove(beatmap.Value.BeatmapInfo))
+                    collectionBeatmaps.Add(beatmap.Value.BeatmapInfo);
+            }
+
+            protected override Drawable CreateContent() => content = (Content)base.CreateContent();
+        }
+    }
+}

osu.Game/Collections/CollectionFilterMenuItem.cs

@@ -0,0 +1,72 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Bindables;
+
+namespace osu.Game.Collections
+{
+    /// <summary>
+    /// A <see cref="BeatmapCollection"/> filter.
+    /// </summary>
+    public class CollectionFilterMenuItem : IEquatable<CollectionFilterMenuItem>
+    {
+        /// <summary>
+        /// The collection to filter beatmaps from.
+        /// May be null to not filter by collection (include all beatmaps).
+        /// </summary>
+        [CanBeNull]
+        public readonly BeatmapCollection Collection;
+
+        /// <summary>
+        /// The name of the collection.
+        /// </summary>
+        [NotNull]
+        public readonly Bindable<string> CollectionName;
+
+        /// <summary>
+        /// Creates a new <see cref="CollectionFilterMenuItem"/>.
+        /// </summary>
+        /// <param name="collection">The collection to filter beatmaps from.</param>
+        public CollectionFilterMenuItem([CanBeNull] BeatmapCollection collection)
+        {
+            Collection = collection;
+            CollectionName = Collection?.Name.GetBoundCopy() ?? new Bindable<string>("All beatmaps");
+        }
+
+        public bool Equals(CollectionFilterMenuItem other)
+        {
+            if (other == null)
+                return false;
+
+            // collections may have the same name, so compare first on reference equality.
+            // this relies on the assumption that only one instance of the BeatmapCollection exists game-wide, managed by CollectionManager.
+            if (Collection != null)
+                return Collection == other.Collection;
+
+            // fallback to name-based comparison.
+            // this is required for special dropdown items which don't have a collection (all beatmaps / manage collections items below).
+            return CollectionName.Value == other.CollectionName.Value;
+        }
+
+        public override int GetHashCode() => CollectionName.Value.GetHashCode();
+    }
+
+    public class AllBeatmapsCollectionFilterMenuItem : CollectionFilterMenuItem
+    {
+        public AllBeatmapsCollectionFilterMenuItem()
+            : base(null)
+        {
+        }
+    }
+
+    public class ManageCollectionsFilterMenuItem : CollectionFilterMenuItem
+    {
+        public ManageCollectionsFilterMenuItem()
+            : base(null)
+        {
+            CollectionName.Value = "Manage collections...";
+        }
+    }
+}

osu.Game/Collections/CollectionManager.cs

@@ -0,0 +1,340 @@
+// 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.Collections.Specialized;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Game.Beatmaps;
+using osu.Game.IO;
+using osu.Game.IO.Legacy;
+using osu.Game.Overlays.Notifications;
+
+namespace osu.Game.Collections
+{
+    /// <summary>
+    /// Handles user-defined collections of beatmaps.
+    /// </summary>
+    /// <remarks>
+    /// This is currently reading and writing from the osu-stable file format. This is a temporary arrangement until we refactor the
+    /// database backing the game. Going forward writing should be done in a similar way to other model stores.
+    /// </remarks>
+    public class CollectionManager : Component
+    {
+        /// <summary>
+        /// Database version in stable-compatible YYYYMMDD format.
+        /// </summary>
+        private const int database_version = 30000000;
+
+        private const string database_name = "collection.db";
+        private const string database_backup_name = "collection.db.bak";
+
+        public readonly BindableList<BeatmapCollection> Collections = new BindableList<BeatmapCollection>();
+
+        [Resolved]
+        private GameHost host { get; set; }
+
+        [Resolved]
+        private BeatmapManager beatmaps { get; set; }
+
+        private readonly Storage storage;
+
+        public CollectionManager(Storage storage)
+        {
+            this.storage = storage;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Collections.CollectionChanged += collectionsChanged;
+
+            if (storage.Exists(database_backup_name))
+            {
+                // If a backup file exists, it means the previous write operation didn't run to completion.
+                // Always prefer the backup file in such a case as it's the most recent copy that is guaranteed to not be malformed.
+                //
+                // The database is saved 100ms after any change, and again when the game is closed, so there shouldn't be a large diff between the two files in the worst case.
+                if (storage.Exists(database_name))
+                    storage.Delete(database_name);
+                File.Copy(storage.GetFullPath(database_backup_name), storage.GetFullPath(database_name));
+            }
+
+            if (storage.Exists(database_name))
+            {
+                List<BeatmapCollection> beatmapCollections;
+
+                using (var stream = storage.GetStream(database_name))
+                    beatmapCollections = readCollections(stream);
+
+                // intentionally fire-and-forget async.
+                importCollections(beatmapCollections);
+            }
+        }
+
+        private void collectionsChanged(object sender, NotifyCollectionChangedEventArgs e) => Schedule(() =>
+        {
+            switch (e.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                    foreach (var c in e.NewItems.Cast<BeatmapCollection>())
+                        c.Changed += backgroundSave;
+                    break;
+
+                case NotifyCollectionChangedAction.Remove:
+                    foreach (var c in e.OldItems.Cast<BeatmapCollection>())
+                        c.Changed -= backgroundSave;
+                    break;
+
+                case NotifyCollectionChangedAction.Replace:
+                    foreach (var c in e.OldItems.Cast<BeatmapCollection>())
+                        c.Changed -= backgroundSave;
+
+                    foreach (var c in e.NewItems.Cast<BeatmapCollection>())
+                        c.Changed += backgroundSave;
+                    break;
+            }
+
+            backgroundSave();
+        });
+
+        /// <summary>
+        /// Set an endpoint for notifications to be posted to.
+        /// </summary>
+        public Action<Notification> PostNotification { protected get; set; }
+
+        /// <summary>
+        /// This is a temporary method and will likely be replaced by a full-fledged (and more correctly placed) migration process in the future.
+        /// </summary>
+        public Task ImportFromStableAsync(StableStorage stableStorage)
+        {
+            if (!stableStorage.Exists(database_name))
+            {
+                // This handles situations like when the user does not have a collections.db file
+                Logger.Log($"No {database_name} available in osu!stable installation", LoggingTarget.Information, LogLevel.Error);
+                return Task.CompletedTask;
+            }
+
+            return Task.Run(async () =>
+            {
+                using (var stream = stableStorage.GetStream(database_name))
+                    await Import(stream).ConfigureAwait(false);
+            });
+        }
+
+        public async Task Import(Stream stream)
+        {
+            var notification = new ProgressNotification
+            {
+                State = ProgressNotificationState.Active,
+                Text = "Collections import is initialising..."
+            };
+
+            PostNotification?.Invoke(notification);
+
+            var collections = readCollections(stream, notification);
+            await importCollections(collections).ConfigureAwait(false);
+
+            notification.CompletionText = $"Imported {collections.Count} collections";
+            notification.State = ProgressNotificationState.Completed;
+        }
+
+        private Task importCollections(List<BeatmapCollection> newCollections)
+        {
+            var tcs = new TaskCompletionSource<bool>();
+
+            Schedule(() =>
+            {
+                try
+                {
+                    foreach (var newCol in newCollections)
+                    {
+                        var existing = Collections.FirstOrDefault(c => c.Name.Value == newCol.Name.Value);
+                        if (existing == null)
+                            Collections.Add(existing = new BeatmapCollection { Name = { Value = newCol.Name.Value } });
+
+                        foreach (var newBeatmap in newCol.Beatmaps)
+                        {
+                            if (!existing.Beatmaps.Contains(newBeatmap))
+                                existing.Beatmaps.Add(newBeatmap);
+                        }
+                    }
+
+                    tcs.SetResult(true);
+                }
+                catch (Exception e)
+                {
+                    Logger.Error(e, "Failed to import collection.");
+                    tcs.SetException(e);
+                }
+            });
+
+            return tcs.Task;
+        }
+
+        private List<BeatmapCollection> readCollections(Stream stream, ProgressNotification notification = null)
+        {
+            if (notification != null)
+            {
+                notification.Text = "Reading collections...";
+                notification.Progress = 0;
+            }
+
+            var result = new List<BeatmapCollection>();
+
+            try
+            {
+                using (var sr = new SerializationReader(stream))
+                {
+                    sr.ReadInt32(); // Version
+
+                    int collectionCount = sr.ReadInt32();
+                    result.Capacity = collectionCount;
+
+                    for (int i = 0; i < collectionCount; i++)
+                    {
+                        if (notification?.CancellationToken.IsCancellationRequested == true)
+                            return result;
+
+                        var collection = new BeatmapCollection { Name = { Value = sr.ReadString() } };
+                        int mapCount = sr.ReadInt32();
+
+                        for (int j = 0; j < mapCount; j++)
+                        {
+                            if (notification?.CancellationToken.IsCancellationRequested == true)
+                                return result;
+
+                            string checksum = sr.ReadString();
+
+                            var beatmap = beatmaps.QueryBeatmap(b => b.MD5Hash == checksum);
+                            if (beatmap != null)
+                                collection.Beatmaps.Add(beatmap);
+                        }
+
+                        if (notification != null)
+                        {
+                            notification.Text = $"Imported {i + 1} of {collectionCount} collections";
+                            notification.Progress = (float)(i + 1) / collectionCount;
+                        }
+
+                        result.Add(collection);
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                Logger.Error(e, "Failed to read collection database.");
+            }
+
+            return result;
+        }
+
+        public void DeleteAll()
+        {
+            Collections.Clear();
+            PostNotification?.Invoke(new ProgressCompletionNotification { Text = "Deleted all collections!" });
+        }
+
+        private readonly object saveLock = new object();
+        private int lastSave;
+        private int saveFailures;
+
+        /// <summary>
+        /// Perform a save with debounce.
+        /// </summary>
+        private void backgroundSave()
+        {
+            var current = Interlocked.Increment(ref lastSave);
+            Task.Delay(100).ContinueWith(task =>
+            {
+                if (current != lastSave)
+                    return;
+
+                if (!save())
+                    backgroundSave();
+            });
+        }
+
+        private bool save()
+        {
+            lock (saveLock)
+            {
+                Interlocked.Increment(ref lastSave);
+
+                // This is NOT thread-safe!!
+                try
+                {
+                    var tempPath = Path.GetTempFileName();
+
+                    using (var ms = new MemoryStream())
+                    {
+                        using (var sw = new SerializationWriter(ms, true))
+                        {
+                            sw.Write(database_version);
+
+                            var collectionsCopy = Collections.ToArray();
+                            sw.Write(collectionsCopy.Length);
+
+                            foreach (var c in collectionsCopy)
+                            {
+                                sw.Write(c.Name.Value);
+
+                                var beatmapsCopy = c.Beatmaps.ToArray();
+                                sw.Write(beatmapsCopy.Length);
+
+                                foreach (var b in beatmapsCopy)
+                                    sw.Write(b.MD5Hash);
+                            }
+                        }
+
+                        using (var fs = File.OpenWrite(tempPath))
+                            ms.WriteTo(fs);
+
+                        var databasePath = storage.GetFullPath(database_name);
+                        var databaseBackupPath = storage.GetFullPath(database_backup_name);
+
+                        // Back up the existing database, clearing any existing backup.
+                        if (File.Exists(databaseBackupPath))
+                            File.Delete(databaseBackupPath);
+                        if (File.Exists(databasePath))
+                            File.Move(databasePath, databaseBackupPath);
+
+                        // Move the new database in-place of the existing one.
+                        File.Move(tempPath, databasePath);
+
+                        // If everything succeeded up to this point, remove the backup file.
+                        if (File.Exists(databaseBackupPath))
+                            File.Delete(databaseBackupPath);
+                    }
+
+                    if (saveFailures < 10)
+                        saveFailures = 0;
+                    return true;
+                }
+                catch (Exception e)
+                {
+                    // Since this code is not thread-safe, we may run into random exceptions (such as collection enumeration or out of range indexing).
+                    // Failures are thus only alerted if they exceed a threshold (once) to indicate "actual" errors having occurred.
+                    if (++saveFailures == 10)
+                        Logger.Error(e, "Failed to save collection database!");
+                }
+
+                return false;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            save();
+        }
+    }
+}

osu.Game/Collections/DeleteCollectionDialog.cs

@@ -0,0 +1,34 @@
+// 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 Humanizer;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Collections
+{
+    public class DeleteCollectionDialog : PopupDialog
+    {
+        public DeleteCollectionDialog(BeatmapCollection collection, Action deleteAction)
+        {
+            HeaderText = "Confirm deletion of";
+            BodyText = $"{collection.Name.Value} ({"beatmap".ToQuantity(collection.Beatmaps.Count)})";
+
+            Icon = FontAwesome.Regular.TrashAlt;
+
+            Buttons = new PopupDialogButton[]
+            {
+                new PopupDialogOkButton
+                {
+                    Text = @"Yes. Go for it.",
+                    Action = deleteAction
+                },
+                new PopupDialogCancelButton
+                {
+                    Text = @"No! Abort mission!",
+                },
+            };
+        }
+    }
+}

osu.Game/Collections/DrawableCollectionList.cs

@@ -0,0 +1,122 @@
+// 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 osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.Containers;
+using osuTK;
+
+namespace osu.Game.Collections
+{
+    /// <summary>
+    /// Visualises a list of <see cref="BeatmapCollection"/>s.
+    /// </summary>
+    public class DrawableCollectionList : OsuRearrangeableListContainer<BeatmapCollection>
+    {
+        private Scroll scroll;
+
+        protected override ScrollContainer<Drawable> CreateScrollContainer() => scroll = new Scroll();
+
+        protected override FillFlowContainer<RearrangeableListItem<BeatmapCollection>> CreateListFillFlowContainer() => new Flow
+        {
+            DragActive = { BindTarget = DragActive }
+        };
+
+        protected override OsuRearrangeableListItem<BeatmapCollection> CreateOsuDrawable(BeatmapCollection item)
+        {
+            if (item == scroll.PlaceholderItem.Model)
+                return scroll.ReplacePlaceholder();
+
+            return new DrawableCollectionListItem(item, true);
+        }
+
+        /// <summary>
+        /// The scroll container for this <see cref="DrawableCollectionList"/>.
+        /// Contains the main flow of <see cref="DrawableCollectionListItem"/> and attaches a placeholder item to the end of the list.
+        /// </summary>
+        /// <remarks>
+        /// Use <see cref="ReplacePlaceholder"/> to transfer the placeholder into the main list.
+        /// </remarks>
+        private class Scroll : OsuScrollContainer
+        {
+            /// <summary>
+            /// The currently-displayed placeholder item.
+            /// </summary>
+            public DrawableCollectionListItem PlaceholderItem { get; private set; }
+
+            protected override Container<Drawable> Content => content;
+            private readonly Container content;
+
+            private readonly Container<DrawableCollectionListItem> placeholderContainer;
+
+            public Scroll()
+            {
+                ScrollbarVisible = false;
+                Padding = new MarginPadding(10);
+
+                base.Content.Add(new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    LayoutDuration = 200,
+                    LayoutEasing = Easing.OutQuint,
+                    Children = new Drawable[]
+                    {
+                        content = new Container { RelativeSizeAxes = Axes.X },
+                        placeholderContainer = new Container<DrawableCollectionListItem>
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y
+                        }
+                    }
+                });
+
+                ReplacePlaceholder();
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                // AutoSizeAxes cannot be used as the height should represent the post-layout-transform height at all times, so that the placeholder doesn't bounce around.
+                content.Height = ((Flow)Child).Children.Sum(c => c.DrawHeight + 5);
+            }
+
+            /// <summary>
+            /// Replaces the current <see cref="PlaceholderItem"/> with a new one, and returns the previous.
+            /// </summary>
+            /// <returns>The current <see cref="PlaceholderItem"/>.</returns>
+            public DrawableCollectionListItem ReplacePlaceholder()
+            {
+                var previous = PlaceholderItem;
+
+                placeholderContainer.Clear(false);
+                placeholderContainer.Add(PlaceholderItem = new DrawableCollectionListItem(new BeatmapCollection(), false));
+
+                return previous;
+            }
+        }
+
+        /// <summary>
+        /// The flow of <see cref="DrawableCollectionListItem"/>. Disables layout easing unless a drag is in progress.
+        /// </summary>
+        private class Flow : FillFlowContainer<RearrangeableListItem<BeatmapCollection>>
+        {
+            public readonly IBindable<bool> DragActive = new Bindable<bool>();
+
+            public Flow()
+            {
+                Spacing = new Vector2(0, 5);
+                LayoutEasing = Easing.OutQuint;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                DragActive.BindValueChanged(active => LayoutDuration = active.NewValue ? 200 : 0);
+            }
+        }
+    }
+}

osu.Game/Collections/DrawableCollectionListItem.cs

@@ -0,0 +1,237 @@
+// 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.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Collections
+{
+    /// <summary>
+    /// Visualises a <see cref="BeatmapCollection"/> inside a <see cref="DrawableCollectionList"/>.
+    /// </summary>
+    public class DrawableCollectionListItem : OsuRearrangeableListItem<BeatmapCollection>
+    {
+        private const float item_height = 35;
+        private const float button_width = item_height * 0.75f;
+
+        /// <summary>
+        /// Whether the <see cref="BeatmapCollection"/> currently exists inside the <see cref="CollectionManager"/>.
+        /// </summary>
+        public IBindable<bool> IsCreated => isCreated;
+
+        private readonly Bindable<bool> isCreated = new Bindable<bool>();
+
+        /// <summary>
+        /// Creates a new <see cref="DrawableCollectionListItem"/>.
+        /// </summary>
+        /// <param name="item">The <see cref="BeatmapCollection"/>.</param>
+        /// <param name="isCreated">Whether <paramref name="item"/> currently exists inside the <see cref="CollectionManager"/>.</param>
+        public DrawableCollectionListItem(BeatmapCollection item, bool isCreated)
+            : base(item)
+        {
+            this.isCreated.Value = isCreated;
+
+            ShowDragHandle.BindTo(this.isCreated);
+        }
+
+        protected override Drawable CreateContent() => new ItemContent(Model)
+        {
+            IsCreated = { BindTarget = isCreated }
+        };
+
+        /// <summary>
+        /// The main content of the <see cref="DrawableCollectionListItem"/>.
+        /// </summary>
+        private class ItemContent : CircularContainer
+        {
+            public readonly Bindable<bool> IsCreated = new Bindable<bool>();
+
+            private readonly IBindable<string> collectionName;
+            private readonly BeatmapCollection collection;
+
+            [Resolved(CanBeNull = true)]
+            private CollectionManager collectionManager { get; set; }
+
+            private Container textBoxPaddingContainer;
+            private ItemTextBox textBox;
+
+            public ItemContent(BeatmapCollection collection)
+            {
+                this.collection = collection;
+
+                RelativeSizeAxes = Axes.X;
+                Height = item_height;
+                Masking = true;
+
+                collectionName = collection.Name.GetBoundCopy();
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                Children = new Drawable[]
+                {
+                    new DeleteButton(collection)
+                    {
+                        Anchor = Anchor.CentreRight,
+                        Origin = Anchor.CentreRight,
+                        IsCreated = { BindTarget = IsCreated },
+                        IsTextBoxHovered = v => textBox.ReceivePositionalInputAt(v)
+                    },
+                    textBoxPaddingContainer = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Right = button_width },
+                        Children = new Drawable[]
+                        {
+                            textBox = new ItemTextBox
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Size = Vector2.One,
+                                CornerRadius = item_height / 2,
+                                Current = collection.Name,
+                                PlaceholderText = IsCreated.Value ? string.Empty : "Create a new collection"
+                            },
+                        }
+                    },
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                collectionName.BindValueChanged(_ => createNewCollection(), true);
+                IsCreated.BindValueChanged(created => textBoxPaddingContainer.Padding = new MarginPadding { Right = created.NewValue ? button_width : 0 }, true);
+            }
+
+            private void createNewCollection()
+            {
+                if (IsCreated.Value)
+                    return;
+
+                if (string.IsNullOrEmpty(collectionName.Value))
+                    return;
+
+                // Add the new collection and disable our placeholder. If all text is removed, the placeholder should not show back again.
+                collectionManager?.Collections.Add(collection);
+                textBox.PlaceholderText = string.Empty;
+
+                // When this item changes from placeholder to non-placeholder (via changing containers), its textbox will lose focus, so it needs to be re-focused.
+                Schedule(() => GetContainingInputManager().ChangeFocus(textBox));
+
+                IsCreated.Value = true;
+            }
+        }
+
+        private class ItemTextBox : OsuTextBox
+        {
+            protected override float LeftRightPadding => item_height / 2;
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                BackgroundUnfocused = colours.GreySeafoamDarker.Darken(0.5f);
+                BackgroundFocused = colours.GreySeafoam;
+            }
+        }
+
+        public class DeleteButton : CompositeDrawable
+        {
+            public readonly IBindable<bool> IsCreated = new Bindable<bool>();
+
+            public Func<Vector2, bool> IsTextBoxHovered;
+
+            [Resolved(CanBeNull = true)]
+            private DialogOverlay dialogOverlay { get; set; }
+
+            [Resolved(CanBeNull = true)]
+            private CollectionManager collectionManager { get; set; }
+
+            private readonly BeatmapCollection collection;
+
+            private Drawable fadeContainer;
+            private Drawable background;
+
+            public DeleteButton(BeatmapCollection collection)
+            {
+                this.collection = collection;
+                RelativeSizeAxes = Axes.Y;
+
+                Width = button_width + item_height / 2; // add corner radius to cover with fill
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                InternalChild = fadeContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.1f,
+                    Children = new[]
+                    {
+                        background = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = colours.Red
+                        },
+                        new SpriteIcon
+                        {
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.Centre,
+                            X = -button_width * 0.6f,
+                            Size = new Vector2(10),
+                            Icon = FontAwesome.Solid.Trash
+                        }
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                IsCreated.BindValueChanged(created => Alpha = created.NewValue ? 1 : 0, true);
+            }
+
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => base.ReceivePositionalInputAt(screenSpacePos) && !IsTextBoxHovered(screenSpacePos);
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                fadeContainer.FadeTo(1f, 100, Easing.Out);
+                return false;
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                fadeContainer.FadeTo(0.1f, 100);
+            }
+
+            protected override bool OnClick(ClickEvent e)
+            {
+                background.FlashColour(Color4.White, 150);
+
+                if (collection.Beatmaps.Count == 0)
+                    deleteCollection();
+                else
+                    dialogOverlay?.Push(new DeleteCollectionDialog(collection, deleteCollection));
+
+                return true;
+            }
+
+            private void deleteCollection() => collectionManager?.Collections.Remove(collection);
+        }
+    }
+}

osu.Game/Collections/ManageCollectionsDialog.cs

@@ -0,0 +1,134 @@
+// 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.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osuTK;
+
+namespace osu.Game.Collections
+{
+    public class ManageCollectionsDialog : OsuFocusedOverlayContainer
+    {
+        private const double enter_duration = 500;
+        private const double exit_duration = 200;
+
+        [Resolved(CanBeNull = true)]
+        private CollectionManager collectionManager { get; set; }
+
+        public ManageCollectionsDialog()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            RelativeSizeAxes = Axes.Both;
+            Size = new Vector2(0.5f, 0.8f);
+
+            Masking = true;
+            CornerRadius = 10;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    Colour = colours.GreySeafoamDark,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = new GridContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        RowDimensions = new[]
+                        {
+                            new Dimension(GridSizeMode.AutoSize),
+                        },
+                        Content = new[]
+                        {
+                            new Drawable[]
+                            {
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Children = new Drawable[]
+                                    {
+                                        new OsuSpriteText
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Text = "Manage collections",
+                                            Font = OsuFont.GetFont(size: 30),
+                                            Padding = new MarginPadding { Vertical = 10 },
+                                        },
+                                        new IconButton
+                                        {
+                                            Anchor = Anchor.CentreRight,
+                                            Origin = Anchor.CentreRight,
+                                            Icon = FontAwesome.Solid.Times,
+                                            Colour = colours.GreySeafoamDarker,
+                                            Scale = new Vector2(0.8f),
+                                            X = -10,
+                                            Action = () => State.Value = Visibility.Hidden
+                                        }
+                                    }
+                                }
+                            },
+                            new Drawable[]
+                            {
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Colour = colours.GreySeafoamDarker
+                                        },
+                                        new DrawableCollectionList
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Items = { BindTarget = collectionManager?.Collections ?? new BindableList<BeatmapCollection>() }
+                                        }
+                                    }
+                                }
+                            },
+                        }
+                    }
+                }
+            };
+        }
+
+        protected override void PopIn()
+        {
+            base.PopIn();
+
+            this.FadeIn(enter_duration, Easing.OutQuint);
+            this.ScaleTo(0.9f).Then().ScaleTo(1f, enter_duration, Easing.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            base.PopOut();
+
+            this.FadeOut(exit_duration, Easing.OutQuint);
+            this.ScaleTo(0.9f, exit_duration);
+
+            // Ensure that textboxes commit
+            GetContainingInputManager()?.TriggerFocusContention(this);
+        }
+    }
+}

osu.Game/Configuration/BackgroundSource.cs

@@ -1,11 +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 System.ComponentModel;
+
 namespace osu.Game.Configuration
 {
     public enum BackgroundSource
     {
         Skin,
-        Beatmap
+        Beatmap,
+
+        [Description("Beatmap (with storyboard / video)")]
+        BeatmapWithStoryboard,
     }
 }

osu.Game/Configuration/DevelopmentOsuConfigManager.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+
+namespace osu.Game.Configuration
+{
+    [ExcludeFromDynamicCompile]
+    public class DevelopmentOsuConfigManager : OsuConfigManager
+    {
+        protected override string Filename => base.Filename.Replace(".ini", ".dev.ini");
+
+        public DevelopmentOsuConfigManager(Storage storage)
+            : base(storage)
+        {
+        }
+    }
+}

osu.Game/Configuration/DiscordRichPresenceMode.cs

@@ -0,0 +1,17 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.ComponentModel;
+
+namespace osu.Game.Configuration
+{
+    public enum DiscordRichPresenceMode
+    {
+        Off,
+
+        [Description("Hide identifiable information")]
+        Limited,
+
+        Full
+    }
+}

osu.Game/Configuration/HUDVisibilityMode.cs

@@ -0,0 +1,17 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.ComponentModel;
+
+namespace osu.Game.Configuration
+{
+    public enum HUDVisibilityMode
+    {
+        Never,
+
+        [Description("Hide during gameplay")]
+        HideDuringGameplay,
+
+        Always
+    }
+}

osu.Game/Configuration/IntroSequence.cs

@@ -6,6 +6,7 @@ namespace osu.Game.Configuration
     public enum IntroSequence
     {
         Circles,
+        Welcome,
         Triangles,
         Random
     }

osu.Game/Configuration/ModSettingChangeTracker.cs

@@ -0,0 +1,52 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Configuration
+{
+    /// <summary>
+    /// A helper class for tracking changes to the settings of a set of <see cref="Mod"/>s.
+    /// </summary>
+    /// <remarks>
+    /// Ensure to dispose when usage is finished.
+    /// </remarks>
+    public class ModSettingChangeTracker : IDisposable
+    {
+        /// <summary>
+        /// Notifies that the setting of a <see cref="Mod"/> has changed.
+        /// </summary>
+        public Action<Mod> SettingChanged;
+
+        private readonly List<ISettingsItem> settings = new List<ISettingsItem>();
+
+        /// <summary>
+        /// Creates a new <see cref="ModSettingChangeTracker"/> for a set of <see cref="Mod"/>s.
+        /// </summary>
+        /// <param name="mods">The set of <see cref="Mod"/>s whose settings need to be tracked.</param>
+        public ModSettingChangeTracker(IEnumerable<Mod> mods)
+        {
+            foreach (var mod in mods)
+            {
+                foreach (var setting in mod.CreateSettingsControls().OfType<ISettingsItem>())
+                {
+                    setting.SettingChanged += () => SettingChanged?.Invoke(mod);
+                    settings.Add(setting);
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            SettingChanged = null;
+
+            foreach (var r in settings)
+                r.Dispose();
+            settings.Clear();
+        }
+    }
+}

osu.Game/Configuration/OsuConfigManager.cs

@@ -1,10 +1,15 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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.Diagnostics;
 using osu.Framework.Configuration;
 using osu.Framework.Configuration.Tracking;
 using osu.Framework.Extensions;
 using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Input;
+using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
@@ -12,127 +17,188 @@ using osu.Game.Screens.Select.Filter;
 
 namespace osu.Game.Configuration
 {
+    [ExcludeFromDynamicCompile]
     public class OsuConfigManager : IniConfigManager<OsuSetting>
     {
         protected override void InitialiseDefaults()
         {
             // UI/selection defaults
-            Set(OsuSetting.Ruleset, 0, 0, int.MaxValue);
-            Set(OsuSetting.Skin, 0, -1, int.MaxValue);
+            SetDefault(OsuSetting.Ruleset, 0, 0, int.MaxValue);
+            SetDefault(OsuSetting.Skin, 0, -1, int.MaxValue);
 
-            Set(OsuSetting.BeatmapDetailTab, PlayBeatmapDetailArea.TabType.Details);
+            SetDefault(OsuSetting.BeatmapDetailTab, PlayBeatmapDetailArea.TabType.Details);
+            SetDefault(OsuSetting.BeatmapDetailModsFilter, false);
 
-            Set(OsuSetting.ShowConvertedBeatmaps, true);
-            Set(OsuSetting.DisplayStarsMinimum, 0.0, 0, 10, 0.1);
-            Set(OsuSetting.DisplayStarsMaximum, 10.1, 0, 10.1, 0.1);
+            SetDefault(OsuSetting.ShowConvertedBeatmaps, true);
+            SetDefault(OsuSetting.DisplayStarsMinimum, 0.0, 0, 10, 0.1);
+            SetDefault(OsuSetting.DisplayStarsMaximum, 10.1, 0, 10.1, 0.1);
 
-            Set(OsuSetting.SongSelectGroupingMode, GroupMode.All);
-            Set(OsuSetting.SongSelectSortingMode, SortMode.Title);
+            SetDefault(OsuSetting.SongSelectGroupingMode, GroupMode.All);
+            SetDefault(OsuSetting.SongSelectSortingMode, SortMode.Title);
 
-            Set(OsuSetting.RandomSelectAlgorithm, RandomSelectAlgorithm.RandomPermutation);
+            SetDefault(OsuSetting.RandomSelectAlgorithm, RandomSelectAlgorithm.RandomPermutation);
 
-            Set(OsuSetting.ChatDisplayHeight, ChatOverlay.DEFAULT_HEIGHT, 0.2f, 1f);
+            SetDefault(OsuSetting.ChatDisplayHeight, ChatOverlay.DEFAULT_HEIGHT, 0.2f, 1f);
 
             // Online settings
-            Set(OsuSetting.Username, string.Empty);
-            Set(OsuSetting.Token, string.Empty);
+            SetDefault(OsuSetting.Username, string.Empty);
+            SetDefault(OsuSetting.Token, string.Empty);
 
-            Set(OsuSetting.SavePassword, false).ValueChanged += enabled =>
+            SetDefault(OsuSetting.AutomaticallyDownloadWhenSpectating, false);
+
+            SetDefault(OsuSetting.SavePassword, false).ValueChanged += enabled =>
             {
-                if (enabled.NewValue) Set(OsuSetting.SaveUsername, true);
+                if (enabled.NewValue) SetValue(OsuSetting.SaveUsername, true);
             };
 
-            Set(OsuSetting.SaveUsername, true).ValueChanged += enabled =>
+            SetDefault(OsuSetting.SaveUsername, true).ValueChanged += enabled =>
             {
-                if (!enabled.NewValue) Set(OsuSetting.SavePassword, false);
+                if (!enabled.NewValue) SetValue(OsuSetting.SavePassword, false);
             };
 
-            Set(OsuSetting.ExternalLinkWarning, true);
+            SetDefault(OsuSetting.ExternalLinkWarning, true);
+            SetDefault(OsuSetting.PreferNoVideo, false);
+
+            SetDefault(OsuSetting.ShowOnlineExplicitContent, false);
+
+            SetDefault(OsuSetting.NotifyOnUsernameMentioned, true);
+            SetDefault(OsuSetting.NotifyOnPrivateMessage, true);
 
             // Audio
-            Set(OsuSetting.VolumeInactive, 0.25, 0, 1, 0.01);
+            SetDefault(OsuSetting.VolumeInactive, 0.25, 0, 1, 0.01);
 
-            Set(OsuSetting.MenuVoice, true);
-            Set(OsuSetting.MenuMusic, true);
+            SetDefault(OsuSetting.MenuVoice, true);
+            SetDefault(OsuSetting.MenuMusic, true);
 
-            Set(OsuSetting.AudioOffset, 0, -500.0, 500.0, 1);
+            SetDefault(OsuSetting.AudioOffset, 0, -500.0, 500.0, 1);
 
             // Input
-            Set(OsuSetting.MenuCursorSize, 1.0f, 0.5f, 2f, 0.01f);
-            Set(OsuSetting.GameplayCursorSize, 1.0f, 0.1f, 2f, 0.01f);
-            Set(OsuSetting.AutoCursorSize, false);
+            SetDefault(OsuSetting.MenuCursorSize, 1.0f, 0.5f, 2f, 0.01f);
+            SetDefault(OsuSetting.GameplayCursorSize, 1.0f, 0.1f, 2f, 0.01f);
+            SetDefault(OsuSetting.AutoCursorSize, false);
 
-            Set(OsuSetting.MouseDisableButtons, false);
-            Set(OsuSetting.MouseDisableWheel, false);
+            SetDefault(OsuSetting.MouseDisableButtons, false);
+            SetDefault(OsuSetting.MouseDisableWheel, false);
+            SetDefault(OsuSetting.ConfineMouseMode, OsuConfineMouseMode.DuringGameplay);
 
             // Graphics
-            Set(OsuSetting.ShowFpsDisplay, false);
+            SetDefault(OsuSetting.ShowFpsDisplay, false);
 
-            Set(OsuSetting.ShowStoryboard, true);
-            Set(OsuSetting.ShowVideoBackground, true);
-            Set(OsuSetting.BeatmapSkins, true);
-            Set(OsuSetting.BeatmapHitsounds, true);
+            SetDefault(OsuSetting.ShowStoryboard, true);
+            SetDefault(OsuSetting.BeatmapSkins, true);
+            SetDefault(OsuSetting.BeatmapColours, true);
+            SetDefault(OsuSetting.BeatmapHitsounds, true);
 
-            Set(OsuSetting.CursorRotation, true);
+            SetDefault(OsuSetting.CursorRotation, true);
 
-            Set(OsuSetting.MenuParallax, true);
+            SetDefault(OsuSetting.MenuParallax, true);
 
             // Gameplay
-            Set(OsuSetting.DimLevel, 0.8, 0, 1, 0.01);
-            Set(OsuSetting.BlurLevel, 0, 0, 1, 0.01);
-            Set(OsuSetting.LightenDuringBreaks, true);
+            SetDefault(OsuSetting.DimLevel, 0.8, 0, 1, 0.01);
+            SetDefault(OsuSetting.BlurLevel, 0, 0, 1, 0.01);
+            SetDefault(OsuSetting.LightenDuringBreaks, true);
 
-            Set(OsuSetting.HitLighting, true);
+            SetDefault(OsuSetting.HitLighting, true);
 
-            Set(OsuSetting.ShowInterface, true);
-            Set(OsuSetting.ShowProgressGraph, true);
-            Set(OsuSetting.ShowHealthDisplayWhenCantFail, true);
-            Set(OsuSetting.KeyOverlay, false);
-            Set(OsuSetting.ScoreMeter, ScoreMeterType.HitErrorBoth);
+            SetDefault(OsuSetting.HUDVisibilityMode, HUDVisibilityMode.Always);
+            SetDefault(OsuSetting.ShowProgressGraph, true);
+            SetDefault(OsuSetting.ShowHealthDisplayWhenCantFail, true);
+            SetDefault(OsuSetting.FadePlayfieldWhenHealthLow, true);
+            SetDefault(OsuSetting.KeyOverlay, false);
+            SetDefault(OsuSetting.PositionalHitSounds, true);
+            SetDefault(OsuSetting.AlwaysPlayFirstComboBreak, true);
 
-            Set(OsuSetting.FloatingComments, false);
+            SetDefault(OsuSetting.FloatingComments, false);
 
-            Set(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised);
+            SetDefault(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised);
 
-            Set(OsuSetting.IncreaseFirstObjectVisibility, true);
+            SetDefault(OsuSetting.IncreaseFirstObjectVisibility, true);
+            SetDefault(OsuSetting.GameplayDisableWinKey, true);
 
             // Update
-            Set(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
+            SetDefault(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
 
-            Set(OsuSetting.Version, string.Empty);
+            SetDefault(OsuSetting.Version, string.Empty);
 
-            Set(OsuSetting.ScreenshotFormat, ScreenshotFormat.Jpg);
-            Set(OsuSetting.ScreenshotCaptureMenuCursor, false);
+            SetDefault(OsuSetting.ScreenshotFormat, ScreenshotFormat.Jpg);
+            SetDefault(OsuSetting.ScreenshotCaptureMenuCursor, false);
 
-            Set(OsuSetting.SongSelectRightMouseScroll, false);
+            SetDefault(OsuSetting.SongSelectRightMouseScroll, false);
 
-            Set(OsuSetting.Scaling, ScalingMode.Off);
+            SetDefault(OsuSetting.Scaling, ScalingMode.Off);
 
-            Set(OsuSetting.ScalingSizeX, 0.8f, 0.2f, 1f);
-            Set(OsuSetting.ScalingSizeY, 0.8f, 0.2f, 1f);
+            SetDefault(OsuSetting.ScalingSizeX, 0.8f, 0.2f, 1f);
+            SetDefault(OsuSetting.ScalingSizeY, 0.8f, 0.2f, 1f);
 
-            Set(OsuSetting.ScalingPositionX, 0.5f, 0f, 1f);
-            Set(OsuSetting.ScalingPositionY, 0.5f, 0f, 1f);
+            SetDefault(OsuSetting.ScalingPositionX, 0.5f, 0f, 1f);
+            SetDefault(OsuSetting.ScalingPositionY, 0.5f, 0f, 1f);
 
-            Set(OsuSetting.UIScale, 1f, 0.8f, 1.6f, 0.01f);
+            SetDefault(OsuSetting.UIScale, 1f, 0.8f, 1.6f, 0.01f);
 
-            Set(OsuSetting.UIHoldActivationDelay, 200f, 0f, 500f, 50f);
+            SetDefault(OsuSetting.UIHoldActivationDelay, 200f, 0f, 500f, 50f);
 
-            Set(OsuSetting.IntroSequence, IntroSequence.Triangles);
+            SetDefault(OsuSetting.IntroSequence, IntroSequence.Triangles);
 
-            Set(OsuSetting.MenuBackgroundSource, BackgroundSource.Skin);
+            SetDefault(OsuSetting.MenuBackgroundSource, BackgroundSource.Skin);
+            SetDefault(OsuSetting.SeasonalBackgroundMode, SeasonalBackgroundMode.Sometimes);
+
+            SetDefault(OsuSetting.DiscordRichPresence, DiscordRichPresenceMode.Full);
+
+            SetDefault(OsuSetting.EditorWaveformOpacity, 0.25f);
+            SetDefault(OsuSetting.EditorHitAnimations, false);
         }
 
         public OsuConfigManager(Storage storage)
             : base(storage)
         {
+            Migrate();
         }
 
-        public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
+        public void Migrate()
         {
-            new TrackedSetting<bool>(OsuSetting.MouseDisableButtons, v => new SettingDescription(!v, "gameplay mouse buttons", v ? "disabled" : "enabled")),
-            new TrackedSetting<ScalingMode>(OsuSetting.Scaling, m => new SettingDescription(m, "scaling", m.GetDescription())),
-        };
+            // arrives as 2020.123.0
+            var rawVersion = Get<string>(OsuSetting.Version);
+
+            if (rawVersion.Length < 6)
+                return;
+
+            var pieces = rawVersion.Split('.');
+
+            // on a fresh install or when coming from a non-release build, execution will end here.
+            // we don't want to run migrations in such cases.
+            if (!int.TryParse(pieces[0], out int year)) return;
+            if (!int.TryParse(pieces[1], out int monthDay)) return;
+
+            int combined = (year * 10000) + monthDay;
+
+            if (combined < 20210413)
+            {
+                SetValue(OsuSetting.EditorWaveformOpacity, 0.25f);
+            }
+        }
+
+        public override TrackedSettings CreateTrackedSettings()
+        {
+            // these need to be assigned in normal game startup scenarios.
+            Debug.Assert(LookupKeyBindings != null);
+            Debug.Assert(LookupSkinName != null);
+
+            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 =>
+                {
+                    string skinName = LookupSkinName(m) ?? string.Empty;
+                    return new SettingDescription(skinName, "skin", skinName, $"random: {LookupKeyBindings(GlobalAction.RandomSkin)}");
+                })
+            };
+        }
+
+        public Func<int, string> LookupSkinName { private get; set; }
+
+        public Func<GlobalAction, string> LookupKeyBindings { get; set; }
     }
 
     public enum OsuSetting
@@ -146,15 +212,17 @@ namespace osu.Game.Configuration
         BlurLevel,
         LightenDuringBreaks,
         ShowStoryboard,
-        ShowVideoBackground,
         KeyOverlay,
-        ScoreMeter,
+        PositionalHitSounds,
+        AlwaysPlayFirstComboBreak,
         FloatingComments,
-        ShowInterface,
+        HUDVisibilityMode,
         ShowProgressGraph,
         ShowHealthDisplayWhenCantFail,
+        FadePlayfieldWhenHealthLow,
         MouseDisableButtons,
         MouseDisableWheel,
+        ConfineMouseMode,
         AudioOffset,
         VolumeInactive,
         MenuMusic,
@@ -162,6 +230,7 @@ namespace osu.Game.Configuration
         CursorRotation,
         MenuParallax,
         BeatmapDetailTab,
+        BeatmapDetailModsFilter,
         Username,
         ReleaseStream,
         SavePassword,
@@ -180,10 +249,12 @@ namespace osu.Game.Configuration
         ScreenshotCaptureMenuCursor,
         SongSelectRightMouseScroll,
         BeatmapSkins,
+        BeatmapColours,
         BeatmapHitsounds,
         IncreaseFirstObjectVisibility,
         ScoreDisplayMode,
         ExternalLinkWarning,
+        PreferNoVideo,
         Scaling,
         ScalingPositionX,
         ScalingPositionY,
@@ -191,8 +262,17 @@ namespace osu.Game.Configuration
         ScalingSizeY,
         UIScale,
         IntroSequence,
+        NotifyOnUsernameMentioned,
+        NotifyOnPrivateMessage,
         UIHoldActivationDelay,
         HitLighting,
-        MenuBackgroundSource
+        MenuBackgroundSource,
+        GameplayDisableWinKey,
+        SeasonalBackgroundMode,
+        EditorWaveformOpacity,
+        EditorHitAnimations,
+        DiscordRichPresence,
+        AutomaticallyDownloadWhenSpectating,
+        ShowOnlineExplicitContent,
     }
 }

osu.Game/Configuration/RankingType.cs

@@ -1,20 +0,0 @@
-// 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.ComponentModel;
-
-namespace osu.Game.Configuration
-{
-    public enum RankingType
-    {
-        Local,
-
-        [Description("Global")]
-        Top,
-
-        [Description("Selected Mods")]
-        SelectedMod,
-        Friends,
-        Country
-    }
-}

osu.Game/Configuration/ScoreMeterType.cs

@@ -1,31 +0,0 @@
-// 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.ComponentModel;
-
-namespace osu.Game.Configuration
-{
-    public enum ScoreMeterType
-    {
-        [Description("None")]
-        None,
-
-        [Description("Hit Error (left)")]
-        HitErrorLeft,
-
-        [Description("Hit Error (right)")]
-        HitErrorRight,
-
-        [Description("Hit Error (both)")]
-        HitErrorBoth,
-
-        [Description("Colour (left)")]
-        ColourLeft,
-
-        [Description("Colour (right)")]
-        ColourRight,
-
-        [Description("Colour (both)")]
-        ColourBoth,
-    }
-}

osu.Game/Configuration/SeasonalBackgroundMode.cs

@@ -0,0 +1,23 @@
+// 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.
+
+namespace osu.Game.Configuration
+{
+    public enum SeasonalBackgroundMode
+    {
+        /// <summary>
+        /// Seasonal backgrounds are shown regardless of season, if at all available.
+        /// </summary>
+        Always,
+
+        /// <summary>
+        /// Seasonal backgrounds are shown only during their corresponding season.
+        /// </summary>
+        Sometimes,
+
+        /// <summary>
+        /// Seasonal backgrounds are never shown.
+        /// </summary>
+        Never
+    }
+}

osu.Game/Configuration/SessionStatics.cs

@@ -1,6 +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 osu.Framework.Bindables;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+
 namespace osu.Game.Configuration
 {
     /// <summary>
@@ -8,16 +13,36 @@ namespace osu.Game.Configuration
     /// </summary>
     public class SessionStatics : InMemoryConfigManager<Static>
     {
-        protected override void InitialiseDefaults()
+        protected override void InitialiseDefaults() => ResetValues();
+
+        public void ResetValues()
         {
-            Set(Static.LoginOverlayDisplayed, false);
-            Set(Static.MutedAudioNotificationShownOnce, false);
+            ensureDefault(SetDefault(Static.LoginOverlayDisplayed, false));
+            ensureDefault(SetDefault(Static.MutedAudioNotificationShownOnce, false));
+            ensureDefault(SetDefault(Static.LowBatteryNotificationShownOnce, false));
+            ensureDefault(SetDefault(Static.LastHoverSoundPlaybackTime, (double?)null));
+            ensureDefault(SetDefault<APISeasonalBackgrounds>(Static.SeasonalBackgrounds, null));
         }
+
+        private void ensureDefault<T>(Bindable<T> bindable) => bindable.SetDefault();
     }
 
     public enum Static
     {
         LoginOverlayDisplayed,
-        MutedAudioNotificationShownOnce
+        MutedAudioNotificationShownOnce,
+        LowBatteryNotificationShownOnce,
+
+        /// <summary>
+        /// Info about seasonal backgrounds available fetched from API - see <see cref="APISeasonalBackgrounds"/>.
+        /// Value under this lookup can be <c>null</c> if there are no backgrounds available (or API is not reachable).
+        /// </summary>
+        SeasonalBackgrounds,
+
+        /// <summary>
+        /// The last playback time in milliseconds of a hover sample (from <see cref="HoverSounds"/>).
+        /// Used to debounce hover sounds game-wide to avoid volume saturation, especially in scrolling views with many UI controls like <see cref="SettingsOverlay"/>.
+        /// </summary>
+        LastHoverSoundPlaybackTime
     }
 }

osu.Game/Configuration/SettingSourceAttribute.cs

@@ -1,14 +1,18 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable enable
+
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Configuration
@@ -23,15 +27,23 @@ namespace osu.Game.Configuration
     /// </remarks>
     [MeansImplicitUse]
     [AttributeUsage(AttributeTargets.Property)]
-    public class SettingSourceAttribute : Attribute
+    public class SettingSourceAttribute : Attribute, IComparable<SettingSourceAttribute>
     {
-        public string Label { get; }
+        public LocalisableString Label { get; }
 
-        public string Description { get; }
+        public LocalisableString Description { get; }
 
         public int? OrderPosition { get; }
 
-        public SettingSourceAttribute(string label, string description = null)
+        /// <summary>
+        /// The type of the settings control which handles this setting source.
+        /// </summary>
+        /// <remarks>
+        /// Must be a type deriving <see cref="SettingsItem{T}"/> with a public parameterless constructor.
+        /// </remarks>
+        public Type? SettingControlType { get; set; }
+
+        public SettingSourceAttribute(string? label, string? description = null)
         {
             Label = label ?? string.Empty;
             Description = description ?? string.Empty;
@@ -42,6 +54,21 @@ namespace osu.Game.Configuration
         {
             OrderPosition = orderPosition;
         }
+
+        public int CompareTo(SettingSourceAttribute other)
+        {
+            if (OrderPosition == other.OrderPosition)
+                return 0;
+
+            // unordered items come last (are greater than any ordered items).
+            if (OrderPosition == null)
+                return 1;
+            if (other.OrderPosition == null)
+                return -1;
+
+            // ordered items are sorted by the order value.
+            return OrderPosition.Value.CompareTo(other.OrderPosition);
+        }
     }
 
     public static class SettingSourceExtensions
@@ -52,13 +79,30 @@ namespace osu.Game.Configuration
             {
                 object value = property.GetValue(obj);
 
+                if (attr.SettingControlType != null)
+                {
+                    var controlType = attr.SettingControlType;
+                    if (controlType.EnumerateBaseTypes().All(t => !t.IsGenericType || t.GetGenericTypeDefinition() != typeof(SettingsItem<>)))
+                        throw new InvalidOperationException($"{nameof(SettingSourceAttribute)} had an unsupported custom control type ({controlType.ReadableName()})");
+
+                    var control = (Drawable)Activator.CreateInstance(controlType);
+                    controlType.GetProperty(nameof(SettingsItem<object>.LabelText))?.SetValue(control, attr.Label);
+                    controlType.GetProperty(nameof(SettingsItem<object>.TooltipText))?.SetValue(control, attr.Description);
+                    controlType.GetProperty(nameof(SettingsItem<object>.Current))?.SetValue(control, value);
+
+                    yield return control;
+
+                    continue;
+                }
+
                 switch (value)
                 {
                     case BindableNumber<float> bNumber:
                         yield return new SettingsSlider<float>
                         {
                             LabelText = attr.Label,
-                            Bindable = bNumber,
+                            TooltipText = attr.Description,
+                            Current = bNumber,
                             KeyboardStep = 0.1f,
                         };
 
@@ -68,7 +112,8 @@ namespace osu.Game.Configuration
                         yield return new SettingsSlider<double>
                         {
                             LabelText = attr.Label,
-                            Bindable = bNumber,
+                            TooltipText = attr.Description,
+                            Current = bNumber,
                             KeyboardStep = 0.1f,
                         };
 
@@ -78,7 +123,8 @@ namespace osu.Game.Configuration
                         yield return new SettingsSlider<int>
                         {
                             LabelText = attr.Label,
-                            Bindable = bNumber
+                            TooltipText = attr.Description,
+                            Current = bNumber
                         };
 
                         break;
@@ -87,7 +133,8 @@ namespace osu.Game.Configuration
                         yield return new SettingsCheckbox
                         {
                             LabelText = attr.Label,
-                            Bindable = bBool
+                            TooltipText = attr.Description,
+                            Current = bBool
                         };
 
                         break;
@@ -96,16 +143,19 @@ namespace osu.Game.Configuration
                         yield return new SettingsTextBox
                         {
                             LabelText = attr.Label,
-                            Bindable = bString
+                            TooltipText = attr.Description,
+                            Current = bString
                         };
 
                         break;
 
                     case IBindable bindable:
-                        var dropdownType = typeof(SettingsEnumDropdown<>).MakeGenericType(bindable.GetType().GetGenericArguments()[0]);
+                        var dropdownType = typeof(ModSettingsEnumDropdown<>).MakeGenericType(bindable.GetType().GetGenericArguments()[0]);
                         var dropdown = (Drawable)Activator.CreateInstance(dropdownType);
 
-                        dropdown.GetType().GetProperty(nameof(IHasCurrentValue<object>.Current))?.SetValue(dropdown, obj);
+                        dropdownType.GetProperty(nameof(SettingsDropdown<object>.LabelText))?.SetValue(dropdown, attr.Label);
+                        dropdownType.GetProperty(nameof(SettingsDropdown<object>.TooltipText))?.SetValue(dropdown, attr.Description);
+                        dropdownType.GetProperty(nameof(SettingsDropdown<object>.Current))?.SetValue(dropdown, bindable);
 
                         yield return dropdown;
 
@@ -130,14 +180,21 @@ namespace osu.Game.Configuration
             }
         }
 
-        public static IEnumerable<(SettingSourceAttribute, PropertyInfo)> GetOrderedSettingsSourceProperties(this object obj)
+        public static ICollection<(SettingSourceAttribute, PropertyInfo)> GetOrderedSettingsSourceProperties(this object obj)
+            => obj.GetSettingsSourceProperties()
+                  .OrderBy(attr => attr.Item1)
+                  .ToArray();
+
+        private class ModSettingsEnumDropdown<T> : SettingsEnumDropdown<T>
+            where T : struct, Enum
         {
-            var original = obj.GetSettingsSourceProperties();
+            protected override OsuDropdown<T> CreateDropdown() => new ModDropdownControl();
 
-            var orderedRelative = original.Where(attr => attr.Item1.OrderPosition != null).OrderBy(attr => attr.Item1.OrderPosition);
-            var unordered = original.Except(orderedRelative);
-
-            return orderedRelative.Concat(unordered);
+            private class ModDropdownControl : DropdownControl
+            {
+                // Set menu's max height low enough to workaround nested scroll issues (see https://github.com/ppy/osu-framework/issues/4536).
+                protected override DropdownMenu CreateMenu() => base.CreateMenu().With(m => m.MaxHeight = 100);
+            }
         }
     }
 }

osu.Game/Configuration/SettingsStore.cs

@@ -22,7 +22,6 @@ namespace osu.Game.Configuration
         /// </summary>
         /// <param name="rulesetId">The ruleset's internal ID.</param>
         /// <param name="variant">An optional variant.</param>
-        /// <returns></returns>
         public List<DatabasedSetting> Query(int? rulesetId = null, int? variant = null) =>
             ContextFactory.Get().DatabasedSetting.Where(b => b.RulesetID == rulesetId && b.Variant == variant).ToList();
 

osu.Game/Configuration/StorageConfigManager.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.Framework.Configuration;
+using osu.Framework.Platform;
+
+namespace osu.Game.Configuration
+{
+    public class StorageConfigManager : IniConfigManager<StorageConfig>
+    {
+        protected override string Filename => "storage.ini";
+
+        public StorageConfigManager(Storage storage)
+            : base(storage)
+        {
+        }
+
+        protected override void InitialiseDefaults()
+        {
+            base.InitialiseDefaults();
+
+            SetDefault(StorageConfig.FullPath, string.Empty);
+        }
+    }
+
+    public enum StorageConfig
+    {
+        FullPath,
+    }
+}

osu.Game/Database/ArchiveModelManager.cs

@@ -10,7 +10,7 @@ using System.Threading.Tasks;
 using Humanizer;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore;
-using osu.Framework;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Logging;
@@ -20,9 +20,7 @@ using osu.Game.IO;
 using osu.Game.IO.Archives;
 using osu.Game.IPC;
 using osu.Game.Overlays.Notifications;
-using osu.Game.Utils;
-using SharpCompress.Common;
-using FileInfo = osu.Game.IO.FileInfo;
+using SharpCompress.Archives.Zip;
 
 namespace osu.Game.Database
 {
@@ -38,6 +36,11 @@ namespace osu.Game.Database
     {
         private const int import_queue_request_concurrency = 1;
 
+        /// <summary>
+        /// The size of a batch import operation before considering it a lower priority operation.
+        /// </summary>
+        private const int low_priority_import_batch_size = 1;
+
         /// <summary>
         /// A singleton scheduler shared by all <see cref="ArchiveModelManager{TModel,TFileModel}"/>.
         /// </summary>
@@ -47,26 +50,35 @@ namespace osu.Game.Database
         /// </remarks>
         private static readonly ThreadedTaskScheduler import_scheduler = new ThreadedTaskScheduler(import_queue_request_concurrency, nameof(ArchiveModelManager<TModel, TFileModel>));
 
+        /// <summary>
+        /// A second scheduler for lower priority imports.
+        /// For simplicity, these will just run in parallel with normal priority imports, but a future refactor would see this implemented via a custom scheduler/queue.
+        /// See https://gist.github.com/peppy/f0e118a14751fc832ca30dd48ba3876b for an incomplete version of this.
+        /// </summary>
+        private static readonly ThreadedTaskScheduler import_scheduler_low_priority = new ThreadedTaskScheduler(import_queue_request_concurrency, nameof(ArchiveModelManager<TModel, TFileModel>));
+
         /// <summary>
         /// Set an endpoint for notifications to be posted to.
         /// </summary>
         public Action<Notification> PostNotification { protected get; set; }
 
         /// <summary>
-        /// Fired when a new <typeparamref name="TModel"/> becomes available in the database.
+        /// Fired when a new or updated <typeparamref name="TModel"/> becomes available in the database.
         /// This is not guaranteed to run on the update thread.
         /// </summary>
-        public event Action<TModel> ItemAdded;
+        public IBindable<WeakReference<TModel>> ItemUpdated => itemUpdated;
+
+        private readonly Bindable<WeakReference<TModel>> itemUpdated = new Bindable<WeakReference<TModel>>();
 
         /// <summary>
         /// Fired when a <typeparamref name="TModel"/> is removed from the database.
         /// This is not guaranteed to run on the update thread.
         /// </summary>
-        public event Action<TModel> ItemRemoved;
+        public IBindable<WeakReference<TModel>> ItemRemoved => itemRemoved;
 
-        public virtual string[] HandledExtensions => new[] { ".zip" };
+        private readonly Bindable<WeakReference<TModel>> itemRemoved = new Bindable<WeakReference<TModel>>();
 
-        public virtual bool SupportsImportFromStable => RuntimeInfo.IsDesktop;
+        public virtual IEnumerable<string> HandledExtensions => new[] { @".zip" };
 
         protected readonly FileStore Files;
 
@@ -77,13 +89,17 @@ namespace osu.Game.Database
         // ReSharper disable once NotAccessedField.Local (we should keep a reference to this so it is not finalised)
         private ArchiveImportIPCChannel ipc;
 
+        private readonly Storage exportStorage;
+
         protected ArchiveModelManager(Storage storage, IDatabaseContextFactory contextFactory, MutableDatabaseBackedStoreWithFileIncludes<TModel, TFileModel> modelStore, IIpcHost importHost = null)
         {
             ContextFactory = contextFactory;
 
             ModelStore = modelStore;
-            ModelStore.ItemAdded += item => handleEvent(() => ItemAdded?.Invoke(item));
-            ModelStore.ItemRemoved += s => handleEvent(() => ItemRemoved?.Invoke(s));
+            ModelStore.ItemUpdated += item => handleEvent(() => itemUpdated.Value = new WeakReference<TModel>(item));
+            ModelStore.ItemRemoved += item => handleEvent(() => itemRemoved.Value = new WeakReference<TModel>(item));
+
+            exportStorage = storage.GetStorageForDirectory(@"exports");
 
             Files = new FileStore(contextFactory, storage);
 
@@ -95,8 +111,11 @@ namespace osu.Game.Database
 
         /// <summary>
         /// Import one or more <typeparamref name="TModel"/> items from filesystem <paramref name="paths"/>.
-        /// This will post notifications tracking progress.
         /// </summary>
+        /// <remarks>
+        /// This will be treated as a low priority import if more than one path is specified; use <see cref="Import(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>
         public Task Import(params string[] paths)
         {
@@ -104,11 +123,27 @@ namespace osu.Game.Database
 
             PostNotification?.Invoke(notification);
 
-            return Import(notification, paths);
+            return Import(notification, paths.Select(p => new ImportTask(p)).ToArray());
         }
 
-        protected async Task<IEnumerable<TModel>> Import(ProgressNotification notification, params string[] paths)
+        public Task Import(params ImportTask[] tasks)
         {
+            var notification = new ProgressNotification { State = ProgressNotificationState.Active };
+
+            PostNotification?.Invoke(notification);
+
+            return Import(notification, tasks);
+        }
+
+        protected async Task<IEnumerable<TModel>> Import(ProgressNotification notification, params ImportTask[] tasks)
+        {
+            if (tasks.Length == 0)
+            {
+                notification.CompletionText = $"No {HumanisedModelName}s were found to import!";
+                notification.State = ProgressNotificationState.Completed;
+                return Enumerable.Empty<TModel>();
+            }
+
             notification.Progress = 0;
             notification.Text = $"{HumanisedModelName.Humanize(LetterCasing.Title)} import is initialising...";
 
@@ -116,33 +151,46 @@ namespace osu.Game.Database
 
             var imported = new List<TModel>();
 
-            await Task.WhenAll(paths.Select(async path =>
+            bool isLowPriorityImport = tasks.Length > low_priority_import_batch_size;
+
+            try
             {
-                notification.CancellationToken.ThrowIfCancellationRequested();
-
-                try
+                await Task.WhenAll(tasks.Select(async task =>
                 {
-                    var model = await Import(path, notification.CancellationToken);
+                    notification.CancellationToken.ThrowIfCancellationRequested();
 
-                    lock (imported)
+                    try
                     {
-                        if (model != null)
-                            imported.Add(model);
-                        current++;
+                        var model = await Import(task, isLowPriorityImport, notification.CancellationToken).ConfigureAwait(false);
 
-                        notification.Text = $"Imported {current} of {paths.Length} {HumanisedModelName}s";
-                        notification.Progress = (float)current / paths.Length;
+                        lock (imported)
+                        {
+                            if (model != null)
+                                imported.Add(model);
+                            current++;
+
+                            notification.Text = $"Imported {current} of {tasks.Length} {HumanisedModelName}s";
+                            notification.Progress = (float)current / tasks.Length;
+                        }
                     }
-                }
-                catch (TaskCanceledException)
+                    catch (TaskCanceledException)
+                    {
+                        throw;
+                    }
+                    catch (Exception e)
+                    {
+                        Logger.Error(e, $@"Could not import ({task})", LoggingTarget.Database);
+                    }
+                })).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                if (imported.Count == 0)
                 {
-                    throw;
+                    notification.State = ProgressNotificationState.Cancelled;
+                    return imported;
                 }
-                catch (Exception e)
-                {
-                    Logger.Error(e, $@"Could not import ({Path.GetFileName(path)})", LoggingTarget.Database);
-                }
-            }));
+            }
 
             if (imported.Count == 0)
             {
@@ -173,17 +221,19 @@ namespace osu.Game.Database
 
         /// <summary>
         /// Import one <typeparamref name="TModel"/> from the filesystem and delete the file on success.
+        /// Note that this bypasses the UI flow and should only be used for special cases or testing.
         /// </summary>
-        /// <param name="path">The archive location on disk.</param>
+        /// <param name="task">The <see cref="ImportTask"/> containing data about the <typeparamref name="TModel"/> to import.</param>
+        /// <param name="lowPriority">Whether this is a low priority import.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The imported model, if successful.</returns>
-        public async Task<TModel> Import(string path, CancellationToken cancellationToken = default)
+        internal async Task<TModel> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
             TModel import;
-            using (ArchiveReader reader = getReaderFrom(path))
-                import = await Import(reader, cancellationToken);
+            using (ArchiveReader reader = task.GetReader())
+                import = await Import(reader, lowPriority, cancellationToken).ConfigureAwait(false);
 
             // We may or may not want to delete the file depending on where it is stored.
             //  e.g. reconstructing/repairing database with items from default storage.
@@ -191,12 +241,12 @@ namespace osu.Game.Database
             // TODO: Add a check to prevent files from storage to be deleted.
             try
             {
-                if (import != null && File.Exists(path) && ShouldDeleteArchive(path))
-                    File.Delete(path);
+                if (import != null && File.Exists(task.Path) && ShouldDeleteArchive(task.Path))
+                    File.Delete(task.Path);
             }
             catch (Exception e)
             {
-                LogForModel(import, $@"Could not delete original file after import ({Path.GetFileName(path)})", e);
+                LogForModel(import, $@"Could not delete original file after import ({task})", e);
             }
 
             return import;
@@ -208,11 +258,12 @@ namespace osu.Game.Database
         public Action<IEnumerable<TModel>> PresentImport;
 
         /// <summary>
-        /// Import an item from an <see cref="ArchiveReader"/>.
+        /// Silently import an item from an <see cref="ArchiveReader"/>.
         /// </summary>
         /// <param name="archive">The archive to be imported.</param>
+        /// <param name="lowPriority">Whether this is a low priority import.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
-        public Task<TModel> Import(ArchiveReader archive, CancellationToken cancellationToken = default)
+        public Task<TModel> Import(ArchiveReader archive, bool lowPriority = false, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
@@ -231,11 +282,11 @@ namespace osu.Game.Database
             }
             catch (Exception e)
             {
-                LogForModel(model, $"Model creation of {archive.Name} failed.", e);
+                LogForModel(model, @$"Model creation of {archive.Name} failed.", e);
                 return null;
             }
 
-            return Import(model, archive, cancellationToken);
+            return Import(model, archive, lowPriority, cancellationToken);
         }
 
         /// <summary>
@@ -243,9 +294,12 @@ namespace osu.Game.Database
         /// Generally should include all file types which determine the file's uniqueness.
         /// Large files should be avoided if possible.
         /// </summary>
+        /// <remarks>
+        /// This is only used by the default hash implementation. If <see cref="ComputeHash"/> is overridden, it will not be used.
+        /// </remarks>
         protected abstract string[] HashableFileTypes { get; }
 
-        protected static void LogForModel(TModel model, string message, Exception e = null)
+        internal static void LogForModel(TModel model, string message, Exception e = null)
         {
             string prefix = $"[{(model?.Hash ?? "?????").Substring(0, 5)}]";
 
@@ -255,18 +309,28 @@ namespace osu.Game.Database
                 Logger.Log($"{prefix} {message}", LoggingTarget.Database);
         }
 
+        /// <summary>
+        /// Whether the implementation overrides <see cref="ComputeHash"/> with a custom implementation.
+        /// Custom hash implementations must bypass the early exit in the import flow (see <see cref="computeHashFast"/> usage).
+        /// </summary>
+        protected virtual bool HasCustomHashFunction => false;
+
         /// <summary>
         /// Create a SHA-2 hash from the provided archive based on file content of all files matching <see cref="HashableFileTypes"/>.
         /// </summary>
         /// <remarks>
         ///  In the case of no matching files, a hash will be generated from the passed archive's <see cref="ArchiveReader.Name"/>.
         /// </remarks>
-        private string computeHash(TModel item, ArchiveReader reader = null)
+        protected virtual string ComputeHash(TModel item, ArchiveReader reader = null)
         {
-            // for now, concatenate all .osu files in the set to create a unique hash.
+            if (reader != null)
+                // fast hashing for cases where the item's files may not be populated.
+                return computeHashFast(reader);
+
+            // for now, concatenate all hashable files in the set to create a unique hash.
             MemoryStream hashable = new MemoryStream();
 
-            foreach (TFileModel file in item.Files.Where(f => HashableFileTypes.Any(f.Filename.EndsWith)))
+            foreach (TFileModel file in item.Files.Where(f => HashableFileTypes.Any(ext => f.Filename.EndsWith(ext, StringComparison.OrdinalIgnoreCase))).OrderBy(f => f.Filename))
             {
                 using (Stream s = Files.Store.GetStream(file.FileInfo.StoragePath))
                     s.CopyTo(hashable);
@@ -275,63 +339,92 @@ namespace osu.Game.Database
             if (hashable.Length > 0)
                 return hashable.ComputeSHA2Hash();
 
-            if (reader != null)
-                return reader.Name.ComputeSHA2Hash();
-
             return item.Hash;
         }
 
         /// <summary>
-        /// Import an item from a <typeparamref name="TModel"/>.
+        /// Silently import an item from a <typeparamref name="TModel"/>.
         /// </summary>
         /// <param name="item">The model to be imported.</param>
         /// <param name="archive">An optional archive to use for model population.</param>
+        /// <param name="lowPriority">Whether this is a low priority import.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
-        public async Task<TModel> Import(TModel item, ArchiveReader archive = null, CancellationToken cancellationToken = default) => await Task.Factory.StartNew(async () =>
+        public virtual async Task<TModel> Import(TModel item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default) => await Task.Factory.StartNew(async () =>
         {
             cancellationToken.ThrowIfCancellationRequested();
 
             delayEvents();
 
+            bool checkedExisting = false;
+            TModel existing = null;
+
+            if (archive != null && !HasCustomHashFunction)
+            {
+                // this is a fast bail condition to improve large import performance.
+                item.Hash = computeHashFast(archive);
+
+                checkedExisting = true;
+                existing = CheckForExisting(item);
+
+                if (existing != null)
+                {
+                    // bare minimum comparisons
+                    //
+                    // note that this should really be checking filesizes on disk (of existing files) for some degree of sanity.
+                    // or alternatively doing a faster hash check. either of these require database changes and reprocessing of existing files.
+                    if (CanSkipImport(existing, item) &&
+                        getFilenames(existing.Files).SequenceEqual(getShortenedFilenames(archive).Select(p => p.shortened).OrderBy(f => f)))
+                    {
+                        LogForModel(item, @$"Found existing (optimised) {HumanisedModelName} for {item} (ID {existing.ID}) – skipping import.");
+                        Undelete(existing);
+                        return existing;
+                    }
+
+                    LogForModel(item, @"Found existing (optimised) but failed pre-check.");
+                }
+            }
+
             void rollback()
             {
                 if (!Delete(item))
                 {
                     // We may have not yet added the model to the underlying table, but should still clean up files.
-                    LogForModel(item, "Dereferencing files for incomplete import.");
+                    LogForModel(item, @"Dereferencing files for incomplete import.");
                     Files.Dereference(item.Files.Select(f => f.FileInfo).ToArray());
                 }
             }
 
             try
             {
-                LogForModel(item, "Beginning import...");
+                LogForModel(item, @"Beginning import...");
 
                 item.Files = archive != null ? createFileInfos(archive, Files) : new List<TFileModel>();
-                item.Hash = computeHash(item, archive);
+                item.Hash = ComputeHash(item, archive);
 
-                await Populate(item, archive, cancellationToken);
+                await Populate(item, archive, cancellationToken).ConfigureAwait(false);
 
                 using (var write = ContextFactory.GetForWrite()) // used to share a context for full import. keep in mind this will block all writes.
                 {
                     try
                     {
-                        if (!write.IsTransactionLeader) throw new InvalidOperationException($"Ensure there is no parent transaction so errors can correctly be handled by {this}");
+                        if (!write.IsTransactionLeader) throw new InvalidOperationException(@$"Ensure there is no parent transaction so errors can correctly be handled by {this}");
 
-                        var existing = CheckForExisting(item);
+                        if (!checkedExisting)
+                            existing = CheckForExisting(item);
 
                         if (existing != null)
                         {
-                            if (CanUndelete(existing, item))
+                            if (CanReuseExisting(existing, item))
                             {
                                 Undelete(existing);
-                                LogForModel(item, $"Found existing {HumanisedModelName} for {item} (ID {existing.ID}) – skipping import.");
+                                LogForModel(item, @$"Found existing {HumanisedModelName} for {item} (ID {existing.ID}) – skipping import.");
                                 // existing item will be used; rollback new import and exit early.
                                 rollback();
                                 flushEvents(true);
                                 return existing;
                             }
 
+                            LogForModel(item, @"Found existing but failed re-use check.");
                             Delete(existing);
                             ModelStore.PurgeDeletable(s => s.ID == existing.ID);
                         }
@@ -348,12 +441,12 @@ namespace osu.Game.Database
                     }
                 }
 
-                LogForModel(item, "Import successfully completed!");
+                LogForModel(item, @"Import successfully completed!");
             }
             catch (Exception e)
             {
                 if (!(e is TaskCanceledException))
-                    LogForModel(item, "Database import or population failed and has been rolled back.", e);
+                    LogForModel(item, @"Database import or population failed and has been rolled back.", e);
 
                 rollback();
                 flushEvents(false);
@@ -362,23 +455,93 @@ namespace osu.Game.Database
 
             flushEvents(true);
             return item;
-        }, cancellationToken, TaskCreationOptions.HideScheduler, import_scheduler).Unwrap();
+        }, cancellationToken, TaskCreationOptions.HideScheduler, lowPriority ? import_scheduler_low_priority : import_scheduler).Unwrap().ConfigureAwait(false);
 
-        public void UpdateFile(TModel model, TFileModel file, Stream contents)
+        /// <summary>
+        /// Exports an item to a legacy (.zip based) package.
+        /// </summary>
+        /// <param name="item">The item to export.</param>
+        public void Export(TModel item)
+        {
+            var retrievedItem = ModelStore.ConsumableItems.FirstOrDefault(s => s.ID == item.ID);
+
+            if (retrievedItem == null)
+                throw new ArgumentException(@"Specified model could not be found", nameof(item));
+
+            using (var outputStream = exportStorage.GetStream($"{getValidFilename(item.ToString())}{HandledExtensions.First()}", FileAccess.Write, FileMode.Create))
+                ExportModelTo(retrievedItem, outputStream);
+
+            exportStorage.OpenInNativeExplorer();
+        }
+
+        /// <summary>
+        /// Exports an item to the given output stream.
+        /// </summary>
+        /// <param name="model">The item to export.</param>
+        /// <param name="outputStream">The output stream to export to.</param>
+        protected virtual void ExportModelTo(TModel model, Stream outputStream)
+        {
+            using (var archive = ZipArchive.Create())
+            {
+                foreach (var file in model.Files)
+                    archive.AddEntry(file.Filename, Files.Storage.GetStream(file.FileInfo.StoragePath));
+
+                archive.SaveTo(outputStream);
+            }
+        }
+
+        /// <summary>
+        /// Replace an existing file with a new version.
+        /// </summary>
+        /// <param name="model">The item to operate on.</param>
+        /// <param name="file">The existing file to be replaced.</param>
+        /// <param name="contents">The new file contents.</param>
+        /// <param name="filename">An optional filename for the new file. Will use the previous filename if not specified.</param>
+        public void ReplaceFile(TModel model, TFileModel file, Stream contents, string filename = null)
+        {
+            using (ContextFactory.GetForWrite())
+            {
+                DeleteFile(model, file);
+                AddFile(model, contents, filename ?? file.Filename);
+            }
+        }
+
+        /// <summary>
+        /// Delete an existing file.
+        /// </summary>
+        /// <param name="model">The item to operate on.</param>
+        /// <param name="file">The existing file to be deleted.</param>
+        public void DeleteFile(TModel model, TFileModel file)
         {
             using (var usage = ContextFactory.GetForWrite())
             {
                 // Dereference the existing file info, since the file model will be removed.
-                Files.Dereference(file.FileInfo);
+                if (file.FileInfo != null)
+                {
+                    Files.Dereference(file.FileInfo);
 
-                // Remove the file model.
-                usage.Context.Set<TFileModel>().Remove(file);
+                    // This shouldn't be required, but here for safety in case the provided TModel is not being change tracked
+                    // Definitely can be removed once we rework the database backend.
+                    usage.Context.Set<TFileModel>().Remove(file);
+                }
 
-                // Add the new file info and containing file model.
                 model.Files.Remove(file);
+            }
+        }
+
+        /// <summary>
+        /// Add a new file.
+        /// </summary>
+        /// <param name="model">The item to operate on.</param>
+        /// <param name="contents">The new file contents.</param>
+        /// <param name="filename">The filename for the new file.</param>
+        public void AddFile(TModel model, Stream contents, string filename)
+        {
+            using (ContextFactory.GetForWrite())
+            {
                 model.Files.Add(new TFileModel
                 {
-                    Filename = file.Filename,
+                    Filename = filename,
                     FileInfo = Files.Add(contents)
                 });
 
@@ -395,8 +558,7 @@ namespace osu.Game.Database
         {
             using (ContextFactory.GetForWrite())
             {
-                item.Hash = computeHash(item);
-
+                item.Hash = ComputeHash(item);
                 ModelStore.Update(item);
             }
         }
@@ -513,25 +675,37 @@ namespace osu.Game.Database
             }
         }
 
+        private string computeHashFast(ArchiveReader reader)
+        {
+            MemoryStream hashable = new MemoryStream();
+
+            foreach (var file in reader.Filenames.Where(f => HashableFileTypes.Any(ext => f.EndsWith(ext, StringComparison.OrdinalIgnoreCase))).OrderBy(f => f))
+            {
+                using (Stream s = reader.GetStream(file))
+                    s.CopyTo(hashable);
+            }
+
+            if (hashable.Length > 0)
+                return hashable.ComputeSHA2Hash();
+
+            return reader.Name.ComputeSHA2Hash();
+        }
+
         /// <summary>
-        /// Create all required <see cref="FileInfo"/>s for the provided archive, adding them to the global file store.
+        /// Create all required <see cref="IO.FileInfo"/>s for the provided archive, adding them to the global file store.
         /// </summary>
         private List<TFileModel> createFileInfos(ArchiveReader reader, FileStore files)
         {
             var fileInfos = new List<TFileModel>();
 
-            string prefix = reader.Filenames.GetCommonPrefix();
-            if (!(prefix.EndsWith("/") || prefix.EndsWith("\\")))
-                prefix = string.Empty;
-
             // import files to manager
-            foreach (string file in reader.Filenames)
+            foreach (var filenames in getShortenedFilenames(reader))
             {
-                using (Stream s = reader.GetStream(file))
+                using (Stream s = reader.GetStream(filenames.original))
                 {
                     fileInfos.Add(new TFileModel
                     {
-                        Filename = file.Substring(prefix.Length).ToStandardisedPath(),
+                        Filename = filenames.shortened,
                         FileInfo = files.Add(s)
                     });
                 }
@@ -540,27 +714,29 @@ namespace osu.Game.Database
             return fileInfos;
         }
 
+        private IEnumerable<(string original, string shortened)> getShortenedFilenames(ArchiveReader reader)
+        {
+            string prefix = reader.Filenames.GetCommonPrefix();
+            if (!(prefix.EndsWith('/') || prefix.EndsWith('\\')))
+                prefix = string.Empty;
+
+            // import files to manager
+            foreach (string file in reader.Filenames)
+                yield return (file, file.Substring(prefix.Length).ToStandardisedPath());
+        }
+
         #region osu-stable import
 
-        /// <summary>
-        /// Set a storage with access to an osu-stable install for import purposes.
-        /// </summary>
-        public Func<Storage> GetStableStorage { private get; set; }
-
-        /// <summary>
-        /// Denotes whether an osu-stable installation is present to perform automated imports from.
-        /// </summary>
-        public bool StableInstallationAvailable => GetStableStorage?.Invoke() != null;
-
         /// <summary>
         /// The relative path from osu-stable's data directory to import items from.
         /// </summary>
         protected virtual string ImportFromStablePath => null;
 
         /// <summary>
-        /// Select paths to import from stable. Default implementation iterates all directories in <see cref="ImportFromStablePath"/>.
+        /// Select paths to import from stable where all paths should be absolute. Default implementation iterates all directories in <see cref="ImportFromStablePath"/>.
         /// </summary>
-        protected virtual IEnumerable<string> GetStableImportPaths(Storage stableStoage) => stableStoage.GetDirectories(ImportFromStablePath);
+        protected virtual IEnumerable<string> GetStableImportPaths(Storage storage) => storage.GetDirectories(ImportFromStablePath)
+                                                                                              .Select(path => storage.GetFullPath(path));
 
         /// <summary>
         /// Whether this specified path should be removed after successful import.
@@ -572,26 +748,29 @@ namespace osu.Game.Database
         /// <summary>
         /// This is a temporary method and will likely be replaced by a full-fledged (and more correctly placed) migration process in the future.
         /// </summary>
-        public Task ImportFromStableAsync()
+        public Task ImportFromStableAsync(StableStorage stableStorage)
         {
-            var stable = GetStableStorage?.Invoke();
+            var storage = PrepareStableStorage(stableStorage);
 
-            if (stable == null)
+            // Handle situations like when the user does not have a Skins folder.
+            if (!storage.ExistsDirectory(ImportFromStablePath))
             {
-                Logger.Log("No osu!stable installation available!", LoggingTarget.Information, LogLevel.Error);
+                string fullPath = storage.GetFullPath(ImportFromStablePath);
+
+                Logger.Log(@$"Folder ""{fullPath}"" not available in the target osu!stable installation to import {HumanisedModelName}s.", LoggingTarget.Information, LogLevel.Error);
                 return Task.CompletedTask;
             }
 
-            if (!stable.ExistsDirectory(ImportFromStablePath))
-            {
-                // This handles situations like when the user does not have a Skins folder
-                Logger.Log($"No {ImportFromStablePath} folder available in osu!stable installation", LoggingTarget.Information, LogLevel.Error);
-                return Task.CompletedTask;
-            }
-
-            return Task.Run(async () => await Import(GetStableImportPaths(GetStableStorage()).Select(f => stable.GetFullPath(f)).ToArray()));
+            return Task.Run(async () => await Import(GetStableImportPaths(storage).ToArray()).ConfigureAwait(false));
         }
 
+        /// <summary>
+        /// Run any required traversal operations on the stable storage location before performing operations.
+        /// </summary>
+        /// <param name="stableStorage">The stable storage.</param>
+        /// <returns>The usable storage. Return the unchanged <paramref name="stableStorage"/> if no traversal is required.</returns>
+        protected virtual Storage PrepareStableStorage(StableStorage stableStorage) => stableStorage;
+
         #endregion
 
         /// <summary>
@@ -609,7 +788,7 @@ namespace osu.Game.Database
         /// <param name="model">The model to populate.</param>
         /// <param name="archive">The archive to use as a reference for population. May be null.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
-        protected virtual Task Populate(TModel model, [CanBeNull] ArchiveReader archive, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        protected abstract Task Populate(TModel model, [CanBeNull] ArchiveReader archive, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Perform any final actions before the import to database executes.
@@ -627,34 +806,42 @@ namespace osu.Game.Database
         protected TModel CheckForExisting(TModel model) => model.Hash == null ? null : ModelStore.ConsumableItems.FirstOrDefault(b => b.Hash == model.Hash);
 
         /// <summary>
-        /// After an existing <typeparamref name="TModel"/> is found during an import process, the default behaviour is to restore the existing
+        /// Whether inport can be skipped after finding an existing import early in the process.
+        /// Only valid when <see cref="ComputeHash"/> is not overridden.
+        /// </summary>
+        /// <param name="existing">The existing model.</param>
+        /// <param name="import">The newly imported model.</param>
+        /// <returns>Whether to skip this import completely.</returns>
+        protected virtual bool CanSkipImport(TModel existing, TModel import) => true;
+
+        /// <summary>
+        /// After an existing <typeparamref name="TModel"/> is found during an import process, the default behaviour is to use/restore the existing
         /// item and skip the import. This method allows changing that behaviour.
         /// </summary>
         /// <param name="existing">The existing model.</param>
         /// <param name="import">The newly imported model.</param>
         /// <returns>Whether the existing model should be restored and used. Returning false will delete the existing and force a re-import.</returns>
-        protected virtual bool CanUndelete(TModel existing, TModel import) => true;
+        protected virtual bool CanReuseExisting(TModel existing, TModel import) =>
+            // for the best or worst, we copy and import files of a new import before checking whether
+            // it is a duplicate. so to check if anything has changed, we can just compare all FileInfo IDs.
+            getIDs(existing.Files).SequenceEqual(getIDs(import.Files)) &&
+            getFilenames(existing.Files).SequenceEqual(getFilenames(import.Files));
+
+        private IEnumerable<long> getIDs(List<TFileModel> files)
+        {
+            foreach (var f in files.OrderBy(f => f.Filename))
+                yield return f.FileInfo.ID;
+        }
+
+        private IEnumerable<string> getFilenames(List<TFileModel> files)
+        {
+            foreach (var f in files.OrderBy(f => f.Filename))
+                yield return f.Filename;
+        }
 
         private DbSet<TModel> queryModel() => ContextFactory.Get().Set<TModel>();
 
-        protected virtual string HumanisedModelName => $"{typeof(TModel).Name.Replace("Info", "").ToLower()}";
-
-        /// <summary>
-        /// Creates an <see cref="ArchiveReader"/> from a valid storage path.
-        /// </summary>
-        /// <param name="path">A file or folder path resolving the archive content.</param>
-        /// <returns>A reader giving access to the archive's content.</returns>
-        private ArchiveReader getReaderFrom(string path)
-        {
-            if (ZipUtils.IsZipArchive(path))
-                return new ZipArchiveReader(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read), Path.GetFileName(path));
-            if (Directory.Exists(path))
-                return new LegacyDirectoryArchiveReader(path);
-            if (File.Exists(path))
-                return new LegacyFileArchiveReader(path);
-
-            throw new InvalidFormatException($"{path} is not a valid archive");
-        }
+        protected virtual string HumanisedModelName => $"{typeof(TModel).Name.Replace(@"Info", "").ToLower()}";
 
         #region Event handling / delaying
 
@@ -705,5 +892,12 @@ namespace osu.Game.Database
         }
 
         #endregion
+
+        private string getValidFilename(string filename)
+        {
+            foreach (char c in Path.GetInvalidFileNameChars())
+                filename = filename.Replace(c, '_');
+            return filename;
+        }
     }
 }

osu.Game/Database/DatabaseContextFactory.cs

@@ -160,5 +160,13 @@ namespace osu.Game.Database
                 }
             }
         }
+
+        public void FlushConnections()
+        {
+            foreach (var context in threadContexts.Values)
+                context.Dispose();
+
+            recycleThreadContexts();
+        }
     }
 }

osu.Game/Database/DatabaseWriteUsage.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Database
         /// Whether this write usage will commit a transaction on completion.
         /// If false, there is a parent usage responsible for transaction commit.
         /// </summary>
-        public bool IsTransactionLeader = false;
+        public bool IsTransactionLeader;
 
         protected void Dispose(bool disposing)
         {
@@ -54,10 +54,5 @@ namespace osu.Game.Database
             Dispose(true);
             GC.SuppressFinalize(this);
         }
-
-        ~DatabaseWriteUsage()
-        {
-            Dispose(false);
-        }
     }
 }

osu.Game/Database/DownloadableArchiveModelManager.cs

@@ -10,6 +10,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using osu.Framework.Bindables;
 
 namespace osu.Game.Database
 {
@@ -23,9 +24,13 @@ namespace osu.Game.Database
         where TModel : class, IHasFiles<TFileModel>, IHasPrimaryKey, ISoftDelete, IEquatable<TModel>
         where TFileModel : class, INamedFileInfo, new()
     {
-        public event Action<ArchiveDownloadRequest<TModel>> DownloadBegan;
+        public IBindable<WeakReference<ArchiveDownloadRequest<TModel>>> DownloadBegan => downloadBegan;
 
-        public event Action<ArchiveDownloadRequest<TModel>> DownloadFailed;
+        private readonly Bindable<WeakReference<ArchiveDownloadRequest<TModel>>> downloadBegan = new Bindable<WeakReference<ArchiveDownloadRequest<TModel>>>();
+
+        public IBindable<WeakReference<ArchiveDownloadRequest<TModel>>> DownloadFailed => downloadFailed;
+
+        private readonly Bindable<WeakReference<ArchiveDownloadRequest<TModel>>> downloadFailed = new Bindable<WeakReference<ArchiveDownloadRequest<TModel>>>();
 
         private readonly IAPIProvider api;
 
@@ -77,11 +82,11 @@ namespace osu.Game.Database
                 Task.Factory.StartNew(async () =>
                 {
                     // This gets scheduled back to the update thread, but we want the import to run in the background.
-                    var imported = await Import(notification, filename);
+                    var imported = await Import(notification, new ImportTask(filename)).ConfigureAwait(false);
 
                     // for now a failed import will be marked as a failed download for simplicity.
                     if (!imported.Any())
-                        DownloadFailed?.Invoke(request);
+                        downloadFailed.Value = new WeakReference<ArchiveDownloadRequest<TModel>>(request);
 
                     currentDownloads.Remove(request);
                 }, TaskCreationOptions.LongRunning);
@@ -100,14 +105,14 @@ namespace osu.Game.Database
 
             api.PerformAsync(request);
 
-            DownloadBegan?.Invoke(request);
+            downloadBegan.Value = new WeakReference<ArchiveDownloadRequest<TModel>>(request);
             return true;
 
             void triggerFailure(Exception error)
             {
                 currentDownloads.Remove(request);
 
-                DownloadFailed?.Invoke(request);
+                downloadFailed.Value = new WeakReference<ArchiveDownloadRequest<TModel>>(request);
 
                 notification.State = ProgressNotificationState.Cancelled;
 

osu.Game/Database/ICanAcceptFiles.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace osu.Game.Database
@@ -16,9 +17,15 @@ namespace osu.Game.Database
         /// <param name="paths">The files which should be imported.</param>
         Task Import(params string[] paths);
 
+        /// <summary>
+        /// Import the specified files from the given import tasks.
+        /// </summary>
+        /// <param name="tasks">The import tasks from which the files should be imported.</param>
+        Task Import(params ImportTask[] tasks);
+
         /// <summary>
         /// An array of accepted file extensions (in the standard format of ".abc").
         /// </summary>
-        string[] HandledExtensions { get; }
+        IEnumerable<string> HandledExtensions { get; }
     }
 }

osu.Game/Database/IHasGuidPrimaryKey.cs

@@ -0,0 +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 System;
+using Newtonsoft.Json;
+using Realms;
+
+namespace osu.Game.Database
+{
+    public interface IHasGuidPrimaryKey
+    {
+        [JsonIgnore]
+        [PrimaryKey]
+        Guid ID { get; set; }
+    }
+}

osu.Game/Database/IModelDownloader.cs

@@ -1,8 +1,9 @@
 // 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.Online.API;
 using System;
+using osu.Game.Online.API;
+using osu.Framework.Bindables;
 
 namespace osu.Game.Database
 {
@@ -15,13 +16,15 @@ namespace osu.Game.Database
     {
         /// <summary>
         /// Fired when a <typeparamref name="TModel"/> download begins.
+        /// This is NOT run on the update thread and should be scheduled.
         /// </summary>
-        event Action<ArchiveDownloadRequest<TModel>> DownloadBegan;
+        IBindable<WeakReference<ArchiveDownloadRequest<TModel>>> DownloadBegan { get; }
 
         /// <summary>
         /// Fired when a <typeparamref name="TModel"/> download is interrupted, either due to user cancellation or failure.
+        /// This is NOT run on the update thread and should be scheduled.
         /// </summary>
-        event Action<ArchiveDownloadRequest<TModel>> DownloadFailed;
+        IBindable<WeakReference<ArchiveDownloadRequest<TModel>>> DownloadFailed { get; }
 
         /// <summary>
         /// Checks whether a given <typeparamref name="TModel"/> is already available in the local store.

osu.Game/Database/IModelManager.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Bindables;
 
 namespace osu.Game.Database
 {
@@ -9,11 +10,11 @@ namespace osu.Game.Database
     /// Represents a model manager that publishes events when <typeparamref name="TModel"/>s are added or removed.
     /// </summary>
     /// <typeparam name="TModel">The model type.</typeparam>
-    public interface IModelManager<out TModel>
+    public interface IModelManager<TModel>
         where TModel : class
     {
-        event Action<TModel> ItemAdded;
+        IBindable<WeakReference<TModel>> ItemUpdated { get; }
 
-        event Action<TModel> ItemRemoved;
+        IBindable<WeakReference<TModel>> ItemRemoved { get; }
     }
 }

osu.Game/Database/IRealmFactory.cs

@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using Realms;
+
+namespace osu.Game.Database
+{
+    public interface IRealmFactory
+    {
+        /// <summary>
+        /// The main realm context, bound to the update thread.
+        /// </summary>
+        Realm Context { get; }
+
+        /// <summary>
+        /// Get a fresh context for read usage.
+        /// </summary>
+        RealmContextFactory.RealmUsage GetForRead();
+
+        /// <summary>
+        /// Request a context for write usage.
+        /// This method may block if a write is already active on a different thread.
+        /// </summary>
+        /// <returns>A usage containing a usable context.</returns>
+        RealmContextFactory.RealmWriteUsage GetForWrite();
+    }
+}

osu.Game/Database/ImportTask.cs

@@ -0,0 +1,75 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System.IO;
+using osu.Game.IO.Archives;
+using osu.Game.Utils;
+using SharpCompress.Common;
+
+namespace osu.Game.Database
+{
+    /// <summary>
+    /// An encapsulated import task to be imported to an <see cref="ArchiveModelManager{TModel,TFileModel}"/>.
+    /// </summary>
+    public class ImportTask
+    {
+        /// <summary>
+        /// The path to the file (or filename in the case a stream is provided).
+        /// </summary>
+        public string Path { get; }
+
+        /// <summary>
+        /// An optional stream which provides the file content.
+        /// </summary>
+        public Stream? Stream { get; }
+
+        /// <summary>
+        /// Construct a new import task from a path (on a local filesystem).
+        /// </summary>
+        public ImportTask(string path)
+        {
+            Path = path;
+        }
+
+        /// <summary>
+        /// Construct a new import task from a stream.
+        /// </summary>
+        public ImportTask(Stream stream, string filename)
+        {
+            Path = filename;
+            Stream = stream;
+        }
+
+        /// <summary>
+        /// Retrieve an archive reader from this task.
+        /// </summary>
+        public ArchiveReader GetReader()
+        {
+            if (Stream != null)
+                return new ZipArchiveReader(Stream, Path);
+
+            return getReaderFrom(Path);
+        }
+
+        /// <summary>
+        /// Creates an <see cref="ArchiveReader"/> from a valid storage path.
+        /// </summary>
+        /// <param name="path">A file or folder path resolving the archive content.</param>
+        /// <returns>A reader giving access to the archive's content.</returns>
+        private ArchiveReader getReaderFrom(string path)
+        {
+            if (ZipUtils.IsZipArchive(path))
+                return new ZipArchiveReader(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read), System.IO.Path.GetFileName(path));
+            if (Directory.Exists(path))
+                return new LegacyDirectoryArchiveReader(path);
+            if (File.Exists(path))
+                return new LegacyFileArchiveReader(path);
+
+            throw new InvalidFormatException($"{path} is not a valid archive");
+        }
+
+        public override string ToString() => System.IO.Path.GetFileName(Path);
+    }
+}

osu.Game/Database/MemoryCachingComponent.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 System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Database
+{
+    /// <summary>
+    /// A component which performs lookups (or calculations) and caches the results.
+    /// Currently not persisted between game sessions.
+    /// </summary>
+    public abstract class MemoryCachingComponent<TLookup, TValue> : Component
+    {
+        private readonly ConcurrentDictionary<TLookup, TValue> cache = new ConcurrentDictionary<TLookup, TValue>();
+
+        protected virtual bool CacheNullValues => true;
+
+        /// <summary>
+        /// Retrieve the cached value for the given lookup.
+        /// </summary>
+        /// <param name="lookup">The lookup to retrieve.</param>
+        /// <param name="token">An optional <see cref="CancellationToken"/> to cancel the operation.</param>
+        protected async Task<TValue> GetAsync([NotNull] TLookup lookup, CancellationToken token = default)
+        {
+            if (CheckExists(lookup, out TValue performance))
+                return performance;
+
+            var computed = await ComputeValueAsync(lookup, token).ConfigureAwait(false);
+
+            if (computed != null || CacheNullValues)
+                cache[lookup] = computed;
+
+            return computed;
+        }
+
+        protected bool CheckExists([NotNull] TLookup lookup, out TValue value) =>
+            cache.TryGetValue(lookup, out value);
+
+        /// <summary>
+        /// Called on cache miss to compute the value for the specified lookup.
+        /// </summary>
+        /// <param name="lookup">The lookup to retrieve.</param>
+        /// <param name="token">An optional <see cref="CancellationToken"/> to cancel the operation.</param>
+        /// <returns>The computed value.</returns>
+        protected abstract Task<TValue> ComputeValueAsync(TLookup lookup, CancellationToken token = default);
+    }
+}

osu.Game/Database/MutableDatabaseBackedStore.cs

@@ -16,7 +16,14 @@ namespace osu.Game.Database
     public abstract class MutableDatabaseBackedStore<T> : DatabaseBackedStore
         where T : class, IHasPrimaryKey, ISoftDelete
     {
-        public event Action<T> ItemAdded;
+        /// <summary>
+        /// Fired when an item was added or updated.
+        /// </summary>
+        public event Action<T> ItemUpdated;
+
+        /// <summary>
+        /// Fired when an item was removed.
+        /// </summary>
         public event Action<T> ItemRemoved;
 
         protected MutableDatabaseBackedStore(IDatabaseContextFactory contextFactory, Storage storage = null)
@@ -41,7 +48,7 @@ namespace osu.Game.Database
                 context.Attach(item);
             }
 
-            ItemAdded?.Invoke(item);
+            ItemUpdated?.Invoke(item);
         }
 
         /// <summary>
@@ -53,8 +60,7 @@ namespace osu.Game.Database
             using (var usage = ContextFactory.GetForWrite())
                 usage.Context.Update(item);
 
-            ItemRemoved?.Invoke(item);
-            ItemAdded?.Invoke(item);
+            ItemUpdated?.Invoke(item);
         }
 
         /// <summary>
@@ -91,7 +97,7 @@ namespace osu.Game.Database
                 item.DeletePending = false;
             }
 
-            ItemAdded?.Invoke(item);
+            ItemUpdated?.Invoke(item);
             return true;
         }
 

osu.Game/Database/OsuDbContext.cs

@@ -24,13 +24,15 @@ namespace osu.Game.Database
         public DbSet<BeatmapDifficulty> BeatmapDifficulty { get; set; }
         public DbSet<BeatmapMetadata> BeatmapMetadata { get; set; }
         public DbSet<BeatmapSetInfo> BeatmapSetInfo { get; set; }
-        public DbSet<DatabasedKeyBinding> DatabasedKeyBinding { get; set; }
         public DbSet<DatabasedSetting> DatabasedSetting { get; set; }
         public DbSet<FileInfo> FileInfo { get; set; }
         public DbSet<RulesetInfo> RulesetInfo { get; set; }
         public DbSet<SkinInfo> SkinInfo { get; set; }
         public DbSet<ScoreInfo> ScoreInfo { get; set; }
 
+        // migrated to realm
+        public DbSet<DatabasedKeyBinding> DatabasedKeyBinding { get; set; }
+
         private readonly string connectionString;
 
         private static readonly Lazy<OsuDbLoggerFactory> logger = new Lazy<OsuDbLoggerFactory>(() => new OsuDbLoggerFactory());
@@ -135,6 +137,8 @@ namespace osu.Game.Database
 
             modelBuilder.Entity<DatabasedKeyBinding>().HasIndex(b => new { b.RulesetID, b.Variant });
             modelBuilder.Entity<DatabasedKeyBinding>().HasIndex(b => b.IntAction);
+            modelBuilder.Entity<DatabasedKeyBinding>().Ignore(b => b.KeyCombination);
+            modelBuilder.Entity<DatabasedKeyBinding>().Ignore(b => b.Action);
 
             modelBuilder.Entity<DatabasedSetting>().HasIndex(b => new { b.RulesetID, b.Variant });
 

osu.Game/Database/RealmContextFactory.cs

@@ -0,0 +1,244 @@
+// 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.Threading;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Statistics;
+using osu.Game.Input.Bindings;
+using Realms;
+
+namespace osu.Game.Database
+{
+    public class RealmContextFactory : Component, IRealmFactory
+    {
+        private readonly Storage storage;
+
+        private const string database_name = @"client";
+
+        private const int schema_version = 6;
+
+        /// <summary>
+        /// Lock object which is held for the duration of a write operation (via <see cref="GetForWrite"/>).
+        /// </summary>
+        private readonly object writeLock = new object();
+
+        /// <summary>
+        /// Lock object which is held during <see cref="BlockAllOperations"/> sections.
+        /// </summary>
+        private readonly SemaphoreSlim blockingLock = new SemaphoreSlim(1);
+
+        private static readonly GlobalStatistic<int> reads = GlobalStatistics.Get<int>("Realm", "Get (Read)");
+        private static readonly GlobalStatistic<int> writes = GlobalStatistics.Get<int>("Realm", "Get (Write)");
+        private static readonly GlobalStatistic<int> refreshes = GlobalStatistics.Get<int>("Realm", "Dirty Refreshes");
+        private static readonly GlobalStatistic<int> contexts_created = GlobalStatistics.Get<int>("Realm", "Contexts (Created)");
+        private static readonly GlobalStatistic<int> pending_writes = GlobalStatistics.Get<int>("Realm", "Pending writes");
+        private static readonly GlobalStatistic<int> active_usages = GlobalStatistics.Get<int>("Realm", "Active usages");
+
+        private Realm context;
+
+        public Realm Context
+        {
+            get
+            {
+                if (context == null)
+                {
+                    context = createContext();
+                    Logger.Log($"Opened realm \"{context.Config.DatabasePath}\" at version {context.Config.SchemaVersion}");
+                }
+
+                // creating a context will ensure our schema is up-to-date and migrated.
+
+                return context;
+            }
+        }
+
+        public RealmContextFactory(Storage storage)
+        {
+            this.storage = storage;
+        }
+
+        public RealmUsage GetForRead()
+        {
+            reads.Value++;
+            return new RealmUsage(createContext());
+        }
+
+        public RealmWriteUsage GetForWrite()
+        {
+            writes.Value++;
+            pending_writes.Value++;
+
+            Monitor.Enter(writeLock);
+            return new RealmWriteUsage(createContext(), writeComplete);
+        }
+
+        /// <summary>
+        /// Flush any active contexts and block any further writes.
+        /// </summary>
+        /// <remarks>
+        /// This should be used in places we need to ensure no ongoing reads/writes are occurring with realm.
+        /// ie. to move the realm backing file to a new location.
+        /// </remarks>
+        /// <returns>An <see cref="IDisposable"/> which should be disposed to end the blocking section.</returns>
+        public IDisposable BlockAllOperations()
+        {
+            if (IsDisposed)
+                throw new ObjectDisposedException(nameof(RealmContextFactory));
+
+            Logger.Log(@"Blocking realm operations.", LoggingTarget.Database);
+
+            blockingLock.Wait();
+            flushContexts();
+
+            return new InvokeOnDisposal<RealmContextFactory>(this, endBlockingSection);
+
+            static void endBlockingSection(RealmContextFactory factory)
+            {
+                factory.blockingLock.Release();
+                Logger.Log(@"Restoring realm operations.", LoggingTarget.Database);
+            }
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (context?.Refresh() == true)
+                refreshes.Value++;
+        }
+
+        private Realm createContext()
+        {
+            try
+            {
+                if (IsDisposed)
+                    throw new ObjectDisposedException(nameof(RealmContextFactory));
+
+                blockingLock.Wait();
+
+                contexts_created.Value++;
+
+                return Realm.GetInstance(new RealmConfiguration(storage.GetFullPath($"{database_name}.realm", true))
+                {
+                    SchemaVersion = schema_version,
+                    MigrationCallback = onMigration,
+                });
+            }
+            finally
+            {
+                blockingLock.Release();
+            }
+        }
+
+        private void writeComplete()
+        {
+            Monitor.Exit(writeLock);
+            pending_writes.Value--;
+        }
+
+        private void onMigration(Migration migration, ulong lastSchemaVersion)
+        {
+            switch (lastSchemaVersion)
+            {
+                case 5:
+                    // let's keep things simple. changing the type of the primary key is a bit involved.
+                    migration.NewRealm.RemoveAll<RealmKeyBinding>();
+                    break;
+            }
+        }
+
+        private void flushContexts()
+        {
+            Logger.Log(@"Flushing realm contexts...", LoggingTarget.Database);
+
+            var previousContext = context;
+            context = null;
+
+            // wait for all threaded usages to finish
+            while (active_usages.Value > 0)
+                Thread.Sleep(50);
+
+            previousContext?.Dispose();
+
+            Logger.Log(@"Realm contexts flushed.", LoggingTarget.Database);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (!IsDisposed)
+            {
+                // intentionally block all operations indefinitely. this ensures that nothing can start consuming a new context after disposal.
+                BlockAllOperations();
+                blockingLock?.Dispose();
+            }
+
+            base.Dispose(isDisposing);
+        }
+
+        /// <summary>
+        /// A usage of realm from an arbitrary thread.
+        /// </summary>
+        public class RealmUsage : IDisposable
+        {
+            public readonly Realm Realm;
+
+            internal RealmUsage(Realm context)
+            {
+                active_usages.Value++;
+                Realm = context;
+            }
+
+            /// <summary>
+            /// Disposes this instance, calling the initially captured action.
+            /// </summary>
+            public virtual void Dispose()
+            {
+                Realm?.Dispose();
+                active_usages.Value--;
+            }
+        }
+
+        /// <summary>
+        /// A transaction used for making changes to realm data.
+        /// </summary>
+        public class RealmWriteUsage : RealmUsage
+        {
+            private readonly Action onWriteComplete;
+            private readonly Transaction transaction;
+
+            internal RealmWriteUsage(Realm context, Action onWriteComplete)
+                : base(context)
+            {
+                this.onWriteComplete = onWriteComplete;
+                transaction = Realm.BeginWrite();
+            }
+
+            /// <summary>
+            /// Commit all changes made in this transaction.
+            /// </summary>
+            public void Commit() => transaction.Commit();
+
+            /// <summary>
+            /// Revert all changes made in this transaction.
+            /// </summary>
+            public void Rollback() => transaction.Rollback();
+
+            /// <summary>
+            /// Disposes this instance, calling the initially captured action.
+            /// </summary>
+            public override void Dispose()
+            {
+                // rollback if not explicitly committed.
+                transaction?.Dispose();
+
+                base.Dispose();
+
+                onWriteComplete();
+            }
+        }
+    }
+}

osu.Game/Database/RealmExtensions.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 System.Collections.Generic;
+using AutoMapper;
+using osu.Game.Input.Bindings;
+using Realms;
+
+namespace osu.Game.Database
+{
+    public static class RealmExtensions
+    {
+        private static readonly IMapper mapper = new MapperConfiguration(c =>
+        {
+            c.ShouldMapField = fi => false;
+            c.ShouldMapProperty = pi => pi.SetMethod != null && pi.SetMethod.IsPublic;
+
+            c.CreateMap<RealmKeyBinding, RealmKeyBinding>();
+        }).CreateMapper();
+
+        /// <summary>
+        /// Create a detached copy of the each item in the collection.
+        /// </summary>
+        /// <param name="items">A list of managed <see cref="RealmObject"/>s to detach.</param>
+        /// <typeparam name="T">The type of object.</typeparam>
+        /// <returns>A list containing non-managed copies of provided items.</returns>
+        public static List<T> Detach<T>(this IEnumerable<T> items) where T : RealmObject
+        {
+            var list = new List<T>();
+
+            foreach (var obj in items)
+                list.Add(obj.Detach());
+
+            return list;
+        }
+
+        /// <summary>
+        /// Create a detached copy of the item.
+        /// </summary>
+        /// <param name="item">The managed <see cref="RealmObject"/> to detach.</param>
+        /// <typeparam name="T">The type of object.</typeparam>
+        /// <returns>A non-managed copy of provided item. Will return the provided item if already detached.</returns>
+        public static T Detach<T>(this T item) where T : RealmObject
+        {
+            if (!item.IsManaged)
+                return item;
+
+            return mapper.Map<T>(item);
+        }
+    }
+}

osu.Game/Database/StableImportManager.cs

@@ -0,0 +1,96 @@
+// 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.Threading.Tasks;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.EnumExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Platform;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.IO;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Settings.Sections.Maintenance;
+using osu.Game.Scoring;
+using osu.Game.Skinning;
+
+namespace osu.Game.Database
+{
+    public class StableImportManager : Component
+    {
+        [Resolved]
+        private SkinManager skins { get; set; }
+
+        [Resolved]
+        private BeatmapManager beatmaps { get; set; }
+
+        [Resolved]
+        private ScoreManager scores { get; set; }
+
+        [Resolved]
+        private CollectionManager collections { get; set; }
+
+        [Resolved]
+        private OsuGame game { get; set; }
+
+        [Resolved]
+        private DialogOverlay dialogOverlay { get; set; }
+
+        [Resolved(CanBeNull = true)]
+        private DesktopGameHost desktopGameHost { get; set; }
+
+        private StableStorage cachedStorage;
+
+        public bool SupportsImportFromStable => RuntimeInfo.IsDesktop;
+
+        public async Task ImportFromStableAsync(StableContent content)
+        {
+            var stableStorage = await getStableStorage().ConfigureAwait(false);
+            var importTasks = new List<Task>();
+
+            Task beatmapImportTask = Task.CompletedTask;
+            if (content.HasFlagFast(StableContent.Beatmaps))
+                importTasks.Add(beatmapImportTask = beatmaps.ImportFromStableAsync(stableStorage));
+
+            if (content.HasFlagFast(StableContent.Skins))
+                importTasks.Add(skins.ImportFromStableAsync(stableStorage));
+
+            if (content.HasFlagFast(StableContent.Collections))
+                importTasks.Add(beatmapImportTask.ContinueWith(_ => collections.ImportFromStableAsync(stableStorage), TaskContinuationOptions.OnlyOnRanToCompletion));
+
+            if (content.HasFlagFast(StableContent.Scores))
+                importTasks.Add(beatmapImportTask.ContinueWith(_ => scores.ImportFromStableAsync(stableStorage), TaskContinuationOptions.OnlyOnRanToCompletion));
+
+            await Task.WhenAll(importTasks.ToArray()).ConfigureAwait(false);
+        }
+
+        private async Task<StableStorage> getStableStorage()
+        {
+            if (cachedStorage != null)
+                return cachedStorage;
+
+            var stableStorage = game.GetStorageForStableInstall();
+            if (stableStorage != null)
+                return cachedStorage = stableStorage;
+
+            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+            Schedule(() => dialogOverlay.Push(new StableDirectoryLocationDialog(taskCompletionSource)));
+            var stablePath = await taskCompletionSource.Task.ConfigureAwait(false);
+
+            return cachedStorage = new StableStorage(stablePath, desktopGameHost);
+        }
+    }
+
+    [Flags]
+    public enum StableContent
+    {
+        Beatmaps = 1 << 0,
+        Scores = 1 << 1,
+        Skins = 1 << 2,
+        Collections = 1 << 3,
+        All = Beatmaps | Scores | Skins | Collections
+    }
+}

osu.Game/Database/UserLookupCache.cs

@@ -0,0 +1,120 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Users;
+
+namespace osu.Game.Database
+{
+    public class UserLookupCache : MemoryCachingComponent<int, User>
+    {
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        /// <summary>
+        /// Perform an API lookup on the specified user, populating a <see cref="User"/> model.
+        /// </summary>
+        /// <param name="userId">The user to lookup.</param>
+        /// <param name="token">An optional cancellation token.</param>
+        /// <returns>The populated user, or null if the user does not exist or the request could not be satisfied.</returns>
+        [ItemCanBeNull]
+        public Task<User> GetUserAsync(int userId, CancellationToken token = default) => GetAsync(userId, token);
+
+        protected override async Task<User> ComputeValueAsync(int lookup, CancellationToken token = default)
+            => await queryUser(lookup).ConfigureAwait(false);
+
+        private readonly Queue<(int id, TaskCompletionSource<User>)> pendingUserTasks = new Queue<(int, TaskCompletionSource<User>)>();
+        private Task pendingRequestTask;
+        private readonly object taskAssignmentLock = new object();
+
+        private Task<User> queryUser(int userId)
+        {
+            lock (taskAssignmentLock)
+            {
+                var tcs = new TaskCompletionSource<User>();
+
+                // Add to the queue.
+                pendingUserTasks.Enqueue((userId, tcs));
+
+                // Create a request task if there's not already one.
+                if (pendingRequestTask == null)
+                    createNewTask();
+
+                return tcs.Task;
+            }
+        }
+
+        private void performLookup()
+        {
+            // contains at most 50 unique user IDs from userTasks, which is used to perform the lookup.
+            var userTasks = new Dictionary<int, List<TaskCompletionSource<User>>>();
+
+            // Grab at most 50 unique user IDs from the queue.
+            lock (taskAssignmentLock)
+            {
+                while (pendingUserTasks.Count > 0 && userTasks.Count < 50)
+                {
+                    (int id, TaskCompletionSource<User> task) next = pendingUserTasks.Dequeue();
+
+                    // Perform a secondary check for existence, in case the user was queried in a previous batch.
+                    if (CheckExists(next.id, out var existing))
+                        next.task.SetResult(existing);
+                    else
+                    {
+                        if (userTasks.TryGetValue(next.id, out var tasks))
+                            tasks.Add(next.task);
+                        else
+                            userTasks[next.id] = new List<TaskCompletionSource<User>> { next.task };
+                    }
+                }
+            }
+
+            // Query the users.
+            var request = new GetUsersRequest(userTasks.Keys.ToArray());
+
+            // rather than queueing, we maintain our own single-threaded request stream.
+            // todo: we probably want retry logic here.
+            api.Perform(request);
+
+            // Create a new request task if there's still more users to query.
+            lock (taskAssignmentLock)
+            {
+                pendingRequestTask = null;
+                if (pendingUserTasks.Count > 0)
+                    createNewTask();
+            }
+
+            List<User> foundUsers = request.Result?.Users;
+
+            if (foundUsers != null)
+            {
+                foreach (var user in foundUsers)
+                {
+                    if (userTasks.TryGetValue(user.Id, out var tasks))
+                    {
+                        foreach (var task in tasks)
+                            task.SetResult(user);
+
+                        userTasks.Remove(user.Id);
+                    }
+                }
+            }
+
+            // if any tasks remain which were not satisfied, return null.
+            foreach (var tasks in userTasks.Values)
+            {
+                foreach (var task in tasks)
+                    task.SetResult(null);
+            }
+        }
+
+        private void createNewTask() => pendingRequestTask = Task.Run(performLookup);
+    }
+}

osu.Game/Extensions/DrawableExtensions.cs

@@ -0,0 +1,71 @@
+// 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.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Threading;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Extensions
+{
+    public static class DrawableExtensions
+    {
+        public const double REPEAT_INTERVAL = 70;
+        public const double INITIAL_DELAY = 250;
+
+        /// <summary>
+        /// Helper method that is used while <see cref="IKeyBindingHandler"/> doesn't support repetitions of <see cref="IKeyBindingHandler{T}.OnPressed"/>.
+        /// Simulates repetitions by continually invoking a delegate according to the default key repeat rate.
+        /// </summary>
+        /// <remarks>
+        /// The returned delegate can be cancelled to stop repeat events from firing (usually in <see cref="IKeyBindingHandler{T}.OnReleased"/>).
+        /// </remarks>
+        /// <param name="handler">The <see cref="IKeyBindingHandler{T}"/> which is handling the repeat.</param>
+        /// <param name="scheduler">The <see cref="Scheduler"/> to schedule repetitions on.</param>
+        /// <param name="action">The <see cref="Action"/> to be invoked once immediately and with every repetition.</param>
+        /// <param name="initialRepeatDelay">The delay imposed on the first repeat. Defaults to <see cref="INITIAL_DELAY"/>.</param>
+        /// <returns>A <see cref="ScheduledDelegate"/> which can be cancelled to stop the repeat events from firing.</returns>
+        public static ScheduledDelegate BeginKeyRepeat(this IKeyBindingHandler handler, Scheduler scheduler, Action action, double initialRepeatDelay = INITIAL_DELAY)
+        {
+            action();
+
+            ScheduledDelegate repeatDelegate = new ScheduledDelegate(action, handler.Time.Current + initialRepeatDelay, REPEAT_INTERVAL);
+            scheduler.Add(repeatDelegate);
+            return repeatDelegate;
+        }
+
+        /// <summary>
+        /// Accepts a delta vector in screen-space coordinates and converts it to one which can be applied to this drawable's position.
+        /// </summary>
+        /// <param name="drawable">The drawable.</param>
+        /// <param name="delta">A delta in screen-space coordinates.</param>
+        /// <returns>The delta vector in Parent's coordinates.</returns>
+        public static Vector2 ScreenSpaceDeltaToParentSpace(this Drawable drawable, Vector2 delta) =>
+            drawable.Parent.ToLocalSpace(drawable.Parent.ToScreenSpace(Vector2.Zero) + delta);
+
+        public static SkinnableInfo CreateSkinnableInfo(this Drawable component) => new SkinnableInfo(component);
+
+        public static void ApplySkinnableInfo(this Drawable component, SkinnableInfo info)
+        {
+            // todo: can probably make this better via deserialisation directly using a common interface.
+            component.Position = info.Position;
+            component.Rotation = info.Rotation;
+            component.Scale = info.Scale;
+            component.Anchor = info.Anchor;
+            component.Origin = info.Origin;
+
+            if (component is ISkinnableDrawable skinnable)
+                skinnable.UsesFixedAnchor = info.UsesFixedAnchor;
+
+            if (component is Container container)
+            {
+                foreach (var child in info.Children)
+                    container.Add(child.CreateInstance());
+            }
+        }
+    }
+}

osu.Game/Extensions/EditorDisplayExtensions.cs

@@ -0,0 +1,26 @@
+// 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;
+
+namespace osu.Game.Extensions
+{
+    public static class EditorDisplayExtensions
+    {
+        /// <summary>
+        /// Get an editor formatted string (mm:ss:mss)
+        /// </summary>
+        /// <param name="milliseconds">A time value in milliseconds.</param>
+        /// <returns>An editor formatted display string.</returns>
+        public static string ToEditorFormattedString(this double milliseconds) =>
+            ToEditorFormattedString(TimeSpan.FromMilliseconds(milliseconds));
+
+        /// <summary>
+        /// Get an editor formatted string (mm:ss:mss)
+        /// </summary>
+        /// <param name="timeSpan">A time value.</param>
+        /// <returns>An editor formatted display string.</returns>
+        public static string ToEditorFormattedString(this TimeSpan timeSpan) =>
+            $"{(timeSpan < TimeSpan.Zero ? "-" : string.Empty)}{timeSpan:mm\\:ss\\:fff}";
+    }
+}

osu.Game/Extensions/LanguageExtensions.cs

@@ -0,0 +1,33 @@
+// 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.Globalization;
+using osu.Game.Localisation;
+
+namespace osu.Game.Extensions
+{
+    /// <summary>
+    /// Conversion utilities for the <see cref="Language"/> enum.
+    /// </summary>
+    public static class LanguageExtensions
+    {
+        /// <summary>
+        /// Returns the culture code of the <see cref="CultureInfo"/> that corresponds to the supplied <paramref name="language"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is required as enum member names are not allowed to contain hyphens.
+        /// </remarks>
+        public static string ToCultureCode(this Language language)
+            => language.ToString().Replace("_", "-");
+
+        /// <summary>
+        /// Attempts to parse the supplied <paramref name="cultureCode"/> to a <see cref="Language"/> value.
+        /// </summary>
+        /// <param name="cultureCode">The code of the culture to parse.</param>
+        /// <param name="language">The parsed <see cref="Language"/>. Valid only if the return value of the method is <see langword="true" />.</param>
+        /// <returns>Whether the parsing succeeded.</returns>
+        public static bool TryParseCultureCode(string cultureCode, out Language language)
+            => Enum.TryParse(cultureCode.Replace("-", "_"), out language);
+    }
+}

osu.Game/Extensions/TaskExtensions.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.
+
+#nullable enable
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using osu.Framework.Extensions.ObjectExtensions;
+
+namespace osu.Game.Extensions
+{
+    public static class TaskExtensions
+    {
+        /// <summary>
+        /// Add a continuation to be performed only after the attached task has completed.
+        /// </summary>
+        /// <param name="task">The previous task to be awaited on.</param>
+        /// <param name="action">The action to run.</param>
+        /// <param name="cancellationToken">An optional cancellation token. Will only cancel the provided action, not the sequence.</param>
+        /// <returns>A task representing the provided action.</returns>
+        public static Task ContinueWithSequential(this Task task, Action action, CancellationToken cancellationToken = default) =>
+            task.ContinueWithSequential(() => Task.Run(action, cancellationToken), cancellationToken);
+
+        /// <summary>
+        /// Add a continuation to be performed only after the attached task has completed.
+        /// </summary>
+        /// <param name="task">The previous task to be awaited on.</param>
+        /// <param name="continuationFunction">The continuation to run. Generally should be an async function.</param>
+        /// <param name="cancellationToken">An optional cancellation token. Will only cancel the provided action, not the sequence.</param>
+        /// <returns>A task representing the provided action.</returns>
+        public static Task ContinueWithSequential(this Task task, Func<Task> continuationFunction, CancellationToken cancellationToken = default)
+        {
+            var tcs = new TaskCompletionSource<bool>();
+
+            task.ContinueWith(t =>
+            {
+                // the previous task has finished execution or been cancelled, so we can run the provided continuation.
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    tcs.SetCanceled();
+                }
+                else
+                {
+                    continuationFunction().ContinueWith(continuationTask =>
+                    {
+                        if (cancellationToken.IsCancellationRequested || continuationTask.IsCanceled)
+                        {
+                            tcs.TrySetCanceled();
+                        }
+                        else if (continuationTask.IsFaulted)
+                        {
+                            tcs.TrySetException(continuationTask.Exception.AsNonNull());
+                        }
+                        else
+                        {
+                            tcs.TrySetResult(true);
+                        }
+                    }, cancellationToken: default);
+                }
+            }, cancellationToken: default);
+
+            // importantly, we are not returning the continuation itself but rather a task which represents its status in sequential execution order.
+            // this will not be cancelled or completed until the previous task has also.
+            return tcs.Task;
+        }
+    }
+}

osu.Game/Extensions/TypeExtensions.cs

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+
+namespace osu.Game.Extensions
+{
+    internal static class TypeExtensions
+    {
+        /// <summary>
+        /// Returns <paramref name="type"/>'s <see cref="Type.AssemblyQualifiedName"/>
+        /// with the assembly version, culture and public key token values removed.
+        /// </summary>
+        /// <remarks>
+        /// This method is usually used in extensibility scenarios (i.e. for custom rulesets or skins)
+        /// when a version-agnostic identifier associated with a C# class - potentially originating from
+        /// an external assembly - is needed.
+        /// Leaving only the type and assembly names in such a scenario allows to preserve compatibility
+        /// across assembly versions.
+        /// </remarks>
+        internal static string GetInvariantInstantiationInfo(this Type type)
+        {
+            string assemblyQualifiedName = type.AssemblyQualifiedName;
+            if (assemblyQualifiedName == null)
+                throw new ArgumentException($"{type}'s assembly-qualified name is null. Ensure that it is a concrete type and not a generic type parameter.", nameof(type));
+
+            return string.Join(',', assemblyQualifiedName.Split(',').Take(2));
+        }
+    }
+}

osu.Game/Extensions/WebRequestExtensions.cs

@@ -0,0 +1,23 @@
+// 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.IO.Network;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Online.API.Requests;
+
+namespace osu.Game.Extensions
+{
+    public static class WebRequestExtensions
+    {
+        /// <summary>
+        /// Add a pagination cursor to the web request in the format required by osu-web.
+        /// </summary>
+        public static void AddCursor(this WebRequest webRequest, Cursor cursor)
+        {
+            cursor?.Properties.ForEach(x =>
+            {
+                webRequest.AddParameter("cursor[" + x.Key + "]", x.Value.ToString());
+            });
+        }
+    }
+}

osu.Game/Graphics/Backgrounds/Background.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -14,7 +15,7 @@ namespace osu.Game.Graphics.Backgrounds
     /// <summary>
     /// A background which offers blurring via a <see cref="BufferedContainer"/> on demand.
     /// </summary>
-    public class Background : CompositeDrawable
+    public class Background : CompositeDrawable, IEquatable<Background>
     {
         private const float blur_scale = 0.5f;
 
@@ -71,5 +72,14 @@ namespace osu.Game.Graphics.Backgrounds
 
             bufferedContainer?.BlurTo(newBlurSigma * blur_scale, duration, easing);
         }
+
+        public virtual bool Equals(Background other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            return other.GetType() == GetType()
+                   && other.textureName == textureName;
+        }
     }
 }

osu.Game/Graphics/Backgrounds/BeatmapBackground.cs

@@ -20,9 +20,18 @@ namespace osu.Game.Graphics.Backgrounds
         }
 
         [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
+        private void load(LargeTextureStore textures)
         {
             Sprite.Texture = Beatmap?.Background ?? textures.Get(fallbackTextureName);
         }
+
+        public override bool Equals(Background other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            return other.GetType() == GetType()
+                   && ((BeatmapBackground)other).Beatmap == Beatmap;
+        }
     }
 }

osu.Game/Graphics/Backgrounds/BeatmapBackgroundWithStoryboard.cs

@@ -0,0 +1,37 @@
+// 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.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Storyboards.Drawables;
+
+namespace osu.Game.Graphics.Backgrounds
+{
+    public class BeatmapBackgroundWithStoryboard : BeatmapBackground
+    {
+        public BeatmapBackgroundWithStoryboard(WorkingBeatmap beatmap, string fallbackTextureName = "Backgrounds/bg1")
+            : base(beatmap, fallbackTextureName)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            if (!Beatmap.Storyboard.HasDrawable)
+                return;
+
+            if (Beatmap.Storyboard.ReplacesBackground)
+                Sprite.Alpha = 0;
+
+            LoadComponentAsync(new AudioContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Volume = { Value = 0 },
+                Child = new DrawableStoryboard(Beatmap.Storyboard) { Clock = new InterpolatingFramedClock(Beatmap.Track) }
+            }, AddInternal);
+        }
+    }
+}

osu.Game/Graphics/Backgrounds/SeasonalBackgroundLoader.cs

@@ -0,0 +1,112 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Graphics.Backgrounds
+{
+    public class SeasonalBackgroundLoader : Component
+    {
+        /// <summary>
+        /// Fired when background should be changed due to receiving backgrounds from API
+        /// or when the user setting is changed (as it might require unloading the seasonal background).
+        /// </summary>
+        public event Action SeasonalBackgroundChanged;
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        private readonly IBindable<APIState> apiState = new Bindable<APIState>();
+        private Bindable<SeasonalBackgroundMode> seasonalBackgroundMode;
+        private Bindable<APISeasonalBackgrounds> seasonalBackgrounds;
+
+        private int current;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config, SessionStatics sessionStatics)
+        {
+            seasonalBackgroundMode = config.GetBindable<SeasonalBackgroundMode>(OsuSetting.SeasonalBackgroundMode);
+            seasonalBackgroundMode.BindValueChanged(_ => SeasonalBackgroundChanged?.Invoke());
+
+            seasonalBackgrounds = sessionStatics.GetBindable<APISeasonalBackgrounds>(Static.SeasonalBackgrounds);
+            seasonalBackgrounds.BindValueChanged(_ => SeasonalBackgroundChanged?.Invoke());
+
+            apiState.BindTo(api.State);
+            apiState.BindValueChanged(fetchSeasonalBackgrounds, true);
+        }
+
+        private void fetchSeasonalBackgrounds(ValueChangedEvent<APIState> stateChanged)
+        {
+            if (seasonalBackgrounds.Value != null || stateChanged.NewValue != APIState.Online)
+                return;
+
+            var request = new GetSeasonalBackgroundsRequest();
+            request.Success += response =>
+            {
+                seasonalBackgrounds.Value = response;
+                current = RNG.Next(0, response.Backgrounds?.Count ?? 0);
+            };
+
+            api.PerformAsync(request);
+        }
+
+        public SeasonalBackground LoadNextBackground()
+        {
+            if (seasonalBackgroundMode.Value == SeasonalBackgroundMode.Never
+                || (seasonalBackgroundMode.Value == SeasonalBackgroundMode.Sometimes && !isInSeason))
+            {
+                return null;
+            }
+
+            var backgrounds = seasonalBackgrounds.Value?.Backgrounds;
+            if (backgrounds == null || !backgrounds.Any())
+                return null;
+
+            current = (current + 1) % backgrounds.Count;
+            string url = backgrounds[current].Url;
+
+            return new SeasonalBackground(url);
+        }
+
+        private bool isInSeason => seasonalBackgrounds.Value != null && DateTimeOffset.Now < seasonalBackgrounds.Value.EndDate;
+    }
+
+    [LongRunningLoad]
+    public class SeasonalBackground : Background
+    {
+        private readonly string url;
+        private const string fallback_texture_name = @"Backgrounds/bg1";
+
+        public SeasonalBackground(string url)
+        {
+            this.url = url;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(LargeTextureStore textures)
+        {
+            Sprite.Texture = textures.Get(url) ?? textures.Get(fallback_texture_name);
+            // ensure we're not loading in without a transition.
+            this.FadeInFromZero(200, Easing.InOutSine);
+        }
+
+        public override bool Equals(Background other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            return other.GetType() == GetType()
+                   && ((SeasonalBackground)other).url == url;
+        }
+    }
+}

osu.Game/Graphics/Backgrounds/SkinBackground.cs

@@ -0,0 +1,34 @@
+// 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.Allocation;
+using osu.Game.Skinning;
+
+namespace osu.Game.Graphics.Backgrounds
+{
+    internal class SkinBackground : Background
+    {
+        private readonly Skin skin;
+
+        public SkinBackground(Skin skin, string fallbackTextureName)
+            : base(fallbackTextureName)
+        {
+            this.skin = skin;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Sprite.Texture = skin.GetTexture("menu-background") ?? Sprite.Texture;
+        }
+
+        public override bool Equals(Background other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            return other.GetType() == GetType()
+                   && ((SkinBackground)other).skin.SkinInfo.Equals(skin.SkinInfo);
+        }
+    }
+}

osu.Game/Graphics/Backgrounds/Triangles.cs

@@ -57,11 +57,6 @@ namespace osu.Game.Graphics.Backgrounds
             }
         }
 
-        /// <summary>
-        /// Whether we want to expire triangles as they exit our draw area completely.
-        /// </summary>
-        protected virtual bool ExpireOffScreenTriangles => true;
-
         /// <summary>
         /// Whether we should create new triangles as others expire.
         /// </summary>
@@ -88,11 +83,19 @@ namespace osu.Game.Graphics.Backgrounds
 
         private readonly SortedList<TriangleParticle> parts = new SortedList<TriangleParticle>(Comparer<TriangleParticle>.Default);
 
+        private Random stableRandom;
         private IShader shader;
         private readonly Texture texture;
 
-        public Triangles()
+        /// <summary>
+        /// Construct a new triangle visualisation.
+        /// </summary>
+        /// <param name="seed">An optional seed to stabilise random positions / attributes. Note that this does not guarantee stable playback when seeking in time.</param>
+        public Triangles(int? seed = null)
         {
+            if (seed != null)
+                stableRandom = new Random(seed.Value);
+
             texture = Texture.WhitePixel;
         }
 
@@ -129,7 +132,7 @@ namespace osu.Game.Graphics.Backgrounds
         {
             base.Update();
 
-            Invalidate(Invalidation.DrawNode, shallPropagate: false);
+            Invalidate(Invalidation.DrawNode);
 
             if (CreateNewTriangles)
                 addTriangles(false);
@@ -161,7 +164,20 @@ namespace osu.Game.Graphics.Backgrounds
             }
         }
 
-        protected int AimCount;
+        /// <summary>
+        /// Clears and re-initialises triangles according to a given seed.
+        /// </summary>
+        /// <param name="seed">An optional seed to stabilise random positions / attributes. Note that this does not guarantee stable playback when seeking in time.</param>
+        public void Reset(int? seed = null)
+        {
+            if (seed != null)
+                stableRandom = new Random(seed.Value);
+
+            parts.Clear();
+            addTriangles(true);
+        }
+
+        protected int AimCount { get; private set; }
 
         private void addTriangles(bool randomY)
         {
@@ -175,8 +191,8 @@ namespace osu.Game.Graphics.Backgrounds
         {
             TriangleParticle particle = CreateTriangle();
 
-            particle.Position = new Vector2(RNG.NextSingle(), randomY ? RNG.NextSingle() : 1);
-            particle.ColourShade = RNG.NextSingle();
+            particle.Position = new Vector2(nextRandom(), randomY ? nextRandom() : 1);
+            particle.ColourShade = nextRandom();
             particle.Colour = CreateTriangleShade(particle.ColourShade);
 
             return particle;
@@ -191,10 +207,10 @@ namespace osu.Game.Graphics.Backgrounds
             const float std_dev = 0.16f;
             const float mean = 0.5f;
 
-            float u1 = 1 - RNG.NextSingle(); //uniform(0,1] random floats
-            float u2 = 1 - RNG.NextSingle();
-            float randStdNormal = (float)(Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2)); //random normal(0,1)
-            var scale = Math.Max(triangleScale * (mean + std_dev * randStdNormal), 0.1f); //random normal(mean,stdDev^2)
+            float u1 = 1 - nextRandom(); //uniform(0,1] random floats
+            float u2 = 1 - nextRandom();
+            float randStdNormal = (float)(Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2)); // random normal(0,1)
+            var scale = Math.Max(triangleScale * (mean + std_dev * randStdNormal), 0.1f); // random normal(mean,stdDev^2)
 
             return new TriangleParticle { Scale = scale };
         }
@@ -215,6 +231,8 @@ namespace osu.Game.Graphics.Backgrounds
             }
         }
 
+        private float nextRandom() => (float)(stableRandom?.NextDouble() ?? RNG.NextSingle());
+
         protected override DrawNode CreateDrawNode() => new TrianglesDrawNode(this);
 
         private class TrianglesDrawNode : DrawNode
@@ -322,7 +340,6 @@ namespace osu.Game.Graphics.Backgrounds
             /// such that the smaller triangles appear on top.
             /// </summary>
             /// <param name="other"></param>
-            /// <returns></returns>
             public int CompareTo(TriangleParticle other) => other.Scale.CompareTo(Scale);
         }
     }