Merge branch 'blinds-pp' of https://github.com/mrowswares/osu into blinds-pp

osu.Android.props

@@ -52,7 +52,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2021.918.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.916.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.929.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
     <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->

osu.Desktop/Program.cs

@@ -74,7 +74,10 @@ namespace osu.Desktop
 
                     // we want to allow multiple instances to be started when in debug.
                     if (!DebugUtils.IsDebugBuild)
+                    {
+                        Logger.Log(@"osu! does not support multiple running instances.", LoggingTarget.Runtime, LogLevel.Error);
                         return 0;
+                    }
                 }
 
                 if (tournamentClient)

osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // In 2B beatmaps, it is possible that a normal Fruit is placed in the middle of a JuiceStream.
             foreach (var hitObject in beatmap.HitObjects
-                                             .SelectMany(obj => obj is JuiceStream stream ? stream.NestedHitObjects : new[] { obj })
+                                             .SelectMany(obj => obj is JuiceStream stream ? stream.NestedHitObjects.AsEnumerable() : new[] { obj })
                                              .Cast<CatchHitObject>()
                                              .OrderBy(x => x.StartTime))
             {

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

@@ -149,7 +149,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         {
             lowerBound ??= RandomStart;
             upperBound ??= TotalColumns;
-            nextColumn ??= (_ => GetRandomColumn(lowerBound, upperBound));
+            nextColumn ??= _ => GetRandomColumn(lowerBound, upperBound);
 
             // Check for the initial column
             if (isValid(initialColumn))
@@ -176,7 +176,19 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             return initialColumn;
 
-            bool isValid(int column) => validation?.Invoke(column) != false && !patterns.Any(p => p.ColumnHasObject(column));
+            bool isValid(int column)
+            {
+                if (validation?.Invoke(column) == false)
+                    return false;
+
+                foreach (var p in patterns)
+                {
+                    if (p.ColumnHasObject(column))
+                        return false;
+                }
+
+                return true;
+            }
         }
 
         /// <summary>

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Pattern.cs

@@ -12,46 +12,68 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
     /// </summary>
     internal class Pattern
     {
-        private readonly List<ManiaHitObject> hitObjects = new List<ManiaHitObject>();
+        private List<ManiaHitObject> hitObjects;
+        private HashSet<int> containedColumns;
 
         /// <summary>
         /// All the hit objects contained in this pattern.
         /// </summary>
-        public IEnumerable<ManiaHitObject> HitObjects => hitObjects;
+        public IEnumerable<ManiaHitObject> HitObjects => hitObjects ?? Enumerable.Empty<ManiaHitObject>();
 
         /// <summary>
         /// Check whether a column of this patterns contains a hit object.
         /// </summary>
         /// <param name="column">The column index.</param>
         /// <returns>Whether the column with index <paramref name="column"/> contains a hit object.</returns>
-        public bool ColumnHasObject(int column) => hitObjects.Exists(h => h.Column == column);
+        public bool ColumnHasObject(int column) => containedColumns?.Contains(column) == true;
 
         /// <summary>
         /// Amount of columns taken up by hit objects in this pattern.
         /// </summary>
-        public int ColumnWithObjects => HitObjects.GroupBy(h => h.Column).Count();
+        public int ColumnWithObjects => containedColumns?.Count ?? 0;
 
         /// <summary>
         /// Adds a hit object to this pattern.
         /// </summary>
         /// <param name="hitObject">The hit object to add.</param>
-        public void Add(ManiaHitObject hitObject) => hitObjects.Add(hitObject);
+        public void Add(ManiaHitObject hitObject)
+        {
+            prepareStorage();
+
+            hitObjects.Add(hitObject);
+            containedColumns.Add(hitObject.Column);
+        }
 
         /// <summary>
         /// Copies hit object from another pattern to this one.
         /// </summary>
         /// <param name="other">The other pattern.</param>
-        public void Add(Pattern other) => hitObjects.AddRange(other.HitObjects);
+        public void Add(Pattern other)
+        {
+            prepareStorage();
+
+            if (other.hitObjects != null)
+            {
+                hitObjects.AddRange(other.hitObjects);
+
+                foreach (var h in other.hitObjects)
+                    containedColumns.Add(h.Column);
+            }
+        }
 
         /// <summary>
         /// Clears this pattern, removing all hit objects.
         /// </summary>
-        public void Clear() => hitObjects.Clear();
+        public void Clear()
+        {
+            hitObjects?.Clear();
+            containedColumns?.Clear();
+        }
 
-        /// <summary>
-        /// Removes a hit object from this pattern.
-        /// </summary>
-        /// <param name="hitObject">The hit object to remove.</param>
-        public bool Remove(ManiaHitObject hitObject) => hitObjects.Remove(hitObject);
+        private void prepareStorage()
+        {
+            hitObjects ??= new List<ManiaHitObject>();
+            containedColumns ??= new HashSet<int>();
+        }
     }
 }

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyReverseArrow.cs

@@ -13,26 +13,20 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 {
     public class LegacyReverseArrow : CompositeDrawable
     {
-        private ISkin skin { get; }
-
         [Resolved(canBeNull: true)]
         private DrawableHitObject drawableHitObject { get; set; }
 
         private Drawable proxy;
 
-        public LegacyReverseArrow(ISkin skin)
-        {
-            this.skin = skin;
-        }
-
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(ISkinSource skinSource)
         {
             AutoSizeAxes = Axes.Both;
 
             string lookupName = new OsuSkinComponent(OsuSkinComponents.ReverseArrow).LookupName;
 
-            InternalChild = skin.GetAnimation(lookupName, true, true) ?? Empty();
+            var skin = skinSource.FindProvider(s => s.GetTexture(lookupName) != null);
+            InternalChild = skin?.GetAnimation(lookupName, true, true) ?? Empty();
         }
 
         protected override void LoadComplete()

osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
                     case OsuSkinComponents.ReverseArrow:
                         if (hasHitCircle.Value)
-                            return new LegacyReverseArrow(this);
+                            return new LegacyReverseArrow();
 
                         return null;
 

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

@@ -582,7 +582,6 @@ namespace osu.Game.Tests.Beatmaps.IO
 
         [Test]
         [NonParallelizable]
-        [Ignore("Binding IPC on Appveyor isn't working (port in use). Need to figure out why")]
         public void TestImportOverIPC()
         {
             using (HeadlessGameHost host = new CleanRunHeadlessGameHost($"{nameof(ImportBeatmapTest)}-host", true))

osu.Game.Tests/Database/TestRealmKeyBindingStore.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Database
 
             storage = new NativeStorage(directory.FullName);
 
-            realmContextFactory = new RealmContextFactory(storage);
+            realmContextFactory = new RealmContextFactory(storage, "test");
             keyBindingStore = new RealmKeyBindingStore(realmContextFactory);
         }
 
@@ -53,9 +53,9 @@ namespace osu.Game.Tests.Database
 
         private int queryCount(GlobalAction? match = null)
         {
-            using (var usage = realmContextFactory.GetForRead())
+            using (var realm = realmContextFactory.CreateContext())
             {
-                var results = usage.Realm.All<RealmKeyBinding>();
+                var results = realm.All<RealmKeyBinding>();
                 if (match.HasValue)
                     results = results.Where(k => k.ActionInt == (int)match.Value);
                 return results.Count();
@@ -69,26 +69,24 @@ namespace osu.Game.Tests.Database
 
             keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
 
-            using (var primaryUsage = realmContextFactory.GetForRead())
+            using (var primaryRealm = realmContextFactory.CreateContext())
             {
-                var backBinding = primaryUsage.Realm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
+                var backBinding = primaryRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
 
                 Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.Escape }));
 
                 var tsr = ThreadSafeReference.Create(backBinding);
 
-                using (var usage = realmContextFactory.GetForWrite())
+                using (var threadedContext = realmContextFactory.CreateContext())
                 {
-                    var binding = usage.Realm.ResolveReference(tsr);
-                    binding.KeyCombination = new KeyCombination(InputKey.BackSpace);
-
-                    usage.Commit();
+                    var binding = threadedContext.ResolveReference(tsr);
+                    threadedContext.Write(() => binding.KeyCombination = new KeyCombination(InputKey.BackSpace));
                 }
 
                 Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
 
                 // check still correct after re-query.
-                backBinding = primaryUsage.Realm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
+                backBinding = primaryRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
                 Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
             }
         }

osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs

@@ -158,18 +158,47 @@ namespace osu.Game.Tests.Online
 
             public Task<BeatmapSetInfo> CurrentImportTask { get; private set; }
 
-            protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize)
-                => new TestDownloadRequest(set);
-
-            public TestBeatmapManager(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, rulesets, api, audioManager, resources, host, defaultBeatmap, performOnlineLookups)
+            public TestBeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, IResourceStore<byte[]> resources, GameHost host = null, WorkingBeatmap defaultBeatmap = null)
+                : base(storage, contextFactory, rulesets, api, audioManager, resources, host, defaultBeatmap)
             {
             }
 
-            public override async Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
+            protected override BeatmapModelManager CreateBeatmapModelManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, GameHost host)
             {
-                await AllowImport.Task.ConfigureAwait(false);
-                return await (CurrentImportTask = base.Import(item, archive, lowPriority, cancellationToken)).ConfigureAwait(false);
+                return new TestBeatmapModelManager(this, storage, contextFactory, rulesets, api, host);
+            }
+
+            protected override BeatmapModelDownloader CreateBeatmapModelDownloader(BeatmapModelManager modelManager, IAPIProvider api, GameHost host)
+            {
+                return new TestBeatmapModelDownloader(modelManager, api, host);
+            }
+
+            internal class TestBeatmapModelDownloader : BeatmapModelDownloader
+            {
+                public TestBeatmapModelDownloader(BeatmapModelManager modelManager, IAPIProvider apiProvider, GameHost gameHost)
+                    : base(modelManager, apiProvider, gameHost)
+                {
+                }
+
+                protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize)
+                    => new TestDownloadRequest(set);
+            }
+
+            internal class TestBeatmapModelManager : BeatmapModelManager
+            {
+                private readonly TestBeatmapManager testBeatmapManager;
+
+                public TestBeatmapModelManager(TestBeatmapManager testBeatmapManager, Storage storage, IDatabaseContextFactory databaseContextFactory, RulesetStore rulesetStore, IAPIProvider apiProvider, GameHost gameHost)
+                    : base(storage, databaseContextFactory, rulesetStore, gameHost)
+                {
+                    this.testBeatmapManager = testBeatmapManager;
+                }
+
+                public override async Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
+                {
+                    await testBeatmapManager.AllowImport.Task.ConfigureAwait(false);
+                    return await (testBeatmapManager.CurrentImportTask = base.Import(item, archive, lowPriority, cancellationToken)).ConfigureAwait(false);
+                }
             }
         }
 

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

@@ -0,0 +1,132 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit.Compose.Components;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneBlueprintOrdering : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        private EditorBlueprintContainer blueprintContainer
+            => Editor.ChildrenOfType<EditorBlueprintContainer>().First();
+
+        [Test]
+        public void TestSelectedObjectHasPriorityWhenOverlapping()
+        {
+            var firstSlider = new Slider
+            {
+                Path = new SliderPath(new[]
+                {
+                    new PathControlPoint(new Vector2()),
+                    new PathControlPoint(new Vector2(150, -50)),
+                    new PathControlPoint(new Vector2(300, 0))
+                }),
+                Position = new Vector2(0, 100)
+            };
+            var secondSlider = new Slider
+            {
+                Path = new SliderPath(new[]
+                {
+                    new PathControlPoint(new Vector2()),
+                    new PathControlPoint(new Vector2(-50, 50)),
+                    new PathControlPoint(new Vector2(-100, 100))
+                }),
+                Position = new Vector2(200, 0)
+            };
+
+            AddStep("add overlapping sliders", () =>
+            {
+                EditorBeatmap.Add(firstSlider);
+                EditorBeatmap.Add(secondSlider);
+            });
+            AddStep("select first slider", () => EditorBeatmap.SelectedHitObjects.Add(firstSlider));
+
+            AddStep("move mouse to common point", () =>
+            {
+                var pos = blueprintContainer.ChildrenOfType<PathControlPointPiece>().ElementAt(1).ScreenSpaceDrawQuad.Centre;
+                InputManager.MoveMouseTo(pos);
+            });
+            AddStep("right click", () => InputManager.Click(MouseButton.Right));
+
+            AddAssert("selection is unchanged", () => EditorBeatmap.SelectedHitObjects.Single() == firstSlider);
+        }
+
+        [Test]
+        public void TestOverlappingObjectsWithSameStartTime()
+        {
+            AddStep("add overlapping circles", () =>
+            {
+                EditorBeatmap.Add(createHitCircle(50, OsuPlayfield.BASE_SIZE / 2));
+                EditorBeatmap.Add(createHitCircle(50, OsuPlayfield.BASE_SIZE / 2 + new Vector2(-10, -20)));
+                EditorBeatmap.Add(createHitCircle(50, OsuPlayfield.BASE_SIZE / 2 + new Vector2(10, -20)));
+            });
+
+            AddStep("click at centre of playfield", () =>
+            {
+                var hitObjectContainer = Editor.ChildrenOfType<HitObjectContainer>().Single();
+                var centre = hitObjectContainer.ToScreenSpace(OsuPlayfield.BASE_SIZE / 2);
+                InputManager.MoveMouseTo(centre);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("frontmost object selected", () =>
+            {
+                var hasCombo = Editor.ChildrenOfType<HitCircleSelectionBlueprint>().Single(b => b.IsSelected).Item as IHasComboInformation;
+                return hasCombo?.IndexInCurrentCombo == 0;
+            });
+        }
+
+        [Test]
+        public void TestPlacementOfConcurrentObjectWithDuration()
+        {
+            AddStep("seek to timing point", () => EditorClock.Seek(2170));
+            AddStep("add hit circle", () => EditorBeatmap.Add(createHitCircle(2170, Vector2.Zero)));
+
+            AddStep("choose spinner placement tool", () =>
+            {
+                InputManager.Key(Key.Number4);
+                var hitObjectContainer = Editor.ChildrenOfType<HitObjectContainer>().Single();
+                InputManager.MoveMouseTo(hitObjectContainer.ScreenSpaceDrawQuad.Centre);
+            });
+
+            AddStep("begin placing spinner", () =>
+            {
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("end placing spinner", () =>
+            {
+                EditorClock.Seek(2500);
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddAssert("two timeline blueprints present", () => Editor.ChildrenOfType<TimelineHitObjectBlueprint>().Count() == 2);
+        }
+
+        private HitCircle createHitCircle(double startTime, Vector2 position) => new HitCircle
+        {
+            StartTime = startTime,
+            Position = position,
+        };
+    }
+}

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

@@ -1,70 +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.Linq;
-using NUnit.Framework;
-using osu.Framework.Testing;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Screens.Edit.Compose.Components;
-using osu.Game.Tests.Beatmaps;
-using osuTK;
-using osuTK.Input;
-
-namespace osu.Game.Tests.Visual.Editing
-{
-    public class TestSceneBlueprintSelection : EditorTestScene
-    {
-        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
-
-        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
-
-        private EditorBlueprintContainer blueprintContainer
-            => Editor.ChildrenOfType<EditorBlueprintContainer>().First();
-
-        [Test]
-        public void TestSelectedObjectHasPriorityWhenOverlapping()
-        {
-            var firstSlider = new Slider
-            {
-                Path = new SliderPath(new[]
-                {
-                    new PathControlPoint(new Vector2()),
-                    new PathControlPoint(new Vector2(150, -50)),
-                    new PathControlPoint(new Vector2(300, 0))
-                }),
-                Position = new Vector2(0, 100)
-            };
-            var secondSlider = new Slider
-            {
-                Path = new SliderPath(new[]
-                {
-                    new PathControlPoint(new Vector2()),
-                    new PathControlPoint(new Vector2(-50, 50)),
-                    new PathControlPoint(new Vector2(-100, 100))
-                }),
-                Position = new Vector2(200, 0)
-            };
-
-            AddStep("add overlapping sliders", () =>
-            {
-                EditorBeatmap.Add(firstSlider);
-                EditorBeatmap.Add(secondSlider);
-            });
-            AddStep("select first slider", () => EditorBeatmap.SelectedHitObjects.Add(firstSlider));
-
-            AddStep("move mouse to common point", () =>
-            {
-                var pos = blueprintContainer.ChildrenOfType<PathControlPointPiece>().ElementAt(1).ScreenSpaceDrawQuad.Centre;
-                InputManager.MoveMouseTo(pos);
-            });
-            AddStep("right click", () => InputManager.Click(MouseButton.Right));
-
-            AddAssert("selection is unchanged", () => EditorBeatmap.SelectedHitObjects.Single() == firstSlider);
-        }
-    }
-}

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

@@ -20,14 +20,14 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Editing
 {
-    public class TestSceneEditorSelection : EditorTestScene
+    public class TestSceneComposerSelection : EditorTestScene
     {
         protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
 
         protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
 
-        private EditorBlueprintContainer blueprintContainer
-            => Editor.ChildrenOfType<EditorBlueprintContainer>().First();
+        private ComposeBlueprintContainer blueprintContainer
+            => Editor.ChildrenOfType<ComposeBlueprintContainer>().First();
 
         private void moveMouseToObject(Func<HitObject> targetFunc)
         {

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

@@ -0,0 +1,266 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneTimelineSelection : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        private TimelineBlueprintContainer blueprintContainer
+            => Editor.ChildrenOfType<TimelineBlueprintContainer>().First();
+
+        private void moveMouseToObject(Func<HitObject> targetFunc)
+        {
+            AddStep("move mouse to object", () =>
+            {
+                var pos = blueprintContainer.SelectionBlueprints
+                                            .First(s => s.Item == targetFunc())
+                                            .ChildrenOfType<TimelineHitObjectBlueprint>()
+                                            .First().ScreenSpaceDrawQuad.Centre;
+
+                InputManager.MoveMouseTo(pos);
+            });
+        }
+
+        [Test]
+        public void TestNudgeSelection()
+        {
+            HitCircle[] addedObjects = null;
+
+            AddStep("add hitobjects", () => EditorBeatmap.AddRange(addedObjects = new[]
+            {
+                new HitCircle { StartTime = 100 },
+                new HitCircle { StartTime = 200, Position = new Vector2(100) },
+                new HitCircle { StartTime = 300, Position = new Vector2(200) },
+                new HitCircle { StartTime = 400, Position = new Vector2(300) },
+            }));
+
+            AddStep("select objects", () => EditorBeatmap.SelectedHitObjects.AddRange(addedObjects));
+
+            AddStep("nudge forwards", () => InputManager.Key(Key.K));
+            AddAssert("objects moved forwards in time", () => addedObjects[0].StartTime > 100);
+
+            AddStep("nudge backwards", () => InputManager.Key(Key.J));
+            AddAssert("objects reverted to original position", () => addedObjects[0].StartTime == 100);
+        }
+
+        [Test]
+        public void TestBasicSelect()
+        {
+            var addedObject = new HitCircle { StartTime = 100 };
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            moveMouseToObject(() => addedObject);
+            AddStep("left click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("hitobject selected", () => EditorBeatmap.SelectedHitObjects.Single() == addedObject);
+
+            var addedObject2 = new HitCircle
+            {
+                StartTime = 200,
+                Position = new Vector2(100),
+            };
+
+            AddStep("add one more hitobject", () => EditorBeatmap.Add(addedObject2));
+            AddAssert("selection unchanged", () => EditorBeatmap.SelectedHitObjects.Single() == addedObject);
+
+            moveMouseToObject(() => addedObject2);
+            AddStep("left click", () => InputManager.Click(MouseButton.Left));
+            AddAssert("hitobject selected", () => EditorBeatmap.SelectedHitObjects.Single() == addedObject2);
+        }
+
+        [Test]
+        public void TestMultiSelect()
+        {
+            var addedObjects = new[]
+            {
+                new HitCircle { StartTime = 100 },
+                new HitCircle { StartTime = 200, Position = new Vector2(100) },
+                new HitCircle { StartTime = 300, Position = new Vector2(200) },
+                new HitCircle { StartTime = 400, Position = new Vector2(300) },
+            };
+
+            AddStep("add hitobjects", () => EditorBeatmap.AddRange(addedObjects));
+
+            moveMouseToObject(() => addedObjects[0]);
+            AddStep("click first", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("hitobject selected", () => EditorBeatmap.SelectedHitObjects.Single() == addedObjects[0]);
+
+            AddStep("hold control", () => InputManager.PressKey(Key.ControlLeft));
+
+            moveMouseToObject(() => addedObjects[1]);
+            AddStep("click second", () => InputManager.Click(MouseButton.Left));
+            AddAssert("2 hitobjects selected", () => EditorBeatmap.SelectedHitObjects.Count == 2 && EditorBeatmap.SelectedHitObjects.Contains(addedObjects[1]));
+
+            moveMouseToObject(() => addedObjects[2]);
+            AddStep("click third", () => InputManager.Click(MouseButton.Left));
+            AddAssert("3 hitobjects selected", () => EditorBeatmap.SelectedHitObjects.Count == 3 && EditorBeatmap.SelectedHitObjects.Contains(addedObjects[2]));
+
+            moveMouseToObject(() => addedObjects[1]);
+            AddStep("click second", () => InputManager.Click(MouseButton.Left));
+            AddAssert("2 hitobjects selected", () => EditorBeatmap.SelectedHitObjects.Count == 2 && !EditorBeatmap.SelectedHitObjects.Contains(addedObjects[1]));
+
+            AddStep("release control", () => InputManager.ReleaseKey(Key.ControlLeft));
+        }
+
+        [Test]
+        public void TestBasicDeselect()
+        {
+            var addedObject = new HitCircle { StartTime = 100 };
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            moveMouseToObject(() => addedObject);
+            AddStep("left click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("hitobject selected", () => EditorBeatmap.SelectedHitObjects.Single() == addedObject);
+
+            AddStep("click away", () =>
+            {
+                InputManager.MoveMouseTo(Editor.ChildrenOfType<TimelineArea>().Single().ScreenSpaceDrawQuad.TopLeft + Vector2.One);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("selection lost", () => EditorBeatmap.SelectedHitObjects.Count == 0);
+        }
+
+        [Test]
+        public void TestQuickDelete()
+        {
+            var addedObject = new HitCircle
+            {
+                StartTime = 0,
+            };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            moveMouseToObject(() => addedObject);
+
+            AddStep("hold shift", () => InputManager.PressKey(Key.ShiftLeft));
+            AddStep("right click", () => InputManager.Click(MouseButton.Right));
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
+
+            AddAssert("no hitobjects in beatmap", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+
+        [Test]
+        public void TestRangeSelect()
+        {
+            var addedObjects = new[]
+            {
+                new HitCircle { StartTime = 100 },
+                new HitCircle { StartTime = 200, Position = new Vector2(100) },
+                new HitCircle { StartTime = 300, Position = new Vector2(200) },
+                new HitCircle { StartTime = 400, Position = new Vector2(300) },
+                new HitCircle { StartTime = 500, Position = new Vector2(400) },
+            };
+
+            AddStep("add hitobjects", () => EditorBeatmap.AddRange(addedObjects));
+
+            moveMouseToObject(() => addedObjects[1]);
+            AddStep("click second", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("hitobject selected", () => EditorBeatmap.SelectedHitObjects.Single() == addedObjects[1]);
+
+            AddStep("hold shift", () => InputManager.PressKey(Key.ShiftLeft));
+
+            moveMouseToObject(() => addedObjects[3]);
+            AddStep("click fourth", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects.Skip(1).Take(3));
+
+            moveMouseToObject(() => addedObjects[0]);
+            AddStep("click first", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects.Take(2));
+
+            AddStep("clear selection", () => EditorBeatmap.SelectedHitObjects.Clear());
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
+
+            moveMouseToObject(() => addedObjects[0]);
+            AddStep("click first", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects.Take(1));
+
+            AddStep("hold ctrl", () => InputManager.PressKey(Key.ControlLeft));
+            moveMouseToObject(() => addedObjects[2]);
+            AddStep("click third", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(new[] { addedObjects[0], addedObjects[2] });
+
+            AddStep("hold shift", () => InputManager.PressKey(Key.ShiftLeft));
+            moveMouseToObject(() => addedObjects[4]);
+            AddStep("click fifth", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects.Except(new[] { addedObjects[1] }));
+
+            moveMouseToObject(() => addedObjects[0]);
+            AddStep("click first", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects);
+
+            AddStep("clear selection", () => EditorBeatmap.SelectedHitObjects.Clear());
+            moveMouseToObject(() => addedObjects[0]);
+            AddStep("click first", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects.Take(1));
+
+            moveMouseToObject(() => addedObjects[1]);
+            AddStep("click first", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects.Take(2));
+
+            moveMouseToObject(() => addedObjects[2]);
+            AddStep("click first", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects.Take(3));
+
+            AddStep("release keys", () =>
+            {
+                InputManager.ReleaseKey(Key.ControlLeft);
+                InputManager.ReleaseKey(Key.ShiftLeft);
+            });
+        }
+
+        [Test]
+        public void TestRangeSelectAfterExternalSelection()
+        {
+            var addedObjects = new[]
+            {
+                new HitCircle { StartTime = 100 },
+                new HitCircle { StartTime = 200, Position = new Vector2(100) },
+                new HitCircle { StartTime = 300, Position = new Vector2(200) },
+                new HitCircle { StartTime = 400, Position = new Vector2(300) },
+            };
+
+            AddStep("add hitobjects", () => EditorBeatmap.AddRange(addedObjects));
+
+            AddStep("select all without mouse", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+            assertSelectionIs(addedObjects);
+
+            AddStep("hold down shift", () => InputManager.PressKey(Key.ShiftLeft));
+
+            moveMouseToObject(() => addedObjects[1]);
+            AddStep("click second object", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects);
+
+            moveMouseToObject(() => addedObjects[3]);
+            AddStep("click fourth object", () => InputManager.Click(MouseButton.Left));
+            assertSelectionIs(addedObjects.Skip(1));
+
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
+        }
+
+        private void assertSelectionIs(IEnumerable<HitObject> hitObjects)
+            => AddAssert("correct hitobjects selected", () => EditorBeatmap.SelectedHitObjects.OrderBy(h => h.StartTime).SequenceEqual(hitObjects));
+    }
+}

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

@@ -3,10 +3,12 @@
 
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
+using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Rulesets;
@@ -39,6 +41,45 @@ namespace osu.Game.Tests.Visual.Gameplay
             confirmClockRunning(true);
         }
 
+        [Test]
+        public void TestPauseWithLargeOffset()
+        {
+            double lastTime;
+            bool alwaysGoingForward = true;
+
+            AddStep("force large offset", () =>
+            {
+                var offset = (BindableDouble)LocalConfig.GetBindable<double>(OsuSetting.AudioOffset);
+
+                // use a large negative offset to avoid triggering a fail from forwards seeking.
+                offset.MinValue = -5000;
+                offset.Value = -5000;
+            });
+
+            AddStep("add time forward check hook", () =>
+            {
+                lastTime = double.MinValue;
+                alwaysGoingForward = true;
+
+                Player.OnUpdate += _ =>
+                {
+                    double currentTime = Player.GameplayClockContainer.CurrentTime;
+                    alwaysGoingForward &= currentTime >= lastTime;
+                    lastTime = currentTime;
+                };
+            });
+
+            AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
+
+            pauseAndConfirm();
+
+            resumeAndConfirm();
+
+            AddAssert("time didn't go backwards", () => alwaysGoingForward);
+
+            AddStep("reset offset", () => LocalConfig.SetValue(OsuSetting.AudioOffset, 0.0));
+        }
+
         [Test]
         public void TestPauseResume()
         {

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

@@ -43,11 +43,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     Spacing = new Vector2(10),
                     Children = new Drawable[]
                     {
-                        createDrawableRoom(new Room
+                        createLoungeRoom(new Room
                         {
-                            Name = { Value = "Flyte's Trash Playlist" },
+                            Name = { Value = "Multiplayer room" },
                             Status = { Value = new RoomStatusOpen() },
                             EndDate = { Value = DateTimeOffset.Now.AddDays(1) },
+                            Type = { Value = MatchType.HeadToHead },
                             Playlist =
                             {
                                 new PlaylistItem
@@ -65,9 +66,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
                                 }
                             }
                         }),
-                        createDrawableRoom(new Room
+                        createLoungeRoom(new Room
                         {
-                            Name = { Value = "Room 2" },
+                            Name = { Value = "Playlist room with multiple beatmaps" },
                             Status = { Value = new RoomStatusPlaying() },
                             EndDate = { Value = DateTimeOffset.Now.AddDays(1) },
                             Playlist =
@@ -100,15 +101,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
                                 }
                             }
                         }),
-                        createDrawableRoom(new Room
+                        createLoungeRoom(new Room
                         {
-                            Name = { Value = "Room 3" },
+                            Name = { Value = "Finished room" },
                             Status = { Value = new RoomStatusEnded() },
                             EndDate = { Value = DateTimeOffset.Now },
                         }),
-                        createDrawableRoom(new Room
+                        createLoungeRoom(new Room
                         {
-                            Name = { Value = "Room 4 (spotlight)" },
+                            Name = { Value = "Spotlight room" },
                             Status = { Value = new RoomStatusOpen() },
                             Category = { Value = RoomCategory.Spotlight },
                         }),
@@ -123,14 +124,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
             DrawableRoom drawableRoom = null;
             Room room = null;
 
-            AddStep("create room", () => Child = drawableRoom = createDrawableRoom(room = new Room
+            AddStep("create room", () => Child = drawableRoom = createLoungeRoom(room = new Room
             {
                 Name = { Value = "Room with password" },
                 Status = { Value = new RoomStatusOpen() },
                 Type = { Value = MatchType.HeadToHead },
             }));
 
-            AddUntilStep("wait for panel load", () => drawableRoom.ChildrenOfType<RecentParticipantsList>().Any());
+            AddUntilStep("wait for panel load", () => drawableRoom.ChildrenOfType<DrawableRoomParticipantsList>().Any());
 
             AddAssert("password icon hidden", () => Precision.AlmostEquals(0, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
 
@@ -141,7 +142,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("password icon hidden", () => Precision.AlmostEquals(0, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
         }
 
-        private DrawableRoom createDrawableRoom(Room room)
+        private DrawableRoom createLoungeRoom(Room room)
         {
             room.Host.Value ??= new User { Username = "peppy", Id = 2 };
 

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

@@ -13,16 +13,27 @@ using osu.Game.Users.Drawables;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
-    public class TestSceneRecentParticipantsList : OnlinePlayTestScene
+    public class TestSceneDrawableRoomParticipantsList : OnlinePlayTestScene
     {
-        private RecentParticipantsList list;
+        private DrawableRoomParticipantsList list;
 
         [SetUp]
         public new void Setup() => Schedule(() =>
         {
-            SelectedRoom.Value = new Room { Name = { Value = "test room" } };
+            SelectedRoom.Value = new Room
+            {
+                Name = { Value = "test room" },
+                Host =
+                {
+                    Value = new User
+                    {
+                        Id = 2,
+                        Username = "peppy",
+                    }
+                }
+            };
 
-            Child = list = new RecentParticipantsList
+            Child = list = new DrawableRoomParticipantsList
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -40,19 +51,19 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("set 8 circles", () => list.NumberOfCircles = 8);
-            AddAssert("0 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 0);
+            AddAssert("0 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 0);
 
             AddStep("add one more user", () => addUser(9));
-            AddAssert("2 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 2);
+            AddAssert("2 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 2);
 
             AddStep("remove first user", () => removeUserAt(0));
-            AddAssert("0 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 0);
+            AddAssert("0 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 0);
 
             AddStep("add one more user", () => addUser(9));
-            AddAssert("2 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 2);
+            AddAssert("2 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 2);
 
             AddStep("remove last user", () => removeUserAt(8));
-            AddAssert("0 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 0);
+            AddAssert("0 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 0);
         }
 
         [Test]
@@ -69,9 +80,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
             for (int i = 0; i < 8; i++)
             {
                 AddStep("remove user", () => removeUserAt(0));
-                int remainingUsers = 7 - i;
+                int remainingUsers = 8 - i;
 
-                int displayedUsers = remainingUsers > 3 ? 2 : remainingUsers;
+                int displayedUsers = remainingUsers > 4 ? 3 : remainingUsers;
                 AddAssert($"{displayedUsers} avatars displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == displayedUsers);
             }
         }
@@ -86,12 +97,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("set 3 circles", () => list.NumberOfCircles = 3);
-            AddAssert("2 users displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 2);
-            AddAssert("48 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 48);
+            AddAssert("3 users displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 3);
+            AddAssert("48 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 48);
 
             AddStep("set 10 circles", () => list.NumberOfCircles = 10);
-            AddAssert("9 users displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 9);
-            AddAssert("41 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 41);
+            AddAssert("10 users displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 10);
+            AddAssert("41 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 41);
         }
 
         [Test]
@@ -104,24 +115,24 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("remove from start", () => removeUserAt(0));
-            AddAssert("3 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 3);
-            AddAssert("46 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 46);
+            AddAssert("4 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 4);
+            AddAssert("46 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 46);
 
             AddStep("remove from end", () => removeUserAt(SelectedRoom.Value.RecentParticipants.Count - 1));
-            AddAssert("3 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 3);
-            AddAssert("45 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 45);
+            AddAssert("4 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 4);
+            AddAssert("45 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 45);
 
             AddRepeatStep("remove 45 users", () => removeUserAt(0), 45);
-            AddAssert("3 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 3);
-            AddAssert("0 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 0);
-            AddAssert("hidden users bubble hidden", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Alpha < 0.5f);
+            AddAssert("4 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 4);
+            AddAssert("0 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 0);
+            AddAssert("hidden users bubble hidden", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Alpha < 0.5f);
 
             AddStep("remove another user", () => removeUserAt(0));
-            AddAssert("2 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 2);
-            AddAssert("0 hidden users", () => list.ChildrenOfType<RecentParticipantsList.HiddenUserCount>().Single().Count == 0);
+            AddAssert("3 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 3);
+            AddAssert("0 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 0);
 
             AddRepeatStep("remove the remaining two users", () => removeUserAt(0), 2);
-            AddAssert("0 circles displayed", () => !list.ChildrenOfType<UpdateableAvatar>().Any());
+            AddAssert("1 circle displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 1);
         }
 
         private void addUser(int id)

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

@@ -24,9 +24,10 @@ namespace osu.Game.Tests.Visual.UserInterface
         [Test]
         public void TestBasic()
         {
-            TestPopupDialog dialog = null;
+            TestPopupDialog firstDialog = null;
+            TestPopupDialog secondDialog = null;
 
-            AddStep("dialog #1", () => overlay.Push(dialog = new TestPopupDialog
+            AddStep("dialog #1", () => overlay.Push(firstDialog = new TestPopupDialog
             {
                 Icon = FontAwesome.Regular.TrashAlt,
                 HeaderText = @"Confirm deletion of",
@@ -46,9 +47,9 @@ namespace osu.Game.Tests.Visual.UserInterface
                 },
             }));
 
-            AddAssert("first dialog displayed", () => overlay.CurrentDialog == dialog);
+            AddAssert("first dialog displayed", () => overlay.CurrentDialog == firstDialog);
 
-            AddStep("dialog #2", () => overlay.Push(dialog = new TestPopupDialog
+            AddStep("dialog #2", () => overlay.Push(secondDialog = new TestPopupDialog
             {
                 Icon = FontAwesome.Solid.Cog,
                 HeaderText = @"What do you want to do with",
@@ -82,30 +83,33 @@ namespace osu.Game.Tests.Visual.UserInterface
                 },
             }));
 
-            AddAssert("second dialog displayed", () => overlay.CurrentDialog == dialog);
+            AddAssert("second dialog displayed", () => overlay.CurrentDialog == secondDialog);
+            AddAssert("first dialog is not part of hierarchy", () => firstDialog.Parent == null);
         }
 
         [Test]
         public void TestDismissBeforePush()
         {
+            TestPopupDialog testDialog = null;
             AddStep("dismissed dialog push", () =>
             {
-                overlay.Push(new TestPopupDialog
+                overlay.Push(testDialog = new TestPopupDialog
                 {
                     State = { Value = Visibility.Hidden }
                 });
             });
 
             AddAssert("no dialog pushed", () => overlay.CurrentDialog == null);
+            AddAssert("dialog is not part of hierarchy", () => testDialog.Parent == null);
         }
 
         [Test]
         public void TestDismissBeforePushViaButtonPress()
         {
+            TestPopupDialog testDialog = null;
             AddStep("dismissed dialog push", () =>
             {
-                TestPopupDialog dialog;
-                overlay.Push(dialog = new TestPopupDialog
+                overlay.Push(testDialog = new TestPopupDialog
                 {
                     Buttons = new PopupDialogButton[]
                     {
@@ -113,10 +117,11 @@ namespace osu.Game.Tests.Visual.UserInterface
                     },
                 });
 
-                dialog.PerformOkAction();
+                testDialog.PerformOkAction();
             });
 
             AddAssert("no dialog pushed", () => overlay.CurrentDialog == null);
+            AddAssert("dialog is not part of hierarchy", () => testDialog.Parent == null);
         }
 
         private class TestPopupDialog : PopupDialog

osu.Game/Beatmaps/BeatmapManager.cs

@@ -6,111 +6,67 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 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.IO.Stores;
-using osu.Framework.Lists;
-using osu.Framework.Logging;
 using osu.Framework.Platform;
-using osu.Framework.Statistics;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps.Formats;
 using osu.Game.Database;
 using osu.Game.IO;
 using osu.Game.IO.Archives;
 using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
+using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Skinning;
 using osu.Game.Users;
-using Decoder = osu.Game.Beatmaps.Formats.Decoder;
 
 namespace osu.Game.Beatmaps
 {
     /// <summary>
-    /// Handles the storage and retrieval of Beatmaps/WorkingBeatmaps.
+    /// Handles general operations related to global beatmap management.
     /// </summary>
     [ExcludeFromDynamicCompile]
-    public partial class BeatmapManager : DownloadableArchiveModelManager<BeatmapSetInfo, BeatmapSetFileInfo>, IDisposable, IBeatmapResourceProvider
+    public class BeatmapManager : IModelDownloader<BeatmapSetInfo>, IModelManager<BeatmapSetInfo>, IModelFileManager<BeatmapSetInfo, BeatmapSetFileInfo>, ICanAcceptFiles, IWorkingBeatmapCache, IDisposable
     {
-        /// <summary>
-        /// Fired when a single difficulty has been hidden.
-        /// </summary>
-        public IBindable<WeakReference<BeatmapInfo>> BeatmapHidden => beatmapHidden;
+        private readonly BeatmapModelManager beatmapModelManager;
+        private readonly BeatmapModelDownloader beatmapModelDownloader;
 
-        private readonly Bindable<WeakReference<BeatmapInfo>> beatmapHidden = new Bindable<WeakReference<BeatmapInfo>>();
-
-        /// <summary>
-        /// Fired when a single difficulty has been restored.
-        /// </summary>
-        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 IEnumerable<string> HandledExtensions => new[] { ".osz" };
-
-        protected override string[] HashableFileTypes => new[] { ".osu" };
-
-        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 IResourceStore<byte[]> resources;
-        private readonly LargeTextureStore largeTextureStore;
-        private readonly ITrackStore trackStore;
-
-        [CanBeNull]
-        private readonly GameHost host;
-
-        [CanBeNull]
-        private readonly BeatmapOnlineLookupQueue onlineLookupQueue;
+        private readonly WorkingBeatmapCache workingBeatmapCache;
+        private readonly BeatmapOnlineLookupQueue onlineBetamapLookupQueue;
 
         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;
+            beatmapModelManager = CreateBeatmapModelManager(storage, contextFactory, rulesets, api, host);
+            beatmapModelDownloader = CreateBeatmapModelDownloader(beatmapModelManager, api, host);
+            workingBeatmapCache = CreateWorkingBeatmapCache(audioManager, resources, new FileStore(contextFactory, storage).Store, defaultBeatmap, host);
 
-            DefaultBeatmap = defaultBeatmap;
-
-            beatmaps = (BeatmapStore)ModelStore;
-            beatmaps.BeatmapHidden += b => beatmapHidden.Value = new WeakReference<BeatmapInfo>(b);
-            beatmaps.BeatmapRestored += b => beatmapRestored.Value = new WeakReference<BeatmapInfo>(b);
-            beatmaps.ItemRemoved += removeWorkingCache;
-            beatmaps.ItemUpdated += removeWorkingCache;
+            workingBeatmapCache.BeatmapManager = beatmapModelManager;
 
             if (performOnlineLookups)
-                onlineLookupQueue = new BeatmapOnlineLookupQueue(api, storage);
-
-            largeTextureStore = new LargeTextureStore(host?.CreateTextureLoaderStore(Files.Store));
-            trackStore = audioManager.GetTrackStore(Files.Store);
+            {
+                onlineBetamapLookupQueue = new BeatmapOnlineLookupQueue(api, storage);
+                beatmapModelManager.OnlineLookupQueue = onlineBetamapLookupQueue;
+            }
         }
 
-        protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize) =>
-            new DownloadBeatmapSetRequest(set, minimiseDownloadSize);
+        protected virtual BeatmapModelDownloader CreateBeatmapModelDownloader(BeatmapModelManager modelManager, IAPIProvider api, GameHost host)
+        {
+            return new BeatmapModelDownloader(modelManager, api, host);
+        }
 
-        protected override bool ShouldDeleteArchive(string path) => Path.GetExtension(path)?.ToLowerInvariant() == ".osz";
+        protected virtual WorkingBeatmapCache CreateWorkingBeatmapCache(AudioManager audioManager, IResourceStore<byte[]> resources, IResourceStore<byte[]> storage, WorkingBeatmap defaultBeatmap, GameHost host) =>
+            new WorkingBeatmapCache(audioManager, resources, storage, defaultBeatmap, host);
 
+        protected virtual BeatmapModelManager CreateBeatmapModelManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, GameHost host) =>
+            new BeatmapModelManager(storage, contextFactory, rulesets, host);
+
+        /// <summary>
+        /// Create a new <see cref="WorkingBeatmap"/>.
+        /// </summary>
         public WorkingBeatmap CreateNew(RulesetInfo ruleset, User user)
         {
             var metadata = new BeatmapMetadata
@@ -134,112 +90,21 @@ namespace osu.Game.Beatmaps
                 }
             };
 
-            var working = Import(set).Result;
+            var working = beatmapModelManager.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);
-
-            foreach (BeatmapInfo b in beatmapSet.Beatmaps)
-            {
-                // remove metadata from difficulties where it matches the set
-                if (beatmapSet.Metadata.Equals(b.Metadata))
-                    b.Metadata = null;
-
-                b.BeatmapSet = beatmapSet;
-            }
-
-            validateOnlineIds(beatmapSet);
-
-            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)
-        {
-            if (beatmapSet.Beatmaps.Any(b => b.BaseDifficulty == null))
-                throw new InvalidOperationException($"Cannot import {nameof(BeatmapInfo)} with null {nameof(BeatmapInfo.BaseDifficulty)}.");
-
-            // check if a set already exists with the same online id, delete if it does.
-            if (beatmapSet.OnlineBeatmapSetID != null)
-            {
-                var existingOnlineId = beatmaps.ConsumableItems.FirstOrDefault(b => b.OnlineBeatmapSetID == beatmapSet.OnlineBeatmapSetID);
-
-                if (existingOnlineId != null)
-                {
-                    Delete(existingOnlineId);
-
-                    // 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.");
-                }
-            }
-        }
-
-        private void validateOnlineIds(BeatmapSetInfo beatmapSet)
-        {
-            var beatmapIds = beatmapSet.Beatmaps.Where(b => b.OnlineBeatmapID.HasValue).Select(b => b.OnlineBeatmapID).ToList();
-
-            // ensure all IDs are unique
-            if (beatmapIds.GroupBy(b => b).Any(g => g.Count() > 1))
-            {
-                LogForModel(beatmapSet, "Found non-unique IDs, resetting...");
-                resetIds();
-                return;
-            }
-
-            // find any existing beatmaps in the database that have matching online ids
-            var existingBeatmaps = QueryBeatmaps(b => beatmapIds.Contains(b.OnlineBeatmapID)).ToList();
-
-            if (existingBeatmaps.Count > 0)
-            {
-                // reset the import ids (to force a re-fetch) *unless* they match the candidate CheckForExisting set.
-                // we can ignore the case where the new ids are contained by the CheckForExisting set as it will either be used (import skipped) or deleted.
-                var existing = CheckForExisting(beatmapSet);
-
-                if (existing == null || existingBeatmaps.Any(b => !existing.Beatmaps.Contains(b)))
-                {
-                    LogForModel(beatmapSet, "Found existing import with IDs already, resetting...");
-                    resetIds();
-                }
-            }
-
-            void resetIds() => beatmapSet.Beatmaps.ForEach(b => b.OnlineBeatmapID = null);
-        }
-
-        protected override bool CheckLocalAvailability(BeatmapSetInfo model, IQueryable<BeatmapSetInfo> items)
-            => base.CheckLocalAvailability(model, items)
-               || (model.OnlineBeatmapSetID != null && items.Any(b => b.OnlineBeatmapSetID == model.OnlineBeatmapSetID));
+        #region Delegation to BeatmapModelManager (methods which previously existed locally).
 
         /// <summary>
-        /// Delete a beatmap difficulty.
+        /// Fired when a single difficulty has been hidden.
         /// </summary>
-        /// <param name="beatmap">The beatmap difficulty to hide.</param>
-        public void Hide(BeatmapInfo beatmap) => beatmaps.Hide(beatmap);
+        public IBindable<WeakReference<BeatmapInfo>> BeatmapHidden => beatmapModelManager.BeatmapHidden;
 
         /// <summary>
-        /// Restore a beatmap difficulty.
+        /// Fired when a single difficulty has been restored.
         /// </summary>
-        /// <param name="beatmap">The beatmap difficulty to restore.</param>
-        public void Restore(BeatmapInfo beatmap) => beatmaps.Restore(beatmap);
+        public IBindable<WeakReference<BeatmapInfo>> BeatmapRestored => beatmapModelManager.BeatmapRestored;
 
         /// <summary>
         /// Saves an <see cref="IBeatmap"/> file against a given <see cref="BeatmapInfo"/>.
@@ -247,109 +112,13 @@ namespace osu.Game.Beatmaps
         /// <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>
         /// <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 = info.BeatmapSet;
-
-            using (var stream = new MemoryStream())
-            {
-                using (var sw = new StreamWriter(stream, Encoding.UTF8, 1024, true))
-                    new LegacyBeatmapEncoder(beatmapContent, beatmapSkin).Encode(sw);
-
-                stream.Seek(0, SeekOrigin.Begin);
-
-                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);
-                }
-            }
-
-            removeWorkingCache(info);
-        }
-
-        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>
-        /// <returns>A <see cref="WorkingBeatmap"/> instance correlating to the provided <see cref="BeatmapInfo"/>.</returns>
-        public virtual WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo)
-        {
-            // 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)
-                return DefaultBeatmap;
-
-            lock (workingCache)
-            {
-                var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == beatmapInfo.ID);
-                if (working != null)
-                    return working;
-
-                beatmapInfo.Metadata ??= beatmapInfo.BeatmapSet.Metadata;
-
-                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();
-
-                return working;
-            }
-        }
-
-        /// <summary>
-        /// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
-        /// </summary>
-        /// <param name="query">The query.</param>
-        /// <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 CanSkipImport(BeatmapSetInfo existing, BeatmapSetInfo import)
-        {
-            if (!base.CanSkipImport(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);
-            var importIds = import.Beatmaps.Select(b => b.OnlineBeatmapID).OrderBy(i => i);
-
-            // force re-import if we are not in a sane state.
-            return existing.OnlineBeatmapSetID == import.OnlineBeatmapSetID && existingIds.SequenceEqual(importIds);
-        }
+        public virtual void Save(BeatmapInfo info, IBeatmap beatmapContent, ISkin beatmapSkin = null) => beatmapModelManager.Save(info, beatmapContent, beatmapSkin);
 
         /// <summary>
         /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
         /// </summary>
         /// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
-        public List<BeatmapSetInfo> GetAllUsableBeatmapSets(IncludedDetails includes = IncludedDetails.All, bool includeProtected = false) =>
-            GetAllUsableBeatmapSetsEnumerable(includes, includeProtected).ToList();
+        public List<BeatmapSetInfo> GetAllUsableBeatmapSets(IncludedDetails includes = IncludedDetails.All, bool includeProtected = false) => beatmapModelManager.GetAllUsableBeatmapSets(includes, includeProtected);
 
         /// <summary>
         /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s. Note that files are not populated.
@@ -357,34 +126,7 @@ namespace osu.Game.Beatmaps
         /// <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 IEnumerable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable(IncludedDetails includes, bool includeProtected = false)
-        {
-            IQueryable<BeatmapSetInfo> queryable;
-
-            switch (includes)
-            {
-                case IncludedDetails.Minimal:
-                    queryable = beatmaps.BeatmapSetsOverview;
-                    break;
-
-                case IncludedDetails.AllButRuleset:
-                    queryable = beatmaps.BeatmapSetsWithoutRuleset;
-                    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));
-        }
+        public IEnumerable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable(IncludedDetails includes, bool includeProtected = false) => beatmapModelManager.GetAllUsableBeatmapSetsEnumerable(includes, includeProtected);
 
         /// <summary>
         /// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
@@ -392,207 +134,204 @@ namespace osu.Game.Beatmaps
         /// <param name="query">The query.</param>
         /// <param name="includes">The level of detail to include in the returned objects.</param>
         /// <returns>Results from the provided query.</returns>
-        public IEnumerable<BeatmapSetInfo> QueryBeatmapSets(Expression<Func<BeatmapSetInfo, bool>> query, IncludedDetails includes = IncludedDetails.All)
-        {
-            IQueryable<BeatmapSetInfo> queryable;
-
-            switch (includes)
-            {
-                case IncludedDetails.Minimal:
-                    queryable = beatmaps.BeatmapSetsOverview;
-                    break;
-
-                case IncludedDetails.AllButRuleset:
-                    queryable = beatmaps.BeatmapSetsWithoutRuleset;
-                    break;
-
-                case IncludedDetails.AllButFiles:
-                    queryable = beatmaps.BeatmapSetsWithoutFiles;
-                    break;
-
-                default:
-                    queryable = beatmaps.ConsumableItems;
-                    break;
-            }
-
-            return queryable.AsNoTracking().Where(query);
-        }
+        public IEnumerable<BeatmapSetInfo> QueryBeatmapSets(Expression<Func<BeatmapSetInfo, bool>> query, IncludedDetails includes = IncludedDetails.All) => beatmapModelManager.QueryBeatmapSets(query, includes);
 
         /// <summary>
-        /// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
+        /// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
         /// </summary>
         /// <param name="query">The query.</param>
         /// <returns>The first result for the provided query, or null if no results were found.</returns>
-        public BeatmapInfo QueryBeatmap(Expression<Func<BeatmapInfo, bool>> query) => beatmaps.Beatmaps.AsNoTracking().FirstOrDefault(query);
+        public BeatmapSetInfo QueryBeatmapSet(Expression<Func<BeatmapSetInfo, bool>> query) => beatmapModelManager.QueryBeatmapSet(query);
 
         /// <summary>
         /// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
         /// </summary>
         /// <param name="query">The query.</param>
         /// <returns>Results from the provided query.</returns>
-        public IQueryable<BeatmapInfo> QueryBeatmaps(Expression<Func<BeatmapInfo, bool>> query) => beatmaps.Beatmaps.AsNoTracking().Where(query);
+        public IQueryable<BeatmapInfo> QueryBeatmaps(Expression<Func<BeatmapInfo, bool>> query) => beatmapModelManager.QueryBeatmaps(query);
 
-        protected override string HumanisedModelName => "beatmap";
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The first result for the provided query, or null if no results were found.</returns>
+        public BeatmapInfo QueryBeatmap(Expression<Func<BeatmapInfo, bool>> query) => beatmapModelManager.QueryBeatmap(query);
 
-        protected override BeatmapSetInfo CreateModel(ArchiveReader reader)
+        /// <summary>
+        /// A default representation of a WorkingBeatmap to use when no beatmap is available.
+        /// </summary>
+        public WorkingBeatmap DefaultBeatmap => workingBeatmapCache.DefaultBeatmap;
+
+        /// <summary>
+        /// Fired when a notification should be presented to the user.
+        /// </summary>
+        public Action<Notification> PostNotification
         {
-            // let's make sure there are actually .osu files to import.
-            string mapName = reader.Filenames.FirstOrDefault(f => f.EndsWith(".osu", StringComparison.OrdinalIgnoreCase));
-
-            if (string.IsNullOrEmpty(mapName))
+            set
             {
-                Logger.Log($"No beatmap files found in the beatmap archive ({reader.Name}).", LoggingTarget.Database);
-                return null;
+                beatmapModelManager.PostNotification = value;
+                beatmapModelDownloader.PostNotification = value;
             }
-
-            Beatmap beatmap;
-            using (var stream = new LineBufferedReader(reader.GetStream(mapName)))
-                beatmap = Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
-
-            return new BeatmapSetInfo
-            {
-                OnlineBeatmapSetID = beatmap.BeatmapInfo.BeatmapSet?.OnlineBeatmapSetID,
-                Beatmaps = new List<BeatmapInfo>(),
-                Metadata = beatmap.Metadata,
-                DateAdded = DateTimeOffset.UtcNow
-            };
         }
 
         /// <summary>
-        /// Create all required <see cref="BeatmapInfo"/>s for the provided archive.
+        /// Fired when the user requests to view the resulting import.
         /// </summary>
-        private List<BeatmapInfo> createBeatmapDifficulties(List<BeatmapSetFileInfo> files)
-        {
-            var beatmapInfos = new List<BeatmapInfo>();
+        public Action<IEnumerable<BeatmapSetInfo>> PresentImport { set => beatmapModelManager.PresentImport = value; }
 
-            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 sr = new LineBufferedReader(ms))
-                {
-                    raw.CopyTo(ms);
-                    ms.Position = 0;
+        /// <summary>
+        /// Delete a beatmap difficulty.
+        /// </summary>
+        /// <param name="beatmap">The beatmap difficulty to hide.</param>
+        public void Hide(BeatmapInfo beatmap) => beatmapModelManager.Hide(beatmap);
 
-                    var decoder = Decoder.GetDecoder<Beatmap>(sr);
-                    IBeatmap beatmap = decoder.Decode(sr);
-
-                    string hash = ms.ComputeSHA2Hash();
-
-                    if (beatmapInfos.Any(b => b.Hash == hash))
-                        continue;
-
-                    beatmap.BeatmapInfo.Path = file.Filename;
-                    beatmap.BeatmapInfo.Hash = hash;
-                    beatmap.BeatmapInfo.MD5Hash = ms.ComputeMD5Hash();
-
-                    var ruleset = rulesets.GetRuleset(beatmap.BeatmapInfo.RulesetID);
-                    beatmap.BeatmapInfo.Ruleset = ruleset;
-
-                    // 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 = 60000 / beatmap.GetMostCommonBeatLength();
-
-                    beatmapInfos.Add(beatmap.BeatmapInfo);
-                }
-            }
-
-            return beatmapInfos;
-        }
-
-        private double calculateLength(IBeatmap b)
-        {
-            if (!b.HitObjects.Any())
-                return 0;
-
-            var lastObject = b.HitObjects.Last();
-
-            //TODO: this isn't always correct (consider mania where a non-last object may last for longer than the last in the list).
-            double endTime = lastObject.GetEndTime();
-            double startTime = b.HitObjects.First().StartTime;
-
-            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);
+        /// <summary>
+        /// Restore a beatmap difficulty.
+        /// </summary>
+        /// <param name="beatmap">The beatmap difficulty to restore.</param>
+        public void Restore(BeatmapInfo beatmap) => beatmapModelManager.Restore(beatmap);
 
         #endregion
 
-        /// <summary>
-        /// A dummy WorkingBeatmap for the purpose of retrieving a beatmap for star difficulty calculation.
-        /// </summary>
-        private class DummyConversionBeatmap : WorkingBeatmap
+        #region Implementation of IModelManager<BeatmapSetInfo>
+
+        public bool IsAvailableLocally(BeatmapSetInfo model)
         {
-            private readonly IBeatmap beatmap;
-
-            public DummyConversionBeatmap(IBeatmap beatmap)
-                : base(beatmap.BeatmapInfo, null)
-            {
-                this.beatmap = beatmap;
-            }
-
-            protected override IBeatmap GetBeatmap() => beatmap;
-            protected override Texture GetBackground() => null;
-            protected override Track GetBeatmapTrack() => null;
-            protected internal override ISkin GetSkin() => null;
-            public override Stream GetStream(string storagePath) => null;
+            return beatmapModelManager.IsAvailableLocally(model);
         }
-    }
 
-    /// <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,
+        public IBindable<WeakReference<BeatmapSetInfo>> ItemUpdated => beatmapModelManager.ItemUpdated;
 
-        /// <summary>
-        /// Include all difficulties, rulesets, difficulty metadata but no files.
-        /// </summary>
-        AllButFiles,
+        public IBindable<WeakReference<BeatmapSetInfo>> ItemRemoved => beatmapModelManager.ItemRemoved;
 
-        /// <summary>
-        /// Include everything except ruleset. Used for cases where we aren't sure the ruleset is present but still want to consume the beatmap.
-        /// </summary>
-        AllButRuleset,
+        public Task ImportFromStableAsync(StableStorage stableStorage)
+        {
+            return beatmapModelManager.ImportFromStableAsync(stableStorage);
+        }
 
-        /// <summary>
-        /// Include everything.
-        /// </summary>
-        All
+        public void Export(BeatmapSetInfo item)
+        {
+            beatmapModelManager.Export(item);
+        }
+
+        public void ExportModelTo(BeatmapSetInfo model, Stream outputStream)
+        {
+            beatmapModelManager.ExportModelTo(model, outputStream);
+        }
+
+        public void Update(BeatmapSetInfo item)
+        {
+            beatmapModelManager.Update(item);
+        }
+
+        public bool Delete(BeatmapSetInfo item)
+        {
+            return beatmapModelManager.Delete(item);
+        }
+
+        public void Delete(List<BeatmapSetInfo> items, bool silent = false)
+        {
+            beatmapModelManager.Delete(items, silent);
+        }
+
+        public void Undelete(List<BeatmapSetInfo> items, bool silent = false)
+        {
+            beatmapModelManager.Undelete(items, silent);
+        }
+
+        public void Undelete(BeatmapSetInfo item)
+        {
+            beatmapModelManager.Undelete(item);
+        }
+
+        #endregion
+
+        #region Implementation of IModelDownloader<BeatmapSetInfo>
+
+        public IBindable<WeakReference<ArchiveDownloadRequest<BeatmapSetInfo>>> DownloadBegan => beatmapModelDownloader.DownloadBegan;
+
+        public IBindable<WeakReference<ArchiveDownloadRequest<BeatmapSetInfo>>> DownloadFailed => beatmapModelDownloader.DownloadFailed;
+
+        public bool Download(BeatmapSetInfo model, bool minimiseDownloadSize = false)
+        {
+            return beatmapModelDownloader.Download(model, minimiseDownloadSize);
+        }
+
+        public ArchiveDownloadRequest<BeatmapSetInfo> GetExistingDownload(BeatmapSetInfo model)
+        {
+            return beatmapModelDownloader.GetExistingDownload(model);
+        }
+
+        #endregion
+
+        #region Implementation of ICanAcceptFiles
+
+        public Task Import(params string[] paths)
+        {
+            return beatmapModelManager.Import(paths);
+        }
+
+        public Task Import(params ImportTask[] tasks)
+        {
+            return beatmapModelManager.Import(tasks);
+        }
+
+        public Task<IEnumerable<BeatmapSetInfo>> Import(ProgressNotification notification, params ImportTask[] tasks)
+        {
+            return beatmapModelManager.Import(notification, tasks);
+        }
+
+        public Task<BeatmapSetInfo> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return beatmapModelManager.Import(task, lowPriority, cancellationToken);
+        }
+
+        public Task<BeatmapSetInfo> Import(ArchiveReader archive, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return beatmapModelManager.Import(archive, lowPriority, cancellationToken);
+        }
+
+        public Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return beatmapModelManager.Import(item, archive, lowPriority, cancellationToken);
+        }
+
+        public IEnumerable<string> HandledExtensions => beatmapModelManager.HandledExtensions;
+
+        #endregion
+
+        #region Implementation of IWorkingBeatmapCache
+
+        public WorkingBeatmap GetWorkingBeatmap(BeatmapInfo importedBeatmap) => workingBeatmapCache.GetWorkingBeatmap(importedBeatmap);
+
+        #endregion
+
+        #region Implementation of IModelFileManager<in BeatmapSetInfo,in BeatmapSetFileInfo>
+
+        public void ReplaceFile(BeatmapSetInfo model, BeatmapSetFileInfo file, Stream contents, string filename = null)
+        {
+            beatmapModelManager.ReplaceFile(model, file, contents, filename);
+        }
+
+        public void DeleteFile(BeatmapSetInfo model, BeatmapSetFileInfo file)
+        {
+            beatmapModelManager.DeleteFile(model, file);
+        }
+
+        public void AddFile(BeatmapSetInfo model, Stream contents, string filename)
+        {
+            beatmapModelManager.AddFile(model, contents, filename);
+        }
+
+        #endregion
+
+        #region Implementation of IDisposable
+
+        public void Dispose()
+        {
+            onlineBetamapLookupQueue?.Dispose();
+        }
+
+        #endregion
     }
 }

osu.Game/Beatmaps/BeatmapManager_BeatmapOnlineLookupQueue.cs

@@ -1,214 +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;
-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;
-
-                if (string.IsNullOrEmpty(beatmap.MD5Hash)
-                    && string.IsNullOrEmpty(beatmap.Path)
-                    && beatmap.OnlineBeatmapID == null)
-                    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/BeatmapModelDownloader.cs

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Platform;
+using osu.Game.Database;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+
+namespace osu.Game.Beatmaps
+{
+    public class BeatmapModelDownloader : ModelDownloader<BeatmapSetInfo>
+    {
+        protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize) =>
+            new DownloadBeatmapSetRequest(set, minimiseDownloadSize);
+
+        public BeatmapModelDownloader(BeatmapModelManager beatmapModelManager, IAPIProvider api, GameHost host = null)
+            : base(beatmapModelManager, api, host)
+        {
+        }
+    }
+}

osu.Game/Beatmaps/BeatmapModelManager.cs

@@ -0,0 +1,473 @@
+// 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 System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.Database;
+using osu.Game.IO;
+using osu.Game.IO.Archives;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Skinning;
+using Decoder = osu.Game.Beatmaps.Formats.Decoder;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// Handles ef-core storage of beatmaps.
+    /// </summary>
+    [ExcludeFromDynamicCompile]
+    public class BeatmapModelManager : ArchiveModelManager<BeatmapSetInfo, BeatmapSetFileInfo>
+    {
+        /// <summary>
+        /// Fired when a single difficulty has been hidden.
+        /// </summary>
+        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 IBindable<WeakReference<BeatmapInfo>> BeatmapRestored => beatmapRestored;
+
+        /// <summary>
+        /// An online lookup queue component which handles populating online beatmap metadata.
+        /// </summary>
+        public BeatmapOnlineLookupQueue OnlineLookupQueue { private get; set; }
+
+        /// <summary>
+        /// The game working beatmap cache, used to invalidate entries on changes.
+        /// </summary>
+        public WorkingBeatmapCache WorkingBeatmapCache { private get; set; }
+
+        private readonly Bindable<WeakReference<BeatmapInfo>> beatmapRestored = new Bindable<WeakReference<BeatmapInfo>>();
+
+        public override IEnumerable<string> HandledExtensions => new[] { ".osz" };
+
+        protected override string[] HashableFileTypes => new[] { ".osu" };
+
+        protected override string ImportFromStablePath => ".";
+
+        protected override Storage PrepareStableStorage(StableStorage stableStorage) => stableStorage.GetSongStorage();
+
+        private readonly BeatmapStore beatmaps;
+        private readonly RulesetStore rulesets;
+
+        public BeatmapModelManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, GameHost host = null)
+            : base(storage, contextFactory, new BeatmapStore(contextFactory), host)
+        {
+            this.rulesets = rulesets;
+
+            beatmaps = (BeatmapStore)ModelStore;
+            beatmaps.BeatmapHidden += b => beatmapHidden.Value = new WeakReference<BeatmapInfo>(b);
+            beatmaps.BeatmapRestored += b => beatmapRestored.Value = new WeakReference<BeatmapInfo>(b);
+            beatmaps.ItemRemoved += b => WorkingBeatmapCache?.Invalidate(b);
+            beatmaps.ItemUpdated += obj => WorkingBeatmapCache?.Invalidate(obj);
+        }
+
+        protected override bool ShouldDeleteArchive(string path) => Path.GetExtension(path)?.ToLowerInvariant() == ".osz";
+
+        protected override async Task Populate(BeatmapSetInfo beatmapSet, ArchiveReader archive, CancellationToken cancellationToken = default)
+        {
+            if (archive != null)
+                beatmapSet.Beatmaps = createBeatmapDifficulties(beatmapSet.Files);
+
+            foreach (BeatmapInfo b in beatmapSet.Beatmaps)
+            {
+                // remove metadata from difficulties where it matches the set
+                if (beatmapSet.Metadata.Equals(b.Metadata))
+                    b.Metadata = null;
+
+                b.BeatmapSet = beatmapSet;
+            }
+
+            validateOnlineIds(beatmapSet);
+
+            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)
+        {
+            if (beatmapSet.Beatmaps.Any(b => b.BaseDifficulty == null))
+                throw new InvalidOperationException($"Cannot import {nameof(BeatmapInfo)} with null {nameof(BeatmapInfo.BaseDifficulty)}.");
+
+            // check if a set already exists with the same online id, delete if it does.
+            if (beatmapSet.OnlineBeatmapSetID != null)
+            {
+                var existingOnlineId = beatmaps.ConsumableItems.FirstOrDefault(b => b.OnlineBeatmapSetID == beatmapSet.OnlineBeatmapSetID);
+
+                if (existingOnlineId != null)
+                {
+                    Delete(existingOnlineId);
+
+                    // 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.");
+                }
+            }
+        }
+
+        private void validateOnlineIds(BeatmapSetInfo beatmapSet)
+        {
+            var beatmapIds = beatmapSet.Beatmaps.Where(b => b.OnlineBeatmapID.HasValue).Select(b => b.OnlineBeatmapID).ToList();
+
+            // ensure all IDs are unique
+            if (beatmapIds.GroupBy(b => b).Any(g => g.Count() > 1))
+            {
+                LogForModel(beatmapSet, "Found non-unique IDs, resetting...");
+                resetIds();
+                return;
+            }
+
+            // find any existing beatmaps in the database that have matching online ids
+            var existingBeatmaps = QueryBeatmaps(b => beatmapIds.Contains(b.OnlineBeatmapID)).ToList();
+
+            if (existingBeatmaps.Count > 0)
+            {
+                // reset the import ids (to force a re-fetch) *unless* they match the candidate CheckForExisting set.
+                // we can ignore the case where the new ids are contained by the CheckForExisting set as it will either be used (import skipped) or deleted.
+                var existing = CheckForExisting(beatmapSet);
+
+                if (existing == null || existingBeatmaps.Any(b => !existing.Beatmaps.Contains(b)))
+                {
+                    LogForModel(beatmapSet, "Found existing import with IDs already, resetting...");
+                    resetIds();
+                }
+            }
+
+            void resetIds() => beatmapSet.Beatmaps.ForEach(b => b.OnlineBeatmapID = null);
+        }
+
+        /// <summary>
+        /// Delete a beatmap difficulty.
+        /// </summary>
+        /// <param name="beatmap">The beatmap difficulty to hide.</param>
+        public void Hide(BeatmapInfo beatmap) => beatmaps.Hide(beatmap);
+
+        /// <summary>
+        /// Restore a beatmap difficulty.
+        /// </summary>
+        /// <param name="beatmap">The beatmap difficulty to restore.</param>
+        public void Restore(BeatmapInfo beatmap) => beatmaps.Restore(beatmap);
+
+        /// <summary>
+        /// Saves an <see cref="IBeatmap"/> file against a given <see cref="BeatmapInfo"/>.
+        /// </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>
+        /// <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 = info.BeatmapSet;
+
+            using (var stream = new MemoryStream())
+            {
+                using (var sw = new StreamWriter(stream, Encoding.UTF8, 1024, true))
+                    new LegacyBeatmapEncoder(beatmapContent, beatmapSkin).Encode(sw);
+
+                stream.Seek(0, SeekOrigin.Begin);
+
+                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);
+                }
+            }
+
+            WorkingBeatmapCache?.Invalidate(info);
+        }
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <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 CanSkipImport(BeatmapSetInfo existing, BeatmapSetInfo import)
+        {
+            if (!base.CanSkipImport(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);
+            var importIds = import.Beatmaps.Select(b => b.OnlineBeatmapID).OrderBy(i => i);
+
+            // force re-import if we are not in a sane state.
+            return existing.OnlineBeatmapSetID == import.OnlineBeatmapSetID && existingIds.SequenceEqual(importIds);
+        }
+
+        /// <summary>
+        /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
+        /// </summary>
+        /// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
+        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. 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 IEnumerable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable(IncludedDetails includes, bool includeProtected = false)
+        {
+            IQueryable<BeatmapSetInfo> queryable;
+
+            switch (includes)
+            {
+                case IncludedDetails.Minimal:
+                    queryable = beatmaps.BeatmapSetsOverview;
+                    break;
+
+                case IncludedDetails.AllButRuleset:
+                    queryable = beatmaps.BeatmapSetsWithoutRuleset;
+                    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.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <param name="includes">The level of detail to include in the returned objects.</param>
+        /// <returns>Results from the provided query.</returns>
+        public IEnumerable<BeatmapSetInfo> QueryBeatmapSets(Expression<Func<BeatmapSetInfo, bool>> query, IncludedDetails includes = IncludedDetails.All)
+        {
+            IQueryable<BeatmapSetInfo> queryable;
+
+            switch (includes)
+            {
+                case IncludedDetails.Minimal:
+                    queryable = beatmaps.BeatmapSetsOverview;
+                    break;
+
+                case IncludedDetails.AllButRuleset:
+                    queryable = beatmaps.BeatmapSetsWithoutRuleset;
+                    break;
+
+                case IncludedDetails.AllButFiles:
+                    queryable = beatmaps.BeatmapSetsWithoutFiles;
+                    break;
+
+                default:
+                    queryable = beatmaps.ConsumableItems;
+                    break;
+            }
+
+            return queryable.AsNoTracking().Where(query);
+        }
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The first result for the provided query, or null if no results were found.</returns>
+        public BeatmapInfo QueryBeatmap(Expression<Func<BeatmapInfo, bool>> query) => beatmaps.Beatmaps.AsNoTracking().FirstOrDefault(query);
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>Results from the provided query.</returns>
+        public IQueryable<BeatmapInfo> QueryBeatmaps(Expression<Func<BeatmapInfo, bool>> query) => beatmaps.Beatmaps.AsNoTracking().Where(query);
+
+        public override string HumanisedModelName => "beatmap";
+
+        protected override bool CheckLocalAvailability(BeatmapSetInfo model, IQueryable<BeatmapSetInfo> items)
+            => base.CheckLocalAvailability(model, items)
+               || (model.OnlineBeatmapSetID != null && items.Any(b => b.OnlineBeatmapSetID == model.OnlineBeatmapSetID));
+
+        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", StringComparison.OrdinalIgnoreCase));
+
+            if (string.IsNullOrEmpty(mapName))
+            {
+                Logger.Log($"No beatmap files found in the beatmap archive ({reader.Name}).", LoggingTarget.Database);
+                return null;
+            }
+
+            Beatmap beatmap;
+            using (var stream = new LineBufferedReader(reader.GetStream(mapName)))
+                beatmap = Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
+
+            return new BeatmapSetInfo
+            {
+                OnlineBeatmapSetID = beatmap.BeatmapInfo.BeatmapSet?.OnlineBeatmapSetID,
+                Beatmaps = new List<BeatmapInfo>(),
+                Metadata = beatmap.Metadata,
+                DateAdded = DateTimeOffset.UtcNow
+            };
+        }
+
+        /// <summary>
+        /// Create all required <see cref="BeatmapInfo"/>s for the provided archive.
+        /// </summary>
+        private List<BeatmapInfo> createBeatmapDifficulties(List<BeatmapSetFileInfo> files)
+        {
+            var beatmapInfos = new List<BeatmapInfo>();
+
+            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 sr = new LineBufferedReader(ms))
+                {
+                    raw.CopyTo(ms);
+                    ms.Position = 0;
+
+                    var decoder = Decoder.GetDecoder<Beatmap>(sr);
+                    IBeatmap beatmap = decoder.Decode(sr);
+
+                    string hash = ms.ComputeSHA2Hash();
+
+                    if (beatmapInfos.Any(b => b.Hash == hash))
+                        continue;
+
+                    beatmap.BeatmapInfo.Path = file.Filename;
+                    beatmap.BeatmapInfo.Hash = hash;
+                    beatmap.BeatmapInfo.MD5Hash = ms.ComputeMD5Hash();
+
+                    var ruleset = rulesets.GetRuleset(beatmap.BeatmapInfo.RulesetID);
+                    beatmap.BeatmapInfo.Ruleset = ruleset;
+
+                    // 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 = 60000 / beatmap.GetMostCommonBeatLength();
+
+                    beatmapInfos.Add(beatmap.BeatmapInfo);
+                }
+            }
+
+            return beatmapInfos;
+        }
+
+        private double calculateLength(IBeatmap b)
+        {
+            if (!b.HitObjects.Any())
+                return 0;
+
+            var lastObject = b.HitObjects.Last();
+
+            //TODO: this isn't always correct (consider mania where a non-last object may last for longer than the last in the list).
+            double endTime = lastObject.GetEndTime();
+            double startTime = b.HitObjects.First().StartTime;
+
+            return endTime - startTime;
+        }
+
+        /// <summary>
+        /// A dummy WorkingBeatmap for the purpose of retrieving a beatmap for star difficulty calculation.
+        /// </summary>
+        private class DummyConversionBeatmap : WorkingBeatmap
+        {
+            private readonly IBeatmap beatmap;
+
+            public DummyConversionBeatmap(IBeatmap beatmap)
+                : base(beatmap.BeatmapInfo, null)
+            {
+                this.beatmap = beatmap;
+            }
+
+            protected override IBeatmap GetBeatmap() => beatmap;
+            protected override Texture GetBackground() => null;
+            protected override Track GetBeatmapTrack() => null;
+            protected internal 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 except ruleset. Used for cases where we aren't sure the ruleset is present but still want to consume the beatmap.
+        /// </summary>
+        AllButRuleset,
+
+        /// <summary>
+        /// Include everything.
+        /// </summary>
+        All
+    }
+}

osu.Game/Beatmaps/BeatmapOnlineLookupQueue.cs

@@ -0,0 +1,222 @@
+// 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.Database;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using SharpCompress.Compressors;
+using SharpCompress.Compressors.BZip2;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// A component which handles population of online IDs for beatmaps using a two part lookup procedure.
+    /// </summary>
+    /// <remarks>
+    /// On creating the component, a copy of a database containing metadata for a large subset of beatmaps (stored to <see cref="cache_database_name"/>) will be downloaded if not already present locally.
+    /// This will always be checked before doing a second online query to get required metadata.
+    /// </remarks>
+    [ExcludeFromDynamicCompile]
+    public 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;
+
+            if (string.IsNullOrEmpty(beatmap.MD5Hash)
+                && string.IsNullOrEmpty(beatmap.Path)
+                && beatmap.OnlineBeatmapID == null)
+                return false;
+
+            try
+            {
+                using (var db = new SqliteConnection(DatabaseContextFactory.CreateDatabaseConnectionString("online.db", storage)))
+                {
+                    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;
+        }
+
+        private void logForModel(BeatmapSetInfo set, string message) =>
+            ArchiveModelManager<BeatmapSetInfo, BeatmapSetFileInfo>.LogForModel(set, $"[{nameof(BeatmapOnlineLookupQueue)}] {message}");
+
+        public void Dispose()
+        {
+            cacheDownloadRequest?.Dispose();
+            updateScheduler?.Dispose();
+        }
+    }
+}

osu.Game/Beatmaps/IWorkingBeatmapCache.cs

@@ -0,0 +1,15 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Beatmaps
+{
+    public interface IWorkingBeatmapCache
+    {
+        /// <summary>
+        /// Retrieve a <see cref="WorkingBeatmap"/> instance for the provided <see cref="BeatmapInfo"/>
+        /// </summary>
+        /// <param name="beatmapInfo">The beatmap to lookup.</param>
+        /// <returns>A <see cref="WorkingBeatmap"/> instance correlating to the provided <see cref="BeatmapInfo"/>.</returns>
+        WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo);
+    }
+}

osu.Game/Beatmaps/WorkingBeatmapCache.cs

@@ -1,12 +1,18 @@
-// 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.CodeAnalysis;
 using System.IO;
+using System.Linq;
+using JetBrains.Annotations;
+using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.IO.Stores;
+using osu.Framework.Lists;
 using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Statistics;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
@@ -15,8 +21,96 @@ using osu.Game.Storyboards;
 
 namespace osu.Game.Beatmaps
 {
-    public partial class BeatmapManager
+    public class WorkingBeatmapCache : IBeatmapResourceProvider, IWorkingBeatmapCache
     {
+        private readonly WeakList<BeatmapManagerWorkingBeatmap> workingCache = new WeakList<BeatmapManagerWorkingBeatmap>();
+
+        /// <summary>
+        /// A default representation of a WorkingBeatmap to use when no beatmap is available.
+        /// </summary>
+        public readonly WorkingBeatmap DefaultBeatmap;
+
+        public BeatmapModelManager BeatmapManager { private get; set; }
+
+        private readonly AudioManager audioManager;
+        private readonly IResourceStore<byte[]> resources;
+        private readonly LargeTextureStore largeTextureStore;
+        private readonly ITrackStore trackStore;
+        private readonly IResourceStore<byte[]> files;
+
+        [CanBeNull]
+        private readonly GameHost host;
+
+        public WorkingBeatmapCache([NotNull] AudioManager audioManager, IResourceStore<byte[]> resources, IResourceStore<byte[]> files, WorkingBeatmap defaultBeatmap = null, GameHost host = null)
+        {
+            DefaultBeatmap = defaultBeatmap;
+
+            this.audioManager = audioManager;
+            this.resources = resources;
+            this.host = host;
+            this.files = files;
+            largeTextureStore = new LargeTextureStore(host?.CreateTextureLoaderStore(files));
+            trackStore = audioManager.GetTrackStore(files);
+        }
+
+        public void Invalidate(BeatmapSetInfo info)
+        {
+            if (info.Beatmaps == null) return;
+
+            foreach (var b in info.Beatmaps)
+                Invalidate(b);
+        }
+
+        public void Invalidate(BeatmapInfo info)
+        {
+            lock (workingCache)
+            {
+                var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == info.ID);
+                if (working != null)
+                    workingCache.Remove(working);
+            }
+        }
+
+        public virtual WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo)
+        {
+            // 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 = BeatmapManager.QueryBeatmap(b => b.ID == lookupId);
+            }
+
+            if (beatmapInfo?.BeatmapSet == null)
+                return DefaultBeatmap;
+
+            lock (workingCache)
+            {
+                var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == beatmapInfo.ID);
+                if (working != null)
+                    return working;
+
+                beatmapInfo.Metadata ??= beatmapInfo.BeatmapSet.Metadata;
+
+                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();
+
+                return working;
+            }
+        }
+
+        #region IResourceStorageProvider
+
+        TextureStore IBeatmapResourceProvider.LargeTextureStore => largeTextureStore;
+        ITrackStore IBeatmapResourceProvider.Tracks => trackStore;
+        AudioManager IStorageResourceProvider.AudioManager => audioManager;
+        IResourceStore<byte[]> IStorageResourceProvider.Files => files;
+        IResourceStore<byte[]> IStorageResourceProvider.Resources => resources;
+        IResourceStore<TextureUpload> IStorageResourceProvider.CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => host?.CreateTextureLoaderStore(underlyingStore);
+
+        #endregion
+
         [ExcludeFromDynamicCompile]
         private class BeatmapManagerWorkingBeatmap : WorkingBeatmap
         {

osu.Game/Collections/CollectionManager.cs

@@ -14,6 +14,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.IO;
 using osu.Game.IO.Legacy;
 using osu.Game.Overlays.Notifications;
@@ -27,7 +28,7 @@ namespace osu.Game.Collections
     /// 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
+    public class CollectionManager : Component, IPostNotifications
     {
         /// <summary>
         /// Database version in stable-compatible YYYYMMDD format.
@@ -106,9 +107,6 @@ namespace osu.Game.Collections
             backgroundSave();
         });
 
-        /// <summary>
-        /// Set an endpoint for notifications to be posted to.
-        /// </summary>
         public Action<Notification> PostNotification { protected get; set; }
 
         /// <summary>

osu.Game/Database/ArchiveModelManager.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Database
     /// </summary>
     /// <typeparam name="TModel">The model type.</typeparam>
     /// <typeparam name="TFileModel">The associated file join type.</typeparam>
-    public abstract class ArchiveModelManager<TModel, TFileModel> : ICanAcceptFiles, IModelManager<TModel>
+    public abstract class ArchiveModelManager<TModel, TFileModel> : ICanAcceptFiles, IModelManager<TModel>, IModelFileManager<TModel, TFileModel>, IPresentImports<TModel>
         where TModel : class, IHasFiles<TFileModel>, IHasPrimaryKey, ISoftDelete
         where TFileModel : class, INamedFileInfo, new()
     {
@@ -57,9 +57,6 @@ namespace osu.Game.Database
         /// </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>
@@ -135,7 +132,7 @@ namespace osu.Game.Database
             return Import(notification, tasks);
         }
 
-        protected async Task<IEnumerable<TModel>> Import(ProgressNotification notification, params ImportTask[] tasks)
+        public async Task<IEnumerable<TModel>> Import(ProgressNotification notification, params ImportTask[] tasks)
         {
             if (tasks.Length == 0)
             {
@@ -227,7 +224,7 @@ namespace osu.Game.Database
         /// <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>
-        internal async Task<TModel> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default)
+        public async Task<TModel> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
@@ -252,10 +249,7 @@ namespace osu.Game.Database
             return import;
         }
 
-        /// <summary>
-        /// Fired when the user requests to view the resulting import.
-        /// </summary>
-        public Action<IEnumerable<TModel>> PresentImport;
+        public Action<IEnumerable<TModel>> PresentImport { protected get; set; }
 
         /// <summary>
         /// Silently import an item from an <see cref="ArchiveReader"/>.
@@ -479,7 +473,7 @@ namespace osu.Game.Database
         /// </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)
+        public virtual void ExportModelTo(TModel model, Stream outputStream)
         {
             using (var archive = ZipArchive.Create())
             {
@@ -745,9 +739,6 @@ namespace osu.Game.Database
         /// <returns>Whether to perform deletion.</returns>
         protected virtual bool ShouldDeleteArchive(string path) => false;
 
-        /// <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)
         {
             var storage = PrepareStableStorage(stableStorage);
@@ -805,6 +796,17 @@ namespace osu.Game.Database
         /// <returns>An existing model which matches the criteria to skip importing, else null.</returns>
         protected TModel CheckForExisting(TModel model) => model.Hash == null ? null : ModelStore.ConsumableItems.FirstOrDefault(b => b.Hash == model.Hash);
 
+        public bool IsAvailableLocally(TModel model) => CheckLocalAvailability(model, ModelStore.ConsumableItems.Where(m => !m.DeletePending));
+
+        /// <summary>
+        /// Performs implementation specific comparisons to determine whether a given model is present in the local store.
+        /// </summary>
+        /// <param name="model">The <typeparamref name="TModel"/> whose existence needs to be checked.</param>
+        /// <param name="items">The usable items present in the store.</param>
+        /// <returns>Whether the <typeparamref name="TModel"/> exists.</returns>
+        protected virtual bool CheckLocalAvailability(TModel model, IQueryable<TModel> items)
+            => model.ID > 0 && items.Any(i => i.ID == model.ID && i.Files.Any());
+
         /// <summary>
         /// Whether import can be skipped after finding an existing import early in the process.
         /// Only valid when <see cref="ComputeHash"/> is not overridden.
@@ -841,7 +843,7 @@ namespace osu.Game.Database
 
         private DbSet<TModel> queryModel() => ContextFactory.Get().Set<TModel>();
 
-        protected virtual string HumanisedModelName => $"{typeof(TModel).Name.Replace(@"Info", "").ToLower()}";
+        public virtual string HumanisedModelName => $"{typeof(TModel).Name.Replace(@"Info", "").ToLower()}";
 
         #region Event handling / delaying
 

osu.Game/Database/DatabaseContextFactory.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Database
     {
         private readonly Storage storage;
 
-        private const string database_name = @"client";
+        private const string database_name = @"client.db";
 
         private ThreadLocal<OsuDbContext> threadContexts;
 
@@ -139,7 +139,7 @@ namespace osu.Game.Database
             threadContexts = new ThreadLocal<OsuDbContext>(CreateContext, true);
         }
 
-        protected virtual OsuDbContext CreateContext() => new OsuDbContext(storage.GetDatabaseConnectionString(database_name))
+        protected virtual OsuDbContext CreateContext() => new OsuDbContext(CreateDatabaseConnectionString(database_name, storage))
         {
             Database = { AutoTransactionsEnabled = false }
         };
@@ -152,7 +152,7 @@ namespace osu.Game.Database
 
                 try
                 {
-                    storage.DeleteDatabase(database_name);
+                    storage.Delete(database_name);
                 }
                 catch
                 {
@@ -171,5 +171,7 @@ namespace osu.Game.Database
 
             recycleThreadContexts();
         }
+
+        public static string CreateDatabaseConnectionString(string filename, Storage storage) => string.Concat("Data Source=", storage.GetFullPath($@"{filename}", true));
     }
 }

osu.Game/Database/IModelDownloader.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Database
     /// Represents a <see cref="IModelManager{TModel}"/> that can download new models from an external source.
     /// </summary>
     /// <typeparam name="TModel">The model type.</typeparam>
-    public interface IModelDownloader<TModel> : IModelManager<TModel>
+    public interface IModelDownloader<TModel> : IPostNotifications
         where TModel : class
     {
         /// <summary>
@@ -26,13 +26,6 @@ namespace osu.Game.Database
         /// </summary>
         IBindable<WeakReference<ArchiveDownloadRequest<TModel>>> DownloadFailed { get; }
 
-        /// <summary>
-        /// Checks whether a given <typeparamref name="TModel"/> is already available in the local store.
-        /// </summary>
-        /// <param name="model">The <typeparamref name="TModel"/> whose existence needs to be checked.</param>
-        /// <returns>Whether the <typeparamref name="TModel"/> exists.</returns>
-        bool IsAvailableLocally(TModel model);
-
         /// <summary>
         /// Begin a download for the requested <typeparamref name="TModel"/>.
         /// </summary>

osu.Game/Database/IModelFileManager.cs

@@ -0,0 +1,36 @@
+// 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.IO;
+
+namespace osu.Game.Database
+{
+    public interface IModelFileManager<in TModel, in TFileModel>
+        where TModel : class
+        where TFileModel : class
+    {
+        /// <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>
+        void ReplaceFile(TModel model, TFileModel file, Stream contents, string filename = null);
+
+        /// <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>
+        void DeleteFile(TModel model, TFileModel 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>
+        void AddFile(TModel model, Stream contents, string filename);
+    }
+}

osu.Game/Database/IModelManager.cs

@@ -1,8 +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.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using osu.Framework.Bindables;
+using osu.Game.IO;
+using osu.Game.IO.Archives;
+using osu.Game.Overlays.Notifications;
 
 namespace osu.Game.Database
 {
@@ -10,7 +17,7 @@ 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<TModel>
+    public interface IModelManager<TModel> : IPostNotifications
         where TModel : class
     {
         /// <summary>
@@ -24,5 +31,109 @@ namespace osu.Game.Database
         /// This is not thread-safe and should be scheduled locally if consumed from a drawable component.
         /// </summary>
         IBindable<WeakReference<TModel>> ItemRemoved { get; }
+
+        /// <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>
+        Task ImportFromStableAsync(StableStorage stableStorage);
+
+        /// <summary>
+        /// Exports an item to a legacy (.zip based) package.
+        /// </summary>
+        /// <param name="item">The item to export.</param>
+        void Export(TModel item);
+
+        /// <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>
+        void ExportModelTo(TModel model, Stream outputStream);
+
+        /// <summary>
+        /// Perform an update of the specified item.
+        /// TODO: Support file additions/removals.
+        /// </summary>
+        /// <param name="item">The item to update.</param>
+        void Update(TModel item);
+
+        /// <summary>
+        /// Delete an item from the manager.
+        /// Is a no-op for already deleted items.
+        /// </summary>
+        /// <param name="item">The item to delete.</param>
+        /// <returns>false if no operation was performed</returns>
+        bool Delete(TModel item);
+
+        /// <summary>
+        /// Delete multiple items.
+        /// This will post notifications tracking progress.
+        /// </summary>
+        void Delete(List<TModel> items, bool silent = false);
+
+        /// <summary>
+        /// Restore multiple items that were previously deleted.
+        /// This will post notifications tracking progress.
+        /// </summary>
+        void Undelete(List<TModel> items, bool silent = false);
+
+        /// <summary>
+        /// Restore an item that was previously deleted. Is a no-op if the item is not in a deleted state, or has its protected flag set.
+        /// </summary>
+        /// <param name="item">The item to restore</param>
+        void Undelete(TModel item);
+
+        /// <summary>
+        /// Import one or more <typeparamref name="TModel"/> items from filesystem <paramref name="paths"/>.
+        /// </summary>
+        /// <remarks>
+        /// This will be treated as a low priority import if more than one path is specified; use <see cref="ArchiveModelManager{TModel,TFileModel}.Import(osu.Game.Database.ImportTask[])"/> to always import at standard priority.
+        /// This will post notifications tracking progress.
+        /// </remarks>
+        /// <param name="paths">One or more archive locations on disk.</param>
+        Task Import(params string[] paths);
+
+        Task Import(params ImportTask[] tasks);
+
+        Task<IEnumerable<TModel>> Import(ProgressNotification notification, params ImportTask[] tasks);
+
+        /// <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="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>
+        Task<TModel> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 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>
+        Task<TModel> Import(ArchiveReader archive, bool lowPriority = false, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// 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>
+        Task<TModel> Import(TModel item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Checks whether a given <typeparamref name="TModel"/> is already available in the local store.
+        /// </summary>
+        /// <param name="model">The <typeparamref name="TModel"/> whose existence needs to be checked.</param>
+        /// <returns>Whether the <typeparamref name="TModel"/> exists.</returns>
+        bool IsAvailableLocally(TModel model);
+
+        /// <summary>
+        /// A user displayable name for the model type associated with this manager.
+        /// </summary>
+        string HumanisedModelName => $"{typeof(TModel).Name.Replace(@"Info", "").ToLower()}";
     }
 }

osu.Game/Database/IPostNotifications.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 osu.Game.Overlays.Notifications;
+
+namespace osu.Game.Database
+{
+    public interface IPostNotifications
+    {
+        /// <summary>
+        /// And action which will be fired when a notification should be presented to the user.
+        /// </summary>
+        public Action<Notification> PostNotification { set; }
+    }
+}

osu.Game/Database/IPresentImports.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;
+using System.Collections.Generic;
+
+namespace osu.Game.Database
+{
+    public interface IPresentImports<TModel>
+        where TModel : class
+    {
+        /// <summary>
+        /// Fired when the user requests to view the resulting import.
+        /// </summary>
+        public Action<IEnumerable<TModel>> PresentImport { set; }
+    }
+}

osu.Game/Database/IRealmFactory.cs

@@ -9,20 +9,12 @@ namespace osu.Game.Database
     {
         /// <summary>
         /// The main realm context, bound to the update thread.
-        /// If querying from a non-update thread is needed, use <see cref="GetForRead"/> or <see cref="GetForWrite"/> to receive a context instead.
         /// </summary>
         Realm Context { get; }
 
         /// <summary>
-        /// Get a fresh context for read usage.
+        /// Create a new realm context for use on the current thread.
         /// </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();
+        Realm CreateContext();
     }
 }

osu.Game/Database/ModelDownloader.cs

@@ -1,29 +1,24 @@
 // 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.Logging;
-using osu.Framework.Platform;
-using osu.Game.Online.API;
-using osu.Game.Overlays.Notifications;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Humanizer;
 using osu.Framework.Bindables;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Game.Online.API;
+using osu.Game.Overlays.Notifications;
 
 namespace osu.Game.Database
 {
-    /// <summary>
-    /// An <see cref="ArchiveModelManager{TModel, TFileModel}"/> that has the ability to download models using an <see cref="IAPIProvider"/> and
-    /// import them into the store.
-    /// </summary>
-    /// <typeparam name="TModel">The model type.</typeparam>
-    /// <typeparam name="TFileModel">The associated file join type.</typeparam>
-    public abstract class DownloadableArchiveModelManager<TModel, TFileModel> : ArchiveModelManager<TModel, TFileModel>, IModelDownloader<TModel>
-        where TModel : class, IHasFiles<TFileModel>, IHasPrimaryKey, ISoftDelete, IEquatable<TModel>
-        where TFileModel : class, INamedFileInfo, new()
+    public abstract class ModelDownloader<TModel> : IModelDownloader<TModel>
+        where TModel : class, IHasPrimaryKey, ISoftDelete, IEquatable<TModel>
     {
+        public Action<Notification> PostNotification { protected get; set; }
+
         public IBindable<WeakReference<ArchiveDownloadRequest<TModel>>> DownloadBegan => downloadBegan;
 
         private readonly Bindable<WeakReference<ArchiveDownloadRequest<TModel>>> downloadBegan = new Bindable<WeakReference<ArchiveDownloadRequest<TModel>>>();
@@ -32,18 +27,15 @@ namespace osu.Game.Database
 
         private readonly Bindable<WeakReference<ArchiveDownloadRequest<TModel>>> downloadFailed = new Bindable<WeakReference<ArchiveDownloadRequest<TModel>>>();
 
+        private readonly IModelManager<TModel> modelManager;
         private readonly IAPIProvider api;
 
         private readonly List<ArchiveDownloadRequest<TModel>> currentDownloads = new List<ArchiveDownloadRequest<TModel>>();
 
-        private readonly MutableDatabaseBackedStoreWithFileIncludes<TModel, TFileModel> modelStore;
-
-        protected DownloadableArchiveModelManager(Storage storage, IDatabaseContextFactory contextFactory, IAPIProvider api, MutableDatabaseBackedStoreWithFileIncludes<TModel, TFileModel> modelStore,
-                                                  IIpcHost importHost = null)
-            : base(storage, contextFactory, modelStore, importHost)
+        protected ModelDownloader(IModelManager<TModel> modelManager, IAPIProvider api, IIpcHost importHost = null)
         {
+            this.modelManager = modelManager;
             this.api = api;
-            this.modelStore = modelStore;
         }
 
         /// <summary>
@@ -54,12 +46,6 @@ namespace osu.Game.Database
         /// <returns>The request object.</returns>
         protected abstract ArchiveDownloadRequest<TModel> CreateDownloadRequest(TModel model, bool minimiseDownloadSize);
 
-        /// <summary>
-        /// Begin a download for the requested <typeparamref name="TModel"/>.
-        /// </summary>
-        /// <param name="model">The <typeparamref name="TModel"/> to be downloaded.</param>
-        /// <param name="minimiseDownloadSize">Whether this download should be optimised for slow connections. Generally means extras are not included in the download bundle.</param>
-        /// <returns>Whether the download was started.</returns>
         public bool Download(TModel model, bool minimiseDownloadSize = false)
         {
             if (!canDownload(model)) return false;
@@ -82,7 +68,7 @@ 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, new ImportTask(filename)).ConfigureAwait(false);
+                    var imported = await modelManager.Import(notification, new ImportTask(filename)).ConfigureAwait(false);
 
                     // for now a failed import will be marked as a failed download for simplicity.
                     if (!imported.Any())
@@ -117,21 +103,10 @@ namespace osu.Game.Database
                 notification.State = ProgressNotificationState.Cancelled;
 
                 if (!(error is OperationCanceledException))
-                    Logger.Error(error, $"{HumanisedModelName.Titleize()} download failed!");
+                    Logger.Error(error, $"{modelManager.HumanisedModelName.Titleize()} download failed!");
             }
         }
 
-        public bool IsAvailableLocally(TModel model) => CheckLocalAvailability(model, modelStore.ConsumableItems.Where(m => !m.DeletePending));
-
-        /// <summary>
-        /// Performs implementation specific comparisons to determine whether a given model is present in the local store.
-        /// </summary>
-        /// <param name="model">The <typeparamref name="TModel"/> whose existence needs to be checked.</param>
-        /// <param name="items">The usable items present in the store.</param>
-        /// <returns>Whether the <typeparamref name="TModel"/> exists.</returns>
-        protected virtual bool CheckLocalAvailability(TModel model, IQueryable<TModel> items)
-            => model.ID > 0 && items.Any(i => i.ID == model.ID && i.Files.Any());
-
         public ArchiveDownloadRequest<TModel> GetExistingDownload(TModel model) => currentDownloads.Find(r => r.Model.Equals(model));
 
         private bool canDownload(TModel model) => GetExistingDownload(model) == null && api != null;

osu.Game/Database/RealmContextFactory.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Development;
@@ -10,80 +9,117 @@ using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Framework.Statistics;
-using osu.Game.Input.Bindings;
 using Realms;
 
+#nullable enable
+
 namespace osu.Game.Database
 {
+    /// <summary>
+    /// A factory which provides both the main (update thread bound) realm context and creates contexts for async usage.
+    /// </summary>
     public class RealmContextFactory : Component, IRealmFactory
     {
         private readonly Storage storage;
 
-        private const string database_name = @"client";
+        /// <summary>
+        /// The filename of this realm.
+        /// </summary>
+        public readonly string Filename;
 
         private const int schema_version = 6;
 
         /// <summary>
-        /// Lock object which is held for the duration of a write operation (via <see cref="GetForWrite"/>).
+        /// Lock object which is held during <see cref="BlockAllOperations"/> sections, blocking context creation during blocking periods.
         /// </summary>
-        private readonly object writeLock = new object();
+        private readonly SemaphoreSlim contextCreationLock = new SemaphoreSlim(1);
 
-        /// <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 readonly object updateContextLock = new object();
-
-        private Realm context;
+        private readonly object contextLock = new object();
+        private Realm? context;
 
         public Realm Context
         {
             get
             {
                 if (!ThreadSafety.IsUpdateThread)
-                    throw new InvalidOperationException($"Use {nameof(GetForRead)} or {nameof(GetForWrite)} when performing realm operations from a non-update thread");
+                    throw new InvalidOperationException($"Use {nameof(CreateContext)} when performing realm operations from a non-update thread");
 
-                lock (updateContextLock)
+                lock (contextLock)
                 {
                     if (context == null)
                     {
-                        context = createContext();
+                        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)
+        public RealmContextFactory(Storage storage, string filename)
         {
             this.storage = storage;
+
+            Filename = filename;
+
+            const string realm_extension = ".realm";
+
+            if (!Filename.EndsWith(realm_extension, StringComparison.Ordinal))
+                Filename += realm_extension;
         }
 
-        public RealmUsage GetForRead()
+        /// <summary>
+        /// Compact this realm.
+        /// </summary>
+        /// <returns></returns>
+        public bool Compact() => Realm.Compact(getConfiguration());
+
+        protected override void Update()
         {
-            reads.Value++;
-            return new RealmUsage(createContext());
+            base.Update();
+
+            lock (contextLock)
+            {
+                if (context?.Refresh() == true)
+                    refreshes.Value++;
+            }
         }
 
-        public RealmWriteUsage GetForWrite()
+        public Realm CreateContext()
         {
-            writes.Value++;
-            pending_writes.Value++;
+            if (IsDisposed)
+                throw new ObjectDisposedException(nameof(RealmContextFactory));
 
-            Monitor.Enter(writeLock);
-            return new RealmWriteUsage(createContext(), writeComplete);
+            try
+            {
+                contextCreationLock.Wait();
+
+                contexts_created.Value++;
+
+                return Realm.GetInstance(getConfiguration());
+            }
+            finally
+            {
+                contextCreationLock.Release();
+            }
+        }
+
+        private RealmConfiguration getConfiguration()
+        {
+            return new RealmConfiguration(storage.GetFullPath(Filename, true))
+            {
+                SchemaVersion = schema_version,
+                MigrationCallback = onMigration,
+            };
+        }
+
+        private void onMigration(Migration migration, ulong lastSchemaVersion)
+        {
         }
 
         /// <summary>
@@ -101,163 +137,38 @@ namespace osu.Game.Database
 
             Logger.Log(@"Blocking realm operations.", LoggingTarget.Database);
 
-            blockingLock.Wait();
-            flushContexts();
+            contextCreationLock.Wait();
+
+            lock (contextLock)
+            {
+                context?.Dispose();
+                context = null;
+            }
 
             return new InvokeOnDisposal<RealmContextFactory>(this, endBlockingSection);
 
             static void endBlockingSection(RealmContextFactory factory)
             {
-                factory.blockingLock.Release();
+                factory.contextCreationLock.Release();
                 Logger.Log(@"Restoring realm operations.", LoggingTarget.Database);
             }
         }
 
-        protected override void Update()
-        {
-            base.Update();
-
-            lock (updateContextLock)
-            {
-                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);
-            Debug.Assert(blockingLock.CurrentCount == 0);
-
-            Realm previousContext;
-
-            lock (updateContextLock)
-            {
-                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)
         {
+            lock (contextLock)
+            {
+                context?.Dispose();
+            }
+
             if (!IsDisposed)
             {
                 // intentionally block all operations indefinitely. this ensures that nothing can start consuming a new context after disposal.
                 BlockAllOperations();
-                blockingLock?.Dispose();
+                contextCreationLock.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

@@ -1,51 +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.Collections.Generic;
-using AutoMapper;
-using osu.Game.Input.Bindings;
+using System;
 using Realms;
 
 namespace osu.Game.Database
 {
     public static class RealmExtensions
     {
-        private static readonly IMapper mapper = new MapperConfiguration(c =>
+        public static void Write(this Realm realm, Action<Realm> function)
         {
-            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;
+            using var transaction = realm.BeginWrite();
+            function(realm);
+            transaction.Commit();
         }
 
-        /// <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
+        public static T Write<T>(this Realm realm, Func<Realm, T> function)
         {
-            if (!item.IsManaged)
-                return item;
-
-            return mapper.Map<T>(item);
+            using var transaction = realm.BeginWrite();
+            var result = function(realm);
+            transaction.Commit();
+            return result;
         }
     }
 }

osu.Game/Database/RealmObjectExtensions.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 RealmObjectExtensions
+    {
+        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/Graphics/UserInterface/OsuDropdown.cs

@@ -274,21 +274,40 @@ namespace osu.Game.Graphics.UserInterface
                 CornerRadius = corner_radius;
                 Height = 40;
 
-                Foreground.Children = new Drawable[]
+                Foreground.Child = new GridContainer
                 {
-                    Text = new OsuSpriteText
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    RowDimensions = new[]
                     {
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
+                        new Dimension(GridSizeMode.AutoSize),
                     },
-                    Icon = new SpriteIcon
+                    ColumnDimensions = new[]
                     {
-                        Icon = FontAwesome.Solid.ChevronDown,
-                        Anchor = Anchor.CentreRight,
-                        Origin = Anchor.CentreRight,
-                        Margin = new MarginPadding { Right = 5 },
-                        Size = new Vector2(12),
+                        new Dimension(),
+                        new Dimension(GridSizeMode.AutoSize),
                     },
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            Text = new OsuSpriteText
+                            {
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                RelativeSizeAxes = Axes.X,
+                                Truncate = true,
+                            },
+                            Icon = new SpriteIcon
+                            {
+                                Icon = FontAwesome.Solid.ChevronDown,
+                                Anchor = Anchor.CentreRight,
+                                Origin = Anchor.CentreRight,
+                                Margin = new MarginPadding { Horizontal = 5 },
+                                Size = new Vector2(12),
+                            },
+                        }
+                    }
                 };
 
                 AddInternal(new HoverClickSounds());

osu.Game/IO/Serialization/JsonSerializableExtensions.cs

@@ -22,7 +22,7 @@ namespace osu.Game.IO.Serialization
             ObjectCreationHandling = ObjectCreationHandling.Replace,
             DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate,
             Converters = new List<JsonConverter> { new Vector2Converter() },
-            ContractResolver = new KeyContractResolver()
+            ContractResolver = new SnakeCaseKeyContractResolver()
         };
     }
 }

osu.Game/IO/Serialization/SnakeCaseKeyContractResolver.cs

@@ -6,7 +6,7 @@ using Newtonsoft.Json.Serialization;
 
 namespace osu.Game.IO.Serialization
 {
-    public class KeyContractResolver : DefaultContractResolver
+    public class SnakeCaseKeyContractResolver : DefaultContractResolver
     {
         protected override string ResolvePropertyName(string propertyName)
         {

osu.Game/IO/WrappedStorage.cs

@@ -70,11 +70,6 @@ namespace osu.Game.IO
         public override Stream GetStream(string path, FileAccess access = FileAccess.Read, FileMode mode = FileMode.OpenOrCreate) =>
             UnderlyingStorage.GetStream(MutatePath(path), access, mode);
 
-        public override string GetDatabaseConnectionString(string name) =>
-            UnderlyingStorage.GetDatabaseConnectionString(MutatePath(name));
-
-        public override void DeleteDatabase(string name) => UnderlyingStorage.DeleteDatabase(MutatePath(name));
-
         public override void OpenPathInNativeExplorer(string path) => UnderlyingStorage.OpenPathInNativeExplorer(MutatePath(path));
 
         public override Storage GetStorageForDirectory(string path)

osu.Game/Input/RealmKeyBindingStore.cs

@@ -7,6 +7,7 @@ using osu.Framework.Input.Bindings;
 using osu.Game.Database;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets;
+using Realms;
 
 #nullable enable
 
@@ -30,9 +31,9 @@ namespace osu.Game.Input
         {
             List<string> combinations = new List<string>();
 
-            using (var context = realmFactory.GetForRead())
+            using (var context = realmFactory.CreateContext())
             {
-                foreach (var action in context.Realm.All<RealmKeyBinding>().Where(b => b.RulesetID == null && (GlobalAction)b.ActionInt == globalAction))
+                foreach (var action in context.All<RealmKeyBinding>().Where(b => b.RulesetID == null && (GlobalAction)b.ActionInt == globalAction))
                 {
                     string str = action.KeyCombination.ReadableString();
 
@@ -52,26 +53,27 @@ namespace osu.Game.Input
         /// <param name="rulesets">The rulesets to populate defaults from.</param>
         public void Register(KeyBindingContainer container, IEnumerable<RulesetInfo> rulesets)
         {
-            using (var usage = realmFactory.GetForWrite())
+            using (var realm = realmFactory.CreateContext())
+            using (var transaction = realm.BeginWrite())
             {
                 // intentionally flattened to a list rather than querying against the IQueryable, as nullable fields being queried against aren't indexed.
                 // this is much faster as a result.
-                var existingBindings = usage.Realm.All<RealmKeyBinding>().ToList();
+                var existingBindings = realm.All<RealmKeyBinding>().ToList();
 
-                insertDefaults(usage, existingBindings, container.DefaultKeyBindings);
+                insertDefaults(realm, existingBindings, container.DefaultKeyBindings);
 
                 foreach (var ruleset in rulesets)
                 {
                     var instance = ruleset.CreateInstance();
                     foreach (var variant in instance.AvailableVariants)
-                        insertDefaults(usage, existingBindings, instance.GetDefaultKeyBindings(variant), ruleset.ID, variant);
+                        insertDefaults(realm, existingBindings, instance.GetDefaultKeyBindings(variant), ruleset.ID, variant);
                 }
 
-                usage.Commit();
+                transaction.Commit();
             }
         }
 
-        private void insertDefaults(RealmContextFactory.RealmUsage usage, List<RealmKeyBinding> existingBindings, IEnumerable<IKeyBinding> defaults, int? rulesetId = null, int? variant = null)
+        private void insertDefaults(Realm realm, List<RealmKeyBinding> existingBindings, IEnumerable<IKeyBinding> defaults, int? rulesetId = null, int? variant = null)
         {
             // compare counts in database vs defaults for each action type.
             foreach (var defaultsForAction in defaults.GroupBy(k => k.Action))
@@ -83,7 +85,7 @@ namespace osu.Game.Input
                     continue;
 
                 // insert any defaults which are missing.
-                usage.Realm.Add(defaultsForAction.Skip(existingCount).Select(k => new RealmKeyBinding
+                realm.Add(defaultsForAction.Skip(existingCount).Select(k => new RealmKeyBinding
                 {
                     KeyCombinationString = k.KeyCombination.ToString(),
                     ActionInt = (int)k.Action,

osu.Game/Online/DownloadTrackingComposite.cs

@@ -16,7 +16,7 @@ namespace osu.Game.Online
     /// </summary>
     public abstract class DownloadTrackingComposite<TModel, TModelManager> : CompositeDrawable
         where TModel : class, IEquatable<TModel>
-        where TModelManager : class, IModelDownloader<TModel>
+        where TModelManager : class, IModelDownloader<TModel>, IModelManager<TModel>
     {
         protected readonly Bindable<TModel> Model = new Bindable<TModel>();
 
@@ -35,7 +35,7 @@ namespace osu.Game.Online
             Model.Value = model;
         }
 
-        private IBindable<WeakReference<TModel>> managedUpdated;
+        private IBindable<WeakReference<TModel>> managerUpdated;
         private IBindable<WeakReference<TModel>> managerRemoved;
         private IBindable<WeakReference<ArchiveDownloadRequest<TModel>>> managerDownloadBegan;
         private IBindable<WeakReference<ArchiveDownloadRequest<TModel>>> managerDownloadFailed;
@@ -60,8 +60,8 @@ namespace osu.Game.Online
             managerDownloadBegan.BindValueChanged(downloadBegan);
             managerDownloadFailed = Manager.DownloadFailed.GetBoundCopy();
             managerDownloadFailed.BindValueChanged(downloadFailed);
-            managedUpdated = Manager.ItemUpdated.GetBoundCopy();
-            managedUpdated.BindValueChanged(itemUpdated);
+            managerUpdated = Manager.ItemUpdated.GetBoundCopy();
+            managerUpdated.BindValueChanged(itemUpdated);
             managerRemoved = Manager.ItemRemoved.GetBoundCopy();
             managerRemoved.BindValueChanged(itemRemoved);
         }
@@ -77,7 +77,7 @@ namespace osu.Game.Online
 
         /// <summary>
         /// Whether the given model is available in the database.
-        /// By default, this calls <see cref="IModelDownloader{TModel}.IsAvailableLocally"/>,
+        /// By default, this calls <see cref="IModelManager{TModel}.IsAvailableLocally"/>,
         /// but can be overriden to add additional checks for verifying the model in database.
         /// </summary>
         protected virtual bool IsModelAvailableLocally() => Manager?.IsAvailableLocally(Model.Value) == true;

osu.Game/OsuGame.cs

@@ -22,7 +22,6 @@ using Humanizer;
 using JetBrains.Annotations;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
-using osu.Framework.Development;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
@@ -210,12 +209,6 @@ namespace osu.Game
         [BackgroundDependencyLoader]
         private void load()
         {
-            if (!Host.IsPrimaryInstance && !DebugUtils.IsDebugBuild)
-            {
-                Logger.Log(@"osu! does not support multiple running instances.", LoggingTarget.Runtime, LogLevel.Error);
-                Environment.Exit(0);
-            }
-
             if (args?.Length > 0)
             {
                 var paths = args.Where(a => !a.StartsWith('-')).ToArray();

osu.Game/OsuGameBase.cs

@@ -187,7 +187,7 @@ namespace osu.Game
 
             dependencies.Cache(contextFactory = new DatabaseContextFactory(Storage));
 
-            dependencies.Cache(realmFactory = new RealmContextFactory(Storage));
+            dependencies.Cache(realmFactory = new RealmContextFactory(Storage, "client"));
 
             updateThreadState = Host.UpdateThread.State.GetBoundCopy();
             updateThreadState.BindValueChanged(updateThreadStateChanged);
@@ -242,7 +242,7 @@ namespace osu.Game
 
             // ordering is important here to ensure foreign keys rules are not broken in ModelStore.Cleanup()
             dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, contextFactory, Scheduler, Host, () => difficultyCache, LocalConfig));
-            dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, contextFactory, RulesetStore, API, Audio, Resources, Host, defaultBeatmap, true));
+            dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, contextFactory, RulesetStore, API, Audio, Resources, Host, defaultBeatmap, performOnlineLookups: true));
 
             // this should likely be moved to ArchiveModelManager when another case appears where it is necessary
             // to have inter-dependent model managers. this could be obtained with an IHasForeign<T> interface to
@@ -448,19 +448,20 @@ namespace osu.Game
         private void migrateDataToRealm()
         {
             using (var db = contextFactory.GetForWrite())
-            using (var usage = realmFactory.GetForWrite())
+            using (var realm = realmFactory.CreateContext())
+            using (var transaction = realm.BeginWrite())
             {
                 // migrate ruleset settings. can be removed 20220315.
                 var existingSettings = db.Context.DatabasedSetting;
 
                 // only migrate data if the realm database is empty.
-                if (!usage.Realm.All<RealmRulesetSetting>().Any())
+                if (!realm.All<RealmRulesetSetting>().Any())
                 {
                     foreach (var dkb in existingSettings)
                     {
                         if (dkb.RulesetID == null) continue;
 
-                        usage.Realm.Add(new RealmRulesetSetting
+                        realm.Add(new RealmRulesetSetting
                         {
                             Key = dkb.Key,
                             Value = dkb.StringValue,
@@ -472,7 +473,7 @@ namespace osu.Game
 
                 db.Context.RemoveRange(existingSettings);
 
-                usage.Commit();
+                transaction.Commit();
             }
         }
 

osu.Game/Overlays/DialogOverlay.cs

@@ -49,6 +49,8 @@ namespace osu.Game.Overlays
             Show();
         }
 
+        public override bool IsPresent => dialogContainer.Children.Count > 0;
+
         protected override bool BlockNonPositionalInput => true;
 
         private void onDialogOnStateChanged(VisibilityContainer dialog, Visibility v)

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

@@ -368,12 +368,10 @@ namespace osu.Game.Overlays.Settings.Sections.Input
 
         private void updateStoreFromButton(KeyButton button)
         {
-            using (var usage = realmFactory.GetForWrite())
+            using (var realm = realmFactory.CreateContext())
             {
-                var binding = usage.Realm.Find<RealmKeyBinding>(((IHasGuidPrimaryKey)button.KeyBinding).ID);
-                binding.KeyCombinationString = button.KeyBinding.KeyCombinationString;
-
-                usage.Commit();
+                var binding = realm.Find<RealmKeyBinding>(((IHasGuidPrimaryKey)button.KeyBinding).ID);
+                realm.Write(() => binding.KeyCombinationString = button.KeyBinding.KeyCombinationString);
             }
         }
 

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

@@ -38,8 +38,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
 
             List<RealmKeyBinding> bindings;
 
-            using (var usage = realmFactory.GetForRead())
-                bindings = usage.Realm.All<RealmKeyBinding>().Where(b => b.RulesetID == rulesetId && b.Variant == variant).Detach();
+            using (var realm = realmFactory.CreateContext())
+                bindings = realm.All<RealmKeyBinding>().Where(b => b.RulesetID == rulesetId && b.Variant == variant).Detach();
 
             foreach (var defaultGroup in Defaults.GroupBy(d => d.Action))
             {

osu.Game/Rulesets/Objects/HitObject.cs

@@ -3,11 +3,12 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ListExtensions;
+using osu.Framework.Lists;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -83,7 +84,7 @@ namespace osu.Game.Rulesets.Objects
         private readonly List<HitObject> nestedHitObjects = new List<HitObject>();
 
         [JsonIgnore]
-        public IReadOnlyList<HitObject> NestedHitObjects => nestedHitObjects;
+        public SlimReadOnlyListWrapper<HitObject> NestedHitObjects => nestedHitObjects.AsSlimReadOnly();
 
         public HitObject()
         {
@@ -91,7 +92,7 @@ namespace osu.Game.Rulesets.Objects
             {
                 double offset = time.NewValue - time.OldValue;
 
-                foreach (var nested in NestedHitObjects)
+                foreach (var nested in nestedHitObjects)
                     nested.StartTime += offset;
             };
         }
@@ -122,11 +123,14 @@ namespace osu.Game.Rulesets.Objects
 
             if (this is IHasComboInformation hasCombo)
             {
-                foreach (var n in NestedHitObjects.OfType<IHasComboInformation>())
+                foreach (HitObject hitObject in nestedHitObjects)
                 {
-                    n.ComboIndexBindable.BindTo(hasCombo.ComboIndexBindable);
-                    n.ComboIndexWithOffsetsBindable.BindTo(hasCombo.ComboIndexWithOffsetsBindable);
-                    n.IndexInCurrentComboBindable.BindTo(hasCombo.IndexInCurrentComboBindable);
+                    if (hitObject is IHasComboInformation n)
+                    {
+                        n.ComboIndexBindable.BindTo(hasCombo.ComboIndexBindable);
+                        n.ComboIndexWithOffsetsBindable.BindTo(hasCombo.ComboIndexWithOffsetsBindable);
+                        n.IndexInCurrentComboBindable.BindTo(hasCombo.IndexInCurrentComboBindable);
+                    }
                 }
             }
 

osu.Game/Scoring/ScoreManager.cs

@@ -9,102 +9,48 @@ using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
-using Microsoft.EntityFrameworkCore;
 using osu.Framework.Bindables;
-using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Database;
+using osu.Game.IO;
 using osu.Game.IO.Archives;
 using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
+using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Scoring.Legacy;
 
 namespace osu.Game.Scoring
 {
-    public class ScoreManager : DownloadableArchiveModelManager<ScoreInfo, ScoreFileInfo>
+    public class ScoreManager : IModelManager<ScoreInfo>, IModelFileManager<ScoreInfo, ScoreFileInfo>, IModelDownloader<ScoreInfo>, ICanAcceptFiles, IPresentImports<ScoreInfo>
     {
-        public override IEnumerable<string> HandledExtensions => new[] { ".osr" };
-
-        protected override string[] HashableFileTypes => new[] { ".osr" };
-
-        protected override string ImportFromStablePath => Path.Combine("Data", "r");
-
-        private readonly RulesetStore rulesets;
-        private readonly Func<BeatmapManager> beatmaps;
         private readonly Scheduler scheduler;
-
-        [CanBeNull]
         private readonly Func<BeatmapDifficultyCache> difficulties;
-
-        [CanBeNull]
         private readonly OsuConfigManager configManager;
+        private readonly ScoreModelManager scoreModelManager;
+        private readonly ScoreModelDownloader scoreModelDownloader;
 
         public ScoreManager(RulesetStore rulesets, Func<BeatmapManager> beatmaps, Storage storage, IAPIProvider api, IDatabaseContextFactory contextFactory, Scheduler scheduler,
                             IIpcHost importHost = null, Func<BeatmapDifficultyCache> difficulties = null, OsuConfigManager configManager = null)
-            : base(storage, contextFactory, api, new ScoreStore(contextFactory, storage), importHost)
         {
-            this.rulesets = rulesets;
-            this.beatmaps = beatmaps;
             this.scheduler = scheduler;
             this.difficulties = difficulties;
             this.configManager = configManager;
+
+            scoreModelManager = new ScoreModelManager(rulesets, beatmaps, storage, contextFactory, importHost);
+            scoreModelDownloader = new ScoreModelDownloader(scoreModelManager, api, importHost);
         }
 
-        protected override ScoreInfo CreateModel(ArchiveReader archive)
-        {
-            if (archive == null)
-                return null;
+        public Score GetScore(ScoreInfo score) => scoreModelManager.GetScore(score);
 
-            using (var stream = archive.GetStream(archive.Filenames.First(f => f.EndsWith(".osr", StringComparison.OrdinalIgnoreCase))))
-            {
-                try
-                {
-                    return new DatabasedLegacyScoreDecoder(rulesets, beatmaps()).Parse(stream).ScoreInfo;
-                }
-                catch (LegacyScoreDecoder.BeatmapNotFoundException e)
-                {
-                    Logger.Log(e.Message, LoggingTarget.Information, LogLevel.Error);
-                    return null;
-                }
-            }
-        }
+        public List<ScoreInfo> GetAllUsableScores() => scoreModelManager.GetAllUsableScores();
 
-        protected override Task Populate(ScoreInfo model, ArchiveReader archive, CancellationToken cancellationToken = default)
-            => Task.CompletedTask;
+        public IEnumerable<ScoreInfo> QueryScores(Expression<Func<ScoreInfo, bool>> query) => scoreModelManager.QueryScores(query);
 
-        protected override void ExportModelTo(ScoreInfo model, Stream outputStream)
-        {
-            var file = model.Files.SingleOrDefault();
-            if (file == null)
-                return;
-
-            using (var inputStream = Files.Storage.GetStream(file.FileInfo.StoragePath))
-                inputStream.CopyTo(outputStream);
-        }
-
-        protected override IEnumerable<string> GetStableImportPaths(Storage storage)
-            => storage.GetFiles(ImportFromStablePath).Where(p => HandledExtensions.Any(ext => Path.GetExtension(p)?.Equals(ext, StringComparison.OrdinalIgnoreCase) ?? false))
-                      .Select(path => storage.GetFullPath(path));
-
-        public Score GetScore(ScoreInfo score) => new LegacyDatabasedScore(score, rulesets, beatmaps(), Files.Store);
-
-        public List<ScoreInfo> GetAllUsableScores() => ModelStore.ConsumableItems.Where(s => !s.DeletePending).ToList();
-
-        public IEnumerable<ScoreInfo> QueryScores(Expression<Func<ScoreInfo, bool>> query) => ModelStore.ConsumableItems.AsNoTracking().Where(query);
-
-        public ScoreInfo Query(Expression<Func<ScoreInfo, bool>> query) => ModelStore.ConsumableItems.AsNoTracking().FirstOrDefault(query);
-
-        protected override ArchiveDownloadRequest<ScoreInfo> CreateDownloadRequest(ScoreInfo score, bool minimiseDownload) => new DownloadReplayRequest(score);
-
-        protected override bool CheckLocalAvailability(ScoreInfo model, IQueryable<ScoreInfo> items)
-            => base.CheckLocalAvailability(model, items)
-               || (model.OnlineScoreID != null && items.Any(i => i.OnlineScoreID == model.OnlineScoreID));
+        public ScoreInfo Query(Expression<Func<ScoreInfo, bool>> query) => scoreModelManager.Query(query);
 
         /// <summary>
         /// Orders an array of <see cref="ScoreInfo"/>s by total score.
@@ -281,5 +227,149 @@ namespace osu.Game.Scoring
                 this.totalScore.BindValueChanged(v => Value = v.NewValue.ToString("N0"), true);
             }
         }
+
+        #region Implementation of IPostNotifications
+
+        public Action<Notification> PostNotification
+        {
+            set
+            {
+                scoreModelManager.PostNotification = value;
+                scoreModelDownloader.PostNotification = value;
+            }
+        }
+
+        #endregion
+
+        #region Implementation of IModelManager<ScoreInfo>
+
+        public IBindable<WeakReference<ScoreInfo>> ItemUpdated => scoreModelManager.ItemUpdated;
+
+        public IBindable<WeakReference<ScoreInfo>> ItemRemoved => scoreModelManager.ItemRemoved;
+
+        public Task ImportFromStableAsync(StableStorage stableStorage)
+        {
+            return scoreModelManager.ImportFromStableAsync(stableStorage);
+        }
+
+        public void Export(ScoreInfo item)
+        {
+            scoreModelManager.Export(item);
+        }
+
+        public void ExportModelTo(ScoreInfo model, Stream outputStream)
+        {
+            scoreModelManager.ExportModelTo(model, outputStream);
+        }
+
+        public void Update(ScoreInfo item)
+        {
+            scoreModelManager.Update(item);
+        }
+
+        public bool Delete(ScoreInfo item)
+        {
+            return scoreModelManager.Delete(item);
+        }
+
+        public void Delete(List<ScoreInfo> items, bool silent = false)
+        {
+            scoreModelManager.Delete(items, silent);
+        }
+
+        public void Undelete(List<ScoreInfo> items, bool silent = false)
+        {
+            scoreModelManager.Undelete(items, silent);
+        }
+
+        public void Undelete(ScoreInfo item)
+        {
+            scoreModelManager.Undelete(item);
+        }
+
+        public Task Import(params string[] paths)
+        {
+            return scoreModelManager.Import(paths);
+        }
+
+        public Task Import(params ImportTask[] tasks)
+        {
+            return scoreModelManager.Import(tasks);
+        }
+
+        public IEnumerable<string> HandledExtensions => scoreModelManager.HandledExtensions;
+
+        public Task<IEnumerable<ScoreInfo>> Import(ProgressNotification notification, params ImportTask[] tasks)
+        {
+            return scoreModelManager.Import(notification, tasks);
+        }
+
+        public Task<ScoreInfo> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return scoreModelManager.Import(task, lowPriority, cancellationToken);
+        }
+
+        public Task<ScoreInfo> Import(ArchiveReader archive, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return scoreModelManager.Import(archive, lowPriority, cancellationToken);
+        }
+
+        public Task<ScoreInfo> Import(ScoreInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return scoreModelManager.Import(item, archive, lowPriority, cancellationToken);
+        }
+
+        public bool IsAvailableLocally(ScoreInfo model)
+        {
+            return scoreModelManager.IsAvailableLocally(model);
+        }
+
+        #endregion
+
+        #region Implementation of IModelFileManager<in ScoreInfo,in ScoreFileInfo>
+
+        public void ReplaceFile(ScoreInfo model, ScoreFileInfo file, Stream contents, string filename = null)
+        {
+            scoreModelManager.ReplaceFile(model, file, contents, filename);
+        }
+
+        public void DeleteFile(ScoreInfo model, ScoreFileInfo file)
+        {
+            scoreModelManager.DeleteFile(model, file);
+        }
+
+        public void AddFile(ScoreInfo model, Stream contents, string filename)
+        {
+            scoreModelManager.AddFile(model, contents, filename);
+        }
+
+        #endregion
+
+        #region Implementation of IModelDownloader<ScoreInfo>
+
+        public IBindable<WeakReference<ArchiveDownloadRequest<ScoreInfo>>> DownloadBegan => scoreModelDownloader.DownloadBegan;
+
+        public IBindable<WeakReference<ArchiveDownloadRequest<ScoreInfo>>> DownloadFailed => scoreModelDownloader.DownloadFailed;
+
+        public bool Download(ScoreInfo model, bool minimiseDownloadSize)
+        {
+            return scoreModelDownloader.Download(model, minimiseDownloadSize);
+        }
+
+        public ArchiveDownloadRequest<ScoreInfo> GetExistingDownload(ScoreInfo model)
+        {
+            return scoreModelDownloader.GetExistingDownload(model);
+        }
+
+        #endregion
+
+        #region Implementation of IPresentImports<ScoreInfo>
+
+        public Action<IEnumerable<ScoreInfo>> PresentImport
+        {
+            set => scoreModelManager.PresentImport = value;
+        }
+
+        #endregion
     }
 }

osu.Game/Scoring/ScoreModelDownloader.cs

@@ -0,0 +1,20 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Platform;
+using osu.Game.Database;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+
+namespace osu.Game.Scoring
+{
+    public class ScoreModelDownloader : ModelDownloader<ScoreInfo>
+    {
+        public ScoreModelDownloader(ScoreModelManager scoreManager, IAPIProvider api, IIpcHost importHost = null)
+            : base(scoreManager, api, importHost)
+        {
+        }
+
+        protected override ArchiveDownloadRequest<ScoreInfo> CreateDownloadRequest(ScoreInfo score, bool minimiseDownload) => new DownloadReplayRequest(score);
+    }
+}

osu.Game/Scoring/ScoreModelManager.cs

@@ -0,0 +1,88 @@
+// 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 System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.IO.Archives;
+using osu.Game.Rulesets;
+using osu.Game.Scoring.Legacy;
+
+namespace osu.Game.Scoring
+{
+    public class ScoreModelManager : ArchiveModelManager<ScoreInfo, ScoreFileInfo>
+    {
+        public override IEnumerable<string> HandledExtensions => new[] { ".osr" };
+
+        protected override string[] HashableFileTypes => new[] { ".osr" };
+
+        protected override string ImportFromStablePath => Path.Combine("Data", "r");
+
+        private readonly RulesetStore rulesets;
+        private readonly Func<BeatmapManager> beatmaps;
+
+        public ScoreModelManager(RulesetStore rulesets, Func<BeatmapManager> beatmaps, Storage storage, IDatabaseContextFactory contextFactory, IIpcHost importHost = null)
+            : base(storage, contextFactory, new ScoreStore(contextFactory, storage), importHost)
+        {
+            this.rulesets = rulesets;
+            this.beatmaps = beatmaps;
+        }
+
+        protected override ScoreInfo CreateModel(ArchiveReader archive)
+        {
+            if (archive == null)
+                return null;
+
+            using (var stream = archive.GetStream(archive.Filenames.First(f => f.EndsWith(".osr", StringComparison.OrdinalIgnoreCase))))
+            {
+                try
+                {
+                    return new DatabasedLegacyScoreDecoder(rulesets, beatmaps()).Parse(stream).ScoreInfo;
+                }
+                catch (LegacyScoreDecoder.BeatmapNotFoundException e)
+                {
+                    Logger.Log(e.Message, LoggingTarget.Information, LogLevel.Error);
+                    return null;
+                }
+            }
+        }
+
+        public Score GetScore(ScoreInfo score) => new LegacyDatabasedScore(score, rulesets, beatmaps(), Files.Store);
+
+        public List<ScoreInfo> GetAllUsableScores() => ModelStore.ConsumableItems.Where(s => !s.DeletePending).ToList();
+
+        public IEnumerable<ScoreInfo> QueryScores(Expression<Func<ScoreInfo, bool>> query) => ModelStore.ConsumableItems.AsNoTracking().Where(query);
+
+        public ScoreInfo Query(Expression<Func<ScoreInfo, bool>> query) => ModelStore.ConsumableItems.AsNoTracking().FirstOrDefault(query);
+
+        protected override Task Populate(ScoreInfo model, ArchiveReader archive, CancellationToken cancellationToken = default)
+            => Task.CompletedTask;
+
+        protected override bool CheckLocalAvailability(ScoreInfo model, IQueryable<ScoreInfo> items)
+            => base.CheckLocalAvailability(model, items)
+               || (model.OnlineScoreID != null && items.Any(i => i.OnlineScoreID == model.OnlineScoreID));
+
+        public override void ExportModelTo(ScoreInfo model, Stream outputStream)
+        {
+            var file = model.Files.SingleOrDefault();
+            if (file == null)
+                return;
+
+            using (var inputStream = Files.Storage.GetStream(file.FileInfo.StoragePath))
+                inputStream.CopyTo(outputStream);
+        }
+
+        protected override IEnumerable<string> GetStableImportPaths(Storage storage)
+            => storage.GetFiles(ImportFromStablePath).Where(p => HandledExtensions.Any(ext => Path.GetExtension(p)?.Equals(ext, StringComparison.OrdinalIgnoreCase) ?? false))
+                      .Select(path => storage.GetFullPath(path));
+    }
+}

osu.Game/Screens/Edit/Compose/Components/HitObjectOrderedSelectionContainer.cs

@@ -1,12 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
-using osu.Framework.Bindables;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
@@ -15,69 +15,62 @@ namespace osu.Game.Screens.Edit.Compose.Components
     /// </summary>
     public sealed class HitObjectOrderedSelectionContainer : Container<SelectionBlueprint<HitObject>>
     {
+        [Resolved]
+        private EditorBeatmap editorBeatmap { get; set; }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            editorBeatmap.HitObjectUpdated += hitObjectUpdated;
+        }
+
+        private void hitObjectUpdated(HitObject _) => SortInternal();
+
         public override void Add(SelectionBlueprint<HitObject> drawable)
         {
+            SortInternal();
             base.Add(drawable);
-            bindStartTime(drawable);
         }
 
         public override bool Remove(SelectionBlueprint<HitObject> drawable)
         {
-            if (!base.Remove(drawable))
-                return false;
-
-            unbindStartTime(drawable);
-            return true;
-        }
-
-        public override void Clear(bool disposeChildren)
-        {
-            base.Clear(disposeChildren);
-            unbindAllStartTimes();
-        }
-
-        private readonly Dictionary<SelectionBlueprint<HitObject>, IBindable> startTimeMap = new Dictionary<SelectionBlueprint<HitObject>, IBindable>();
-
-        private void bindStartTime(SelectionBlueprint<HitObject> blueprint)
-        {
-            var bindable = blueprint.Item.StartTimeBindable.GetBoundCopy();
-
-            bindable.BindValueChanged(_ =>
-            {
-                if (LoadState >= LoadState.Ready)
-                    SortInternal();
-            });
-
-            startTimeMap[blueprint] = bindable;
-        }
-
-        private void unbindStartTime(SelectionBlueprint<HitObject> blueprint)
-        {
-            startTimeMap[blueprint].UnbindAll();
-            startTimeMap.Remove(blueprint);
-        }
-
-        private void unbindAllStartTimes()
-        {
-            foreach (var kvp in startTimeMap)
-                kvp.Value.UnbindAll();
-            startTimeMap.Clear();
+            SortInternal();
+            return base.Remove(drawable);
         }
 
         protected override int Compare(Drawable x, Drawable y)
         {
-            var xObj = (SelectionBlueprint<HitObject>)x;
-            var yObj = (SelectionBlueprint<HitObject>)y;
+            var xObj = ((SelectionBlueprint<HitObject>)x).Item;
+            var yObj = ((SelectionBlueprint<HitObject>)y).Item;
 
             // Put earlier blueprints towards the end of the list, so they handle input first
-            int i = yObj.Item.StartTime.CompareTo(xObj.Item.StartTime);
-
-            if (i != 0) return i;
+            int result = yObj.StartTime.CompareTo(xObj.StartTime);
+            if (result != 0) return result;
 
             // Fall back to end time if the start time is equal.
-            i = yObj.Item.GetEndTime().CompareTo(xObj.Item.GetEndTime());
+            result = yObj.GetEndTime().CompareTo(xObj.GetEndTime());
+            if (result != 0) return result;
 
-            return i == 0 ? CompareReverseChildID(y, x) : i;
+            // As a final fallback, use combo information if available.
+            if (xObj is IHasComboInformation xHasCombo && yObj is IHasComboInformation yHasCombo)
+            {
+                result = yHasCombo.ComboIndex.CompareTo(xHasCombo.ComboIndex);
+                if (result != 0) return result;
+
+                result = yHasCombo.IndexInCurrentCombo.CompareTo(xHasCombo.IndexInCurrentCombo);
+                if (result != 0) return result;
+            }
+
+            return CompareReverseChildID(y, x);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (editorBeatmap != null)
+                editorBeatmap.HitObjectUpdated -= hitObjectUpdated;
         }
     }
 }

osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs

@@ -191,7 +191,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <param name="blueprint">The blueprint.</param>
         /// <param name="e">The mouse event responsible for selection.</param>
         /// <returns>Whether a selection was performed.</returns>
-        internal bool MouseDownSelectionRequested(SelectionBlueprint<T> blueprint, MouseButtonEvent e)
+        internal virtual bool MouseDownSelectionRequested(SelectionBlueprint<T> blueprint, MouseButtonEvent e)
         {
             if (e.ShiftPressed && e.Button == MouseButton.Right)
             {

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineSelectionHandler.cs

@@ -1,13 +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 System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Input.Bindings;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
@@ -62,5 +68,62 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 EditorBeatmap.Update(h);
             });
         }
+
+        /// <summary>
+        /// The "pivot" object, used in range selection mode.
+        /// When in range selection, the range to select is determined by the pivot object
+        /// (last existing object interacted with prior to holding down Shift)
+        /// and by the object clicked last when Shift was pressed.
+        /// </summary>
+        [CanBeNull]
+        private HitObject pivot;
+
+        internal override bool MouseDownSelectionRequested(SelectionBlueprint<HitObject> blueprint, MouseButtonEvent e)
+        {
+            if (e.ShiftPressed && e.Button == MouseButton.Left && pivot != null)
+            {
+                handleRangeSelection(blueprint, e.ControlPressed);
+                return true;
+            }
+
+            bool result = base.MouseDownSelectionRequested(blueprint, e);
+            // ensure that the object wasn't removed by the base implementation before making it the new pivot.
+            if (EditorBeatmap.HitObjects.Contains(blueprint.Item))
+                pivot = blueprint.Item;
+            return result;
+        }
+
+        /// <summary>
+        /// Handles a request for range selection (triggered when Shift is held down).
+        /// </summary>
+        /// <param name="blueprint">The blueprint which was clicked in range selection mode.</param>
+        /// <param name="cumulative">
+        /// Whether the selection should be cumulative.
+        /// In cumulative mode, consecutive range selections will shift the pivot (which usually stays fixed for the duration of a range selection)
+        /// and will never deselect an object that was previously selected.
+        /// </param>
+        private void handleRangeSelection(SelectionBlueprint<HitObject> blueprint, bool cumulative)
+        {
+            var clickedObject = blueprint.Item;
+
+            Debug.Assert(pivot != null);
+
+            double rangeStart = Math.Min(clickedObject.StartTime, pivot.StartTime);
+            double rangeEnd = Math.Max(clickedObject.GetEndTime(), pivot.GetEndTime());
+
+            var newSelection = new HashSet<HitObject>(EditorBeatmap.HitObjects.Where(obj => isInRange(obj, rangeStart, rangeEnd)));
+
+            if (cumulative)
+            {
+                pivot = clickedObject;
+                newSelection.UnionWith(EditorBeatmap.SelectedHitObjects);
+            }
+
+            EditorBeatmap.SelectedHitObjects.Clear();
+            EditorBeatmap.SelectedHitObjects.AddRange(newSelection);
+
+            bool isInRange(HitObject hitObject, double start, double end)
+                => hitObject.StartTime >= start && hitObject.GetEndTime() <= end;
+        }
     }
 }

osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoom.cs

@@ -14,6 +14,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Online.Chat;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.Components;
@@ -38,7 +39,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         private readonly Bindable<RoomCategory> roomCategory = new Bindable<RoomCategory>();
         private readonly Bindable<bool> hasPassword = new Bindable<bool>();
 
-        private RecentParticipantsList recentParticipantsList;
+        private DrawableRoomParticipantsList drawableRoomParticipantsList;
         private RoomSpecialCategoryPill specialCategoryPill;
         private PasswordProtectedIcon passwordIcon;
         private EndDateInfo endDateInfo;
@@ -136,7 +137,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                     {
                                         new FillFlowContainer
                                         {
-                                            AutoSizeAxes = Axes.Both,
+                                            RelativeSizeAxes = Axes.X,
+                                            AutoSizeAxes = Axes.Y,
                                             Direction = FillDirection.Vertical,
                                             Children = new Drawable[]
                                             {
@@ -166,13 +168,14 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                                 },
                                                 new FillFlowContainer
                                                 {
-                                                    AutoSizeAxes = Axes.Both,
+                                                    RelativeSizeAxes = Axes.X,
+                                                    AutoSizeAxes = Axes.Y,
                                                     Padding = new MarginPadding { Top = 3 },
                                                     Direction = FillDirection.Vertical,
                                                     Children = new Drawable[]
                                                     {
                                                         new RoomNameText(),
-                                                        new RoomHostText(),
+                                                        new RoomStatusText()
                                                     }
                                                 }
                                             },
@@ -217,7 +220,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                     Children = new Drawable[]
                                     {
                                         ButtonsContainer,
-                                        recentParticipantsList = new RecentParticipantsList
+                                        drawableRoomParticipantsList = new DrawableRoomParticipantsList
                                         {
                                             Anchor = Anchor.CentreRight,
                                             Origin = Anchor.CentreRight,
@@ -280,8 +283,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             {
                 numberOfAvatars = value;
 
-                if (recentParticipantsList != null)
-                    recentParticipantsList.NumberOfCircles = value;
+                if (drawableRoomParticipantsList != null)
+                    drawableRoomParticipantsList.NumberOfCircles = value;
             }
         }
 
@@ -304,38 +307,87 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             }
         }
 
-        private class RoomHostText : OnlinePlayComposite
+        private class RoomStatusText : OnlinePlayComposite
         {
-            private LinkFlowContainer hostText;
+            [Resolved]
+            private OsuColour colours { get; set; }
 
-            public RoomHostText()
+            private SpriteText statusText;
+            private LinkFlowContainer beatmapText;
+
+            public RoomStatusText()
             {
-                AutoSizeAxes = Axes.Both;
+                RelativeSizeAxes = Axes.X;
+                AutoSizeAxes = Axes.Y;
+                Width = 0.5f;
             }
 
             [BackgroundDependencyLoader]
             private void load()
             {
-                InternalChild = hostText = new LinkFlowContainer(s => s.Font = OsuFont.GetFont(size: 16))
+                InternalChild = new GridContainer
                 {
-                    AutoSizeAxes = Axes.Both
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    ColumnDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.AutoSize),
+                    },
+                    RowDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.AutoSize)
+                    },
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            statusText = new OsuSpriteText
+                            {
+                                Font = OsuFont.Default.With(size: 16),
+                                Colour = colours.Lime1
+                            },
+                            beatmapText = new LinkFlowContainer(s =>
+                            {
+                                s.Font = OsuFont.Default.With(size: 16);
+                                s.Colour = colours.Lime1;
+                            })
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y
+                            }
+                        }
+                    }
                 };
             }
 
             protected override void LoadComplete()
             {
                 base.LoadComplete();
+                SelectedItem.BindValueChanged(onSelectedItemChanged, true);
+            }
 
-                Host.BindValueChanged(host =>
+            private void onSelectedItemChanged(ValueChangedEvent<PlaylistItem> item)
+            {
+                beatmapText.Clear();
+
+                if (Type.Value == MatchType.Playlists)
                 {
-                    hostText.Clear();
+                    statusText.Text = "Ready to play";
+                    return;
+                }
 
-                    if (host.NewValue != null)
-                    {
-                        hostText.AddText("hosted by ");
-                        hostText.AddUserLink(host.NewValue);
-                    }
-                }, true);
+                if (item.NewValue?.Beatmap.Value != null)
+                {
+                    statusText.Text = "Currently playing ";
+                    beatmapText.AddLink(item.NewValue.Beatmap.Value.ToRomanisableString(),
+                        LinkAction.OpenBeatmap,
+                        item.NewValue.Beatmap.Value.OnlineBeatmapID.ToString(),
+                        creationParameters: s =>
+                        {
+                            s.Truncate = true;
+                            s.RelativeSizeAxes = Axes.X;
+                        });
+                }
             }
         }
 

osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs

@@ -4,11 +4,13 @@
 using System.Collections.Specialized;
 using System.Linq;
 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.Overlays;
 using osu.Game.Users;
@@ -17,16 +19,18 @@ using osuTK;
 
 namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 {
-    public class RecentParticipantsList : OnlinePlayComposite
+    public class DrawableRoomParticipantsList : OnlinePlayComposite
     {
         private const float avatar_size = 36;
 
         private FillFlowContainer<CircularAvatar> avatarFlow;
 
+        private CircularAvatar hostAvatar;
+        private LinkFlowContainer hostText;
         private HiddenUserCount hiddenUsers;
         private OsuSpriteText totalCount;
 
-        public RecentParticipantsList()
+        public DrawableRoomParticipantsList()
         {
             AutoSizeAxes = Axes.X;
             Height = 60;
@@ -51,42 +55,98 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 },
                 new FillFlowContainer
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    AutoSizeAxes = Axes.Both,
-                    Direction = FillDirection.Horizontal,
-                    Spacing = new Vector2(4),
-                    Padding = new MarginPadding { Right = 16 },
+                    RelativeSizeAxes = Axes.Y,
+                    AutoSizeAxes = Axes.X,
                     Children = new Drawable[]
                     {
-                        new SpriteIcon
+                        new FillFlowContainer
                         {
-                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.CentreLeft,
-                            Size = new Vector2(16),
-                            Margin = new MarginPadding { Left = 8 },
-                            Icon = FontAwesome.Solid.User,
+                            RelativeSizeAxes = Axes.Y,
+                            AutoSizeAxes = Axes.X,
+                            Spacing = new Vector2(8),
+                            Padding = new MarginPadding
+                            {
+                                Left = 8,
+                                Right = 16
+                            },
+                            Children = new Drawable[]
+                            {
+                                hostAvatar = new CircularAvatar
+                                {
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                },
+                                hostText = new LinkFlowContainer
+                                {
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    AutoSizeAxes = Axes.Both
+                                }
+                            }
                         },
-                        totalCount = new OsuSpriteText
+                        new Container
                         {
-                            Font = OsuFont.Default.With(weight: FontWeight.Bold),
-                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.CentreLeft,
+                            RelativeSizeAxes = Axes.Y,
+                            AutoSizeAxes = Axes.X,
+                            Children = new Drawable[]
+                            {
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Masking = true,
+                                    CornerRadius = 10,
+                                    Shear = new Vector2(0.2f, 0),
+                                    Child = new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = colours.Background3,
+                                    }
+                                },
+                                new FillFlowContainer
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    AutoSizeAxes = Axes.Both,
+                                    Direction = FillDirection.Horizontal,
+                                    Spacing = new Vector2(4),
+                                    Padding = new MarginPadding
+                                    {
+                                        Left = 8,
+                                        Right = 16
+                                    },
+                                    Children = new Drawable[]
+                                    {
+                                        new SpriteIcon
+                                        {
+                                            Anchor = Anchor.CentreLeft,
+                                            Origin = Anchor.CentreLeft,
+                                            Size = new Vector2(16),
+                                            Icon = FontAwesome.Solid.User,
+                                        },
+                                        totalCount = new OsuSpriteText
+                                        {
+                                            Font = OsuFont.Default.With(weight: FontWeight.Bold),
+                                            Anchor = Anchor.CentreLeft,
+                                            Origin = Anchor.CentreLeft,
+                                        },
+                                        avatarFlow = new FillFlowContainer<CircularAvatar>
+                                        {
+                                            Anchor = Anchor.CentreLeft,
+                                            Origin = Anchor.CentreLeft,
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Spacing = new Vector2(4),
+                                            Margin = new MarginPadding { Left = 4 },
+                                        },
+                                        hiddenUsers = new HiddenUserCount
+                                        {
+                                            Anchor = Anchor.CentreLeft,
+                                            Origin = Anchor.CentreLeft,
+                                        }
+                                    }
+                                }
+                            }
                         },
-                        avatarFlow = new FillFlowContainer<CircularAvatar>
-                        {
-                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.CentreLeft,
-                            AutoSizeAxes = Axes.Both,
-                            Direction = FillDirection.Horizontal,
-                            Spacing = new Vector2(4),
-                            Margin = new MarginPadding { Left = 4 },
-                        },
-                        hiddenUsers = new HiddenUserCount
-                        {
-                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.CentreLeft,
-                        }
                     }
                 }
             };
@@ -102,6 +162,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 updateHiddenUsers();
                 totalCount.Text = ParticipantCount.Value.ToString();
             }, true);
+
+            Host.BindValueChanged(onHostChanged, true);
         }
 
         private int numberOfCircles = 4;
@@ -194,6 +256,18 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             }
         }
 
+        private void onHostChanged(ValueChangedEvent<User> host)
+        {
+            hostAvatar.User = host.NewValue;
+            hostText.Clear();
+
+            if (host.NewValue != null)
+            {
+                hostText.AddText("hosted by ");
+                hostText.AddUserLink(host.NewValue);
+            }
+        }
+
         private class CircularAvatar : CompositeDrawable
         {
             public User User

osu.Game/Screens/OnlinePlay/Multiplayer/Match/BeatmapSelectionControl.cs

@@ -12,7 +12,7 @@ using osuTK;
 
 namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
 {
-    public class BeatmapSelectionControl : RoomSubScreenComposite
+    public class BeatmapSelectionControl : OnlinePlayComposite
     {
         [Resolved]
         private MultiplayerMatchSubScreen matchSubScreen { get; set; }

osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs

@@ -65,8 +65,11 @@ namespace osu.Game.Screens.OnlinePlay
         [Resolved(typeof(Room))]
         protected Bindable<TimeSpan?> Duration { get; private set; }
 
+        [Resolved(CanBeNull = true)]
+        private IBindable<PlaylistItem> subScreenSelectedItem { get; set; }
+
         /// <summary>
-        /// The currently selected item in the <see cref="RoomSubScreen"/>, or the first item from <see cref="Playlist"/>
+        /// The currently selected item in the <see cref="RoomSubScreen"/>, or the last item from <see cref="Playlist"/>
         /// if this <see cref="OnlinePlayComposite"/> is not within a <see cref="RoomSubScreen"/>.
         /// </summary>
         protected readonly Bindable<PlaylistItem> SelectedItem = new Bindable<PlaylistItem>();
@@ -75,12 +78,13 @@ namespace osu.Game.Screens.OnlinePlay
         {
             base.LoadComplete();
 
+            subScreenSelectedItem?.BindValueChanged(_ => UpdateSelectedItem());
             Playlist.BindCollectionChanged((_, __) => UpdateSelectedItem(), true);
         }
 
         protected virtual void UpdateSelectedItem()
-        {
-            SelectedItem.Value = Playlist.FirstOrDefault();
-        }
+            => SelectedItem.Value = RoomID.Value == null || subScreenSelectedItem == null
+                ? Playlist.LastOrDefault()
+                : subScreenSelectedItem.Value;
     }
 }

osu.Game/Screens/OnlinePlay/RoomSubScreenComposite.cs

@@ -1,38 +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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay.Match;
-
-namespace osu.Game.Screens.OnlinePlay
-{
-    /// <summary>
-    /// An <see cref="OnlinePlayComposite"/> with additional logic tracking the currently-selected <see cref="PlaylistItem"/> inside a <see cref="RoomSubScreen"/>.
-    /// </summary>
-    public class RoomSubScreenComposite : OnlinePlayComposite
-    {
-        [Resolved]
-        private IBindable<PlaylistItem> subScreenSelectedItem { get; set; }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            subScreenSelectedItem.BindValueChanged(_ => UpdateSelectedItem(), true);
-        }
-
-        protected override void UpdateSelectedItem()
-        {
-            if (RoomID.Value == null)
-            {
-                // If the room hasn't been created yet, fall-back to the base logic.
-                base.UpdateSelectedItem();
-                return;
-            }
-
-            SelectedItem.Value = subScreenSelectedItem.Value;
-        }
-    }
-}

osu.Game/Screens/Play/MasterGameplayClockContainer.cs

@@ -158,10 +158,10 @@ namespace osu.Game.Screens.Play
         {
             // Lazer's audio timings in general doesn't match stable. This is the result of user testing, albeit limited.
             // This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
-            platformOffsetClock = new HardwareCorrectionOffsetClock(source) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
+            platformOffsetClock = new HardwareCorrectionOffsetClock(source, pauseFreqAdjust) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
 
             // the final usable gameplay clock with user-set offsets applied.
-            userOffsetClock = new HardwareCorrectionOffsetClock(platformOffsetClock);
+            userOffsetClock = new HardwareCorrectionOffsetClock(platformOffsetClock, pauseFreqAdjust);
 
             return masterGameplayClock = new MasterGameplayClock(userOffsetClock);
         }
@@ -216,11 +216,25 @@ namespace osu.Game.Screens.Play
         {
             // we always want to apply the same real-time offset, so it should be adjusted by the difference in playback rate (from realtime) to achieve this.
             // base implementation already adds offset at 1.0 rate, so we only add the difference from that here.
-            public override double CurrentTime => base.CurrentTime + Offset * (Rate - 1);
+            public override double CurrentTime => base.CurrentTime + offsetAdjust;
 
-            public HardwareCorrectionOffsetClock(IClock source, bool processSource = true)
-                : base(source, processSource)
+            private readonly BindableDouble pauseRateAdjust;
+
+            private double offsetAdjust;
+
+            public HardwareCorrectionOffsetClock(IClock source, BindableDouble pauseRateAdjust)
+                : base(source)
             {
+                this.pauseRateAdjust = pauseRateAdjust;
+            }
+
+            public override void ProcessFrame()
+            {
+                base.ProcessFrame();
+
+                // changing this during the pause transform effect will cause a potentially large offset to be suddenly applied as we approach zero rate.
+                if (pauseRateAdjust.Value == 1)
+                    offsetAdjust = Offset * (Rate - 1);
             }
         }
 

osu.Game/Screens/Ranking/ReplayDownloadButton.cs

@@ -40,7 +40,7 @@ namespace osu.Game.Screens.Ranking
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(OsuGame game, ScoreManager scores)
+        private void load(OsuGame game, ScoreModelDownloader scores)
         {
             InternalChild = shakeContainer = new ShakeContainer
             {

osu.Game/Skinning/Editor/SkinEditorOverlay.cs

@@ -1,6 +1,8 @@
 // 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.Diagnostics;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -20,6 +22,8 @@ namespace osu.Game.Skinning.Editor
     public class SkinEditorOverlay : CompositeDrawable, IKeyBindingHandler<GlobalAction>
     {
         private readonly ScalingContainer target;
+
+        [CanBeNull]
         private SkinEditor skinEditor;
 
         public const float VISIBLE_TARGET_SCALE = 0.8f;
@@ -63,7 +67,7 @@ namespace osu.Game.Skinning.Editor
         public override void Hide()
         {
             // base call intentionally omitted.
-            skinEditor.Hide();
+            skinEditor?.Hide();
         }
 
         public override void Show()
@@ -71,8 +75,12 @@ namespace osu.Game.Skinning.Editor
             // base call intentionally omitted.
             if (skinEditor == null)
             {
-                LoadComponentAsync(skinEditor = new SkinEditor(target), AddInternal);
+                skinEditor = new SkinEditor(target);
                 skinEditor.State.BindValueChanged(editorVisibilityChanged);
+
+                Debug.Assert(skinEditor != null);
+
+                LoadComponentAsync(skinEditor, AddInternal);
             }
             else
                 skinEditor.Show();
@@ -98,8 +106,13 @@ namespace osu.Game.Skinning.Editor
             }
         }
 
-        private void updateMasking() =>
+        private void updateMasking()
+        {
+            if (skinEditor == null)
+                return;
+
             target.Masking = skinEditor.State.Value == Visibility.Visible;
+        }
 
         public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
         {

osu.Game/Tests/Visual/EditorTestScene.cs

@@ -123,11 +123,40 @@ namespace osu.Game.Tests.Visual
                 this.testBeatmap = testBeatmap;
             }
 
-            protected override string ComputeHash(BeatmapSetInfo item, ArchiveReader reader = null)
-                => string.Empty;
+            protected override BeatmapModelManager CreateBeatmapModelManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, GameHost host)
+            {
+                return new TestBeatmapModelManager(storage, contextFactory, rulesets, api, host);
+            }
 
-            public override WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo)
-                => testBeatmap;
+            protected override WorkingBeatmapCache CreateWorkingBeatmapCache(AudioManager audioManager, IResourceStore<byte[]> resources, IResourceStore<byte[]> storage, WorkingBeatmap defaultBeatmap, GameHost host)
+            {
+                return new TestWorkingBeatmapCache(this, audioManager, resources, storage, defaultBeatmap, host);
+            }
+
+            private class TestWorkingBeatmapCache : WorkingBeatmapCache
+            {
+                private readonly TestBeatmapManager testBeatmapManager;
+
+                public TestWorkingBeatmapCache(TestBeatmapManager testBeatmapManager, AudioManager audioManager, IResourceStore<byte[]> resourceStore, IResourceStore<byte[]> storage, WorkingBeatmap defaultBeatmap, GameHost gameHost)
+                    : base(audioManager, resourceStore, storage, defaultBeatmap, gameHost)
+                {
+                    this.testBeatmapManager = testBeatmapManager;
+                }
+
+                public override WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo)
+                    => testBeatmapManager.testBeatmap;
+            }
+
+            internal class TestBeatmapModelManager : BeatmapModelManager
+            {
+                public TestBeatmapModelManager(Storage storage, IDatabaseContextFactory databaseContextFactory, RulesetStore rulesetStore, IAPIProvider apiProvider, GameHost gameHost)
+                    : base(storage, databaseContextFactory, rulesetStore, gameHost)
+                {
+                }
+
+                protected override string ComputeHash(BeatmapSetInfo item, ArchiveReader reader = null)
+                    => string.Empty;
+            }
 
             public override void Save(BeatmapInfo info, IBeatmap beatmapContent, ISkin beatmapSkin = null)
             {

osu.Game/osu.Game.csproj

@@ -36,7 +36,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="10.5.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2021.916.1" />
+    <PackageReference Include="ppy.osu.Framework" Version="2021.929.0" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2021.918.0" />
     <PackageReference Include="Sentry" Version="3.9.0" />
     <PackageReference Include="SharpCompress" Version="0.29.0" />

osu.iOS.props

@@ -70,7 +70,7 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2021.916.1" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2021.929.0" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2021.918.0" />
   </ItemGroup>
   <!-- See https://github.com/dotnet/runtime/issues/35988 (can be removed after Xamarin uses net5.0 / net6.0) -->
@@ -93,7 +93,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="ppy.osu.Framework" Version="2021.916.1" />
+    <PackageReference Include="ppy.osu.Framework" Version="2021.929.0" />
     <PackageReference Include="SharpCompress" Version="0.28.3" />
     <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />