Merge pull request #16657 from peppy/skip-scores-missing-beatmap

Skip scores missing beatmaps during realm migration

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform.Tests/VisualTestRunner.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.EmptyFreeform.Tests
         [STAThread]
         public static int Main(string[] args)
         {
-            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true))
+            using (DesktopGameHost host = Host.GetSuitableDesktopHost(@"osu", new HostOptions { BindIPC = true }))
             {
                 host.Run(new OsuTestBrowser());
                 return 0;

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform.Tests/osu.Game.Rulesets.EmptyFreeform.Tests.csproj

@@ -12,7 +12,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <ItemGroup>

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon.Tests/VisualTestRunner.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Pippidon.Tests
         [STAThread]
         public static int Main(string[] args)
         {
-            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true))
+            using (DesktopGameHost host = Host.GetSuitableDesktopHost(@"osu", new HostOptions { BindIPC = true }))
             {
                 host.Run(new OsuTestBrowser());
                 return 0;

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj

@@ -12,7 +12,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <ItemGroup>

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling.Tests/VisualTestRunner.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.EmptyScrolling.Tests
         [STAThread]
         public static int Main(string[] args)
         {
-            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true))
+            using (DesktopGameHost host = Host.GetSuitableDesktopHost(@"osu", new HostOptions { BindIPC = true }))
             {
                 host.Run(new OsuTestBrowser());
                 return 0;

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling.Tests/osu.Game.Rulesets.EmptyScrolling.Tests.csproj

@@ -12,7 +12,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <ItemGroup>

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon.Tests/VisualTestRunner.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Pippidon.Tests
         [STAThread]
         public static int Main(string[] args)
         {
-            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true))
+            using (DesktopGameHost host = Host.GetSuitableDesktopHost(@"osu", new HostOptions { BindIPC = true }))
             {
                 host.Run(new OsuTestBrowser());
                 return 0;

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj

@@ -12,7 +12,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <ItemGroup>

osu.Android.props

@@ -52,7 +52,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2022.115.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.118.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.126.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

@@ -55,7 +55,7 @@ namespace osu.Desktop
                 }
             }
 
-            using (DesktopGameHost host = Host.GetSuitableHost(gameName, true))
+            using (DesktopGameHost host = Host.GetSuitableDesktopHost(gameName, new HostOptions { BindIPC = true }))
             {
                 host.ExceptionThrown += handleException;
 

osu.Game.Benchmarks/BenchmarkRealmReads.cs

@@ -0,0 +1,141 @@
+// 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 System.Threading;
+using BenchmarkDotNet.Attributes;
+using osu.Framework.Testing;
+using osu.Framework.Threading;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Benchmarks
+{
+    public class BenchmarkRealmReads : BenchmarkTest
+    {
+        private TemporaryNativeStorage storage;
+        private RealmAccess realm;
+        private UpdateThread updateThread;
+
+        [Params(1, 100, 1000)]
+        public int ReadsPerFetch { get; set; }
+
+        public override void SetUp()
+        {
+            storage = new TemporaryNativeStorage("realm-benchmark");
+            storage.DeleteDirectory(string.Empty);
+
+            realm = new RealmAccess(storage, "client");
+
+            realm.Run(r =>
+            {
+                realm.Write(c => c.Add(TestResources.CreateTestBeatmapSetInfo(rulesets: new[] { new OsuRuleset().RulesetInfo })));
+            });
+
+            updateThread = new UpdateThread(() => { }, null);
+            updateThread.Start();
+        }
+
+        [Benchmark]
+        public void BenchmarkDirectPropertyRead()
+        {
+            realm.Run(r =>
+            {
+                var beatmapSet = r.All<BeatmapSetInfo>().First();
+
+                for (int i = 0; i < ReadsPerFetch; i++)
+                {
+                    string _ = beatmapSet.Beatmaps.First().Hash;
+                }
+            });
+        }
+
+        [Benchmark]
+        public void BenchmarkDirectPropertyReadUpdateThread()
+        {
+            var done = new ManualResetEventSlim();
+
+            updateThread.Scheduler.Add(() =>
+            {
+                try
+                {
+                    var beatmapSet = realm.Realm.All<BeatmapSetInfo>().First();
+
+                    for (int i = 0; i < ReadsPerFetch; i++)
+                    {
+                        string _ = beatmapSet.Beatmaps.First().Hash;
+                    }
+                }
+                finally
+                {
+                    done.Set();
+                }
+            });
+
+            done.Wait();
+        }
+
+        [Benchmark]
+        public void BenchmarkRealmLivePropertyRead()
+        {
+            realm.Run(r =>
+            {
+                var beatmapSet = r.All<BeatmapSetInfo>().First().ToLive(realm);
+
+                for (int i = 0; i < ReadsPerFetch; i++)
+                {
+                    string _ = beatmapSet.PerformRead(b => b.Beatmaps.First().Hash);
+                }
+            });
+        }
+
+        [Benchmark]
+        public void BenchmarkRealmLivePropertyReadUpdateThread()
+        {
+            var done = new ManualResetEventSlim();
+
+            updateThread.Scheduler.Add(() =>
+            {
+                try
+                {
+                    var beatmapSet = realm.Realm.All<BeatmapSetInfo>().First().ToLive(realm);
+
+                    for (int i = 0; i < ReadsPerFetch; i++)
+                    {
+                        string _ = beatmapSet.PerformRead(b => b.Beatmaps.First().Hash);
+                    }
+                }
+                finally
+                {
+                    done.Set();
+                }
+            });
+
+            done.Wait();
+        }
+
+        [Benchmark]
+        public void BenchmarkDetachedPropertyRead()
+        {
+            realm.Run(r =>
+            {
+                var beatmapSet = r.All<BeatmapSetInfo>().First().Detach();
+
+                for (int i = 0; i < ReadsPerFetch; i++)
+                {
+                    string _ = beatmapSet.Beatmaps.First().Hash;
+                }
+            });
+        }
+
+        [GlobalCleanup]
+        public void Cleanup()
+        {
+            realm?.Dispose();
+            storage?.Dispose();
+            updateThread?.Exit();
+        }
+    }
+}

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

@@ -9,7 +9,7 @@
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
     <PackageReference Include="nunit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
   </ItemGroup>
 
   <ItemGroup>

osu.Game.Rulesets.Catch.Tests/Editor/CatchSelectionBlueprintTestScene.cs

@@ -29,7 +29,13 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
 
         protected CatchSelectionBlueprintTestScene()
         {
-            EditorBeatmap = new EditorBeatmap(new CatchBeatmap()) { Difficulty = { CircleSize = 0 } };
+            EditorBeatmap = new EditorBeatmap(new CatchBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Ruleset = new CatchRuleset().RulesetInfo,
+                }
+            }) { Difficulty = { CircleSize = 0 } };
             EditorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint
             {
                 BeatLength = 100

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty { CircleSize = 6, SliderMultiplier = 3 },
+                    Difficulty = new BeatmapDifficulty { CircleSize = 6, SliderMultiplier = 3 },
                     Ruleset = ruleset
                 }
             };

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty { CircleSize = 6 },
+                    Difficulty = new BeatmapDifficulty { CircleSize = 6 },
                     Ruleset = ruleset
                 }
             };

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

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty { CircleSize = 6 },
+                    Difficulty = new BeatmapDifficulty { CircleSize = 6 },
                     Ruleset = ruleset
                 }
             };

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

@@ -35,12 +35,12 @@ namespace osu.Game.Rulesets.Catch.Tests
                 HitObjects = new List<HitObject> { new Fruit() },
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty(),
+                    Difficulty = new BeatmapDifficulty(),
                     Metadata = new BeatmapMetadata
                     {
                         Artist = @"Unknown",
                         Title = @"You're breathtaking",
-                        AuthorString = @"Everyone",
+                        Author = { Username = @"Everyone" },
                     },
                     Ruleset = new CatchRuleset().RulesetInfo
                 },

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

@@ -63,7 +63,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                 BeatmapInfo =
                 {
                     Ruleset = ruleset,
-                    BaseDifficulty = new BeatmapDifficulty { CircleSize = 3.6f }
+                    Difficulty = new BeatmapDifficulty { CircleSize = 3.6f }
                 }
             };
 

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             BeatmapInfo = new BeatmapInfo
             {
-                BaseDifficulty = new BeatmapDifficulty { CircleSize = 5, SliderMultiplier = 2 },
+                Difficulty = new BeatmapDifficulty { CircleSize = 5, SliderMultiplier = 2 },
                 Ruleset = ruleset
             },
             HitObjects = new List<HitObject>

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

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

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

@@ -3,6 +3,7 @@
 
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
@@ -15,9 +16,26 @@ namespace osu.Game.Rulesets.Catch.Mods
     {
         public override double ScoreMultiplier => 1.12;
 
-        private const float default_flashlight_size = 350;
+        [SettingSource("Flashlight size", "Multiplier applied to the default flashlight size.")]
+        public override BindableNumber<float> SizeMultiplier { get; } = new BindableNumber<float>
+        {
+            MinValue = 0.5f,
+            MaxValue = 1.5f,
+            Default = 1f,
+            Value = 1f,
+            Precision = 0.1f
+        };
 
-        public override Flashlight CreateFlashlight() => new CatchFlashlight(playfield);
+        [SettingSource("Change size based on combo", "Decrease the flashlight size as combo increases.")]
+        public override BindableBool ComboBasedSize { get; } = new BindableBool
+        {
+            Default = true,
+            Value = true
+        };
+
+        public override float DefaultFlashlightSize => 350;
+
+        protected override Flashlight CreateFlashlight() => new CatchFlashlight(this, playfield);
 
         private CatchPlayfield playfield;
 
@@ -31,10 +49,11 @@ namespace osu.Game.Rulesets.Catch.Mods
         {
             private readonly CatchPlayfield playfield;
 
-            public CatchFlashlight(CatchPlayfield playfield)
+            public CatchFlashlight(CatchModFlashlight modFlashlight, CatchPlayfield playfield)
+                : base(modFlashlight)
             {
                 this.playfield = playfield;
-                FlashlightSize = new Vector2(0, getSizeFor(0));
+                FlashlightSize = new Vector2(0, GetSizeFor(0));
             }
 
             protected override void Update()
@@ -44,19 +63,9 @@ namespace osu.Game.Rulesets.Catch.Mods
                 FlashlightPosition = playfield.CatcherArea.ToSpaceOfOtherDrawable(playfield.Catcher.DrawPosition, this);
             }
 
-            private float getSizeFor(int combo)
-            {
-                if (combo > 200)
-                    return default_flashlight_size * 0.8f;
-                else if (combo > 100)
-                    return default_flashlight_size * 0.9f;
-                else
-                    return default_flashlight_size;
-            }
-
             protected override void OnComboChange(ValueChangedEvent<int> e)
             {
-                this.TransformTo(nameof(FlashlightSize), new Vector2(0, getSizeFor(e.NewValue)), FLASHLIGHT_FADE_DURATION);
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, GetSizeFor(e.NewValue)), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "CircularFlashlight";

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

@@ -29,7 +29,13 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         private ScrollingTestContainer.TestScrollingInfo scrollingInfo = new ScrollingTestContainer.TestScrollingInfo();
 
         [Cached(typeof(EditorBeatmap))]
-        private EditorBeatmap editorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition()));
+        private EditorBeatmap editorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition())
+        {
+            BeatmapInfo =
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            }
+        });
 
         private readonly ManiaBeatSnapGrid beatSnapGrid;
 

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

@@ -31,10 +31,10 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         {
             AddStep("setup compose screen", () =>
             {
-                var editorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 }))
+                var editorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 })
                 {
                     BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
-                };
+                });
 
                 Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
 

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

@@ -203,10 +203,10 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             {
                 InternalChildren = new Drawable[]
                 {
-                    EditorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 }))
+                    EditorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 })
                     {
                         BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo }
-                    },
+                    }),
                     Composer = new ManiaHitObjectComposer(new ManiaRuleset())
                 };
 

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

@@ -264,7 +264,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 },
                 BeatmapInfo =
                 {
-                    BaseDifficulty = new BeatmapDifficulty
+                    Difficulty = new BeatmapDifficulty
                     {
                         SliderTickRate = 4,
                         OverallDifficulty = 10,
@@ -306,7 +306,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 },
                 BeatmapInfo =
                 {
-                    BaseDifficulty = new BeatmapDifficulty { SliderTickRate = tick_rate },
+                    Difficulty = new BeatmapDifficulty { SliderTickRate = tick_rate },
                     Ruleset = new ManiaRuleset().RulesetInfo
                 },
             };
@@ -383,7 +383,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                     },
                     BeatmapInfo =
                     {
-                        BaseDifficulty = new BeatmapDifficulty { SliderTickRate = 4 },
+                        Difficulty = new BeatmapDifficulty { SliderTickRate = 4 },
                         Ruleset = new ManiaRuleset().RulesetInfo
                     },
                 };

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

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         public static int GetColumnCountForNonConvert(BeatmapInfo beatmapInfo)
         {
-            double roundedCircleSize = Math.Round(beatmapInfo.BaseDifficulty.CircleSize);
+            double roundedCircleSize = Math.Round(beatmapInfo.Difficulty.CircleSize);
             return (int)Math.Max(1, roundedCircleSize);
         }
 

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Mania
 
         public bool Matches(BeatmapInfo beatmapInfo)
         {
-            return !keys.HasFilter || (beatmapInfo.RulesetID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmapInfo)));
+            return !keys.HasFilter || (beatmapInfo.Ruleset.OnlineID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmapInfo)));
         }
 
         public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)

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

@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Layout;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 using osuTK;
@@ -16,17 +17,35 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(ModHidden) };
 
-        private const float default_flashlight_size = 180;
+        [SettingSource("Flashlight size", "Multiplier applied to the default flashlight size.")]
+        public override BindableNumber<float> SizeMultiplier { get; } = new BindableNumber<float>
+        {
+            MinValue = 0.5f,
+            MaxValue = 3f,
+            Default = 1f,
+            Value = 1f,
+            Precision = 0.1f
+        };
 
-        public override Flashlight CreateFlashlight() => new ManiaFlashlight();
+        [SettingSource("Change size based on combo", "Decrease the flashlight size as combo increases.")]
+        public override BindableBool ComboBasedSize { get; } = new BindableBool
+        {
+            Default = false,
+            Value = false
+        };
+
+        public override float DefaultFlashlightSize => 50;
+
+        protected override Flashlight CreateFlashlight() => new ManiaFlashlight(this);
 
         private class ManiaFlashlight : Flashlight
         {
             private readonly LayoutValue flashlightProperties = new LayoutValue(Invalidation.DrawSize);
 
-            public ManiaFlashlight()
+            public ManiaFlashlight(ManiaModFlashlight modFlashlight)
+                : base(modFlashlight)
             {
-                FlashlightSize = new Vector2(0, default_flashlight_size);
+                FlashlightSize = new Vector2(DrawWidth, GetSizeFor(0));
 
                 AddLayout(flashlightProperties);
             }
@@ -46,6 +65,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
             protected override void OnComboChange(ValueChangedEvent<int> e)
             {
+                this.TransformTo(nameof(FlashlightSize), new Vector2(DrawWidth, GetSizeFor(e.NewValue)), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "RectangularFlashlight";

osu.Game.Rulesets.Osu.Tests/Editor/Checks/CheckTooShortSpinnersTest.cs

@@ -107,7 +107,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor.Checks
             var beatmap = new Beatmap<HitObject>
             {
                 HitObjects = hitObjects,
-                BeatmapInfo = new BeatmapInfo { BaseDifficulty = new BeatmapDifficulty(beatmapDifficulty) }
+                BeatmapInfo = new BeatmapInfo { Difficulty = new BeatmapDifficulty(beatmapDifficulty) }
             };
 
             return new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));

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

@@ -40,7 +40,13 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
         public TestSceneOsuDistanceSnapGrid()
         {
-            editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+            editorBeatmap = new EditorBeatmap(new OsuBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo
+                }
+            });
         }
 
         [SetUp]

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

@@ -0,0 +1,98 @@
+// 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 System.Linq;
+using NUnit.Framework;
+using osu.Framework.Input;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osu.Game.Screens.Edit.Timing;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    public class TestSceneSliderVelocityAdjust : OsuGameTestScene
+    {
+        private Screens.Edit.Editor editor => Game.ScreenStack.CurrentScreen as Screens.Edit.Editor;
+
+        private EditorBeatmap editorBeatmap => editor.ChildrenOfType<EditorBeatmap>().FirstOrDefault();
+
+        private EditorClock editorClock => editor.ChildrenOfType<EditorClock>().FirstOrDefault();
+
+        private Slider slider => editorBeatmap.HitObjects.OfType<Slider>().FirstOrDefault();
+
+        private TimelineHitObjectBlueprint blueprint => editor.ChildrenOfType<TimelineHitObjectBlueprint>().FirstOrDefault();
+
+        private DifficultyPointPiece difficultyPointPiece => blueprint.ChildrenOfType<DifficultyPointPiece>().First();
+
+        private IndeterminateSliderWithTextBoxInput<double> velocityTextBox => Game.ChildrenOfType<DifficultyPointPiece.DifficultyEditPopover>().First().ChildrenOfType<IndeterminateSliderWithTextBoxInput<double>>().First();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        private bool editorComponentsReady => editor.ChildrenOfType<HitObjectComposer>().FirstOrDefault()?.IsLoaded == true
+                                              && editor.ChildrenOfType<TimelineArea>().FirstOrDefault()?.IsLoaded == true
+                                              && editor?.ChildrenOfType<Playfield>().FirstOrDefault()?.IsLoaded == true;
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestVelocityChangeSavesCorrectly(bool adjustVelocity)
+        {
+            double? velocity = null;
+
+            AddStep("enter editor", () => Game.ScreenStack.Push(new EditorLoader()));
+            AddUntilStep("wait for editor load", () => editorComponentsReady);
+
+            AddStep("seek to first control point", () => editorClock.Seek(editorBeatmap.ControlPointInfo.TimingPoints.First().Time));
+            AddStep("enter slider placement mode", () => InputManager.Key(Key.Number3));
+
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(editor.ChildrenOfType<Playfield>().First().ScreenSpaceDrawQuad.Centre));
+            AddStep("start placement", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move mouse to bottom right", () => InputManager.MoveMouseTo(editor.ChildrenOfType<Playfield>().First().ScreenSpaceDrawQuad.BottomRight - new Vector2(10)));
+            AddStep("end placement", () => InputManager.Click(MouseButton.Right));
+
+            AddStep("exit placement mode", () => InputManager.Key(Key.Number1));
+
+            AddAssert("slider placed", () => slider != null);
+
+            AddStep("select slider", () => editorBeatmap.SelectedHitObjects.Add(slider));
+
+            AddAssert("ensure one slider placed", () => slider != null);
+
+            AddStep("store velocity", () => velocity = slider.Velocity);
+
+            if (adjustVelocity)
+            {
+                AddStep("open velocity adjust panel", () => difficultyPointPiece.TriggerClick());
+                AddStep("change velocity", () => velocityTextBox.Current.Value = 2);
+
+                AddAssert("velocity adjusted", () =>
+                {
+                    Debug.Assert(velocity != null);
+                    return Precision.AlmostEquals(velocity.Value * 2, slider.Velocity);
+                });
+
+                AddStep("store velocity", () => velocity = slider.Velocity);
+            }
+
+            AddStep("save", () => InputManager.Keys(PlatformAction.Save));
+            AddStep("exit", () => InputManager.Key(Key.Escape));
+
+            AddStep("enter editor (again)", () => Game.ScreenStack.Push(new EditorLoader()));
+            AddUntilStep("wait for editor load", () => editorComponentsReady);
+
+            AddStep("seek to slider", () => editorClock.Seek(slider.StartTime));
+            AddAssert("slider has correct velocity", () => slider.Velocity == velocity);
+        }
+    }
+}

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty
+                    Difficulty = new BeatmapDifficulty
                     {
                         CircleSize = 8
                     }

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

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty { CircleSize = 6 },
+                    Difficulty = new BeatmapDifficulty { CircleSize = 6 },
                     Ruleset = ruleset
                 }
             };

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

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty { OverallDifficulty = 10 },
+                    Difficulty = new BeatmapDifficulty { OverallDifficulty = 10 },
                     Ruleset = ruleset
                 }
             };

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

@@ -358,7 +358,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     },
                     BeatmapInfo =
                     {
-                        BaseDifficulty = new BeatmapDifficulty { SliderTickRate = 3 },
+                        Difficulty = new BeatmapDifficulty { SliderTickRate = 3 },
                         Ruleset = new OsuRuleset().RulesetInfo
                     },
                 });

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

@@ -364,7 +364,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     HitObjects = hitObjects,
                     BeatmapInfo =
                     {
-                        BaseDifficulty = new BeatmapDifficulty { SliderTickRate = 3 },
+                        Difficulty = new BeatmapDifficulty { SliderTickRate = 3 },
                         Ruleset = new OsuRuleset().RulesetInfo
                     },
                 });

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

@@ -5,7 +5,7 @@
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="Moq" Version="4.16.1" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         private int countMeh;
         private int countMiss;
 
-        private int effectiveMissCount;
+        private double effectiveMissCount;
 
         public OsuPerformanceCalculator(Ruleset ruleset, DifficultyAttributes attributes, ScoreInfo score)
             : base(ruleset, attributes, score)
@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             if (effectiveMissCount > 0)
-                aimValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), effectiveMissCount);
+                aimValue *= 0.97 * Math.Pow(1 - Math.Pow(effectiveMissCount / totalHits, 0.775), effectiveMissCount);
 
             aimValue *= getComboScalingFactor();
 
@@ -144,7 +144,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             if (effectiveMissCount > 0)
-                speedValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
+                speedValue *= 0.97 * Math.Pow(1 - Math.Pow(effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
 
             speedValue *= getComboScalingFactor();
 
@@ -228,7 +228,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             if (effectiveMissCount > 0)
-                flashlightValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
+                flashlightValue *= 0.97 * Math.Pow(1 - Math.Pow(effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
 
             flashlightValue *= getComboScalingFactor();
 
@@ -244,7 +244,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             return flashlightValue;
         }
 
-        private int calculateEffectiveMissCount()
+        private double calculateEffectiveMissCount()
         {
             // Guess the number of misses + slider breaks from combo
             double comboBasedMissCount = 0.0;
@@ -256,10 +256,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                     comboBasedMissCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
             }
 
-            // Clamp misscount since it's derived from combo and can be higher than total hits and that breaks some calculations
+            // Clamp miss count since it's derived from combo and can be higher than total hits and that breaks some calculations
             comboBasedMissCount = Math.Min(comboBasedMissCount, totalHits);
 
-            return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
+            return Math.Max(countMiss, comboBasedMissCount);
         }
 
         private double getComboScalingFactor() => Attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);

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

@@ -12,7 +12,6 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.UI;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
@@ -21,27 +20,8 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override double ScoreMultiplier => 1.12;
 
-        private const float default_flashlight_size = 180;
-
         private const double default_follow_delay = 120;
 
-        private OsuFlashlight flashlight;
-
-        public override Flashlight CreateFlashlight() => flashlight = new OsuFlashlight();
-
-        public void ApplyToDrawableHitObject(DrawableHitObject drawable)
-        {
-            if (drawable is DrawableSlider s)
-                s.Tracking.ValueChanged += flashlight.OnSliderTrackingChange;
-        }
-
-        public override void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
-        {
-            base.ApplyToDrawableRuleset(drawableRuleset);
-
-            flashlight.FollowDelay = FollowDelay.Value;
-        }
-
         [SettingSource("Follow delay", "Milliseconds until the flashlight reaches the cursor")]
         public BindableNumber<double> FollowDelay { get; } = new BindableDouble(default_follow_delay)
         {
@@ -50,13 +30,45 @@ namespace osu.Game.Rulesets.Osu.Mods
             Precision = default_follow_delay,
         };
 
+        [SettingSource("Flashlight size", "Multiplier applied to the default flashlight size.")]
+        public override BindableNumber<float> SizeMultiplier { get; } = new BindableNumber<float>
+        {
+            MinValue = 0.5f,
+            MaxValue = 2f,
+            Default = 1f,
+            Value = 1f,
+            Precision = 0.1f
+        };
+
+        [SettingSource("Change size based on combo", "Decrease the flashlight size as combo increases.")]
+        public override BindableBool ComboBasedSize { get; } = new BindableBool
+        {
+            Default = true,
+            Value = true
+        };
+
+        public override float DefaultFlashlightSize => 180;
+
+        private OsuFlashlight flashlight;
+
+        protected override Flashlight CreateFlashlight() => flashlight = new OsuFlashlight(this);
+
+        public void ApplyToDrawableHitObject(DrawableHitObject drawable)
+        {
+            if (drawable is DrawableSlider s)
+                s.Tracking.ValueChanged += flashlight.OnSliderTrackingChange;
+        }
+
         private class OsuFlashlight : Flashlight, IRequireHighFrequencyMousePosition
         {
-            public double FollowDelay { private get; set; }
+            private readonly double followDelay;
 
-            public OsuFlashlight()
+            public OsuFlashlight(OsuModFlashlight modFlashlight)
+                : base(modFlashlight)
             {
-                FlashlightSize = new Vector2(0, getSizeFor(0));
+                followDelay = modFlashlight.FollowDelay.Value;
+
+                FlashlightSize = new Vector2(0, GetSizeFor(0));
             }
 
             public void OnSliderTrackingChange(ValueChangedEvent<bool> e)
@@ -71,24 +83,14 @@ namespace osu.Game.Rulesets.Osu.Mods
                 var destination = e.MousePosition;
 
                 FlashlightPosition = Interpolation.ValueAt(
-                    Math.Min(Math.Abs(Clock.ElapsedFrameTime), FollowDelay), position, destination, 0, FollowDelay, Easing.Out);
+                    Math.Min(Math.Abs(Clock.ElapsedFrameTime), followDelay), position, destination, 0, followDelay, Easing.Out);
 
                 return base.OnMouseMove(e);
             }
 
-            private float getSizeFor(int combo)
-            {
-                if (combo > 200)
-                    return default_flashlight_size * 0.8f;
-                else if (combo > 100)
-                    return default_flashlight_size * 0.9f;
-                else
-                    return default_flashlight_size;
-            }
-
             protected override void OnComboChange(ValueChangedEvent<int> e)
             {
-                this.TransformTo(nameof(FlashlightSize), new Vector2(0, getSizeFor(e.NewValue)), FLASHLIGHT_FADE_DURATION);
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, GetSizeFor(e.NewValue)), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "CircularFlashlight";

osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs

@@ -174,7 +174,7 @@ namespace osu.Game.Rulesets.Osu.Statistics
 
             pointGrid.Content = points;
 
-            if (score.HitEvents == null || score.HitEvents.Count == 0)
+            if (score.HitEvents.Count == 0)
                 return;
 
             // Todo: This should probably not be done like this.

osu.Game.Rulesets.Taiko.Tests/DrawableTaikoRulesetTestScene.cs

@@ -32,12 +32,12 @@ namespace osu.Game.Rulesets.Taiko.Tests
                 HitObjects = new List<HitObject> { new Hit { Type = HitType.Centre } },
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty(),
+                    Difficulty = new BeatmapDifficulty(),
                     Metadata = new BeatmapMetadata
                     {
                         Artist = @"Unknown",
                         Title = @"Sample Beatmap",
-                        AuthorString = @"peppy",
+                        Author = { Username = @"peppy" },
                     },
                     Ruleset = new TaikoRuleset().RulesetInfo
                 },

osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneEditorSaving.cs

@@ -1,91 +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.Input;
-using osu.Framework.Testing;
-using osu.Framework.Utils;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Taiko.Beatmaps;
-using osu.Game.Screens.Edit;
-using osu.Game.Screens.Edit.Setup;
-using osu.Game.Screens.Menu;
-using osu.Game.Screens.Select;
-using osu.Game.Tests.Visual;
-using osuTK.Input;
-
-namespace osu.Game.Rulesets.Taiko.Tests.Editor
-{
-    public class TestSceneEditorSaving : OsuGameTestScene
-    {
-        private Screens.Edit.Editor editor => Game.ChildrenOfType<Screens.Edit.Editor>().FirstOrDefault();
-
-        private EditorBeatmap editorBeatmap => (EditorBeatmap)editor.Dependencies.Get(typeof(EditorBeatmap));
-
-        /// <summary>
-        /// Tests the general expected flow of creating a new beatmap, saving it, then loading it back from song select.
-        /// Emphasis is placed on <see cref="BeatmapDifficulty.SliderMultiplier"/>, since taiko has special handling for it to keep compatibility with stable.
-        /// </summary>
-        [Test]
-        public void TestNewBeatmapSaveThenLoad()
-        {
-            AddStep("set default beatmap", () => Game.Beatmap.SetDefault());
-            AddStep("set taiko ruleset", () => Ruleset.Value = new TaikoRuleset().RulesetInfo);
-
-            PushAndConfirm(() => new EditorLoader());
-
-            AddUntilStep("wait for editor load", () => editor?.IsLoaded == true);
-
-            AddUntilStep("wait for metadata screen load", () => editor.ChildrenOfType<MetadataSection>().FirstOrDefault()?.IsLoaded == true);
-
-            // We intentionally switch away from the metadata screen, else there is a feedback loop with the textbox handling which causes metadata changes below to get overwritten.
-
-            AddStep("Enter compose mode", () => InputManager.Key(Key.F1));
-            AddUntilStep("Wait for compose mode load", () => editor.ChildrenOfType<HitObjectComposer>().FirstOrDefault()?.IsLoaded == true);
-
-            AddStep("Set slider multiplier", () => editorBeatmap.Difficulty.SliderMultiplier = 2);
-            AddStep("Set artist and title", () =>
-            {
-                editorBeatmap.BeatmapInfo.Metadata.Artist = "artist";
-                editorBeatmap.BeatmapInfo.Metadata.Title = "title";
-            });
-            AddStep("Set difficulty name", () => editorBeatmap.BeatmapInfo.DifficultyName = "difficulty");
-
-            checkMutations();
-
-            AddStep("Save", () => InputManager.Keys(PlatformAction.Save));
-
-            checkMutations();
-
-            AddStep("Exit", () => InputManager.Key(Key.Escape));
-
-            AddUntilStep("Wait for main menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
-
-            PushAndConfirm(() => new PlaySongSelect());
-
-            AddUntilStep("Wait for beatmap selected", () => !Game.Beatmap.IsDefault);
-            AddStep("Open options", () => InputManager.Key(Key.F3));
-            AddStep("Enter editor", () => InputManager.Key(Key.Number5));
-
-            AddUntilStep("Wait for editor load", () => editor != null);
-
-            checkMutations();
-        }
-
-        private void checkMutations()
-        {
-            AddAssert("Beatmap has correct slider multiplier", () =>
-            {
-                // we can only assert value correctness on TaikoMultiplierAppliedDifficulty, because that is the final difficulty converted taiko beatmaps use.
-                // therefore, ensure that we have that difficulty type by calling .CopyFrom(), which is a no-op if the type is already correct.
-                var taikoDifficulty = new TaikoBeatmapConverter.TaikoMultiplierAppliedDifficulty();
-                taikoDifficulty.CopyFrom(editorBeatmap.Difficulty);
-                return Precision.AlmostEquals(taikoDifficulty.SliderMultiplier, 2);
-            });
-            AddAssert("Beatmap has correct metadata", () => editorBeatmap.BeatmapInfo.Metadata.Artist == "artist" && editorBeatmap.BeatmapInfo.Metadata.Title == "title");
-            AddAssert("Beatmap has correct difficulty name", () => editorBeatmap.BeatmapInfo.DifficultyName == "difficulty");
-        }
-    }
-}

osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneTaikoEditorSaving.cs

@@ -0,0 +1,38 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Editor
+{
+    public class TestSceneTaikoEditorSaving : EditorSavingTestScene
+    {
+        protected override Ruleset CreateRuleset() => new TaikoRuleset();
+
+        [Test]
+        public void TestTaikoSliderMultiplier()
+        {
+            AddStep("Set slider multiplier", () => EditorBeatmap.Difficulty.SliderMultiplier = 2);
+
+            SaveEditor();
+
+            AddAssert("Beatmap has correct slider multiplier", assertTaikoSliderMulitplier);
+
+            ReloadEditorToSameBeatmap();
+
+            AddAssert("Beatmap still has correct slider multiplier", assertTaikoSliderMulitplier);
+
+            bool assertTaikoSliderMulitplier()
+            {
+                // we can only assert value correctness on TaikoMultiplierAppliedDifficulty, because that is the final difficulty converted taiko beatmaps use.
+                // therefore, ensure that we have that difficulty type by calling .CopyFrom(), which is a no-op if the type is already correct.
+                var taikoDifficulty = new TaikoBeatmapConverter.TaikoMultiplierAppliedDifficulty();
+                taikoDifficulty.CopyFrom(EditorBeatmap.Difficulty);
+                return Precision.AlmostEquals(taikoDifficulty.SliderMultiplier, 2);
+            }
+        }
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneTaikoHitObjectComposer.cs

@@ -40,10 +40,10 @@ namespace osu.Game.Rulesets.Taiko.Tests.Editor
             {
                 InternalChildren = new Drawable[]
                 {
-                    EditorBeatmap = new EditorBeatmap(new TaikoBeatmap())
+                    EditorBeatmap = new EditorBeatmap(new TaikoBeatmap
                     {
                         BeatmapInfo = { Ruleset = new TaikoRuleset().RulesetInfo }
-                    },
+                    }),
                     new TaikoHitObjectComposer(new TaikoRuleset())
                 };
 

osu.Game.Rulesets.Taiko.Tests/Skinning/TestSceneDrawableTaikoMascot.cs

@@ -158,12 +158,12 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
                 HitObjects = new List<HitObject> { new Hit { Type = HitType.Centre } },
                 BeatmapInfo = new BeatmapInfo
                 {
-                    BaseDifficulty = new BeatmapDifficulty(),
+                    Difficulty = new BeatmapDifficulty(),
                     Metadata = new BeatmapMetadata
                     {
                         Artist = "Unknown",
                         Title = "Sample Beatmap",
-                        AuthorString = "Craftplacer",
+                        Author = { Username = "Craftplacer" },
                     },
                     Ruleset = new TaikoRuleset().RulesetInfo
                 },

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

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

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

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 
             Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original, cancellationToken);
 
-            if (original.BeatmapInfo.RulesetID == 3)
+            if (original.BeatmapInfo.Ruleset.OnlineID == 3)
             {
                 // Post processing step to transform mania hit objects with the same start time into strong hits
                 converted.HitObjects = converted.HitObjects.GroupBy(t => t.StartTime).Select(x =>
@@ -191,6 +191,9 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 
         protected override Beatmap<TaikoHitObject> CreateBeatmap() => new TaikoBeatmap();
 
+        // Important to note that this is subclassing a realm object.
+        // Realm doesn't allow this, but for now this can work since we aren't (in theory?) persisting this to the database.
+        // It is only used during beatmap conversion and processing.
         internal class TaikoMultiplierAppliedDifficulty : BeatmapDifficulty
         {
             public TaikoMultiplierAppliedDifficulty(IBeatmapDifficultyInfo difficulty)
@@ -205,6 +208,8 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 
             #region Overrides of BeatmapDifficulty
 
+            public override BeatmapDifficulty Clone() => new TaikoMultiplierAppliedDifficulty(this);
+
             public override void CopyTo(BeatmapDifficulty other)
             {
                 base.CopyTo(other);

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

@@ -4,6 +4,7 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Layout;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.UI;
@@ -16,9 +17,26 @@ namespace osu.Game.Rulesets.Taiko.Mods
     {
         public override double ScoreMultiplier => 1.12;
 
-        private const float default_flashlight_size = 250;
+        [SettingSource("Flashlight size", "Multiplier applied to the default flashlight size.")]
+        public override BindableNumber<float> SizeMultiplier { get; } = new BindableNumber<float>
+        {
+            MinValue = 0.5f,
+            MaxValue = 1.5f,
+            Default = 1f,
+            Value = 1f,
+            Precision = 0.1f
+        };
 
-        public override Flashlight CreateFlashlight() => new TaikoFlashlight(playfield);
+        [SettingSource("Change size based on combo", "Decrease the flashlight size as combo increases.")]
+        public override BindableBool ComboBasedSize { get; } = new BindableBool
+        {
+            Default = true,
+            Value = true
+        };
+
+        public override float DefaultFlashlightSize => 250;
+
+        protected override Flashlight CreateFlashlight() => new TaikoFlashlight(this, playfield);
 
         private TaikoPlayfield playfield;
 
@@ -33,7 +51,8 @@ namespace osu.Game.Rulesets.Taiko.Mods
             private readonly LayoutValue flashlightProperties = new LayoutValue(Invalidation.DrawSize);
             private readonly TaikoPlayfield taikoPlayfield;
 
-            public TaikoFlashlight(TaikoPlayfield taikoPlayfield)
+            public TaikoFlashlight(TaikoModFlashlight modFlashlight, TaikoPlayfield taikoPlayfield)
+                : base(modFlashlight)
             {
                 this.taikoPlayfield = taikoPlayfield;
                 FlashlightSize = getSizeFor(0);
@@ -43,15 +62,8 @@ namespace osu.Game.Rulesets.Taiko.Mods
 
             private Vector2 getSizeFor(int combo)
             {
-                float size = default_flashlight_size;
-
-                if (combo > 200)
-                    size *= 0.8f;
-                else if (combo > 100)
-                    size *= 0.9f;
-
                 // Preserve flashlight size through the playfield's aspect adjustment.
-                return new Vector2(0, size * taikoPlayfield.DrawHeight / TaikoPlayfield.DEFAULT_HEIGHT);
+                return new Vector2(0, GetSizeFor(combo) * taikoPlayfield.DrawHeight / TaikoPlayfield.DEFAULT_HEIGHT);
             }
 
             protected override void OnComboChange(ValueChangedEvent<int> e)

osu.Game.Rulesets.Taiko/Skinning/Default/CirclePiece.cs

@@ -153,7 +153,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Default
             if (!effectPoint.KiaiMode)
                 return;
 
-            if (beatIndex % (int)timingPoint.TimeSignature != 0)
+            if (beatIndex % timingPoint.TimeSignature.Numerator != 0)
                 return;
 
             double duration = timingPoint.BeatLength * 2;

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

@@ -60,7 +60,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(0, beatmapInfo.AudioLeadIn);
                 Assert.AreEqual(164471, metadata.PreviewTime);
                 Assert.AreEqual(0.7f, beatmapInfo.StackLeniency);
-                Assert.IsTrue(beatmapInfo.RulesetID == 0);
+                Assert.IsTrue(beatmapInfo.Ruleset.OnlineID == 0);
                 Assert.IsFalse(beatmapInfo.LetterboxInBreaks);
                 Assert.IsFalse(beatmapInfo.SpecialStyle);
                 Assert.IsFalse(beatmapInfo.WidescreenStoryboard);
@@ -117,7 +117,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(string.Empty, metadata.Source);
                 Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", metadata.Tags);
                 Assert.AreEqual(557821, beatmapInfo.OnlineID);
-                Assert.AreEqual(241526, beatmapInfo.BeatmapSet.OnlineID);
+                Assert.AreEqual(241526, beatmapInfo.BeatmapSet?.OnlineID);
             }
         }
 
@@ -178,17 +178,17 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var timingPoint = controlPoints.TimingPointAt(0);
                 Assert.AreEqual(956, timingPoint.Time);
                 Assert.AreEqual(329.67032967033, timingPoint.BeatLength);
-                Assert.AreEqual(TimeSignatures.SimpleQuadruple, timingPoint.TimeSignature);
+                Assert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
 
                 timingPoint = controlPoints.TimingPointAt(48428);
                 Assert.AreEqual(956, timingPoint.Time);
                 Assert.AreEqual(329.67032967033d, timingPoint.BeatLength);
-                Assert.AreEqual(TimeSignatures.SimpleQuadruple, timingPoint.TimeSignature);
+                Assert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
 
                 timingPoint = controlPoints.TimingPointAt(119637);
                 Assert.AreEqual(119637, timingPoint.Time);
                 Assert.AreEqual(659.340659340659, timingPoint.BeatLength);
-                Assert.AreEqual(TimeSignatures.SimpleQuadruple, timingPoint.TimeSignature);
+                Assert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
 
                 var difficultyPoint = controlPoints.DifficultyPointAt(0);
                 Assert.AreEqual(0, difficultyPoint.Time);

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

@@ -195,7 +195,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
         private IBeatmap convert(IBeatmap beatmap)
         {
-            switch (beatmap.BeatmapInfo.RulesetID)
+            switch (beatmap.BeatmapInfo.Ruleset.OnlineID)
             {
                 case 0:
                     beatmap.BeatmapInfo.Ruleset = new OsuRuleset().RulesetInfo;

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

@@ -12,6 +12,7 @@ using osu.Game.Replays;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.UI;
@@ -51,6 +52,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 Assert.AreEqual(829_931, score.ScoreInfo.TotalScore);
                 Assert.AreEqual(3, score.ScoreInfo.MaxCombo);
+
+                Assert.IsTrue(score.ScoreInfo.Mods.Any(m => m is ManiaModClassic));
+                Assert.IsTrue(score.ScoreInfo.APIMods.Any(m => m.Acronym == "CL"));
+                Assert.IsTrue(score.ScoreInfo.ModsJson.Contains("CL"));
+
                 Assert.IsTrue(Precision.AlmostEquals(0.8889, score.ScoreInfo.Accuracy, 0.0001));
                 Assert.AreEqual(ScoreRank.B, score.ScoreInfo.Rank);
 
@@ -128,7 +134,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 {
                     MD5Hash = md5Hash,
                     Ruleset = new OsuRuleset().RulesetInfo,
-                    BaseDifficulty = new BeatmapDifficulty()
+                    Difficulty = new BeatmapDifficulty()
                 }
             });
         }

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

@@ -31,7 +31,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         {
             var beatmap = decodeAsJson(normal);
             var meta = beatmap.BeatmapInfo.Metadata;
-            Assert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet.OnlineID);
+            Assert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet?.OnlineID);
             Assert.AreEqual("Soleily", meta.Artist);
             Assert.AreEqual("Soleily", meta.ArtistUnicode);
             Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
@@ -52,7 +52,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             Assert.AreEqual(0, beatmapInfo.AudioLeadIn);
             Assert.AreEqual(0.7f, beatmapInfo.StackLeniency);
             Assert.AreEqual(false, beatmapInfo.SpecialStyle);
-            Assert.IsTrue(beatmapInfo.RulesetID == 0);
+            Assert.IsTrue(beatmapInfo.Ruleset.OnlineID == 0);
             Assert.AreEqual(false, beatmapInfo.LetterboxInBreaks);
             Assert.AreEqual(false, beatmapInfo.WidescreenStoryboard);
             Assert.AreEqual(CountdownType.None, beatmapInfo.Countdown);

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

@@ -0,0 +1,85 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Tests.Database;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Beatmaps.IO
+{
+    public static class BeatmapImportHelper
+    {
+        public static async Task<BeatmapSetInfo> LoadQuickOszIntoOsu(OsuGameBase osu)
+        {
+            string temp = TestResources.GetQuickTestBeatmapForImport();
+
+            var manager = osu.Dependencies.Get<BeatmapManager>();
+
+            var importedSet = await manager.Import(new ImportTask(temp)).ConfigureAwait(false);
+
+            Debug.Assert(importedSet != null);
+
+            ensureLoaded(osu);
+
+            waitForOrAssert(() => !File.Exists(temp), "Temporary file still exists after standard import", 5000);
+
+            return manager.GetAllUsableBeatmapSets().Find(beatmapSet => beatmapSet.ID == importedSet.ID);
+        }
+
+        public static async Task<BeatmapSetInfo> LoadOszIntoOsu(OsuGameBase osu, string path = null, bool virtualTrack = false)
+        {
+            string temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
+
+            var manager = osu.Dependencies.Get<BeatmapManager>();
+
+            var importedSet = await manager.Import(new ImportTask(temp)).ConfigureAwait(false);
+
+            Debug.Assert(importedSet != null);
+
+            ensureLoaded(osu);
+
+            waitForOrAssert(() => !File.Exists(temp), "Temporary file still exists after standard import", 5000);
+
+            return manager.GetAllUsableBeatmapSets().Find(beatmapSet => beatmapSet.ID == importedSet.ID);
+        }
+
+        private static void ensureLoaded(OsuGameBase osu, int timeout = 60000)
+        {
+            var realm = osu.Dependencies.Get<RealmAccess>();
+
+            realm.Run(r => BeatmapImporterTests.EnsureLoaded(r, timeout));
+
+            // TODO: add back some extra checks outside of the realm ones?
+            // var set = queryBeatmapSets().First();
+            // foreach (BeatmapInfo b in set.Beatmaps)
+            //     Assert.IsTrue(set.Beatmaps.Any(c => c.OnlineID == b.OnlineID));
+            // Assert.IsTrue(set.Beatmaps.Count > 0);
+            // var beatmap = store.GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 0))?.Beatmap;
+            // Assert.IsTrue(beatmap?.HitObjects.Any() == true);
+            // beatmap = store.GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 1))?.Beatmap;
+            // Assert.IsTrue(beatmap?.HitObjects.Any() == true);
+            // beatmap = store.GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 2))?.Beatmap;
+            // Assert.IsTrue(beatmap?.HitObjects.Any() == true);
+            // beatmap = store.GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 3))?.Beatmap;
+            // Assert.IsTrue(beatmap?.HitObjects.Any() == true);
+        }
+
+        private static void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
+        {
+            Task task = Task.Run(() =>
+            {
+                while (!result()) Thread.Sleep(200);
+            });
+
+            Assert.IsTrue(task.Wait(timeout), failureMessage);
+        }
+    }
+}

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

@@ -56,7 +56,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
                 var meta = beatmap.Metadata;
 
-                Assert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet.OnlineID);
+                Assert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet?.OnlineID);
                 Assert.AreEqual("Soleily", meta.Artist);
                 Assert.AreEqual("Soleily", meta.ArtistUnicode);
                 Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);

osu.Game.Tests/Beatmaps/TestSceneBeatmapDifficultyCache.cs

@@ -24,6 +24,8 @@ namespace osu.Game.Tests.Beatmaps
     {
         public const double BASE_STARS = 5.55;
 
+        private static readonly Guid guid = Guid.NewGuid();
+
         private BeatmapSetInfo importedSet;
 
         private TestBeatmapDifficultyCache difficultyCache;
@@ -33,7 +35,7 @@ namespace osu.Game.Tests.Beatmaps
         [BackgroundDependencyLoader]
         private void load(OsuGameBase osu)
         {
-            importedSet = ImportBeatmapTest.LoadQuickOszIntoOsu(osu).GetResultSafely();
+            importedSet = BeatmapImportHelper.LoadQuickOszIntoOsu(osu).GetResultSafely();
         }
 
         [SetUpSteps]
@@ -98,8 +100,8 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestKeyEqualsWithDifferentModInstances()
         {
-            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = 1234 }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
-            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = 1234 }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
 
             Assert.That(key1, Is.EqualTo(key2));
             Assert.That(key1.GetHashCode(), Is.EqualTo(key2.GetHashCode()));
@@ -108,8 +110,8 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestKeyEqualsWithDifferentModOrder()
         {
-            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = 1234 }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
-            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = 1234 }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModHidden(), new OsuModHardRock() });
+            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModHidden(), new OsuModHardRock() });
 
             Assert.That(key1, Is.EqualTo(key2));
             Assert.That(key1.GetHashCode(), Is.EqualTo(key2.GetHashCode()));
@@ -118,8 +120,8 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestKeyDoesntEqualWithDifferentModSettings()
         {
-            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = 1234 }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.1 } } });
-            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = 1234 }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.9 } } });
+            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.1 } } });
+            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.9 } } });
 
             Assert.That(key1, Is.Not.EqualTo(key2));
             Assert.That(key1.GetHashCode(), Is.Not.EqualTo(key2.GetHashCode()));
@@ -128,8 +130,8 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestKeyEqualWithMatchingModSettings()
         {
-            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = 1234 }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } });
-            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = 1234 }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } });
+            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } });
+            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } });
 
             Assert.That(key1, Is.EqualTo(key2));
             Assert.That(key1.GetHashCode(), Is.EqualTo(key2.GetHashCode()));

osu.Game.Tests/Beatmaps/TestSceneEditorBeatmap.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
@@ -30,7 +31,13 @@ namespace osu.Game.Tests.Beatmaps
 
             AddStep("add beatmap", () =>
             {
-                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                    },
+                });
                 editorBeatmap.HitObjectAdded += h => addedObject = h;
             });
 
@@ -49,7 +56,14 @@ namespace osu.Game.Tests.Beatmaps
             EditorBeatmap editorBeatmap = null;
             AddStep("add beatmap", () =>
             {
-                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap { HitObjects = { hitCircle } });
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                    },
+                    HitObjects = { hitCircle }
+                });
                 editorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
             AddStep("remove hitobject", () => editorBeatmap.Remove(editorBeatmap.HitObjects.First()));
@@ -71,7 +85,14 @@ namespace osu.Game.Tests.Beatmaps
             {
                 EditorBeatmap editorBeatmap;
 
-                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap { HitObjects = { hitCircle } });
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                    },
+                    HitObjects = { hitCircle }
+                });
                 editorBeatmap.HitObjectUpdated += h => changedObject = h;
             });
 
@@ -91,7 +112,13 @@ namespace osu.Game.Tests.Beatmaps
 
             AddStep("add beatmap", () =>
             {
-                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                    },
+                });
                 editorBeatmap.HitObjectUpdated += h => changedObject = h;
             });
 
@@ -111,7 +138,14 @@ namespace osu.Game.Tests.Beatmaps
         public void TestRemovedHitObjectStartTimeChangeEvent()
         {
             var hitCircle = new HitCircle();
-            var editorBeatmap = new EditorBeatmap(new OsuBeatmap { HitObjects = { hitCircle } });
+            var editorBeatmap = new EditorBeatmap(new OsuBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                },
+                HitObjects = { hitCircle }
+            });
 
             HitObject changedObject = null;
             editorBeatmap.HitObjectUpdated += h => changedObject = h;
@@ -131,6 +165,10 @@ namespace osu.Game.Tests.Beatmaps
         {
             var editorBeatmap = new EditorBeatmap(new OsuBeatmap
             {
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                },
                 HitObjects =
                 {
                     new HitCircle(),
@@ -156,6 +194,10 @@ namespace osu.Game.Tests.Beatmaps
 
             var editorBeatmap = new EditorBeatmap(new OsuBeatmap
             {
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                },
                 HitObjects =
                 {
                     new HitCircle(),
@@ -185,7 +227,13 @@ namespace osu.Game.Tests.Beatmaps
             {
                 updatedObjects.Clear();
 
-                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                    },
+                });
 
                 for (int i = 0; i < 10; i++)
                 {
@@ -220,7 +268,13 @@ namespace osu.Game.Tests.Beatmaps
             {
                 updatedObjects.Clear();
 
-                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                    },
+                });
                 editorBeatmap.Add(new HitCircle());
             });
 

osu.Game.Tests/Beatmaps/ToStringFormattingTest.cs

@@ -3,7 +3,7 @@
 
 using NUnit.Framework;
 using osu.Game.Beatmaps;
-using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Models;
 
 namespace osu.Game.Tests.Beatmaps
 {
@@ -34,7 +34,7 @@ namespace osu.Game.Tests.Beatmaps
                 {
                     Artist = "artist",
                     Title = "title",
-                    Author = new APIUser { Username = "creator" }
+                    Author = new RealmUser { Username = "creator" }
                 }
             };
 
@@ -50,7 +50,7 @@ namespace osu.Game.Tests.Beatmaps
                 {
                     Artist = "artist",
                     Title = "title",
-                    Author = new APIUser { Username = "creator" }
+                    Author = new RealmUser { Username = "creator" }
                 },
                 DifficultyName = "difficulty"
             };

osu.Game.Tests/Collections/IO/ImportCollectionsTest.cs

@@ -155,7 +155,7 @@ namespace osu.Game.Tests.Collections.IO
             }
 
             // Name matches the automatically chosen name from `CleanRunHeadlessGameHost` above, so we end up using the same storage location.
-            using (HeadlessGameHost host = new TestRunHeadlessGameHost(firstRunName))
+            using (HeadlessGameHost host = new TestRunHeadlessGameHost(firstRunName, null))
             {
                 try
                 {

osu.Game.Tests/Database/BeatmapImporterTests.cs

@@ -19,6 +19,7 @@ using osu.Game.Extensions;
 using osu.Game.IO.Archives;
 using osu.Game.Models;
 using osu.Game.Overlays.Notifications;
+using osu.Game.Rulesets;
 using osu.Game.Stores;
 using osu.Game.Tests.Resources;
 using Realms;
@@ -34,56 +35,157 @@ namespace osu.Game.Tests.Database
     [TestFixture]
     public class BeatmapImporterTests : RealmTest
     {
+        [Test]
+        public void TestDetachBeatmapSet()
+        {
+            RunTestWithRealmAsync(async (realm, storage) =>
+            {
+                using (var importer = new BeatmapModelManager(realm, storage))
+                using (new RulesetStore(realm, storage))
+                {
+                    Live<BeatmapSetInfo>? beatmapSet;
+
+                    using (var reader = new ZipArchiveReader(TestResources.GetTestBeatmapStream()))
+                        beatmapSet = await importer.Import(reader);
+
+                    Assert.NotNull(beatmapSet);
+                    Debug.Assert(beatmapSet != null);
+
+                    BeatmapSetInfo? detachedBeatmapSet = null;
+
+                    beatmapSet.PerformRead(live =>
+                    {
+                        detachedBeatmapSet = live.Detach();
+
+                        // files are omitted
+                        Assert.AreEqual(0, detachedBeatmapSet.Files.Count);
+
+                        Assert.AreEqual(live.Beatmaps.Count, detachedBeatmapSet.Beatmaps.Count);
+                        Assert.AreEqual(live.Beatmaps.Select(f => f.Difficulty).Count(), detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
+                        Assert.AreEqual(live.Metadata, detachedBeatmapSet.Metadata);
+                    });
+
+                    Debug.Assert(detachedBeatmapSet != null);
+
+                    // Check detached instances can all be accessed without throwing.
+                    Assert.AreEqual(0, detachedBeatmapSet.Files.Count);
+                    Assert.NotNull(detachedBeatmapSet.Beatmaps.Count);
+                    Assert.NotZero(detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
+                    Assert.NotNull(detachedBeatmapSet.Metadata);
+
+                    // Check cyclic reference to beatmap set
+                    Assert.AreEqual(detachedBeatmapSet, detachedBeatmapSet.Beatmaps.First().BeatmapSet);
+                }
+            });
+        }
+
+        [Test]
+        public void TestUpdateDetachedBeatmapSet()
+        {
+            RunTestWithRealmAsync(async (realm, storage) =>
+            {
+                using (var importer = new BeatmapModelManager(realm, storage))
+                using (new RulesetStore(realm, storage))
+                {
+                    Live<BeatmapSetInfo>? beatmapSet;
+
+                    using (var reader = new ZipArchiveReader(TestResources.GetTestBeatmapStream()))
+                        beatmapSet = await importer.Import(reader);
+
+                    Assert.NotNull(beatmapSet);
+                    Debug.Assert(beatmapSet != null);
+
+                    // Detach at the BeatmapInfo point, similar to what GetWorkingBeatmap does.
+                    BeatmapInfo? detachedBeatmap = null;
+
+                    beatmapSet.PerformRead(s => detachedBeatmap = s.Beatmaps.First().Detach());
+
+                    BeatmapSetInfo? detachedBeatmapSet = detachedBeatmap?.BeatmapSet;
+
+                    Debug.Assert(detachedBeatmapSet != null);
+
+                    var newUser = new RealmUser { Username = "peppy", OnlineID = 2 };
+
+                    detachedBeatmapSet.Beatmaps.First().Metadata.Artist = "New Artist";
+                    detachedBeatmapSet.Beatmaps.First().Metadata.Author = newUser;
+
+                    Assert.AreNotEqual(detachedBeatmapSet.Status, BeatmapOnlineStatus.Ranked);
+                    detachedBeatmapSet.Status = BeatmapOnlineStatus.Ranked;
+
+                    beatmapSet.PerformWrite(s =>
+                    {
+                        detachedBeatmapSet.CopyChangesToRealm(s);
+                    });
+
+                    beatmapSet.PerformRead(s =>
+                    {
+                        // Check above changes explicitly.
+                        Assert.AreEqual(BeatmapOnlineStatus.Ranked, s.Status);
+                        Assert.AreEqual("New Artist", s.Beatmaps.First().Metadata.Artist);
+                        Assert.AreEqual(newUser, s.Beatmaps.First().Metadata.Author);
+                        Assert.NotZero(s.Files.Count);
+
+                        // Check nothing was lost in the copy operation.
+                        Assert.AreEqual(s.Files.Count, detachedBeatmapSet.Files.Count);
+                        Assert.AreEqual(s.Files.Select(f => f.File).Count(), detachedBeatmapSet.Files.Select(f => f.File).Count());
+                        Assert.AreEqual(s.Beatmaps.Count, detachedBeatmapSet.Beatmaps.Count);
+                        Assert.AreEqual(s.Beatmaps.Select(f => f.Difficulty).Count(), detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
+                        Assert.AreEqual(s.Metadata, detachedBeatmapSet.Metadata);
+                    });
+                }
+            });
+        }
+
         [Test]
         public void TestImportBeatmapThenCleanup()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using (var importer = new BeatmapImporter(realmFactory, storage))
-                using (new RealmRulesetStore(realmFactory, storage))
+                using (var importer = new BeatmapModelManager(realm, storage))
+                using (new RulesetStore(realm, storage))
                 {
-                    ILive<RealmBeatmapSet>? imported;
+                    Live<BeatmapSetInfo>? imported;
 
                     using (var reader = new ZipArchiveReader(TestResources.GetTestBeatmapStream()))
                         imported = await importer.Import(reader);
 
-                    Assert.AreEqual(1, realmFactory.Context.All<RealmBeatmapSet>().Count());
+                    Assert.AreEqual(1, realm.Realm.All<BeatmapSetInfo>().Count());
 
                     Assert.NotNull(imported);
                     Debug.Assert(imported != null);
 
                     imported.PerformWrite(s => s.DeletePending = true);
 
-                    Assert.AreEqual(1, realmFactory.Context.All<RealmBeatmapSet>().Count(s => s.DeletePending));
+                    Assert.AreEqual(1, realm.Realm.All<BeatmapSetInfo>().Count(s => s.DeletePending));
                 }
             });
 
             Logger.Log("Running with no work to purge pending deletions");
 
-            RunTestWithRealm((realmFactory, _) => { Assert.AreEqual(0, realmFactory.Context.All<RealmBeatmapSet>().Count()); });
+            RunTestWithRealm((realm, _) => { Assert.AreEqual(0, realm.Realm.All<BeatmapSetInfo>().Count()); });
         }
 
         [Test]
         public void TestImportWhenClosed()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                await LoadOszIntoStore(importer, realmFactory.Context);
+                await LoadOszIntoStore(importer, realm.Realm);
             });
         }
 
         [Test]
         public void TestAccessFileAfterImport()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                var imported = await LoadOszIntoStore(importer, realm.Realm);
 
                 var beatmap = imported.Beatmaps.First();
                 var file = beatmap.File;
@@ -96,33 +198,33 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportThenDelete()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                var imported = await LoadOszIntoStore(importer, realm.Realm);
 
-                deleteBeatmapSet(imported, realmFactory.Context);
+                deleteBeatmapSet(imported, realm.Realm);
             });
         }
 
         [Test]
         public void TestImportThenDeleteFromStream()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? tempPath = TestResources.GetTestBeatmapForImport();
 
-                ILive<RealmBeatmapSet>? importedSet;
+                Live<BeatmapSetInfo>? importedSet;
 
                 using (var stream = File.OpenRead(tempPath))
                 {
                     importedSet = await importer.Import(new ImportTask(stream, Path.GetFileName(tempPath)));
-                    ensureLoaded(realmFactory.Context);
+                    EnsureLoaded(realm.Realm);
                 }
 
                 Assert.NotNull(importedSet);
@@ -131,39 +233,39 @@ namespace osu.Game.Tests.Database
                 Assert.IsTrue(File.Exists(tempPath), "Stream source file somehow went missing");
                 File.Delete(tempPath);
 
-                var imported = realmFactory.Context.All<RealmBeatmapSet>().First(beatmapSet => beatmapSet.ID == importedSet.ID);
+                var imported = realm.Realm.All<BeatmapSetInfo>().First(beatmapSet => beatmapSet.ID == importedSet.ID);
 
-                deleteBeatmapSet(imported, realmFactory.Context);
+                deleteBeatmapSet(imported, realm.Realm);
             });
         }
 
         [Test]
         public void TestImportThenImport()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
-                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+                var imported = await LoadOszIntoStore(importer, realm.Realm);
+                var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
                 Assert.IsTrue(imported.ID == importedSecondTime.ID);
                 Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
 
-                checkBeatmapSetCount(realmFactory.Context, 1);
-                checkSingleReferencedFileCount(realmFactory.Context, 18);
+                checkBeatmapSetCount(realm.Realm, 1);
+                checkSingleReferencedFileCount(realm.Realm, 18);
             });
         }
 
         [Test]
         public void TestImportThenImportWithReZip()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
 
@@ -172,7 +274,7 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                    var imported = await LoadOszIntoStore(importer, realm.Realm);
 
                     string hashBefore = hashFile(temp);
 
@@ -190,7 +292,7 @@ namespace osu.Game.Tests.Database
 
                     var importedSecondTime = await importer.Import(new ImportTask(temp));
 
-                    ensureLoaded(realmFactory.Context);
+                    EnsureLoaded(realm.Realm);
 
                     Assert.NotNull(importedSecondTime);
                     Debug.Assert(importedSecondTime != null);
@@ -209,10 +311,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportThenImportWithChangedHashedFile()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
 
@@ -221,9 +323,9 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                    var imported = await LoadOszIntoStore(importer, realm.Realm);
 
-                    await createScoreForBeatmap(realmFactory.Context, imported.Beatmaps.First());
+                    await createScoreForBeatmap(realm.Realm, imported.Beatmaps.First());
 
                     using (var zip = ZipArchive.Open(temp))
                         zip.WriteToDirectory(extractedFolder);
@@ -241,7 +343,7 @@ namespace osu.Game.Tests.Database
 
                     var importedSecondTime = await importer.Import(new ImportTask(temp));
 
-                    ensureLoaded(realmFactory.Context);
+                    EnsureLoaded(realm.Realm);
 
                     // check the newly "imported" beatmap is not the original.
                     Assert.NotNull(importedSecondTime);
@@ -261,10 +363,10 @@ namespace osu.Game.Tests.Database
         [Ignore("intentionally broken by import optimisations")]
         public void TestImportThenImportWithChangedFile()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
 
@@ -273,7 +375,7 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                    var imported = await LoadOszIntoStore(importer, realm.Realm);
 
                     using (var zip = ZipArchive.Open(temp))
                         zip.WriteToDirectory(extractedFolder);
@@ -290,7 +392,7 @@ namespace osu.Game.Tests.Database
 
                     var importedSecondTime = await importer.Import(new ImportTask(temp));
 
-                    ensureLoaded(realmFactory.Context);
+                    EnsureLoaded(realm.Realm);
 
                     Assert.NotNull(importedSecondTime);
                     Debug.Assert(importedSecondTime != null);
@@ -309,10 +411,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportThenImportWithDifferentFilename()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
 
@@ -321,7 +423,7 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                    var imported = await LoadOszIntoStore(importer, realm.Realm);
 
                     using (var zip = ZipArchive.Open(temp))
                         zip.WriteToDirectory(extractedFolder);
@@ -338,7 +440,7 @@ namespace osu.Game.Tests.Database
 
                     var importedSecondTime = await importer.Import(new ImportTask(temp));
 
-                    ensureLoaded(realmFactory.Context);
+                    EnsureLoaded(realm.Realm);
 
                     Assert.NotNull(importedSecondTime);
                     Debug.Assert(importedSecondTime != null);
@@ -358,12 +460,12 @@ namespace osu.Game.Tests.Database
         [Ignore("intentionally broken by import optimisations")]
         public void TestImportCorruptThenImport()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                var imported = await LoadOszIntoStore(importer, realm.Realm);
 
                 var firstFile = imported.Files.First();
 
@@ -374,7 +476,7 @@ namespace osu.Game.Tests.Database
                 using (var stream = storage.GetStream(firstFile.File.GetStoragePath(), FileAccess.Write, FileMode.Create))
                     stream.WriteByte(0);
 
-                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+                var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 using (var stream = storage.GetStream(firstFile.File.GetStoragePath()))
                     Assert.AreEqual(stream.Length, originalLength, "Corruption was not fixed on second import");
@@ -383,18 +485,18 @@ namespace osu.Game.Tests.Database
                 Assert.IsTrue(imported.ID == importedSecondTime.ID);
                 Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
 
-                checkBeatmapSetCount(realmFactory.Context, 1);
-                checkSingleReferencedFileCount(realmFactory.Context, 18);
+                checkBeatmapSetCount(realm.Realm, 1);
+                checkSingleReferencedFileCount(realm.Realm, 18);
             });
         }
 
         [Test]
         public void TestModelCreationFailureDoesntReturn()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 var progressNotification = new ImportProgressNotification();
 
@@ -408,8 +510,8 @@ namespace osu.Game.Tests.Database
                     new ImportTask(zipStream, string.Empty)
                 );
 
-                checkBeatmapSetCount(realmFactory.Context, 0);
-                checkBeatmapCount(realmFactory.Context, 0);
+                checkBeatmapSetCount(realm.Realm, 0);
+                checkBeatmapCount(realm.Realm, 0);
 
                 Assert.IsEmpty(imported);
                 Assert.AreEqual(ProgressNotificationState.Cancelled, progressNotification.State);
@@ -419,7 +521,7 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestRollbackOnFailure()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
                 int loggedExceptionCount = 0;
 
@@ -429,16 +531,16 @@ namespace osu.Game.Tests.Database
                         Interlocked.Increment(ref loggedExceptionCount);
                 };
 
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                var imported = await LoadOszIntoStore(importer, realm.Realm);
 
-                realmFactory.Context.Write(() => imported.Hash += "-changed");
+                realm.Realm.Write(() => imported.Hash += "-changed");
 
-                checkBeatmapSetCount(realmFactory.Context, 1);
-                checkBeatmapCount(realmFactory.Context, 12);
-                checkSingleReferencedFileCount(realmFactory.Context, 18);
+                checkBeatmapSetCount(realm.Realm, 1);
+                checkBeatmapCount(realm.Realm, 12);
+                checkSingleReferencedFileCount(realm.Realm, 18);
 
                 string? brokenTempFilename = TestResources.GetTestBeatmapForImport();
 
@@ -463,10 +565,10 @@ namespace osu.Game.Tests.Database
                 {
                 }
 
-                checkBeatmapSetCount(realmFactory.Context, 1);
-                checkBeatmapCount(realmFactory.Context, 12);
+                checkBeatmapSetCount(realm.Realm, 1);
+                checkBeatmapCount(realm.Realm, 12);
 
-                checkSingleReferencedFileCount(realmFactory.Context, 18);
+                checkSingleReferencedFileCount(realm.Realm, 18);
 
                 Assert.AreEqual(1, loggedExceptionCount);
 
@@ -477,18 +579,18 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportThenDeleteThenImportOptimisedPath()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                var imported = await LoadOszIntoStore(importer, realm.Realm);
 
-                deleteBeatmapSet(imported, realmFactory.Context);
+                deleteBeatmapSet(imported, realm.Realm);
 
                 Assert.IsTrue(imported.DeletePending);
 
-                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+                var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
                 Assert.IsTrue(imported.ID == importedSecondTime.ID);
@@ -499,20 +601,52 @@ namespace osu.Game.Tests.Database
         }
 
         [Test]
-        public void TestImportThenDeleteThenImportNonOptimisedPath()
+        public void TestImportThenReimportAfterMissingFiles()
         {
             RunTestWithRealmAsync(async (realmFactory, storage) =>
             {
-                using var importer = new NonOptimisedBeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realmFactory, storage);
+                using var store = new RulesetStore(realmFactory, storage);
 
-                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                var imported = await LoadOszIntoStore(importer, realmFactory.Realm);
 
-                deleteBeatmapSet(imported, realmFactory.Context);
+                deleteBeatmapSet(imported, realmFactory.Realm);
 
                 Assert.IsTrue(imported.DeletePending);
 
-                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+                // intentionally nuke all files
+                storage.DeleteDirectory("files");
+
+                Assert.That(imported.Files.All(f => !storage.GetStorageForDirectory("files").Exists(f.File.GetStoragePath())));
+
+                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Realm);
+
+                // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
+                Assert.IsTrue(imported.ID == importedSecondTime.ID);
+                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+                Assert.IsFalse(imported.DeletePending);
+                Assert.IsFalse(importedSecondTime.DeletePending);
+
+                // check that the files now exist, even though they were deleted above.
+                Assert.That(importedSecondTime.Files.All(f => storage.GetStorageForDirectory("files").Exists(f.File.GetStoragePath())));
+            });
+        }
+
+        [Test]
+        public void TestImportThenDeleteThenImportNonOptimisedPath()
+        {
+            RunTestWithRealmAsync(async (realm, storage) =>
+            {
+                using var importer = new NonOptimisedBeatmapImporter(realm, storage);
+                using var store = new RulesetStore(realm, storage);
+
+                var imported = await LoadOszIntoStore(importer, realm.Realm);
+
+                deleteBeatmapSet(imported, realm.Realm);
+
+                Assert.IsTrue(imported.DeletePending);
+
+                var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
                 Assert.IsTrue(imported.ID == importedSecondTime.ID);
@@ -525,22 +659,22 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportThenDeleteThenImportWithOnlineIDsMissing()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                var imported = await LoadOszIntoStore(importer, realmFactory.Context);
+                var imported = await LoadOszIntoStore(importer, realm.Realm);
 
-                realmFactory.Context.Write(() =>
+                realm.Realm.Write(() =>
                 {
                     foreach (var b in imported.Beatmaps)
                         b.OnlineID = -1;
                 });
 
-                deleteBeatmapSet(imported, realmFactory.Context);
+                deleteBeatmapSet(imported, realm.Realm);
 
-                var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Context);
+                var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap has been reimported due to mismatch (even though hashes matched)
                 Assert.IsTrue(imported.ID != importedSecondTime.ID);
@@ -551,12 +685,12 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportWithDuplicateBeatmapIDs()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealm((realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
-                var metadata = new RealmBeatmapMetadata
+                var metadata = new BeatmapMetadata
                 {
                     Artist = "SomeArtist",
                     Author =
@@ -565,18 +699,18 @@ namespace osu.Game.Tests.Database
                     }
                 };
 
-                var ruleset = realmFactory.Context.All<RealmRuleset>().First();
+                var ruleset = realm.Realm.All<RulesetInfo>().First();
 
-                var toImport = new RealmBeatmapSet
+                var toImport = new BeatmapSetInfo
                 {
                     OnlineID = 1,
                     Beatmaps =
                     {
-                        new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), metadata)
+                        new BeatmapInfo(ruleset, new BeatmapDifficulty(), metadata)
                         {
                             OnlineID = 2,
                         },
-                        new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), metadata)
+                        new BeatmapInfo(ruleset, new BeatmapDifficulty(), metadata)
                         {
                             OnlineID = 2,
                             Status = BeatmapOnlineStatus.Loved,
@@ -584,7 +718,7 @@ namespace osu.Game.Tests.Database
                     }
                 };
 
-                var imported = await importer.Import(toImport);
+                var imported = importer.Import(toImport);
 
                 Assert.NotNull(imported);
                 Debug.Assert(imported != null);
@@ -597,15 +731,15 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportWhenFileOpen()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
                 using (File.OpenRead(temp))
                     await importer.Import(temp);
-                ensureLoaded(realmFactory.Context);
+                EnsureLoaded(realm.Realm);
                 File.Delete(temp);
                 Assert.IsFalse(File.Exists(temp), "We likely held a read lock on the file when we shouldn't");
             });
@@ -614,10 +748,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportWithDuplicateHashes()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
 
@@ -638,7 +772,7 @@ namespace osu.Game.Tests.Database
 
                     await importer.Import(temp);
 
-                    ensureLoaded(realmFactory.Context);
+                    EnsureLoaded(realm.Realm);
                 }
                 finally
                 {
@@ -650,10 +784,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportNestedStructure()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
 
@@ -678,7 +812,7 @@ namespace osu.Game.Tests.Database
                     Assert.NotNull(imported);
                     Debug.Assert(imported != null);
 
-                    ensureLoaded(realmFactory.Context);
+                    EnsureLoaded(realm.Realm);
 
                     Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("subfolder"))), "Files contain common subfolder");
                 }
@@ -692,10 +826,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportWithIgnoredDirectoryInArchive()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
 
@@ -728,7 +862,7 @@ namespace osu.Game.Tests.Database
                     Assert.NotNull(imported);
                     Debug.Assert(imported != null);
 
-                    ensureLoaded(realmFactory.Context);
+                    EnsureLoaded(realm.Realm);
 
                     Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("__MACOSX"))), "Files contain resource fork folder, which should be ignored");
                     Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("actual_data"))), "Files contain common subfolder");
@@ -743,27 +877,27 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestUpdateBeatmapInfo()
         {
-            RunTestWithRealmAsync(async (realmFactory, storage) =>
+            RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new BeatmapImporter(realmFactory, storage);
-                using var store = new RealmRulesetStore(realmFactory, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
+                using var store = new RulesetStore(realm, storage);
 
                 string? temp = TestResources.GetTestBeatmapForImport();
                 await importer.Import(temp);
 
                 // Update via the beatmap, not the beatmap info, to ensure correct linking
-                RealmBeatmapSet setToUpdate = realmFactory.Context.All<RealmBeatmapSet>().First();
+                BeatmapSetInfo setToUpdate = realm.Realm.All<BeatmapSetInfo>().First();
 
                 var beatmapToUpdate = setToUpdate.Beatmaps.First();
 
-                realmFactory.Context.Write(() => beatmapToUpdate.DifficultyName = "updated");
+                realm.Realm.Write(() => beatmapToUpdate.DifficultyName = "updated");
 
-                RealmBeatmap updatedInfo = realmFactory.Context.All<RealmBeatmap>().First(b => b.ID == beatmapToUpdate.ID);
+                BeatmapInfo updatedInfo = realm.Realm.All<BeatmapInfo>().First(b => b.ID == beatmapToUpdate.ID);
                 Assert.That(updatedInfo.DifficultyName, Is.EqualTo("updated"));
             });
         }
 
-        public static async Task<RealmBeatmapSet?> LoadQuickOszIntoOsu(BeatmapImporter importer, Realm realm)
+        public static async Task<BeatmapSetInfo?> LoadQuickOszIntoOsu(BeatmapImporter importer, Realm realm)
         {
             string? temp = TestResources.GetQuickTestBeatmapForImport();
 
@@ -771,14 +905,14 @@ namespace osu.Game.Tests.Database
 
             Assert.NotNull(importedSet);
 
-            ensureLoaded(realm);
+            EnsureLoaded(realm);
 
             waitForOrAssert(() => !File.Exists(temp), "Temporary file still exists after standard import", 5000);
 
-            return realm.All<RealmBeatmapSet>().FirstOrDefault(beatmapSet => beatmapSet.ID == importedSet!.ID);
+            return realm.All<BeatmapSetInfo>().FirstOrDefault(beatmapSet => beatmapSet.ID == importedSet!.ID);
         }
 
-        public static async Task<RealmBeatmapSet> LoadOszIntoStore(BeatmapImporter importer, Realm realm, string? path = null, bool virtualTrack = false)
+        public static async Task<BeatmapSetInfo> LoadOszIntoStore(BeatmapImporter importer, Realm realm, string? path = null, bool virtualTrack = false)
         {
             string? temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
 
@@ -787,24 +921,24 @@ namespace osu.Game.Tests.Database
             Assert.NotNull(importedSet);
             Debug.Assert(importedSet != null);
 
-            ensureLoaded(realm);
+            EnsureLoaded(realm);
 
             waitForOrAssert(() => !File.Exists(temp), "Temporary file still exists after standard import", 5000);
 
-            return realm.All<RealmBeatmapSet>().First(beatmapSet => beatmapSet.ID == importedSet.ID);
+            return realm.All<BeatmapSetInfo>().First(beatmapSet => beatmapSet.ID == importedSet.ID);
         }
 
-        private void deleteBeatmapSet(RealmBeatmapSet imported, Realm realm)
+        private void deleteBeatmapSet(BeatmapSetInfo imported, Realm realm)
         {
             realm.Write(() => imported.DeletePending = true);
 
             checkBeatmapSetCount(realm, 0);
             checkBeatmapSetCount(realm, 1, true);
 
-            Assert.IsTrue(realm.All<RealmBeatmapSet>().First(_ => true).DeletePending);
+            Assert.IsTrue(realm.All<BeatmapSetInfo>().First(_ => true).DeletePending);
         }
 
-        private static Task createScoreForBeatmap(Realm realm, RealmBeatmap beatmap)
+        private static Task createScoreForBeatmap(Realm realm, BeatmapInfo beatmap)
         {
             // TODO: reimplement when we have score support in realm.
             // return ImportScoreTest.LoadScoreIntoOsu(osu, new ScoreInfo
@@ -820,8 +954,8 @@ namespace osu.Game.Tests.Database
         private static void checkBeatmapSetCount(Realm realm, int expected, bool includeDeletePending = false)
         {
             Assert.AreEqual(expected, includeDeletePending
-                ? realm.All<RealmBeatmapSet>().Count()
-                : realm.All<RealmBeatmapSet>().Count(s => !s.DeletePending));
+                ? realm.All<BeatmapSetInfo>().Count()
+                : realm.All<BeatmapSetInfo>().Count(s => !s.DeletePending));
         }
 
         private static string hashFile(string filename)
@@ -832,7 +966,7 @@ namespace osu.Game.Tests.Database
 
         private static void checkBeatmapCount(Realm realm, int expected)
         {
-            Assert.AreEqual(expected, realm.All<RealmBeatmap>().Where(_ => true).ToList().Count);
+            Assert.AreEqual(expected, realm.All<BeatmapInfo>().Where(_ => true).ToList().Count);
         }
 
         private static void checkSingleReferencedFileCount(Realm realm, int expected)
@@ -848,26 +982,25 @@ namespace osu.Game.Tests.Database
             Assert.AreEqual(expected, singleReferencedCount);
         }
 
-        private static void ensureLoaded(Realm realm, int timeout = 60000)
+        internal static void EnsureLoaded(Realm realm, int timeout = 60000)
         {
-            IQueryable<RealmBeatmapSet>? resultSets = null;
+            IQueryable<BeatmapSetInfo>? resultSets = null;
 
             waitForOrAssert(() =>
-                {
-                    realm.Refresh();
-                    return (resultSets = realm.All<RealmBeatmapSet>().Where(s => !s.DeletePending && s.OnlineID == 241526)).Any();
-                },
-                @"BeatmapSet did not import to the database in allocated time.", timeout);
+            {
+                realm.Refresh();
+                return (resultSets = realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending && s.OnlineID == 241526)).Any();
+            }, @"BeatmapSet did not import to the database in allocated time.", timeout);
 
             // ensure we were stored to beatmap database backing...
             Assert.IsTrue(resultSets?.Count() == 1, $@"Incorrect result count found ({resultSets?.Count()} but should be 1).");
 
-            IEnumerable<RealmBeatmapSet> queryBeatmapSets() => realm.All<RealmBeatmapSet>().Where(s => !s.DeletePending && s.OnlineID == 241526);
+            IEnumerable<BeatmapSetInfo> queryBeatmapSets() => realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending && s.OnlineID == 241526);
 
             var set = queryBeatmapSets().First();
 
             // ReSharper disable once PossibleUnintendedReferenceComparison
-            IEnumerable<RealmBeatmap> queryBeatmaps() => realm.All<RealmBeatmap>().Where(s => s.BeatmapSet != null && s.BeatmapSet == set);
+            IEnumerable<BeatmapInfo> queryBeatmaps() => realm.All<BeatmapInfo>().Where(s => s.BeatmapSet != null && s.BeatmapSet == set);
 
             Assert.AreEqual(12, queryBeatmaps().Count(), @"Beatmap count was not correct");
             Assert.AreEqual(1, queryBeatmapSets().Count(), @"Beatmapset count was not correct");
@@ -880,7 +1013,7 @@ namespace osu.Game.Tests.Database
                 countBeatmaps = queryBeatmaps().Count(),
                 $@"Incorrect database beatmap count post-import ({countBeatmaps} but should be {countBeatmapSetBeatmaps}).");
 
-            foreach (RealmBeatmap b in set.Beatmaps)
+            foreach (BeatmapInfo b in set.Beatmaps)
                 Assert.IsTrue(set.Beatmaps.Any(c => c.OnlineID == b.OnlineID));
             Assert.IsTrue(set.Beatmaps.Count > 0);
         }
@@ -903,8 +1036,8 @@ namespace osu.Game.Tests.Database
 
         public class NonOptimisedBeatmapImporter : BeatmapImporter
         {
-            public NonOptimisedBeatmapImporter(RealmContextFactory realmFactory, Storage storage)
-                : base(realmFactory, storage)
+            public NonOptimisedBeatmapImporter(RealmAccess realm, Storage storage)
+                : base(realm, storage)
             {
             }
 

osu.Game.Tests/Database/FileStoreTests.cs

@@ -19,10 +19,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportFile()
         {
-            RunTestWithRealm((realmFactory, storage) =>
+            RunTestWithRealm((realmAccess, storage) =>
             {
-                var realm = realmFactory.Context;
-                var files = new RealmFileStore(realmFactory, storage);
+                var realm = realmAccess.Realm;
+                var files = new RealmFileStore(realmAccess, storage);
 
                 var testData = new MemoryStream(new byte[] { 0, 1, 2, 3 });
 
@@ -36,10 +36,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestImportSameFileTwice()
         {
-            RunTestWithRealm((realmFactory, storage) =>
+            RunTestWithRealm((realmAccess, storage) =>
             {
-                var realm = realmFactory.Context;
-                var files = new RealmFileStore(realmFactory, storage);
+                var realm = realmAccess.Realm;
+                var files = new RealmFileStore(realmAccess, storage);
 
                 var testData = new MemoryStream(new byte[] { 0, 1, 2, 3 });
 
@@ -53,10 +53,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestDontPurgeReferenced()
         {
-            RunTestWithRealm((realmFactory, storage) =>
+            RunTestWithRealm((realmAccess, storage) =>
             {
-                var realm = realmFactory.Context;
-                var files = new RealmFileStore(realmFactory, storage);
+                var realm = realmAccess.Realm;
+                var files = new RealmFileStore(realmAccess, storage);
 
                 var file = realm.Write(() => files.Add(new MemoryStream(new byte[] { 0, 1, 2, 3 }), realm));
 
@@ -92,10 +92,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestPurgeUnreferenced()
         {
-            RunTestWithRealm((realmFactory, storage) =>
+            RunTestWithRealm((realmAccess, storage) =>
             {
-                var realm = realmFactory.Context;
-                var files = new RealmFileStore(realmFactory, storage);
+                var realm = realmAccess.Realm;
+                var files = new RealmFileStore(realmAccess, storage);
 
                 var file = realm.Write(() => files.Add(new MemoryStream(new byte[] { 0, 1, 2, 3 }), realm));
 

osu.Game.Tests/Database/GeneralUsageTests.cs

@@ -5,8 +5,8 @@ using System;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using osu.Game.Beatmaps;
 using osu.Game.Database;
-using osu.Game.Models;
 
 #nullable enable
 
@@ -21,15 +21,15 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestConstructRealm()
         {
-            RunTestWithRealm((realmFactory, _) => { realmFactory.CreateContext().Refresh(); });
+            RunTestWithRealm((realm, _) => { realm.Run(r => r.Refresh()); });
         }
 
         [Test]
         public void TestBlockOperations()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
-                using (realmFactory.BlockAllOperations())
+                using (realm.BlockAllOperations())
                 {
                 }
             });
@@ -42,27 +42,26 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestNestedContextCreationWithSubscription()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
                 bool callbackRan = false;
 
-                using (var context = realmFactory.CreateContext())
+                realm.RegisterCustomSubscription(r =>
                 {
-                    var subscription = context.All<RealmBeatmap>().QueryAsyncWithNotifications((sender, changes, error) =>
+                    var subscription = r.All<BeatmapInfo>().QueryAsyncWithNotifications((sender, changes, error) =>
                     {
-                        using (realmFactory.CreateContext())
+                        realm.Run(_ =>
                         {
                             callbackRan = true;
-                        }
+                        });
                     });
 
                     // Force the callback above to run.
-                    using (realmFactory.CreateContext())
-                    {
-                    }
+                    realm.Run(rr => rr.Refresh());
 
                     subscription?.Dispose();
-                }
+                    return null;
+                });
 
                 Assert.IsTrue(callbackRan);
             });
@@ -71,31 +70,36 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestBlockOperationsWithContention()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
                 ManualResetEventSlim stopThreadedUsage = new ManualResetEventSlim();
                 ManualResetEventSlim hasThreadedUsage = new ManualResetEventSlim();
 
                 Task.Factory.StartNew(() =>
                 {
-                    using (realmFactory.CreateContext())
+                    realm.Run(_ =>
                     {
                         hasThreadedUsage.Set();
 
                         stopThreadedUsage.Wait();
-                    }
+                    });
                 }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler);
 
                 hasThreadedUsage.Wait();
 
                 Assert.Throws<TimeoutException>(() =>
                 {
-                    using (realmFactory.BlockAllOperations())
+                    using (realm.BlockAllOperations())
                     {
                     }
                 });
 
                 stopThreadedUsage.Set();
+
+                // Ensure we can block a second time after the usage has ended.
+                using (realm.BlockAllOperations())
+                {
+                }
             });
         }
     }

osu.Game.Tests/Database/RealmLiveTests.cs

@@ -8,8 +8,8 @@ using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Extensions;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps;
 using osu.Game.Database;
-using osu.Game.Models;
 using Realms;
 
 #nullable enable
@@ -21,11 +21,11 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestLiveEquality()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
-                ILive<RealmBeatmap> beatmap = realmFactory.CreateContext().Write(r => r.Add(new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata()))).ToLive(realmFactory);
+                Live<BeatmapInfo> beatmap = realm.Run(r => r.Write(_ => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata()))).ToLive(realm));
 
-                ILive<RealmBeatmap> beatmap2 = realmFactory.CreateContext().All<RealmBeatmap>().First().ToLive(realmFactory);
+                Live<BeatmapInfo> beatmap2 = realm.Run(r => r.All<BeatmapInfo>().First().ToLive(realm));
 
                 Assert.AreEqual(beatmap, beatmap2);
             });
@@ -34,26 +34,29 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestAccessAfterStorageMigrate()
         {
-            RunTestWithRealm((realmFactory, storage) =>
+            RunTestWithRealm((realm, storage) =>
             {
-                var beatmap = new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata());
+                var beatmap = new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata());
 
-                ILive<RealmBeatmap> liveBeatmap;
+                Live<BeatmapInfo>? liveBeatmap = null;
 
-                using (var context = realmFactory.CreateContext())
+                realm.Run(r =>
                 {
-                    context.Write(r => r.Add(beatmap));
+                    r.Write(_ => r.Add(beatmap));
 
-                    liveBeatmap = beatmap.ToLive(realmFactory);
-                }
+                    liveBeatmap = beatmap.ToLive(realm);
+                });
 
                 using (var migratedStorage = new TemporaryNativeStorage("realm-test-migration-target"))
                 {
                     migratedStorage.DeleteDirectory(string.Empty);
 
-                    storage.Migrate(migratedStorage);
+                    using (realm.BlockAllOperations())
+                    {
+                        storage.Migrate(migratedStorage);
+                    }
 
-                    Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
+                    Assert.IsFalse(liveBeatmap?.PerformRead(l => l.Hidden));
                 }
             });
         }
@@ -61,14 +64,13 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestAccessAfterAttach()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
-                var beatmap = new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata());
+                var beatmap = new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata());
 
-                var liveBeatmap = beatmap.ToLive(realmFactory);
+                var liveBeatmap = beatmap.ToLive(realm);
 
-                using (var context = realmFactory.CreateContext())
-                    context.Write(r => r.Add(beatmap));
+                realm.Run(r => r.Write(_ => r.Add(beatmap)));
 
                 Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
             });
@@ -77,7 +79,7 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestAccessNonManaged()
         {
-            var beatmap = new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata());
+            var beatmap = new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata());
             var liveBeatmap = beatmap.ToLiveUnmanaged();
 
             Assert.IsFalse(beatmap.Hidden);
@@ -94,17 +96,17 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestScopedReadWithoutContext()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
-                ILive<RealmBeatmap>? liveBeatmap = null;
+                Live<BeatmapInfo>? liveBeatmap = null;
                 Task.Factory.StartNew(() =>
                 {
-                    using (var threadContext = realmFactory.CreateContext())
+                    realm.Run(threadContext =>
                     {
-                        var beatmap = threadContext.Write(r => r.Add(new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata())));
+                        var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata())));
 
-                        liveBeatmap = beatmap.ToLive(realmFactory);
-                    }
+                        liveBeatmap = beatmap.ToLive(realm);
+                    });
                 }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
 
                 Debug.Assert(liveBeatmap != null);
@@ -123,17 +125,17 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestScopedWriteWithoutContext()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
-                ILive<RealmBeatmap>? liveBeatmap = null;
+                Live<BeatmapInfo>? liveBeatmap = null;
                 Task.Factory.StartNew(() =>
                 {
-                    using (var threadContext = realmFactory.CreateContext())
+                    realm.Run(threadContext =>
                     {
-                        var beatmap = threadContext.Write(r => r.Add(new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata())));
+                        var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata())));
 
-                        liveBeatmap = beatmap.ToLive(realmFactory);
-                    }
+                        liveBeatmap = beatmap.ToLive(realm);
+                    });
                 }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
 
                 Debug.Assert(liveBeatmap != null);
@@ -149,10 +151,10 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestValueAccessNonManaged()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
-                var beatmap = new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata());
-                var liveBeatmap = beatmap.ToLive(realmFactory);
+                var beatmap = new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata());
+                var liveBeatmap = beatmap.ToLive(realm);
 
                 Assert.DoesNotThrow(() =>
                 {
@@ -164,18 +166,18 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestValueAccessWithOpenContextFails()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
-                ILive<RealmBeatmap>? liveBeatmap = null;
+                Live<BeatmapInfo>? liveBeatmap = null;
 
                 Task.Factory.StartNew(() =>
                 {
-                    using (var threadContext = realmFactory.CreateContext())
+                    realm.Run(threadContext =>
                     {
-                        var beatmap = threadContext.Write(r => r.Add(new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata())));
+                        var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata())));
 
-                        liveBeatmap = beatmap.ToLive(realmFactory);
-                    }
+                        liveBeatmap = beatmap.ToLive(realm);
+                    });
                 }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
 
                 Debug.Assert(liveBeatmap != null);
@@ -189,13 +191,13 @@ namespace osu.Game.Tests.Database
                     });
 
                     // Can't be used, even from within a valid context.
-                    using (realmFactory.CreateContext())
+                    realm.Run(threadContext =>
                     {
                         Assert.Throws<InvalidOperationException>(() =>
                         {
                             var __ = liveBeatmap.Value;
                         });
-                    }
+                    });
                 }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
             });
         }
@@ -203,17 +205,17 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestValueAccessWithoutOpenContextFails()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
-                ILive<RealmBeatmap>? liveBeatmap = null;
+                Live<BeatmapInfo>? liveBeatmap = null;
                 Task.Factory.StartNew(() =>
                 {
-                    using (var threadContext = realmFactory.CreateContext())
+                    realm.Run(threadContext =>
                     {
-                        var beatmap = threadContext.Write(r => r.Add(new RealmBeatmap(CreateRuleset(), new RealmBeatmapDifficulty(), new RealmBeatmapMetadata())));
+                        var beatmap = threadContext.Write(r => r.Add(new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata())));
 
-                        liveBeatmap = beatmap.ToLive(realmFactory);
-                    }
+                        liveBeatmap = beatmap.ToLive(realm);
+                    });
                 }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
 
                 Debug.Assert(liveBeatmap != null);
@@ -231,56 +233,58 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestLiveAssumptions()
         {
-            RunTestWithRealm((realmFactory, _) =>
+            RunTestWithRealm((realm, _) =>
             {
                 int changesTriggered = 0;
 
-                using (var updateThreadContext = realmFactory.CreateContext())
+                realm.RegisterCustomSubscription(outerRealm =>
                 {
-                    updateThreadContext.All<RealmBeatmap>().QueryAsyncWithNotifications(gotChange);
-                    ILive<RealmBeatmap>? liveBeatmap = null;
+                    outerRealm.All<BeatmapInfo>().QueryAsyncWithNotifications(gotChange);
+                    Live<BeatmapInfo>? liveBeatmap = null;
 
                     Task.Factory.StartNew(() =>
                     {
-                        using (var threadContext = realmFactory.CreateContext())
+                        realm.Run(innerRealm =>
                         {
                             var ruleset = CreateRuleset();
-                            var beatmap = threadContext.Write(r => r.Add(new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), new RealmBeatmapMetadata())));
+                            var beatmap = innerRealm.Write(r => r.Add(new BeatmapInfo(ruleset, new BeatmapDifficulty(), new BeatmapMetadata())));
 
                             // add a second beatmap to ensure that a full refresh occurs below.
                             // not just a refresh from the resolved Live.
-                            threadContext.Write(r => r.Add(new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), new RealmBeatmapMetadata())));
+                            innerRealm.Write(r => r.Add(new BeatmapInfo(ruleset, new BeatmapDifficulty(), new BeatmapMetadata())));
 
-                            liveBeatmap = beatmap.ToLive(realmFactory);
-                        }
+                            liveBeatmap = beatmap.ToLive(realm);
+                        });
                     }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
 
                     Debug.Assert(liveBeatmap != null);
 
                     // not yet seen by main context
-                    Assert.AreEqual(0, updateThreadContext.All<RealmBeatmap>().Count());
+                    Assert.AreEqual(0, outerRealm.All<BeatmapInfo>().Count());
                     Assert.AreEqual(0, changesTriggered);
 
                     liveBeatmap.PerformRead(resolved =>
                     {
                         // retrieval causes an implicit refresh. even changes that aren't related to the retrieval are fired at this point.
                         // ReSharper disable once AccessToDisposedClosure
-                        Assert.AreEqual(2, updateThreadContext.All<RealmBeatmap>().Count());
+                        Assert.AreEqual(2, outerRealm.All<BeatmapInfo>().Count());
                         Assert.AreEqual(1, changesTriggered);
 
                         // can access properties without a crash.
                         Assert.IsFalse(resolved.Hidden);
 
                         // ReSharper disable once AccessToDisposedClosure
-                        updateThreadContext.Write(r =>
+                        outerRealm.Write(r =>
                         {
                             // can use with the main context.
                             r.Remove(resolved);
                         });
                     });
-                }
 
-                void gotChange(IRealmCollection<RealmBeatmap> sender, ChangeSet changes, Exception error)
+                    return null;
+                });
+
+                void gotChange(IRealmCollection<BeatmapInfo> sender, ChangeSet changes, Exception error)
                 {
                     changesTriggered++;
                 }

osu.Game.Tests/Database/RealmSubscriptionRegistrationTests.cs

@@ -0,0 +1,138 @@
+// 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.Allocation;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Tests.Resources;
+using Realms;
+
+#nullable enable
+
+namespace osu.Game.Tests.Database
+{
+    [TestFixture]
+    public class RealmSubscriptionRegistrationTests : RealmTest
+    {
+        [Test]
+        public void TestSubscriptionWithContextLoss()
+        {
+            IEnumerable<BeatmapSetInfo>? resolvedItems = null;
+            ChangeSet? lastChanges = null;
+
+            RunTestWithRealm((realm, _) =>
+            {
+                realm.Write(r => r.Add(TestResources.CreateTestBeatmapSetInfo()));
+
+                var registration = realm.RegisterForNotifications(r => r.All<BeatmapSetInfo>(), onChanged);
+
+                testEventsArriving(true);
+
+                // All normal until here.
+                // Now let's yank the main realm context.
+                resolvedItems = null;
+                lastChanges = null;
+
+                using (realm.BlockAllOperations())
+                    Assert.That(resolvedItems, Is.Empty);
+
+                realm.Write(r => r.Add(TestResources.CreateTestBeatmapSetInfo()));
+
+                testEventsArriving(true);
+
+                // Now let's try unsubscribing.
+                resolvedItems = null;
+                lastChanges = null;
+
+                registration.Dispose();
+
+                realm.Write(r => r.Add(TestResources.CreateTestBeatmapSetInfo()));
+
+                testEventsArriving(false);
+
+                // And make sure even after another context loss we don't get firings.
+                using (realm.BlockAllOperations())
+                    Assert.That(resolvedItems, Is.Null);
+
+                realm.Write(r => r.Add(TestResources.CreateTestBeatmapSetInfo()));
+
+                testEventsArriving(false);
+
+                void testEventsArriving(bool shouldArrive)
+                {
+                    realm.Run(r => r.Refresh());
+
+                    if (shouldArrive)
+                        Assert.That(resolvedItems, Has.One.Items);
+                    else
+                        Assert.That(resolvedItems, Is.Null);
+
+                    realm.Write(r =>
+                    {
+                        r.RemoveAll<BeatmapSetInfo>();
+                        r.RemoveAll<RulesetInfo>();
+                    });
+
+                    realm.Run(r => r.Refresh());
+
+                    if (shouldArrive)
+                        Assert.That(lastChanges?.DeletedIndices, Has.One.Items);
+                    else
+                        Assert.That(lastChanges, Is.Null);
+                }
+            });
+
+            void onChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet? changes, Exception error)
+            {
+                if (changes == null)
+                    resolvedItems = sender;
+
+                lastChanges = changes;
+            }
+        }
+
+        [Test]
+        public void TestCustomRegisterWithContextLoss()
+        {
+            RunTestWithRealm((realm, _) =>
+            {
+                BeatmapSetInfo? beatmapSetInfo = null;
+
+                realm.Write(r => r.Add(TestResources.CreateTestBeatmapSetInfo()));
+
+                var subscription = realm.RegisterCustomSubscription(r =>
+                {
+                    beatmapSetInfo = r.All<BeatmapSetInfo>().First();
+
+                    return new InvokeOnDisposal(() => beatmapSetInfo = null);
+                });
+
+                Assert.That(beatmapSetInfo, Is.Not.Null);
+
+                using (realm.BlockAllOperations())
+                {
+                    // custom disposal action fired when context lost.
+                    Assert.That(beatmapSetInfo, Is.Null);
+                }
+
+                // re-registration after context restore.
+                realm.Run(r => r.Refresh());
+                Assert.That(beatmapSetInfo, Is.Not.Null);
+
+                subscription.Dispose();
+
+                Assert.That(beatmapSetInfo, Is.Null);
+
+                using (realm.BlockAllOperations())
+                    Assert.That(beatmapSetInfo, Is.Null);
+
+                realm.Run(r => r.Refresh());
+                Assert.That(beatmapSetInfo, Is.Null);
+            });
+        }
+    }
+}

osu.Game.Tests/Database/RealmTest.cs

@@ -9,9 +9,11 @@ using osu.Framework.Extensions;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.IO;
 using osu.Game.Models;
+using osu.Game.Rulesets;
 
 #nullable enable
 
@@ -28,7 +30,7 @@ namespace osu.Game.Tests.Database
             storage.DeleteDirectory(string.Empty);
         }
 
-        protected void RunTestWithRealm(Action<RealmContextFactory, OsuStorage> testAction, [CallerMemberName] string caller = "")
+        protected void RunTestWithRealm(Action<RealmAccess, OsuStorage> testAction, [CallerMemberName] string caller = "")
         {
             using (HeadlessGameHost host = new CleanRunHeadlessGameHost(callingMethodName: caller))
             {
@@ -37,22 +39,22 @@ namespace osu.Game.Tests.Database
                     // ReSharper disable once AccessToDisposedClosure
                     var testStorage = new OsuStorage(host, storage.GetStorageForDirectory(caller));
 
-                    using (var realmFactory = new RealmContextFactory(testStorage, "client"))
+                    using (var realm = new RealmAccess(testStorage, "client"))
                     {
-                        Logger.Log($"Running test using realm file {testStorage.GetFullPath(realmFactory.Filename)}");
-                        testAction(realmFactory, testStorage);
+                        Logger.Log($"Running test using realm file {testStorage.GetFullPath(realm.Filename)}");
+                        testAction(realm, testStorage);
 
-                        realmFactory.Dispose();
+                        realm.Dispose();
 
-                        Logger.Log($"Final database size: {getFileSize(testStorage, realmFactory)}");
-                        realmFactory.Compact();
-                        Logger.Log($"Final database size after compact: {getFileSize(testStorage, realmFactory)}");
+                        Logger.Log($"Final database size: {getFileSize(testStorage, realm)}");
+                        realm.Compact();
+                        Logger.Log($"Final database size after compact: {getFileSize(testStorage, realm)}");
                     }
                 }));
             }
         }
 
-        protected void RunTestWithRealmAsync(Func<RealmContextFactory, Storage, Task> testAction, [CallerMemberName] string caller = "")
+        protected void RunTestWithRealmAsync(Func<RealmAccess, Storage, Task> testAction, [CallerMemberName] string caller = "")
         {
             using (HeadlessGameHost host = new CleanRunHeadlessGameHost(callingMethodName: caller))
             {
@@ -60,38 +62,38 @@ namespace osu.Game.Tests.Database
                 {
                     var testStorage = storage.GetStorageForDirectory(caller);
 
-                    using (var realmFactory = new RealmContextFactory(testStorage, "client"))
+                    using (var realm = new RealmAccess(testStorage, "client"))
                     {
-                        Logger.Log($"Running test using realm file {testStorage.GetFullPath(realmFactory.Filename)}");
-                        await testAction(realmFactory, testStorage);
+                        Logger.Log($"Running test using realm file {testStorage.GetFullPath(realm.Filename)}");
+                        await testAction(realm, testStorage);
 
-                        realmFactory.Dispose();
+                        realm.Dispose();
 
-                        Logger.Log($"Final database size: {getFileSize(testStorage, realmFactory)}");
-                        realmFactory.Compact();
+                        Logger.Log($"Final database size: {getFileSize(testStorage, realm)}");
+                        realm.Compact();
                     }
                 }));
             }
         }
 
-        protected static RealmBeatmapSet CreateBeatmapSet(RealmRuleset ruleset)
+        protected static BeatmapSetInfo CreateBeatmapSet(RulesetInfo ruleset)
         {
             RealmFile createRealmFile() => new RealmFile { Hash = Guid.NewGuid().ToString().ComputeSHA2Hash() };
 
-            var metadata = new RealmBeatmapMetadata
+            var metadata = new BeatmapMetadata
             {
                 Title = "My Love",
                 Artist = "Kuba Oms"
             };
 
-            var beatmapSet = new RealmBeatmapSet
+            var beatmapSet = new BeatmapSetInfo
             {
                 Beatmaps =
                 {
-                    new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), metadata) { DifficultyName = "Easy", },
-                    new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), metadata) { DifficultyName = "Normal", },
-                    new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), metadata) { DifficultyName = "Hard", },
-                    new RealmBeatmap(ruleset, new RealmBeatmapDifficulty(), metadata) { DifficultyName = "Insane", }
+                    new BeatmapInfo(ruleset, new BeatmapDifficulty(), metadata) { DifficultyName = "Easy", },
+                    new BeatmapInfo(ruleset, new BeatmapDifficulty(), metadata) { DifficultyName = "Normal", },
+                    new BeatmapInfo(ruleset, new BeatmapDifficulty(), metadata) { DifficultyName = "Hard", },
+                    new BeatmapInfo(ruleset, new BeatmapDifficulty(), metadata) { DifficultyName = "Insane", }
                 },
                 Files =
                 {
@@ -111,8 +113,8 @@ namespace osu.Game.Tests.Database
             return beatmapSet;
         }
 
-        protected static RealmRuleset CreateRuleset() =>
-            new RealmRuleset(0, "osu!", "osu", true);
+        protected static RulesetInfo CreateRuleset() =>
+            new RulesetInfo("osu", "osu!", string.Empty, 0) { Available = true };
 
         private class RealmTestGame : Framework.Game
         {
@@ -136,11 +138,11 @@ namespace osu.Game.Tests.Database
             }
         }
 
-        private static long getFileSize(Storage testStorage, RealmContextFactory realmFactory)
+        private static long getFileSize(Storage testStorage, RealmAccess realm)
         {
             try
             {
-                using (var stream = testStorage.GetStream(realmFactory.Filename))
+                using (var stream = testStorage.GetStream(realm.Filename))
                     return stream?.Length ?? 0;
             }
             catch

osu.Game.Tests/Database/RulesetStoreTests.cs

@@ -3,8 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Game.Models;
-using osu.Game.Stores;
+using osu.Game.Rulesets;
 
 namespace osu.Game.Tests.Database
 {
@@ -13,37 +12,37 @@ namespace osu.Game.Tests.Database
         [Test]
         public void TestCreateStore()
         {
-            RunTestWithRealm((realmFactory, storage) =>
+            RunTestWithRealm((realm, storage) =>
             {
-                var rulesets = new RealmRulesetStore(realmFactory, storage);
+                var rulesets = new RulesetStore(realm, storage);
 
                 Assert.AreEqual(4, rulesets.AvailableRulesets.Count());
-                Assert.AreEqual(4, realmFactory.Context.All<RealmRuleset>().Count());
+                Assert.AreEqual(4, realm.Realm.All<RulesetInfo>().Count());
             });
         }
 
         [Test]
         public void TestCreateStoreTwiceDoesntAddRulesetsAgain()
         {
-            RunTestWithRealm((realmFactory, storage) =>
+            RunTestWithRealm((realm, storage) =>
             {
-                var rulesets = new RealmRulesetStore(realmFactory, storage);
-                var rulesets2 = new RealmRulesetStore(realmFactory, storage);
+                var rulesets = new RulesetStore(realm, storage);
+                var rulesets2 = new RulesetStore(realm, storage);
 
                 Assert.AreEqual(4, rulesets.AvailableRulesets.Count());
                 Assert.AreEqual(4, rulesets2.AvailableRulesets.Count());
 
                 Assert.AreEqual(rulesets.AvailableRulesets.First(), rulesets2.AvailableRulesets.First());
-                Assert.AreEqual(4, realmFactory.Context.All<RealmRuleset>().Count());
+                Assert.AreEqual(4, realm.Realm.All<RulesetInfo>().Count());
             });
         }
 
         [Test]
         public void TestRetrievedRulesetsAreDetached()
         {
-            RunTestWithRealm((realmFactory, storage) =>
+            RunTestWithRealm((realm, storage) =>
             {
-                var rulesets = new RealmRulesetStore(realmFactory, storage);
+                var rulesets = new RulesetStore(realm, storage);
 
                 Assert.IsFalse(rulesets.AvailableRulesets.First().IsManaged);
                 Assert.IsFalse(rulesets.GetRuleset(0)?.IsManaged);

osu.Game.Tests/Database/TestRealmKeyBindingStore.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Tests.Database
 
         private RealmKeyBindingStore keyBindingStore;
 
-        private RealmContextFactory realmContextFactory;
+        private RealmAccess realm;
 
         [SetUp]
         public void SetUp()
@@ -33,8 +33,8 @@ namespace osu.Game.Tests.Database
 
             storage = new NativeStorage(directory.FullName);
 
-            realmContextFactory = new RealmContextFactory(storage, "test");
-            keyBindingStore = new RealmKeyBindingStore(realmContextFactory, new ReadableKeyCombinationProvider());
+            realm = new RealmAccess(storage, "test");
+            keyBindingStore = new RealmKeyBindingStore(realm, new ReadableKeyCombinationProvider());
         }
 
         [Test]
@@ -60,29 +60,12 @@ namespace osu.Game.Tests.Database
             KeyBindingContainer testContainer = new TestKeyBindingContainer();
 
             // Add some excess bindings for an action which only supports 1.
-            using (var realm = realmContextFactory.CreateContext())
-            using (var transaction = realm.BeginWrite())
+            realm.Write(r =>
             {
-                realm.Add(new RealmKeyBinding
-                {
-                    Action = GlobalAction.Back,
-                    KeyCombination = new KeyCombination(InputKey.A)
-                });
-
-                realm.Add(new RealmKeyBinding
-                {
-                    Action = GlobalAction.Back,
-                    KeyCombination = new KeyCombination(InputKey.S)
-                });
-
-                realm.Add(new RealmKeyBinding
-                {
-                    Action = GlobalAction.Back,
-                    KeyCombination = new KeyCombination(InputKey.D)
-                });
-
-                transaction.Commit();
-            }
+                r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.A)));
+                r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.S)));
+                r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.D)));
+            });
 
             Assert.That(queryCount(GlobalAction.Back), Is.EqualTo(3));
 
@@ -93,13 +76,13 @@ namespace osu.Game.Tests.Database
 
         private int queryCount(GlobalAction? match = null)
         {
-            using (var realm = realmContextFactory.CreateContext())
+            return realm.Run(r =>
             {
-                var results = realm.All<RealmKeyBinding>();
+                var results = r.All<RealmKeyBinding>();
                 if (match.HasValue)
                     results = results.Where(k => k.ActionInt == (int)match.Value);
                 return results.Count();
-            }
+            });
         }
 
         [Test]
@@ -109,32 +92,32 @@ namespace osu.Game.Tests.Database
 
             keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
 
-            using (var primaryRealm = realmContextFactory.CreateContext())
+            realm.Run(outerRealm =>
             {
-                var backBinding = primaryRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
+                var backBinding = outerRealm.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 threadedContext = realmContextFactory.CreateContext())
+                realm.Run(innerRealm =>
                 {
-                    var binding = threadedContext.ResolveReference(tsr);
-                    threadedContext.Write(() => binding.KeyCombination = new KeyCombination(InputKey.BackSpace));
-                }
+                    var binding = innerRealm.ResolveReference(tsr);
+                    innerRealm.Write(() => binding.KeyCombination = new KeyCombination(InputKey.BackSpace));
+                });
 
                 Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
 
                 // check still correct after re-query.
-                backBinding = primaryRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
+                backBinding = outerRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
                 Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
-            }
+            });
         }
 
         [TearDown]
         public void TearDown()
         {
-            realmContextFactory.Dispose();
+            realm.Dispose();
             storage.DeleteDirectory(string.Empty);
         }
 

osu.Game.Tests/Editing/Checks/CheckAudioInVideoTest.cs

@@ -74,7 +74,7 @@ namespace osu.Game.Tests.Editing.Checks
         [Test]
         public void TestMissingFile()
         {
-            beatmap.BeatmapInfo.BeatmapSet.Files.Clear();
+            beatmap.BeatmapInfo.BeatmapSet?.Files.Clear();
 
             var issues = check.Run(getContext(null)).ToList();
 

osu.Game.Tests/Editing/Checks/CheckFilePresenceTest.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Tests.Editing.Checks
         [Test]
         public void TestBackgroundSetAndNotInFiles()
         {
-            beatmap.BeatmapInfo.BeatmapSet.Files.Clear();
+            beatmap.BeatmapInfo.BeatmapSet?.Files.Clear();
 
             var context = new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
             var issues = check.Run(context).ToList();

osu.Game.Tests/Editing/Checks/CheckTestHelpers.cs

@@ -1,18 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Beatmaps;
-using osu.Game.IO;
+using osu.Game.Models;
 
 namespace osu.Game.Tests.Editing.Checks
 {
     public static class CheckTestHelpers
     {
-        public static BeatmapSetFileInfo CreateMockFile(string extension) =>
-            new BeatmapSetFileInfo
-            {
-                Filename = $"abc123.{extension}",
-                FileInfo = new FileInfo { Hash = "abcdef" }
-            };
+        public static RealmNamedFileUsage CreateMockFile(string extension) =>
+            new RealmNamedFileUsage(new RealmFile { Hash = "abcdef" }, $"abc123.{extension}");
     }
 }

osu.Game.Tests/Editing/Checks/CheckTooShortAudioFilesTest.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using ManagedBass;
@@ -45,6 +46,8 @@ namespace osu.Game.Tests.Editing.Checks
         [Test]
         public void TestDifferentExtension()
         {
+            Debug.Assert(beatmap.BeatmapInfo.BeatmapSet != null);
+
             beatmap.BeatmapInfo.BeatmapSet.Files.Clear();
             beatmap.BeatmapInfo.BeatmapSet.Files.Add(CheckTestHelpers.CreateMockFile("jpg"));
 

osu.Game.Tests/Editing/EditorChangeHandlerTest.cs

@@ -2,7 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
-using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
 
@@ -158,7 +159,13 @@ namespace osu.Game.Tests.Editing
 
         private (EditorChangeHandler, EditorBeatmap) createChangeHandler()
         {
-            var beatmap = new EditorBeatmap(new Beatmap());
+            var beatmap = new EditorBeatmap(new OsuBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                },
+            });
 
             var changeHandler = new EditorChangeHandler(beatmap);
 

osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs

@@ -35,7 +35,13 @@ namespace osu.Game.Tests.Editing
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
                 {
-                    editorBeatmap = new EditorBeatmap(new OsuBeatmap()),
+                    editorBeatmap = new EditorBeatmap(new OsuBeatmap
+                    {
+                        BeatmapInfo =
+                        {
+                            Ruleset = new OsuRuleset().RulesetInfo,
+                        },
+                    }),
                     Content = new Container
                     {
                         RelativeSizeAxes = Axes.Both,

osu.Game.Tests/Gameplay/TestSceneStoryboardSamples.cs

@@ -261,7 +261,7 @@ namespace osu.Game.Tests.Gameplay
         public AudioManager AudioManager => Audio;
         public IResourceStore<byte[]> Files => null;
         public new IResourceStore<byte[]> Resources => base.Resources;
-        public RealmContextFactory RealmContextFactory => null;
+        public RealmAccess RealmAccess => null;
         public IResourceStore<TextureUpload> CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => null;
 
         #endregion

osu.Game.Tests/NonVisual/BarLineGeneratorTest.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Tests.NonVisual
 
             const int beat_length_numerator = 2000;
             const int beat_length_denominator = 7;
-            const TimeSignatures signature = TimeSignatures.SimpleQuadruple;
+            TimeSignature signature = TimeSignature.SimpleQuadruple;
 
             var beatmap = new Beatmap
             {
@@ -49,7 +49,7 @@ namespace osu.Game.Tests.NonVisual
             for (int i = 0; i * beat_length_denominator < barLines.Count; i++)
             {
                 var barLine = barLines[i * beat_length_denominator];
-                int expectedTime = beat_length_numerator * (int)signature * i;
+                int expectedTime = beat_length_numerator * signature.Numerator * i;
 
                 // every seventh bar's start time should be at least greater than the whole number we expect.
                 // It cannot be less, as that can affect overlapping scroll algorithms
@@ -60,7 +60,7 @@ namespace osu.Game.Tests.NonVisual
                 Assert.IsTrue(Precision.AlmostEquals(barLine.StartTime, expectedTime));
 
                 // check major/minor lines for good measure too
-                Assert.AreEqual(i % (int)signature == 0, barLine.Major);
+                Assert.AreEqual(i % signature.Numerator == 0, barLine.Major);
             }
         }
 

osu.Game.Tests/NonVisual/BeatmapSetInfoEqualityTest.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Extensions;
@@ -23,8 +24,10 @@ namespace osu.Game.Tests.NonVisual
         [Test]
         public void TestDatabasedWithDatabased()
         {
-            var ourInfo = new BeatmapSetInfo { ID = 123 };
-            var otherInfo = new BeatmapSetInfo { ID = 123 };
+            var guid = Guid.NewGuid();
+
+            var ourInfo = new BeatmapSetInfo { ID = guid };
+            var otherInfo = new BeatmapSetInfo { ID = guid };
 
             Assert.AreEqual(ourInfo, otherInfo);
         }
@@ -32,7 +35,7 @@ namespace osu.Game.Tests.NonVisual
         [Test]
         public void TestDatabasedWithOnline()
         {
-            var ourInfo = new BeatmapSetInfo { ID = 123, OnlineID = 12 };
+            var ourInfo = new BeatmapSetInfo { ID = Guid.NewGuid(), OnlineID = 12 };
             var otherInfo = new BeatmapSetInfo { OnlineID = 12 };
 
             Assert.AreNotEqual(ourInfo, otherInfo);

osu.Game.Tests/NonVisual/CustomDataDirectoryTest.cs

@@ -142,19 +142,28 @@ namespace osu.Game.Tests.NonVisual
 
                     Assert.That(osuStorage, Is.Not.Null);
 
+                    // In the following tests, realm files are ignored as
+                    // - in the case of checking the source, interacting with the pipe files (client.realm.note) may
+                    //   lead to unexpected behaviour.
+                    // - in the case of checking the destination, the files may have already been recreated by the game
+                    //   as part of the standard migration flow.
+
                     foreach (string file in osuStorage.IgnoreFiles)
                     {
-                        // avoid touching realm files which may be a pipe and break everything.
-                        // this is also done locally inside OsuStorage via the IgnoreFiles list.
-                        if (file.EndsWith(".ini", StringComparison.Ordinal))
+                        if (!file.Contains("realm", StringComparison.Ordinal))
+                        {
                             Assert.That(File.Exists(Path.Combine(originalDirectory, file)));
-                        Assert.That(storage.Exists(file), Is.False);
+                            Assert.That(storage.Exists(file), Is.False, () => $"{file} exists in destination when it was expected to be ignored");
+                        }
                     }
 
                     foreach (string dir in osuStorage.IgnoreDirectories)
                     {
-                        Assert.That(Directory.Exists(Path.Combine(originalDirectory, dir)));
-                        Assert.That(storage.ExistsDirectory(dir), Is.False);
+                        if (!dir.Contains("realm", StringComparison.Ordinal))
+                        {
+                            Assert.That(Directory.Exists(Path.Combine(originalDirectory, dir)));
+                            Assert.That(storage.Exists(dir), Is.False, () => $"{dir} exists in destination when it was expected to be ignored");
+                        }
                     }
 
                     Assert.That(new StreamReader(Path.Combine(originalDirectory, "storage.ini")).ReadToEnd().Contains($"FullPath = {customPath}"));
@@ -179,7 +188,7 @@ namespace osu.Game.Tests.NonVisual
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    const string database_filename = "client.db";
+                    const string database_filename = "client.realm";
 
                     Assert.DoesNotThrow(() => osu.Migrate(customPath));
                     Assert.That(File.Exists(Path.Combine(customPath, database_filename)));

osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs

@@ -16,10 +16,13 @@ namespace osu.Game.Tests.NonVisual.Filtering
     {
         private BeatmapInfo getExampleBeatmap() => new BeatmapInfo
         {
-            Ruleset = new RulesetInfo { OnlineID = 0 },
-            RulesetID = 0,
+            Ruleset = new RulesetInfo
+            {
+                ShortName = "osu",
+                OnlineID = 0
+            },
             StarRating = 4.0d,
-            BaseDifficulty = new BeatmapDifficulty
+            Difficulty = new BeatmapDifficulty
             {
                 ApproachRate = 5.0f,
                 DrainRate = 3.0f,
@@ -31,7 +34,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
                 ArtistUnicode = "check unicode too",
                 Title = "Title goes here",
                 TitleUnicode = "Title goes here",
-                AuthorString = "The Author",
+                Author = { Username = "The Author" },
                 Source = "unit tests",
                 Tags = "look for tags too",
             },
@@ -58,7 +61,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var exampleBeatmapInfo = getExampleBeatmap();
             var criteria = new FilterCriteria
             {
-                Ruleset = new RulesetInfo { OnlineID = 6 }
+                Ruleset = new RulesetInfo { ShortName = "catch" }
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
@@ -79,6 +82,20 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.IsFalse(carouselItem.Filtered.Value);
         }
 
+        [Test]
+        public void TestCriteriaMatchingConvertedBeatmapsForCustomRulesets()
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { OnlineID = -1 },
+                AllowConvertedBeatmaps = true
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.IsFalse(carouselItem.Filtered.Value);
+        }
+
         [Test]
         [TestCase(true)]
         [TestCase(false)]

osu.Game.Tests/NonVisual/RulesetInfoOrderingTest.cs

@@ -0,0 +1,38 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Osu;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class RulesetInfoOrderingTest
+    {
+        [Test]
+        public void TestOrdering()
+        {
+            var rulesets = new[]
+            {
+                new RulesetInfo("custom2", "Custom Ruleset 2", string.Empty, -1),
+                new OsuRuleset().RulesetInfo,
+                new RulesetInfo("custom3", "Custom Ruleset 3", string.Empty, -1),
+                new RulesetInfo("custom2", "Custom Ruleset 2", string.Empty, -1),
+                new CatchRuleset().RulesetInfo,
+                new RulesetInfo("custom3", "Custom Ruleset 3", string.Empty, -1),
+            };
+
+            var orderedRulesets = rulesets.OrderBy(r => r);
+
+            // Ensure all customs are after official.
+            Assert.That(orderedRulesets.Select(r => r.OnlineID), Is.EqualTo(new[] { 0, 2, -1, -1, -1, -1 }));
+
+            // Ensure customs are grouped next to each other (ie. stably sorted).
+            Assert.That(orderedRulesets.SkipWhile(r => r.ShortName != "custom2").Skip(1).First().ShortName, Is.EqualTo("custom2"));
+            Assert.That(orderedRulesets.SkipWhile(r => r.ShortName != "custom3").Skip(1).First().ShortName, Is.EqualTo("custom3"));
+        }
+    }
+}

osu.Game.Tests/NonVisual/ScoreInfoTest.cs

@@ -2,6 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Game.Online.API;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 
@@ -22,12 +26,52 @@ namespace osu.Game.Tests.NonVisual
 
             score.Statistics[HitResult.Good]++;
             score.Rank = ScoreRank.X;
+            score.RealmUser.Username = "test";
 
             Assert.That(scoreCopy.Statistics[HitResult.Good], Is.EqualTo(10));
             Assert.That(score.Statistics[HitResult.Good], Is.EqualTo(11));
 
             Assert.That(scoreCopy.Rank, Is.EqualTo(ScoreRank.B));
             Assert.That(score.Rank, Is.EqualTo(ScoreRank.X));
+
+            Assert.That(scoreCopy.RealmUser.Username, Is.Empty);
+            Assert.That(score.RealmUser.Username, Is.EqualTo("test"));
+        }
+
+        [Test]
+        public void TestModsInitiallyEmpty()
+        {
+            var score = new ScoreInfo();
+
+            Assert.That(score.Mods, Is.Empty);
+            Assert.That(score.APIMods, Is.Empty);
+            Assert.That(score.ModsJson, Is.Empty);
+        }
+
+        [Test]
+        public void TestModsUpdatedCorrectly()
+        {
+            var score = new ScoreInfo
+            {
+                Mods = new Mod[] { new ManiaModClassic() },
+                Ruleset = new ManiaRuleset().RulesetInfo,
+            };
+
+            Assert.That(score.Mods, Contains.Item(new ManiaModClassic()));
+            Assert.That(score.APIMods, Contains.Item(new APIMod(new ManiaModClassic())));
+            Assert.That(score.ModsJson, Contains.Substring("CL"));
+
+            score.APIMods = new[] { new APIMod(new ManiaModDoubleTime()) };
+
+            Assert.That(score.Mods, Contains.Item(new ManiaModDoubleTime()));
+            Assert.That(score.APIMods, Contains.Item(new APIMod(new ManiaModDoubleTime())));
+            Assert.That(score.ModsJson, Contains.Substring("DT"));
+
+            score.Mods = new Mod[] { new ManiaModClassic() };
+
+            Assert.That(score.Mods, Contains.Item(new ManiaModClassic()));
+            Assert.That(score.APIMods, Contains.Item(new APIMod(new ManiaModClassic())));
+            Assert.That(score.ModsJson, Contains.Substring("CL"));
         }
     }
 }

osu.Game.Tests/Online/TestAPIModJsonSerialization.cs

@@ -9,10 +9,12 @@ using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Solo;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
@@ -93,7 +95,11 @@ namespace osu.Game.Tests.Online
         [Test]
         public void TestDeserialiseSubmittableScoreWithEmptyMods()
         {
-            var score = new SubmittableScore(new ScoreInfo());
+            var score = new SubmittableScore(new ScoreInfo
+            {
+                User = new APIUser(),
+                Ruleset = new OsuRuleset().RulesetInfo,
+            });
 
             var deserialised = JsonConvert.DeserializeObject<SubmittableScore>(JsonConvert.SerializeObject(score));
 
@@ -105,7 +111,9 @@ namespace osu.Game.Tests.Online
         {
             var score = new SubmittableScore(new ScoreInfo
             {
-                Mods = new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 2 } } }
+                Mods = new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 2 } } },
+                User = new APIUser(),
+                Ruleset = new OsuRuleset().RulesetInfo,
             });
 
             var deserialised = JsonConvert.DeserializeObject<SubmittableScore>(JsonConvert.SerializeObject(score));

osu.Game.Tests/Online/TestSceneBeatmapDownloading.cs

@@ -5,6 +5,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Models;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Tests.Visual;
@@ -20,13 +21,19 @@ namespace osu.Game.Tests.Online
         private static readonly BeatmapSetInfo test_db_model = new BeatmapSetInfo
         {
             OnlineID = 1,
-            Metadata = new BeatmapMetadata
+            Beatmaps =
             {
-                Artist = "test author",
-                Title = "test title",
-                Author = new APIUser
+                new BeatmapInfo
                 {
-                    Username = "mapper"
+                    Metadata = new BeatmapMetadata
+                    {
+                        Artist = "test author",
+                        Title = "test title",
+                        Author = new RealmUser
+                        {
+                            Username = "mapper"
+                        }
+                    }
                 }
             }
         };

osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs

@@ -45,8 +45,8 @@ namespace osu.Game.Tests.Online
         [BackgroundDependencyLoader]
         private void load(AudioManager audio, GameHost host)
         {
-            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.CacheAs<BeatmapManager>(beatmaps = new TestBeatmapManager(LocalStorage, ContextFactory, rulesets, API, audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(rulesets = new RulesetStore(Realm));
+            Dependencies.CacheAs<BeatmapManager>(beatmaps = new TestBeatmapManager(LocalStorage, Realm, rulesets, API, audio, Resources, host, Beatmap.Default));
             Dependencies.CacheAs<BeatmapModelDownloader>(beatmapDownloader = new TestBeatmapModelDownloader(beatmaps, API, host));
         }
 
@@ -60,9 +60,8 @@ namespace osu.Game.Tests.Online
             testBeatmapInfo = getTestBeatmapInfo(testBeatmapFile);
             testBeatmapSet = testBeatmapInfo.BeatmapSet;
 
-            var existing = beatmaps.QueryBeatmapSet(s => s.OnlineID == testBeatmapSet.OnlineID);
-            if (existing != null)
-                beatmaps.Delete(existing);
+            Realm.Write(r => r.RemoveAll<BeatmapSetInfo>());
+            Realm.Write(r => r.RemoveAll<BeatmapInfo>());
 
             selectedItem.Value = new PlaylistItem
             {
@@ -92,7 +91,7 @@ namespace osu.Game.Tests.Online
             addAvailabilityCheckStep("state importing", BeatmapAvailability.Importing);
 
             AddStep("allow importing", () => beatmaps.AllowImport.SetResult(true));
-            AddUntilStep("wait for import", () => beatmaps.CurrentImportTask?.IsCompleted == true);
+            AddUntilStep("wait for import", () => beatmaps.CurrentImport != null);
             addAvailabilityCheckStep("state locally available", BeatmapAvailability.LocallyAvailable);
         }
 
@@ -103,10 +102,10 @@ namespace osu.Game.Tests.Online
             AddStep("import beatmap", () => beatmaps.Import(testBeatmapFile).WaitSafely());
             addAvailabilityCheckStep("state locally available", BeatmapAvailability.LocallyAvailable);
 
-            AddStep("delete beatmap", () => beatmaps.Delete(beatmaps.QueryBeatmapSet(b => b.OnlineID == testBeatmapSet.OnlineID)));
+            AddStep("delete beatmap", () => beatmaps.Delete(beatmaps.QueryBeatmapSet(b => b.OnlineID == testBeatmapSet.OnlineID)!.Value));
             addAvailabilityCheckStep("state not downloaded", BeatmapAvailability.NotDownloaded);
 
-            AddStep("undelete beatmap", () => beatmaps.Undelete(beatmaps.QueryBeatmapSet(b => b.OnlineID == testBeatmapSet.OnlineID)));
+            AddStep("undelete beatmap", () => beatmaps.Undelete(beatmaps.QueryBeatmapSet(b => b.OnlineID == testBeatmapSet.OnlineID)!.Value));
             addAvailabilityCheckStep("state locally available", BeatmapAvailability.LocallyAvailable);
         }
 
@@ -154,7 +153,6 @@ namespace osu.Game.Tests.Online
                 Debug.Assert(info.BeatmapSet != null);
 
                 info.BeatmapSet.Beatmaps.Add(info);
-                info.BeatmapSet.Metadata = info.Metadata;
                 info.MD5Hash = stream.ComputeMD5Hash();
                 info.Hash = stream.ComputeSHA2Hash();
             }
@@ -166,32 +164,32 @@ namespace osu.Game.Tests.Online
         {
             public TaskCompletionSource<bool> AllowImport = new TaskCompletionSource<bool>();
 
-            public Task<ILive<BeatmapSetInfo>> CurrentImportTask { get; private set; }
+            public Live<BeatmapSetInfo> CurrentImport { get; private set; }
 
-            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 TestBeatmapManager(Storage storage, RealmAccess realm, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, IResourceStore<byte[]> resources, GameHost host = null, WorkingBeatmap defaultBeatmap = null)
+                : base(storage, realm, rulesets, api, audioManager, resources, host, defaultBeatmap)
             {
             }
 
-            protected override BeatmapModelManager CreateBeatmapModelManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, GameHost host)
+            protected override BeatmapModelManager CreateBeatmapModelManager(Storage storage, RealmAccess realm, RulesetStore rulesets, BeatmapOnlineLookupQueue onlineLookupQueue)
             {
-                return new TestBeatmapModelManager(this, storage, contextFactory, rulesets, api, host);
+                return new TestBeatmapModelManager(this, storage, realm, rulesets, onlineLookupQueue);
             }
 
             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)
+                public TestBeatmapModelManager(TestBeatmapManager testBeatmapManager, Storage storage, RealmAccess databaseAccess, RulesetStore rulesetStore, BeatmapOnlineLookupQueue beatmapOnlineLookupQueue)
+                    : base(databaseAccess, storage, beatmapOnlineLookupQueue)
                 {
                     this.testBeatmapManager = testBeatmapManager;
                 }
 
-                public override async Task<ILive<BeatmapSetInfo>> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
+                public override Live<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);
+                    testBeatmapManager.AllowImport.Task.WaitSafely();
+                    return (testBeatmapManager.CurrentImport = base.Import(item, archive, lowPriority, cancellationToken));
                 }
             }
         }

osu.Game.Tests/Resources/TestResources.cs

@@ -80,7 +80,10 @@ namespace osu.Game.Tests.Resources
         public static BeatmapSetInfo CreateTestBeatmapSetInfo(int? difficultyCount = null, RulesetInfo[] rulesets = null)
         {
             int j = 0;
-            RulesetInfo getRuleset() => rulesets?[j++ % rulesets.Length] ?? new OsuRuleset().RulesetInfo;
+
+            rulesets ??= new[] { new OsuRuleset().RulesetInfo };
+
+            RulesetInfo getRuleset() => rulesets?[j++ % rulesets.Length];
 
             int setId = Interlocked.Increment(ref importId);
 
@@ -89,7 +92,7 @@ namespace osu.Game.Tests.Resources
                 // Create random metadata, then we can check if sorting works based on these
                 Artist = "Some Artist " + RNG.Next(0, 9),
                 Title = $"Some Song (set id {setId}) {Guid.NewGuid()}",
-                AuthorString = "Some Guy " + RNG.Next(0, 9),
+                Author = { Username = "Some Guy " + RNG.Next(0, 9) },
             };
 
             var beatmapSet = new BeatmapSetInfo
@@ -97,7 +100,6 @@ namespace osu.Game.Tests.Resources
                 OnlineID = setId,
                 Hash = new MemoryStream(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())).ComputeMD5Hash(),
                 DateAdded = DateTimeOffset.UtcNow,
-                Metadata = metadata
             };
 
             foreach (var b in getBeatmaps(difficultyCount ?? RNG.Next(1, 20)))
@@ -131,10 +133,10 @@ namespace osu.Game.Tests.Resources
                         StarRating = diff,
                         Length = length,
                         BPM = bpm,
+                        Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
                         Ruleset = rulesetInfo,
-                        RulesetID = rulesetInfo.ID ?? -1,
                         Metadata = metadata,
-                        BaseDifficulty = new BeatmapDifficulty
+                        Difficulty = new BeatmapDifficulty
                         {
                             OverallDifficulty = diff,
                         }
@@ -166,7 +168,6 @@ namespace osu.Game.Tests.Resources
             },
             BeatmapInfo = beatmap,
             Ruleset = beatmap.Ruleset,
-            RulesetID = beatmap.Ruleset.ID ?? 0,
             Mods = new Mod[] { new TestModHardRock(), new TestModDoubleTime() },
             TotalScore = 2845370,
             Accuracy = 0.95,

osu.Game.Tests/Scores/IO/ImportScoreTest.cs

@@ -5,11 +5,10 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions;
 using osu.Framework.Platform;
-using osu.Game.Beatmaps;
 using osu.Game.IO.Archives;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
@@ -17,13 +16,15 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
+using osu.Game.Tests.Beatmaps.IO;
+using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Scores.IO
 {
     public class ImportScoreTest : ImportTest
     {
         [Test]
-        public async Task TestBasicImport()
+        public void TestBasicImport()
         {
             using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
@@ -31,6 +32,8 @@ namespace osu.Game.Tests.Scores.IO
                 {
                     var osu = LoadOsuIntoHost(host, true);
 
+                    var beatmap = BeatmapImportHelper.LoadOszIntoOsu(osu, TestResources.GetQuickTestBeatmapForImport()).GetResultSafely();
+
                     var toImport = new ScoreInfo
                     {
                         Rank = ScoreRank.B,
@@ -41,15 +44,16 @@ namespace osu.Game.Tests.Scores.IO
                         User = new APIUser { Username = "Test user" },
                         Date = DateTimeOffset.Now,
                         OnlineID = 12345,
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                        BeatmapInfo = beatmap.Beatmaps.First()
                     };
 
-                    var imported = await LoadScoreIntoOsu(osu, toImport);
+                    var imported = LoadScoreIntoOsu(osu, toImport);
 
                     Assert.AreEqual(toImport.Rank, imported.Rank);
                     Assert.AreEqual(toImport.TotalScore, imported.TotalScore);
                     Assert.AreEqual(toImport.Accuracy, imported.Accuracy);
                     Assert.AreEqual(toImport.MaxCombo, imported.MaxCombo);
-                    Assert.AreEqual(toImport.Combo, imported.Combo);
                     Assert.AreEqual(toImport.User.Username, imported.User.Username);
                     Assert.AreEqual(toImport.Date, imported.Date);
                     Assert.AreEqual(toImport.OnlineID, imported.OnlineID);
@@ -62,7 +66,7 @@ namespace osu.Game.Tests.Scores.IO
         }
 
         [Test]
-        public async Task TestImportMods()
+        public void TestImportMods()
         {
             using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
@@ -70,12 +74,17 @@ namespace osu.Game.Tests.Scores.IO
                 {
                     var osu = LoadOsuIntoHost(host, true);
 
+                    var beatmap = BeatmapImportHelper.LoadOszIntoOsu(osu, TestResources.GetQuickTestBeatmapForImport()).GetResultSafely();
+
                     var toImport = new ScoreInfo
                     {
+                        User = new APIUser { Username = "Test user" },
+                        BeatmapInfo = beatmap.Beatmaps.First(),
+                        Ruleset = new OsuRuleset().RulesetInfo,
                         Mods = new Mod[] { new OsuModHardRock(), new OsuModDoubleTime() },
                     };
 
-                    var imported = await LoadScoreIntoOsu(osu, toImport);
+                    var imported = LoadScoreIntoOsu(osu, toImport);
 
                     Assert.IsTrue(imported.Mods.Any(m => m is OsuModHardRock));
                     Assert.IsTrue(imported.Mods.Any(m => m is OsuModDoubleTime));
@@ -88,7 +97,7 @@ namespace osu.Game.Tests.Scores.IO
         }
 
         [Test]
-        public async Task TestImportStatistics()
+        public void TestImportStatistics()
         {
             using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
@@ -96,8 +105,13 @@ namespace osu.Game.Tests.Scores.IO
                 {
                     var osu = LoadOsuIntoHost(host, true);
 
+                    var beatmap = BeatmapImportHelper.LoadOszIntoOsu(osu, TestResources.GetQuickTestBeatmapForImport()).GetResultSafely();
+
                     var toImport = new ScoreInfo
                     {
+                        User = new APIUser { Username = "Test user" },
+                        BeatmapInfo = beatmap.Beatmaps.First(),
+                        Ruleset = new OsuRuleset().RulesetInfo,
                         Statistics = new Dictionary<HitResult, int>
                         {
                             { HitResult.Perfect, 100 },
@@ -105,7 +119,7 @@ namespace osu.Game.Tests.Scores.IO
                         }
                     };
 
-                    var imported = await LoadScoreIntoOsu(osu, toImport);
+                    var imported = LoadScoreIntoOsu(osu, toImport);
 
                     Assert.AreEqual(toImport.Statistics[HitResult.Perfect], imported.Statistics[HitResult.Perfect]);
                     Assert.AreEqual(toImport.Statistics[HitResult.Miss], imported.Statistics[HitResult.Miss]);
@@ -118,7 +132,7 @@ namespace osu.Game.Tests.Scores.IO
         }
 
         [Test]
-        public async Task TestImportWithDeletedBeatmapSet()
+        public void TestOnlineScoreIsAvailableLocally()
         {
             using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
@@ -126,49 +140,25 @@ namespace osu.Game.Tests.Scores.IO
                 {
                     var osu = LoadOsuIntoHost(host, true);
 
-                    var toImport = new ScoreInfo
+                    var beatmap = BeatmapImportHelper.LoadOszIntoOsu(osu, TestResources.GetQuickTestBeatmapForImport()).GetResultSafely();
+
+                    LoadScoreIntoOsu(osu, new ScoreInfo
                     {
-                        Hash = Guid.NewGuid().ToString(),
-                        Statistics = new Dictionary<HitResult, int>
-                        {
-                            { HitResult.Perfect, 100 },
-                            { HitResult.Miss, 50 }
-                        }
-                    };
-
-                    var imported = await LoadScoreIntoOsu(osu, toImport);
-
-                    var beatmapManager = osu.Dependencies.Get<BeatmapManager>();
-                    var scoreManager = osu.Dependencies.Get<ScoreManager>();
-
-                    beatmapManager.Delete(beatmapManager.QueryBeatmapSet(s => s.Beatmaps.Any(b => b.ID == imported.BeatmapInfo.ID)));
-                    Assert.That(scoreManager.Query(s => s.Equals(imported)).DeletePending, Is.EqualTo(true));
-
-                    var secondImport = await LoadScoreIntoOsu(osu, imported);
-                    Assert.That(secondImport, Is.Null);
-                }
-                finally
-                {
-                    host.Exit();
-                }
-            }
-        }
-
-        [Test]
-        public async Task TestOnlineScoreIsAvailableLocally()
-        {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
-            {
-                try
-                {
-                    var osu = LoadOsuIntoHost(host, true);
-
-                    await LoadScoreIntoOsu(osu, new ScoreInfo { OnlineID = 2 }, new TestArchiveReader());
+                        User = new APIUser { Username = "Test user" },
+                        BeatmapInfo = beatmap.Beatmaps.First(),
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                        OnlineID = 2
+                    }, new TestArchiveReader());
 
                     var scoreManager = osu.Dependencies.Get<ScoreManager>();
 
                     // Note: A new score reference is used here since the import process mutates the original object to set an ID
-                    Assert.That(scoreManager.IsAvailableLocally(new ScoreInfo { OnlineID = 2 }));
+                    Assert.That(scoreManager.IsAvailableLocally(new ScoreInfo
+                    {
+                        User = new APIUser { Username = "Test user" },
+                        BeatmapInfo = beatmap.Beatmaps.First(),
+                        OnlineID = 2
+                    }));
                 }
                 finally
                 {
@@ -177,17 +167,16 @@ namespace osu.Game.Tests.Scores.IO
             }
         }
 
-        public static async Task<ScoreInfo> LoadScoreIntoOsu(OsuGameBase osu, ScoreInfo score, ArchiveReader archive = null)
+        public static ScoreInfo LoadScoreIntoOsu(OsuGameBase osu, ScoreInfo score, ArchiveReader archive = null)
         {
-            var beatmapManager = osu.Dependencies.Get<BeatmapManager>();
-
-            score.BeatmapInfo ??= beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps.First();
-            score.Ruleset ??= new OsuRuleset().RulesetInfo;
+            // clone to avoid attaching the input score to realm.
+            score = score.DeepClone();
 
             var scoreManager = osu.Dependencies.Get<ScoreManager>();
-            await scoreManager.Import(score, archive);
 
-            return scoreManager.GetAllUsableScores().FirstOrDefault();
+            scoreManager.Import(score, archive);
+
+            return scoreManager.Query(_ => true);
         }
 
         internal class TestArchiveReader : ArchiveReader

osu.Game.Tests/Scores/IO/TestScoreEquality.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using NUnit.Framework;
 using osu.Game.Scoring;
 
@@ -29,8 +30,8 @@ namespace osu.Game.Tests.Scores.IO
         [Test]
         public void TestNonMatchingByPrimaryKey()
         {
-            ScoreInfo score1 = new ScoreInfo { ID = 1 };
-            ScoreInfo score2 = new ScoreInfo { ID = 2 };
+            ScoreInfo score1 = new ScoreInfo { ID = Guid.NewGuid() };
+            ScoreInfo score2 = new ScoreInfo { ID = Guid.NewGuid() };
 
             Assert.That(score1, Is.Not.EqualTo(score2));
         }
@@ -38,8 +39,10 @@ namespace osu.Game.Tests.Scores.IO
         [Test]
         public void TestMatchingByPrimaryKey()
         {
-            ScoreInfo score1 = new ScoreInfo { ID = 1 };
-            ScoreInfo score2 = new ScoreInfo { ID = 1 };
+            Guid id = Guid.NewGuid();
+
+            ScoreInfo score1 = new ScoreInfo { ID = id };
+            ScoreInfo score2 = new ScoreInfo { ID = id };
 
             Assert.That(score1, Is.EqualTo(score2));
         }

osu.Game.Tests/Skins/IO/ImportSkinTest.cs

@@ -235,7 +235,7 @@ namespace osu.Game.Tests.Skins.IO
 
         #endregion
 
-        private void assertCorrectMetadata(ILive<SkinInfo> import1, string name, string creator, OsuGameBase osu)
+        private void assertCorrectMetadata(Live<SkinInfo> import1, string name, string creator, OsuGameBase osu)
         {
             import1.PerformRead(i =>
             {
@@ -250,7 +250,7 @@ namespace osu.Game.Tests.Skins.IO
             });
         }
 
-        private void assertImportedBoth(ILive<SkinInfo> import1, ILive<SkinInfo> import2)
+        private void assertImportedBoth(Live<SkinInfo> import1, Live<SkinInfo> import2)
         {
             import1.PerformRead(i1 => import2.PerformRead(i2 =>
             {
@@ -260,7 +260,7 @@ namespace osu.Game.Tests.Skins.IO
             }));
         }
 
-        private void assertImportedOnce(ILive<SkinInfo> import1, ILive<SkinInfo> import2)
+        private void assertImportedOnce(Live<SkinInfo> import1, Live<SkinInfo> import2)
         {
             import1.PerformRead(i1 => import2.PerformRead(i2 =>
             {
@@ -334,7 +334,7 @@ namespace osu.Game.Tests.Skins.IO
             }
         }
 
-        private async Task<ILive<SkinInfo>> loadSkinIntoOsu(OsuGameBase osu, ArchiveReader archive = null)
+        private async Task<Live<SkinInfo>> loadSkinIntoOsu(OsuGameBase osu, ArchiveReader archive = null)
         {
             var skinManager = osu.Dependencies.Get<SkinManager>();
             return await skinManager.Import(archive);

osu.Game.Tests/Skins/TestSceneBeatmapSkinResources.cs

@@ -26,8 +26,12 @@ namespace osu.Game.Tests.Skins
         private void load()
         {
             var imported = beatmaps.Import(new ZipArchiveReader(TestResources.OpenResource("Archives/ogg-beatmap.osz"))).GetResultSafely();
-            beatmap = beatmaps.GetWorkingBeatmap(imported.Value.Beatmaps[0]);
-            beatmap.LoadTrack();
+
+            imported?.PerformRead(s =>
+            {
+                beatmap = beatmaps.GetWorkingBeatmap(s.Beatmaps[0]);
+                beatmap.LoadTrack();
+            });
         }
 
         [Test]

osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs

@@ -47,9 +47,10 @@ namespace osu.Game.Tests.Visual.Background
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
-            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(rulesets = new RulesetStore(Realm));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, Realm, rulesets, null, audio, Resources, host, Beatmap.Default));
             Dependencies.Cache(new OsuConfigManager(LocalStorage));
+            Dependencies.Cache(Realm);
 
             manager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
 
@@ -387,6 +388,9 @@ namespace osu.Game.Tests.Visual.Background
                 while (BlockLoad && !token.IsCancellationRequested)
                     Thread.Sleep(1);
 
+                if (!LoadedBeatmapSuccessfully)
+                    return;
+
                 StoryboardEnabled = config.GetBindable<bool>(OsuSetting.ShowStoryboard);
                 DrawableRuleset.IsPaused.BindTo(IsPaused);
             }

osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCard.cs

@@ -204,7 +204,7 @@ namespace osu.Game.Tests.Visual.Beatmaps
             {
                 var beatmap = beatmaps.QueryBeatmapSet(b => b.OnlineID == online_id);
 
-                if (beatmap != null) beatmaps.Delete(beatmap);
+                if (beatmap != null) beatmaps.Delete(beatmap.Value);
             });
         }
 

osu.Game.Tests/Visual/Collections/TestSceneManageCollectionsDialog.cs

@@ -36,8 +36,9 @@ namespace osu.Game.Tests.Visual.Collections
         [BackgroundDependencyLoader]
         private void load(GameHost host)
         {
-            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, Audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(rulesets = new RulesetStore(Realm));
+            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, rulesets, null, Audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(Realm);
 
             beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
 

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

@@ -29,9 +29,10 @@ namespace osu.Game.Tests.Visual.Editing
         [Cached]
         private EditorClipboard clipboard = new EditorClipboard();
 
-        [BackgroundDependencyLoader]
-        private void load()
+        protected override void LoadComplete()
         {
+            base.LoadComplete();
+
             Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
 
             Child = new ComposeScreen

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

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Setup;
 using osuTK.Input;
@@ -25,7 +26,13 @@ namespace osu.Game.Tests.Visual.Editing
         [SetUpSteps]
         public void SetUp()
         {
-            AddStep("create blank beatmap", () => editorBeatmap = new EditorBeatmap(new Beatmap()));
+            AddStep("create blank beatmap", () => editorBeatmap = new EditorBeatmap(new Beatmap
+            {
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo
+                }
+            }));
             AddStep("create section", () => Child = new DependencyProvidingContainer
             {
                 RelativeSizeAxes = Axes.Both,

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

@@ -13,6 +13,7 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit;
+using osu.Game.Storyboards;
 using osu.Game.Tests.Beatmaps.IO;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -33,15 +34,12 @@ namespace osu.Game.Tests.Visual.Editing
 
         public override void SetUpSteps()
         {
-            AddStep("import test beatmap", () => importedBeatmapSet = ImportBeatmapTest.LoadOszIntoOsu(game, virtualTrack: true).GetResultSafely());
+            AddStep("import test beatmap", () => importedBeatmapSet = BeatmapImportHelper.LoadOszIntoOsu(game, virtualTrack: true).GetResultSafely());
             base.SetUpSteps();
         }
 
-        protected override void LoadEditor()
-        {
-            Beatmap.Value = beatmaps.GetWorkingBeatmap(importedBeatmapSet.Beatmaps.First());
-            base.LoadEditor();
-        }
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
+            => beatmaps.GetWorkingBeatmap(importedBeatmapSet.Beatmaps.First());
 
         [Test]
         public void TestBasicSwitch()
@@ -84,8 +82,8 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("set target difficulty", () =>
             {
                 targetDifficulty = sameRuleset
-                    ? importedBeatmapSet.Beatmaps.Last(beatmap => !beatmap.Equals(Beatmap.Value.BeatmapInfo) && beatmap.RulesetID == Beatmap.Value.BeatmapInfo.RulesetID)
-                    : importedBeatmapSet.Beatmaps.Last(beatmap => !beatmap.Equals(Beatmap.Value.BeatmapInfo) && beatmap.RulesetID != Beatmap.Value.BeatmapInfo.RulesetID);
+                    ? importedBeatmapSet.Beatmaps.Last(beatmap => !beatmap.Equals(Beatmap.Value.BeatmapInfo) && beatmap.Ruleset.ShortName == Beatmap.Value.BeatmapInfo.Ruleset.ShortName)
+                    : importedBeatmapSet.Beatmaps.Last(beatmap => !beatmap.Equals(Beatmap.Value.BeatmapInfo) && beatmap.Ruleset.ShortName != Beatmap.Value.BeatmapInfo.Ruleset.ShortName);
             });
             switchToDifficulty(() => targetDifficulty);
             confirmEditingBeatmap(() => targetDifficulty);

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

@@ -8,6 +8,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components;
@@ -29,7 +30,13 @@ namespace osu.Game.Tests.Visual.Editing
 
         public TestSceneDistanceSnapGrid()
         {
-            editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+            editorBeatmap = new EditorBeatmap(new OsuBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo
+                }
+            });
             editorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = beat_length });
         }
 

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

@@ -13,6 +13,7 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Setup;
+using osu.Game.Storyboards;
 using osu.Game.Tests.Resources;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
@@ -39,18 +40,13 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("make new beatmap unique", () => EditorBeatmap.Metadata.Title = Guid.NewGuid().ToString());
         }
 
-        protected override void LoadEditor()
-        {
-            Beatmap.Value = new DummyWorkingBeatmap(Audio, null);
-            base.LoadEditor();
-        }
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null) => new DummyWorkingBeatmap(Audio, null);
 
         [Test]
         public void TestCreateNewBeatmap()
         {
             AddStep("save beatmap", () => Editor.Save());
-            AddAssert("new beatmap persisted", () => EditorBeatmap.BeatmapInfo.IsManaged);
-            AddAssert("new beatmap in database", () => beatmapManager.QueryBeatmapSet(s => s.ID == EditorBeatmap.BeatmapInfo.BeatmapSet.ID)?.DeletePending == false);
+            AddAssert("new beatmap in database", () => beatmapManager.QueryBeatmapSet(s => s.ID == EditorBeatmap.BeatmapInfo.BeatmapSet.ID)?.Value.DeletePending == false);
         }
 
         [Test]
@@ -66,7 +62,7 @@ namespace osu.Game.Tests.Visual.Editing
             });
 
             AddUntilStep("wait for exit", () => !Editor.IsCurrentScreen());
-            AddAssert("new beatmap not persisted", () => beatmapManager.QueryBeatmapSet(s => s.ID == editorBeatmap.BeatmapInfo.BeatmapSet.ID)?.DeletePending == true);
+            AddAssert("new beatmap not persisted", () => beatmapManager.QueryBeatmapSet(s => s.ID == editorBeatmap.BeatmapInfo.BeatmapSet.ID)?.Value.DeletePending == true);
         }
 
         [Test]

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Osu;
@@ -37,9 +36,10 @@ namespace osu.Game.Tests.Visual.Editing
             });
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
+        protected override void LoadComplete()
         {
+            base.LoadComplete();
+
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
             // ensure that music controller does not change this beatmap due to it
             // completing naturally as part of the test.

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

@@ -3,92 +3,139 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Input;
+using osu.Framework.Allocation;
+using osu.Framework.Screens;
 using osu.Framework.Testing;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit;
-using osu.Game.Screens.Edit.Setup;
-using osu.Game.Screens.Menu;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osu.Game.Screens.Select;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Editing
 {
-    public class TestSceneEditorSaving : OsuGameTestScene
+    public class TestSceneEditorSaving : EditorSavingTestScene
     {
-        private Editor editor => Game.ChildrenOfType<Editor>().FirstOrDefault();
-
-        private EditorBeatmap editorBeatmap => (EditorBeatmap)editor.Dependencies.Get(typeof(EditorBeatmap));
-
-        /// <summary>
-        /// Tests the general expected flow of creating a new beatmap, saving it, then loading it back from song select.
-        /// </summary>
         [Test]
-        public void TestNewBeatmapSaveThenLoad()
+        public void TestMetadata()
         {
-            AddStep("set default beatmap", () => Game.Beatmap.SetDefault());
-
-            PushAndConfirm(() => new EditorLoader());
-
-            AddUntilStep("wait for editor load", () => editor?.IsLoaded == true);
-
-            AddUntilStep("wait for metadata screen load", () => editor.ChildrenOfType<MetadataSection>().FirstOrDefault()?.IsLoaded == true);
-
-            // We intentionally switch away from the metadata screen, else there is a feedback loop with the textbox handling which causes metadata changes below to get overwritten.
-
-            AddStep("Enter compose mode", () => InputManager.Key(Key.F1));
-            AddUntilStep("Wait for compose mode load", () => editor.ChildrenOfType<HitObjectComposer>().FirstOrDefault()?.IsLoaded == true);
-
-            AddStep("Set overall difficulty", () => editorBeatmap.Difficulty.OverallDifficulty = 7);
             AddStep("Set artist and title", () =>
             {
-                editorBeatmap.BeatmapInfo.Metadata.Artist = "artist";
-                editorBeatmap.BeatmapInfo.Metadata.Title = "title";
+                EditorBeatmap.BeatmapInfo.Metadata.Artist = "artist";
+                EditorBeatmap.BeatmapInfo.Metadata.Title = "title";
             });
-            AddStep("Set difficulty name", () => editorBeatmap.BeatmapInfo.DifficultyName = "difficulty");
+            AddStep("Set author", () => EditorBeatmap.BeatmapInfo.Metadata.Author.Username = "author");
+            AddStep("Set difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName = "difficulty");
 
-            AddStep("Add timing point", () => editorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint()));
+            SaveEditor();
 
+            AddAssert("Beatmap has correct metadata", () => EditorBeatmap.BeatmapInfo.Metadata.Artist == "artist" && EditorBeatmap.BeatmapInfo.Metadata.Title == "title");
+            AddAssert("Beatmap has correct author", () => EditorBeatmap.BeatmapInfo.Metadata.Author.Username == "author");
+            AddAssert("Beatmap has correct difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName == "difficulty");
+            AddAssert("Beatmap has correct .osu file path", () => EditorBeatmap.BeatmapInfo.Path == "artist - title (author) [difficulty].osu");
+
+            ReloadEditorToSameBeatmap();
+
+            AddAssert("Beatmap still has correct metadata", () => EditorBeatmap.BeatmapInfo.Metadata.Artist == "artist" && EditorBeatmap.BeatmapInfo.Metadata.Title == "title");
+            AddAssert("Beatmap still has correct author", () => EditorBeatmap.BeatmapInfo.Metadata.Author.Username == "author");
+            AddAssert("Beatmap still has correct difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName == "difficulty");
+            AddAssert("Beatmap still has correct .osu file path", () => EditorBeatmap.BeatmapInfo.Path == "artist - title (author) [difficulty].osu");
+        }
+
+        [Test]
+        public void TestConfiguration()
+        {
+            double originalTimelineZoom = 0;
+            double changedTimelineZoom = 0;
+
+            AddStep("Set beat divisor", () => Editor.Dependencies.Get<BindableBeatDivisor>().Value = 16);
+            AddStep("Set timeline zoom", () =>
+            {
+                originalTimelineZoom = EditorBeatmap.BeatmapInfo.TimelineZoom;
+
+                var timeline = Editor.ChildrenOfType<Timeline>().Single();
+                InputManager.MoveMouseTo(timeline);
+                InputManager.PressKey(Key.AltLeft);
+                InputManager.ScrollVerticalBy(15f);
+                InputManager.ReleaseKey(Key.AltLeft);
+            });
+
+            AddAssert("Ensure timeline zoom changed", () =>
+            {
+                changedTimelineZoom = EditorBeatmap.BeatmapInfo.TimelineZoom;
+                return !Precision.AlmostEquals(changedTimelineZoom, originalTimelineZoom);
+            });
+
+            SaveEditor();
+
+            AddAssert("Beatmap has correct beat divisor", () => EditorBeatmap.BeatmapInfo.BeatDivisor == 16);
+            AddAssert("Beatmap has correct timeline zoom", () => EditorBeatmap.BeatmapInfo.TimelineZoom == changedTimelineZoom);
+
+            ReloadEditorToSameBeatmap();
+
+            AddAssert("Beatmap still has correct beat divisor", () => EditorBeatmap.BeatmapInfo.BeatDivisor == 16);
+            AddAssert("Beatmap still has correct timeline zoom", () => EditorBeatmap.BeatmapInfo.TimelineZoom == changedTimelineZoom);
+        }
+
+        [Test]
+        public void TestDifficulty()
+        {
+            AddStep("Set overall difficulty", () => EditorBeatmap.Difficulty.OverallDifficulty = 7);
+
+            SaveEditor();
+
+            AddAssert("Beatmap has correct overall difficulty", () => EditorBeatmap.Difficulty.OverallDifficulty == 7);
+
+            ReloadEditorToSameBeatmap();
+
+            AddAssert("Beatmap still has correct overall difficulty", () => EditorBeatmap.Difficulty.OverallDifficulty == 7);
+        }
+
+        [Test]
+        public void TestHitObjectPlacement()
+        {
+            AddStep("Add timing point", () => EditorBeatmap.ControlPointInfo.Add(500, new TimingControlPoint()));
             AddStep("Change to placement mode", () => InputManager.Key(Key.Number2));
             AddStep("Move to playfield", () => InputManager.MoveMouseTo(Game.ScreenSpaceDrawQuad.Centre));
             AddStep("Place single hitcircle", () => InputManager.Click(MouseButton.Left));
 
-            checkMutations();
+            SaveEditor();
+
+            AddAssert("Beatmap has correct timing point", () => EditorBeatmap.ControlPointInfo.TimingPoints.Single().Time == 500);
 
             // After placement these must be non-default as defaults are read-only.
             AddAssert("Placed object has non-default control points", () =>
-                editorBeatmap.HitObjects[0].SampleControlPoint != SampleControlPoint.DEFAULT &&
-                editorBeatmap.HitObjects[0].DifficultyControlPoint != DifficultyControlPoint.DEFAULT);
+                EditorBeatmap.HitObjects[0].SampleControlPoint != SampleControlPoint.DEFAULT &&
+                EditorBeatmap.HitObjects[0].DifficultyControlPoint != DifficultyControlPoint.DEFAULT);
 
-            AddStep("Save", () => InputManager.Keys(PlatformAction.Save));
+            ReloadEditorToSameBeatmap();
 
-            checkMutations();
+            AddAssert("Beatmap still has correct timing point", () => EditorBeatmap.ControlPointInfo.TimingPoints.Single().Time == 500);
 
-            AddStep("Exit", () => InputManager.Key(Key.Escape));
-
-            AddUntilStep("Wait for main menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
-
-            Screens.Select.SongSelect songSelect = null;
-
-            PushAndConfirm(() => songSelect = new PlaySongSelect());
-            AddUntilStep("wait for carousel load", () => songSelect.BeatmapSetsLoaded);
-
-            AddUntilStep("Wait for beatmap selected", () => !Game.Beatmap.IsDefault);
-            AddStep("Open options", () => InputManager.Key(Key.F3));
-            AddStep("Enter editor", () => InputManager.Key(Key.Number5));
-
-            AddUntilStep("Wait for editor load", () => editor != null);
-
-            checkMutations();
+            // After placement these must be non-default as defaults are read-only.
+            AddAssert("Placed object still has non-default control points", () =>
+                EditorBeatmap.HitObjects[0].SampleControlPoint != SampleControlPoint.DEFAULT &&
+                EditorBeatmap.HitObjects[0].DifficultyControlPoint != DifficultyControlPoint.DEFAULT);
         }
 
-        private void checkMutations()
+        [Test]
+        public void TestExitWithoutSaveFromExistingBeatmap()
         {
-            AddAssert("Beatmap contains single hitcircle", () => editorBeatmap.HitObjects.Count == 1);
-            AddAssert("Beatmap has correct overall difficulty", () => editorBeatmap.Difficulty.OverallDifficulty == 7);
-            AddAssert("Beatmap has correct metadata", () => editorBeatmap.BeatmapInfo.Metadata.Artist == "artist" && editorBeatmap.BeatmapInfo.Metadata.Title == "title");
-            AddAssert("Beatmap has correct difficulty name", () => editorBeatmap.BeatmapInfo.DifficultyName == "difficulty");
+            const string tags_to_save = "these tags will be saved";
+            const string tags_to_discard = "these tags should be discarded";
+
+            AddStep("Set tags", () => EditorBeatmap.BeatmapInfo.Metadata.Tags = tags_to_save);
+            SaveEditor();
+            AddAssert("Tags saved correctly", () => EditorBeatmap.BeatmapInfo.Metadata.Tags == tags_to_save);
+
+            ReloadEditorToSameBeatmap();
+            AddAssert("Tags saved correctly", () => EditorBeatmap.BeatmapInfo.Metadata.Tags == tags_to_save);
+            AddStep("Set tags again", () => EditorBeatmap.BeatmapInfo.Metadata.Tags = tags_to_discard);
+
+            AddStep("Exit editor", () => Editor.Exit());
+            AddUntilStep("Wait for song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
+            AddAssert("Tags reverted correctly", () => Game.Beatmap.Value.BeatmapInfo.Metadata.Tags == tags_to_save);
         }
     }
 }