Merge branch 'master' into skin-editor-closest-anchor

2025-08-02 22:26:41 +09:00 · 2021-06-22 16:41:51 +09:00
parent 4b3165084d 6c3d2315d0
commit 1fff9a93b9
76 changed files with 2147 additions and 368 deletions
--- a/osu.Game/Database/IHasGuidPrimaryKey.cs
+++ b/osu.Game/Database/IHasGuidPrimaryKey.cs
@ -0,0 +1,16 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using Newtonsoft.Json;
+using Realms;
+
+namespace osu.Game.Database
+{
+    public interface IHasGuidPrimaryKey
+    {
+        [JsonIgnore]
+        [PrimaryKey]
+        Guid ID { get; set; }
+    }
+}
--- a/osu.Game/Database/IRealmFactory.cs
+++ b/osu.Game/Database/IRealmFactory.cs
@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using Realms;
+
+namespace osu.Game.Database
+{
+    public interface IRealmFactory
+    {
+        /// <summary>
+        /// The main realm context, bound to the update thread.
+        /// </summary>
+        Realm Context { get; }
+
+        /// <summary>
+        /// Get a fresh context for read usage.
+        /// </summary>
+        RealmContextFactory.RealmUsage GetForRead();
+
+        /// <summary>
+        /// Request a context for write usage.
+        /// This method may block if a write is already active on a different thread.
+        /// </summary>
+        /// <returns>A usage containing a usable context.</returns>
+        RealmContextFactory.RealmWriteUsage GetForWrite();
+    }
+}
--- a/osu.Game/Database/OsuDbContext.cs
+++ b/osu.Game/Database/OsuDbContext.cs
@ -24,13 +24,15 @@ namespace osu.Game.Database
        public DbSet<BeatmapDifficulty> BeatmapDifficulty { get; set; }
        public DbSet<BeatmapMetadata> BeatmapMetadata { get; set; }
        public DbSet<BeatmapSetInfo> BeatmapSetInfo { get; set; }
-        public DbSet<DatabasedKeyBinding> DatabasedKeyBinding { get; set; }
        public DbSet<DatabasedSetting> DatabasedSetting { get; set; }
        public DbSet<FileInfo> FileInfo { get; set; }
        public DbSet<RulesetInfo> RulesetInfo { get; set; }
        public DbSet<SkinInfo> SkinInfo { get; set; }
        public DbSet<ScoreInfo> ScoreInfo { get; set; }

+        // migrated to realm
+        public DbSet<DatabasedKeyBinding> DatabasedKeyBinding { get; set; }
+
        private readonly string connectionString;

        private static readonly Lazy<OsuDbLoggerFactory> logger = new Lazy<OsuDbLoggerFactory>(() => new OsuDbLoggerFactory());
--- a/osu.Game/Database/RealmContextFactory.cs
+++ b/osu.Game/Database/RealmContextFactory.cs
@ -0,0 +1,208 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Threading;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Statistics;
+using osu.Game.Input.Bindings;
+using Realms;
+
+namespace osu.Game.Database
+{
+    public class RealmContextFactory : Component, IRealmFactory
+    {
+        private readonly Storage storage;
+
+        private const string database_name = @"client";
+
+        private const int schema_version = 6;
+
+        /// <summary>
+        /// Lock object which is held for the duration of a write operation (via <see cref="GetForWrite"/>).
+        /// </summary>
+        private readonly object writeLock = new object();
+
+        private static readonly GlobalStatistic<int> reads = GlobalStatistics.Get<int>("Realm", "Get (Read)");
+        private static readonly GlobalStatistic<int> writes = GlobalStatistics.Get<int>("Realm", "Get (Write)");
+        private static readonly GlobalStatistic<int> refreshes = GlobalStatistics.Get<int>("Realm", "Dirty Refreshes");
+        private static readonly GlobalStatistic<int> contexts_created = GlobalStatistics.Get<int>("Realm", "Contexts (Created)");
+        private static readonly GlobalStatistic<int> pending_writes = GlobalStatistics.Get<int>("Realm", "Pending writes");
+        private static readonly GlobalStatistic<int> active_usages = GlobalStatistics.Get<int>("Realm", "Active usages");
+
+        private readonly ManualResetEventSlim blockingResetEvent = new ManualResetEventSlim(true);
+
+        private Realm context;
+
+        public Realm Context
+        {
+            get
+            {
+                if (IsDisposed)
+                    throw new InvalidOperationException($"Attempted to access {nameof(Context)} on a disposed context factory");
+
+                if (context == null)
+                {
+                    context = createContext();
+                    Logger.Log($"Opened realm \"{context.Config.DatabasePath}\" at version {context.Config.SchemaVersion}");
+                }
+
+                // creating a context will ensure our schema is up-to-date and migrated.
+
+                return context;
+            }
+        }
+
+        public RealmContextFactory(Storage storage)
+        {
+            this.storage = storage;
+        }
+
+        public RealmUsage GetForRead()
+        {
+            reads.Value++;
+            return new RealmUsage(this);
+        }
+
+        public RealmWriteUsage GetForWrite()
+        {
+            writes.Value++;
+            pending_writes.Value++;
+
+            Monitor.Enter(writeLock);
+
+            return new RealmWriteUsage(this);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (context?.Refresh() == true)
+                refreshes.Value++;
+        }
+
+        private Realm createContext()
+        {
+            blockingResetEvent.Wait();
+
+            contexts_created.Value++;
+
+            return Realm.GetInstance(new RealmConfiguration(storage.GetFullPath($"{database_name}.realm", true))
+            {
+                SchemaVersion = schema_version,
+                MigrationCallback = onMigration,
+            });
+        }
+
+        private void onMigration(Migration migration, ulong lastSchemaVersion)
+        {
+            switch (lastSchemaVersion)
+            {
+                case 5:
+                    // let's keep things simple. changing the type of the primary key is a bit involved.
+                    migration.NewRealm.RemoveAll<RealmKeyBinding>();
+                    break;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            BlockAllOperations();
+        }
+
+        public IDisposable BlockAllOperations()
+        {
+            blockingResetEvent.Reset();
+            flushContexts();
+
+            return new InvokeOnDisposal<RealmContextFactory>(this, r => endBlockingSection());
+        }
+
+        private void endBlockingSection()
+        {
+            blockingResetEvent.Set();
+        }
+
+        private void flushContexts()
+        {
+            var previousContext = context;
+            context = null;
+
+            // wait for all threaded usages to finish
+            while (active_usages.Value > 0)
+                Thread.Sleep(50);
+
+            previousContext?.Dispose();
+        }
+
+        /// <summary>
+        /// A usage of realm from an arbitrary thread.
+        /// </summary>
+        public class RealmUsage : IDisposable
+        {
+            public readonly Realm Realm;
+
+            protected readonly RealmContextFactory Factory;
+
+            internal RealmUsage(RealmContextFactory factory)
+            {
+                active_usages.Value++;
+                Factory = factory;
+                Realm = factory.createContext();
+            }
+
+            /// <summary>
+            /// Disposes this instance, calling the initially captured action.
+            /// </summary>
+            public virtual void Dispose()
+            {
+                Realm?.Dispose();
+                active_usages.Value--;
+            }
+        }
+
+        /// <summary>
+        /// A transaction used for making changes to realm data.
+        /// </summary>
+        public class RealmWriteUsage : RealmUsage
+        {
+            private readonly Transaction transaction;
+
+            internal RealmWriteUsage(RealmContextFactory factory)
+                : base(factory)
+            {
+                transaction = Realm.BeginWrite();
+            }
+
+            /// <summary>
+            /// Commit all changes made in this transaction.
+            /// </summary>
+            public void Commit() => transaction.Commit();
+
+            /// <summary>
+            /// Revert all changes made in this transaction.
+            /// </summary>
+            public void Rollback() => transaction.Rollback();
+
+            /// <summary>
+            /// Disposes this instance, calling the initially captured action.
+            /// </summary>
+            public override void Dispose()
+            {
+                // rollback if not explicitly committed.
+                transaction?.Dispose();
+
+                base.Dispose();
+
+                Monitor.Exit(Factory.writeLock);
+                pending_writes.Value--;
+            }
+        }
+    }
+}
--- a/osu.Game/Database/RealmExtensions.cs
+++ b/osu.Game/Database/RealmExtensions.cs
@ -0,0 +1,51 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using AutoMapper;
+using osu.Game.Input.Bindings;
+using Realms;
+
+namespace osu.Game.Database
+{
+    public static class RealmExtensions
+    {
+        private static readonly IMapper mapper = new MapperConfiguration(c =>
+        {
+            c.ShouldMapField = fi => false;
+            c.ShouldMapProperty = pi => pi.SetMethod != null && pi.SetMethod.IsPublic;
+
+            c.CreateMap<RealmKeyBinding, RealmKeyBinding>();
+        }).CreateMapper();
+
+        /// <summary>
+        /// Create a detached copy of the each item in the collection.
+        /// </summary>
+        /// <param name="items">A list of managed <see cref="RealmObject"/>s to detach.</param>
+        /// <typeparam name="T">The type of object.</typeparam>
+        /// <returns>A list containing non-managed copies of provided items.</returns>
+        public static List<T> Detach<T>(this IEnumerable<T> items) where T : RealmObject
+        {
+            var list = new List<T>();
+
+            foreach (var obj in items)
+                list.Add(obj.Detach());
+
+            return list;
+        }
+
+        /// <summary>
+        /// Create a detached copy of the item.
+        /// </summary>
+        /// <param name="item">The managed <see cref="RealmObject"/> to detach.</param>
+        /// <typeparam name="T">The type of object.</typeparam>
+        /// <returns>A non-managed copy of provided item. Will return the provided item if already detached.</returns>
+        public static T Detach<T>(this T item) where T : RealmObject
+        {
+            if (!item.IsManaged)
+                return item;
+
+            return mapper.Map<T>(item);
+        }
+    }
+}
--- a/osu.Game/Graphics/Containers/OsuHoverContainer.cs
+++ b/osu.Game/Graphics/Containers/OsuHoverContainer.cs
@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osuTK.Graphics;
 using System.Collections.Generic;
+using osu.Game.Graphics.UserInterface;

 namespace osu.Game.Graphics.Containers
 {
@ -20,7 +21,8 @@ namespace osu.Game.Graphics.Containers

        protected virtual IEnumerable<Drawable> EffectTargets => new[] { Content };

-        public OsuHoverContainer()
+        public OsuHoverContainer(HoverSampleSet sampleSet = HoverSampleSet.Default)
+            : base(sampleSet)
        {
            Enabled.ValueChanged += e =>
            {
--- a/osu.Game/Graphics/UserInterface/HoverSampleSet.cs
+++ b/osu.Game/Graphics/UserInterface/HoverSampleSet.cs
@ -13,13 +13,13 @@ namespace osu.Game.Graphics.UserInterface
        [Description("button")]
        Button,

-        [Description("softer")]
-        Soft,
-
        [Description("toolbar")]
        Toolbar,

-        [Description("songselect")]
-        SongSelect
+        [Description("tabselect")]
+        TabSelect,
+
+        [Description("scrolltotop")]
+        ScrollToTop
    }
 }
--- a/osu.Game/Graphics/UserInterface/OsuDropdown.cs
+++ b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
@ -4,6 +4,8 @@
 using System.Linq;
 using osuTK.Graphics;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@ -57,6 +59,9 @@ namespace osu.Game.Graphics.UserInterface
        {
            public override bool HandleNonPositionalInput => State == MenuState.Open;

+            private Sample sampleOpen;
+            private Sample sampleClose;
+
            // todo: this uses the same styling as OsuMenu. hopefully we can just use OsuMenu in the future with some refactoring
            public OsuDropdownMenu()
            {
@ -69,9 +74,30 @@ namespace osu.Game.Graphics.UserInterface
                ItemsContainer.Padding = new MarginPadding(5);
            }

+            [BackgroundDependencyLoader]
+            private void load(AudioManager audio)
+            {
+                sampleOpen = audio.Samples.Get(@"UI/dropdown-open");
+                sampleClose = audio.Samples.Get(@"UI/dropdown-close");
+            }
+
+            // todo: this shouldn't be required after https://github.com/ppy/osu-framework/issues/4519 is fixed.
+            private bool wasOpened;
+
            // todo: this uses the same styling as OsuMenu. hopefully we can just use OsuMenu in the future with some refactoring
-            protected override void AnimateOpen() => this.FadeIn(300, Easing.OutQuint);
-            protected override void AnimateClose() => this.FadeOut(300, Easing.OutQuint);
+            protected override void AnimateOpen()
+            {
+                wasOpened = true;
+                this.FadeIn(300, Easing.OutQuint);
+                sampleOpen?.Play();
+            }
+
+            protected override void AnimateClose()
+            {
+                this.FadeOut(300, Easing.OutQuint);
+                if (wasOpened)
+                    sampleClose?.Play();
+            }

            // todo: this uses the same styling as OsuMenu. hopefully we can just use OsuMenu in the future with some refactoring
            protected override void UpdateSize(Vector2 newSize)
@ -155,7 +181,7 @@ namespace osu.Game.Graphics.UserInterface
                    nonAccentSelectedColour = Color4.Black.Opacity(0.5f);
                    updateColours();

-                    AddInternal(new HoverClickSounds(HoverSampleSet.Soft));
+                    AddInternal(new HoverSounds());
                }

                protected override void UpdateForegroundColour()
@ -262,7 +288,7 @@ namespace osu.Game.Graphics.UserInterface
                    },
                };

-                AddInternal(new HoverClickSounds());
+                AddInternal(new HoverSounds());
            }

            [BackgroundDependencyLoader]
--- a/osu.Game/Graphics/UserInterface/OsuTabControl.cs
+++ b/osu.Game/Graphics/UserInterface/OsuTabControl.cs
@ -172,7 +172,7 @@ namespace osu.Game.Graphics.UserInterface
                        Origin = Anchor.BottomLeft,
                        Anchor = Anchor.BottomLeft,
                    },
-                    new HoverClickSounds()
+                    new HoverClickSounds(HoverSampleSet.TabSelect)
                };
            }

--- a/osu.Game/Graphics/UserInterface/OsuTabControlCheckbox.cs
+++ b/osu.Game/Graphics/UserInterface/OsuTabControlCheckbox.cs
@ -4,6 +4,8 @@
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@ -43,6 +45,8 @@ namespace osu.Game.Graphics.UserInterface
        }

        private const float transition_length = 500;
+        private Sample sampleChecked;
+        private Sample sampleUnchecked;

        public OsuTabControlCheckbox()
        {
@ -77,8 +81,7 @@ namespace osu.Game.Graphics.UserInterface
                    Colour = Color4.White,
                    Origin = Anchor.BottomLeft,
                    Anchor = Anchor.BottomLeft,
-                },
-                new HoverClickSounds()
+                }
            };

            Current.ValueChanged += selected =>
@ -91,10 +94,13 @@ namespace osu.Game.Graphics.UserInterface
        }

        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load(OsuColour colours, AudioManager audio)
        {
            if (accentColour == null)
                AccentColour = colours.Blue;
+
+            sampleChecked = audio.Samples.Get(@"UI/check-on");
+            sampleUnchecked = audio.Samples.Get(@"UI/check-off");
        }

        protected override bool OnHover(HoverEvent e)
@ -111,6 +117,16 @@ namespace osu.Game.Graphics.UserInterface
            base.OnHoverLost(e);
        }

+        protected override void OnUserChange(bool value)
+        {
+            base.OnUserChange(value);
+
+            if (value)
+                sampleChecked?.Play();
+            else
+                sampleUnchecked?.Play();
+        }
+
        private void updateFade()
        {
            box.FadeTo(Current.Value || IsHovered ? 1 : 0, transition_length, Easing.OutQuint);
--- a/osu.Game/Graphics/UserInterface/PageTabControl.cs
+++ b/osu.Game/Graphics/UserInterface/PageTabControl.cs
@ -76,7 +76,7 @@ namespace osu.Game.Graphics.UserInterface
                        Origin = Anchor.BottomLeft,
                        Anchor = Anchor.BottomLeft,
                    },
-                    new HoverClickSounds()
+                    new HoverClickSounds(HoverSampleSet.TabSelect)
                };

                Active.BindValueChanged(active => Text.Font = Text.Font.With(Typeface.Torus, weight: active.NewValue ? FontWeight.Bold : FontWeight.Medium), true);
--- a/osu.Game/IO/OsuStorage.cs
+++ b/osu.Game/IO/OsuStorage.cs
@ -33,12 +33,18 @@ namespace osu.Game.IO
        private readonly StorageConfigManager storageConfig;
        private readonly Storage defaultStorage;

-        public override string[] IgnoreDirectories => new[] { "cache" };
+        public override string[] IgnoreDirectories => new[]
+        {
+            "cache",
+            "client.realm.management"
+        };

        public override string[] IgnoreFiles => new[]
        {
            "framework.ini",
-            "storage.ini"
+            "storage.ini",
+            "client.realm.note",
+            "client.realm.lock",
        };

        public OsuStorage(GameHost host, Storage defaultStorage)
--- a/osu.Game/Input/Bindings/DatabasedKeyBinding.cs
+++ b/osu.Game/Input/Bindings/DatabasedKeyBinding.cs
@ -8,7 +8,7 @@ using osu.Game.Database;
 namespace osu.Game.Input.Bindings
 {
    [Table("KeyBinding")]
-    public class DatabasedKeyBinding : KeyBinding, IHasPrimaryKey
+    public class DatabasedKeyBinding : IKeyBinding, IHasPrimaryKey
    {
        public int ID { get; set; }

@ -17,17 +17,23 @@ namespace osu.Game.Input.Bindings
        public int? Variant { get; set; }

        [Column("Keys")]
-        public string KeysString
-        {
-            get => KeyCombination.ToString();
-            private set => KeyCombination = value;
-        }
+        public string KeysString { get; set; }

        [Column("Action")]
-        public int IntAction
+        public int IntAction { get; set; }
+
+        [NotMapped]
+        public KeyCombination KeyCombination
        {
-            get => (int)Action;
-            set => Action = value;
+            get => KeysString;
+            set => KeysString = value.ToString();
+        }
+
+        [NotMapped]
+        public object Action
+        {
+            get => IntAction;
+            set => IntAction = (int)value;
        }
    }
 }
--- a/osu.Game/Input/Bindings/DatabasedKeyBindingContainer.cs
+++ b/osu.Game/Input/Bindings/DatabasedKeyBindingContainer.cs
@ -3,10 +3,12 @@

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Input.Bindings;
+using osu.Game.Database;
 using osu.Game.Rulesets;
-using System.Linq;
+using Realms;

 namespace osu.Game.Input.Bindings
 {
@ -21,7 +23,11 @@ namespace osu.Game.Input.Bindings

        private readonly int? variant;

-        private KeyBindingStore store;
+        private IDisposable realmSubscription;
+        private IQueryable<RealmKeyBinding> realmKeyBindings;
+
+        [Resolved]
+        private RealmContextFactory realmFactory { get; set; }

        public override IEnumerable<IKeyBinding> DefaultKeyBindings => ruleset.CreateInstance().GetDefaultKeyBindings(variant ?? 0);

@ -42,24 +48,34 @@ namespace osu.Game.Input.Bindings
                throw new InvalidOperationException($"{nameof(variant)} can not be null when a non-null {nameof(ruleset)} is provided.");
        }

-        [BackgroundDependencyLoader]
-        private void load(KeyBindingStore keyBindings)
-        {
-            store = keyBindings;
-        }
-
        protected override void LoadComplete()
        {
+            if (ruleset == null || ruleset.ID.HasValue)
+            {
+                var rulesetId = ruleset?.ID;
+
+                realmKeyBindings = realmFactory.Context.All<RealmKeyBinding>()
+                                               .Where(b => b.RulesetID == rulesetId && b.Variant == variant);
+
+                realmSubscription = realmKeyBindings
+                    .SubscribeForNotifications((sender, changes, error) =>
+                    {
+                        // first subscription ignored as we are handling this in LoadComplete.
+                        if (changes == null)
+                            return;
+
+                        ReloadMappings();
+                    });
+            }
+
            base.LoadComplete();
-            store.KeyBindingChanged += ReloadMappings;
        }

        protected override void Dispose(bool isDisposing)
        {
            base.Dispose(isDisposing);

-            if (store != null)
-                store.KeyBindingChanged -= ReloadMappings;
+            realmSubscription?.Dispose();
        }

        protected override void ReloadMappings()
@ -67,17 +83,17 @@ namespace osu.Game.Input.Bindings
            var defaults = DefaultKeyBindings.ToList();

            if (ruleset != null && !ruleset.ID.HasValue)
-                // if the provided ruleset is not stored to the database, we have no way to retrieve custom bindings.
-                // fallback to defaults instead.
+                // some tests instantiate a ruleset which is not present in the database.
+                // in these cases we still want key bindings to work, but matching to database instances would result in none being present,
+                // so let's populate the defaults directly.
                KeyBindings = defaults;
            else
            {
-                KeyBindings = store.Query(ruleset?.ID, variant)
-                                   .OrderBy(b => defaults.FindIndex(d => (int)d.Action == b.IntAction))
-                                   // this ordering is important to ensure that we read entries from the database in the order
-                                   // enforced by DefaultKeyBindings. allow for song select to handle actions that may otherwise
-                                   // have been eaten by the music controller due to query order.
-                                   .ToList();
+                KeyBindings = realmKeyBindings.Detach()
+                                              // this ordering is important to ensure that we read entries from the database in the order
+                                              // enforced by DefaultKeyBindings. allow for song select to handle actions that may otherwise
+                                              // have been eaten by the music controller due to query order.
+                                              .OrderBy(b => defaults.FindIndex(d => (int)d.Action == b.ActionInt)).ToList();
            }
        }
    }
--- a/osu.Game/Input/Bindings/RealmKeyBinding.cs
+++ b/osu.Game/Input/Bindings/RealmKeyBinding.cs
@ -0,0 +1,39 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Input.Bindings;
+using osu.Game.Database;
+using Realms;
+
+namespace osu.Game.Input.Bindings
+{
+    [MapTo(nameof(KeyBinding))]
+    public class RealmKeyBinding : RealmObject, IHasGuidPrimaryKey, IKeyBinding
+    {
+        [PrimaryKey]
+        public Guid ID { get; set; } = Guid.NewGuid();
+
+        public int? RulesetID { get; set; }
+
+        public int? Variant { get; set; }
+
+        public KeyCombination KeyCombination
+        {
+            get => KeyCombinationString;
+            set => KeyCombinationString = value.ToString();
+        }
+
+        public object Action
+        {
+            get => ActionInt;
+            set => ActionInt = (int)value;
+        }
+
+        [MapTo(nameof(Action))]
+        public int ActionInt { get; set; }
+
+        [MapTo(nameof(KeyCombination))]
+        public string KeyCombinationString { get; set; }
+    }
+}
--- a/osu.Game/Input/KeyBindingStore.cs
+++ b/osu.Game/Input/KeyBindingStore.cs
@ -1,133 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using osu.Framework.Input.Bindings;
-using osu.Framework.Platform;
-using osu.Game.Database;
-using osu.Game.Input.Bindings;
-using osu.Game.Rulesets;
-
-namespace osu.Game.Input
-{
-    public class KeyBindingStore : DatabaseBackedStore
-    {
-        public event Action KeyBindingChanged;
-
-        /// <summary>
-        /// Keys which should not be allowed for gameplay input purposes.
-        /// </summary>
-        private static readonly IEnumerable<InputKey> banned_keys = new[]
-        {
-            InputKey.MouseWheelDown,
-            InputKey.MouseWheelLeft,
-            InputKey.MouseWheelUp,
-            InputKey.MouseWheelRight
-        };
-
-        public KeyBindingStore(DatabaseContextFactory contextFactory, RulesetStore rulesets, Storage storage = null)
-            : base(contextFactory, storage)
-        {
-            using (ContextFactory.GetForWrite())
-            {
-                foreach (var info in rulesets.AvailableRulesets)
-                {
-                    var ruleset = info.CreateInstance();
-                    foreach (var variant in ruleset.AvailableVariants)
-                        insertDefaults(ruleset.GetDefaultKeyBindings(variant), info.ID, variant);
-                }
-            }
-        }
-
-        public void Register(KeyBindingContainer manager) => insertDefaults(manager.DefaultKeyBindings);
-
-        /// <summary>
-        /// Retrieve all user-defined key combinations (in a format that can be displayed) for a specific action.
-        /// </summary>
-        /// <param name="globalAction">The action to lookup.</param>
-        /// <returns>A set of display strings for all the user's key configuration for the action.</returns>
-        public IEnumerable<string> GetReadableKeyCombinationsFor(GlobalAction globalAction)
-        {
-            foreach (var action in Query().Where(b => (GlobalAction)b.Action == globalAction))
-            {
-                string str = action.KeyCombination.ReadableString();
-
-                // even if found, the readable string may be empty for an unbound action.
-                if (str.Length > 0)
-                    yield return str;
-            }
-        }
-
-        private void insertDefaults(IEnumerable<IKeyBinding> defaults, int? rulesetId = null, int? variant = null)
-        {
-            using (var usage = ContextFactory.GetForWrite())
-            {
-                // compare counts in database vs defaults
-                foreach (var group in defaults.GroupBy(k => k.Action))
-                {
-                    int count = Query(rulesetId, variant).Count(k => (int)k.Action == (int)group.Key);
-                    int aimCount = group.Count();
-
-                    if (aimCount <= count)
-                        continue;
-
-                    foreach (var insertable in group.Skip(count).Take(aimCount - count))
-                    {
-                        // insert any defaults which are missing.
-                        usage.Context.DatabasedKeyBinding.Add(new DatabasedKeyBinding
-                        {
-                            KeyCombination = insertable.KeyCombination,
-                            Action = insertable.Action,
-                            RulesetID = rulesetId,
-                            Variant = variant
-                        });
-
-                        // required to ensure stable insert order (https://github.com/dotnet/efcore/issues/11686)
-                        usage.Context.SaveChanges();
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Retrieve <see cref="DatabasedKeyBinding"/>s for a specified ruleset/variant content.
-        /// </summary>
-        /// <param name="rulesetId">The ruleset's internal ID.</param>
-        /// <param name="variant">An optional variant.</param>
-        public List<DatabasedKeyBinding> Query(int? rulesetId = null, int? variant = null) =>
-            ContextFactory.Get().DatabasedKeyBinding.Where(b => b.RulesetID == rulesetId && b.Variant == variant).ToList();
-
-        public void Update(KeyBinding keyBinding)
-        {
-            using (ContextFactory.GetForWrite())
-            {
-                var dbKeyBinding = (DatabasedKeyBinding)keyBinding;
-
-                Debug.Assert(dbKeyBinding.RulesetID == null || CheckValidForGameplay(keyBinding.KeyCombination));
-
-                Refresh(ref dbKeyBinding);
-
-                if (dbKeyBinding.KeyCombination.Equals(keyBinding.KeyCombination))
-                    return;
-
-                dbKeyBinding.KeyCombination = keyBinding.KeyCombination;
-            }
-
-            KeyBindingChanged?.Invoke();
-        }
-
-        public static bool CheckValidForGameplay(KeyCombination combination)
-        {
-            foreach (var key in banned_keys)
-            {
-                if (combination.Keys.Contains(key))
-                    return false;
-            }
-
-            return true;
-        }
-    }
-}
--- a/osu.Game/Input/RealmKeyBindingStore.cs
+++ b/osu.Game/Input/RealmKeyBindingStore.cs
@ -0,0 +1,117 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Input.Bindings;
+using osu.Game.Database;
+using osu.Game.Input.Bindings;
+using osu.Game.Rulesets;
+
+#nullable enable
+
+namespace osu.Game.Input
+{
+    public class RealmKeyBindingStore
+    {
+        private readonly RealmContextFactory realmFactory;
+
+        public RealmKeyBindingStore(RealmContextFactory realmFactory)
+        {
+            this.realmFactory = realmFactory;
+        }
+
+        /// <summary>
+        /// Retrieve all user-defined key combinations (in a format that can be displayed) for a specific action.
+        /// </summary>
+        /// <param name="globalAction">The action to lookup.</param>
+        /// <returns>A set of display strings for all the user's key configuration for the action.</returns>
+        public IReadOnlyList<string> GetReadableKeyCombinationsFor(GlobalAction globalAction)
+        {
+            List<string> combinations = new List<string>();
+
+            using (var context = realmFactory.GetForRead())
+            {
+                foreach (var action in context.Realm.All<RealmKeyBinding>().Where(b => b.RulesetID == null && (GlobalAction)b.ActionInt == globalAction))
+                {
+                    string str = action.KeyCombination.ReadableString();
+
+                    // even if found, the readable string may be empty for an unbound action.
+                    if (str.Length > 0)
+                        combinations.Add(str);
+                }
+            }
+
+            return combinations;
+        }
+
+        /// <summary>
+        /// Register a new type of <see cref="KeyBindingContainer{T}"/>, adding default bindings from <see cref="KeyBindingContainer.DefaultKeyBindings"/>.
+        /// </summary>
+        /// <param name="container">The container to populate defaults from.</param>
+        public void Register(KeyBindingContainer container) => insertDefaults(container.DefaultKeyBindings);
+
+        /// <summary>
+        /// Register a ruleset, adding default bindings for each of its variants.
+        /// </summary>
+        /// <param name="ruleset">The ruleset to populate defaults from.</param>
+        public void Register(RulesetInfo ruleset)
+        {
+            var instance = ruleset.CreateInstance();
+
+            foreach (var variant in instance.AvailableVariants)
+                insertDefaults(instance.GetDefaultKeyBindings(variant), ruleset.ID, variant);
+        }
+
+        private void insertDefaults(IEnumerable<IKeyBinding> defaults, int? rulesetId = null, int? variant = null)
+        {
+            using (var usage = realmFactory.GetForWrite())
+            {
+                // compare counts in database vs defaults
+                foreach (var defaultsForAction in defaults.GroupBy(k => k.Action))
+                {
+                    int existingCount = usage.Realm.All<RealmKeyBinding>().Count(k => k.RulesetID == rulesetId && k.Variant == variant && k.ActionInt == (int)defaultsForAction.Key);
+
+                    if (defaultsForAction.Count() <= existingCount)
+                        continue;
+
+                    foreach (var k in defaultsForAction.Skip(existingCount))
+                    {
+                        // insert any defaults which are missing.
+                        usage.Realm.Add(new RealmKeyBinding
+                        {
+                            KeyCombinationString = k.KeyCombination.ToString(),
+                            ActionInt = (int)k.Action,
+                            RulesetID = rulesetId,
+                            Variant = variant
+                        });
+                    }
+                }
+
+                usage.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Keys which should not be allowed for gameplay input purposes.
+        /// </summary>
+        private static readonly IEnumerable<InputKey> banned_keys = new[]
+        {
+            InputKey.MouseWheelDown,
+            InputKey.MouseWheelLeft,
+            InputKey.MouseWheelUp,
+            InputKey.MouseWheelRight
+        };
+
+        public static bool CheckValidForGameplay(KeyCombination combination)
+        {
+            foreach (var key in banned_keys)
+            {
+                if (combination.Keys.Contains(key))
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}
--- a/osu.Game/Localisation/Language.cs
+++ b/osu.Game/Localisation/Language.cs
@ -14,9 +14,8 @@ namespace osu.Game.Localisation
        // [Description(@"اَلْعَرَبِيَّةُ")]
        // ar,

-        // TODO: Some accented glyphs are missing. Revisit when adding Inter.
-        // [Description(@"Беларуская мова")]
-        // be,
+        [Description(@"Беларуская мова")]
+        be,

        [Description(@"Български")]
        bg,
@ -30,9 +29,8 @@ namespace osu.Game.Localisation
        [Description(@"Deutsch")]
        de,

-        // TODO: Some accented glyphs are missing. Revisit when adding Inter.
-        // [Description(@"Ελληνικά")]
-        // el,
+        [Description(@"Ελληνικά")]
+        el,

        [Description(@"español")]
        es,
@ -88,15 +86,16 @@ namespace osu.Game.Localisation
        [Description(@"ไทย")]
        th,

-        [Description(@"Tagalog")]
-        tl,
+        // Tagalog has no associated localisations yet, and is not supported on Xamarin platforms or Windows versions <10.
+        // Can be revisited if localisations ever arrive.
+        //[Description(@"Tagalog")]
+        //tl,

        [Description(@"Türkçe")]
        tr,

-        // TODO: Some accented glyphs are missing. Revisit when adding Inter.
-        // [Description(@"Українська мова")]
-        // uk,
+        [Description(@"Українська мова")]
+        uk,

        [Description(@"Tiếng Việt")]
        vi,
--- a/osu.Game/Online/Chat/MessageFormatter.cs
+++ b/osu.Game/Online/Chat/MessageFormatter.cs
@ -154,6 +154,10 @@ namespace osu.Game.Online.Chat
                            case "beatmapsets":
                            case "d":
                            {
+                                if (mainArg == "discussions")
+                                    // handle discussion links externally for now
+                                    return new LinkDetails(LinkAction.External, url);
+
                                if (args.Length > 4 && int.TryParse(args[4], out var id))
                                    // https://osu.ppy.sh/beatmapsets/1154158#osu/2768184
                                    return new LinkDetails(LinkAction.OpenBeatmap, id.ToString());
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@ -585,7 +585,15 @@ namespace osu.Game
            foreach (var language in Enum.GetValues(typeof(Language)).OfType<Language>())
            {
                var cultureCode = language.ToCultureCode();
-                Localisation.AddLanguage(cultureCode, new ResourceManagerLocalisationStore(cultureCode));
+
+                try
+                {
+                    Localisation.AddLanguage(cultureCode, new ResourceManagerLocalisationStore(cultureCode));
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error(ex, $"Could not load localisations for language \"{cultureCode}\"");
+                }
            }

            // The next time this is updated is in UpdateAfterChildren, which occurs too late and results
@ -608,9 +616,9 @@ namespace osu.Game

            LocalConfig.LookupKeyBindings = l =>
            {
-                var combinations = KeyBindingStore.GetReadableKeyCombinationsFor(l).ToArray();
+                var combinations = KeyBindingStore.GetReadableKeyCombinationsFor(l);

-                if (combinations.Length == 0)
+                if (combinations.Count == 0)
                    return "none";

                return string.Join(" or ", combinations);
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@ -95,7 +95,7 @@ namespace osu.Game

        protected RulesetStore RulesetStore { get; private set; }

-        protected KeyBindingStore KeyBindingStore { get; private set; }
+        protected RealmKeyBindingStore KeyBindingStore { get; private set; }

        protected MenuCursorContainer MenuCursorContainer { get; private set; }

@ -144,6 +144,8 @@ namespace osu.Game

        private DatabaseContextFactory contextFactory;

+        private RealmContextFactory realmFactory;
+
        protected override Container<Drawable> Content => content;

        private Container content;
@ -179,6 +181,9 @@ namespace osu.Game

            dependencies.Cache(contextFactory = new DatabaseContextFactory(Storage));

+            dependencies.Cache(realmFactory = new RealmContextFactory(Storage));
+            AddInternal(realmFactory);
+
            dependencies.CacheAs(Storage);

            var largeStore = new LargeTextureStore(Host.CreateTextureLoaderStore(new NamespacedResourceStore<byte[]>(Resources, @"Textures")));
@ -190,20 +195,29 @@ namespace osu.Game

            AddFont(Resources, @"Fonts/osuFont");

-            AddFont(Resources, @"Fonts/Torus-Regular");
-            AddFont(Resources, @"Fonts/Torus-Light");
-            AddFont(Resources, @"Fonts/Torus-SemiBold");
-            AddFont(Resources, @"Fonts/Torus-Bold");
+            AddFont(Resources, @"Fonts/Torus/Torus-Regular");
+            AddFont(Resources, @"Fonts/Torus/Torus-Light");
+            AddFont(Resources, @"Fonts/Torus/Torus-SemiBold");
+            AddFont(Resources, @"Fonts/Torus/Torus-Bold");

-            AddFont(Resources, @"Fonts/Noto-Basic");
-            AddFont(Resources, @"Fonts/Noto-Hangul");
-            AddFont(Resources, @"Fonts/Noto-CJK-Basic");
-            AddFont(Resources, @"Fonts/Noto-CJK-Compatibility");
-            AddFont(Resources, @"Fonts/Noto-Thai");
+            AddFont(Resources, @"Fonts/Inter/Inter-Regular");
+            AddFont(Resources, @"Fonts/Inter/Inter-RegularItalic");
+            AddFont(Resources, @"Fonts/Inter/Inter-Light");
+            AddFont(Resources, @"Fonts/Inter/Inter-LightItalic");
+            AddFont(Resources, @"Fonts/Inter/Inter-SemiBold");
+            AddFont(Resources, @"Fonts/Inter/Inter-SemiBoldItalic");
+            AddFont(Resources, @"Fonts/Inter/Inter-Bold");
+            AddFont(Resources, @"Fonts/Inter/Inter-BoldItalic");

-            AddFont(Resources, @"Fonts/Venera-Light");
-            AddFont(Resources, @"Fonts/Venera-Bold");
-            AddFont(Resources, @"Fonts/Venera-Black");
+            AddFont(Resources, @"Fonts/Noto/Noto-Basic");
+            AddFont(Resources, @"Fonts/Noto/Noto-Hangul");
+            AddFont(Resources, @"Fonts/Noto/Noto-CJK-Basic");
+            AddFont(Resources, @"Fonts/Noto/Noto-CJK-Compatibility");
+            AddFont(Resources, @"Fonts/Noto/Noto-Thai");
+
+            AddFont(Resources, @"Fonts/Venera/Venera-Light");
+            AddFont(Resources, @"Fonts/Venera/Venera-Bold");
+            AddFont(Resources, @"Fonts/Venera/Venera-Black");

            Audio.Samples.PlaybackConcurrency = SAMPLE_CONCURRENCY;

@ -275,7 +289,8 @@ namespace osu.Game
            dependencies.Cache(scorePerformanceManager);
            AddInternal(scorePerformanceManager);

-            dependencies.Cache(KeyBindingStore = new KeyBindingStore(contextFactory, RulesetStore));
+            migrateDataToRealm();
+
            dependencies.Cache(settingsStore = new SettingsStore(contextFactory));
            dependencies.Cache(rulesetConfigCache = new RulesetConfigCache(settingsStore));

@ -323,7 +338,12 @@ namespace osu.Game

            base.Content.Add(CreateScalingContainer().WithChildren(mainContent));

+            KeyBindingStore = new RealmKeyBindingStore(realmFactory);
            KeyBindingStore.Register(globalBindings);
+
+            foreach (var r in RulesetStore.AvailableRulesets)
+                KeyBindingStore.Register(r);
+
            dependencies.Cache(globalBindings);

            PreviewTrackManager previewTrackManager;
@ -378,8 +398,11 @@ namespace osu.Game

        public void Migrate(string path)
        {
-            contextFactory.FlushConnections();
-            (Storage as OsuStorage)?.Migrate(Host.GetStorage(path));
+            using (realmFactory.BlockAllOperations())
+            {
+                contextFactory.FlushConnections();
+                (Storage as OsuStorage)?.Migrate(Host.GetStorage(path));
+            }
        }

        protected override UserInputManager CreateUserInputManager() => new OsuUserInputManager();
@ -390,6 +413,34 @@ namespace osu.Game

        protected override Storage CreateStorage(GameHost host, Storage defaultStorage) => new OsuStorage(host, defaultStorage);

+        private void migrateDataToRealm()
+        {
+            using (var db = contextFactory.GetForWrite())
+            using (var usage = realmFactory.GetForWrite())
+            {
+                var existingBindings = db.Context.DatabasedKeyBinding;
+
+                // only migrate data if the realm database is empty.
+                if (!usage.Realm.All<RealmKeyBinding>().Any())
+                {
+                    foreach (var dkb in existingBindings)
+                    {
+                        usage.Realm.Add(new RealmKeyBinding
+                        {
+                            KeyCombinationString = dkb.KeyCombination.ToString(),
+                            ActionInt = (int)dkb.Action,
+                            RulesetID = dkb.RulesetID,
+                            Variant = dkb.Variant
+                        });
+                    }
+                }
+
+                db.Context.RemoveRange(existingBindings);
+
+                usage.Commit();
+            }
+        }
+
        private void onRulesetChanged(ValueChangedEvent<RulesetInfo> r)
        {
            var dict = new Dictionary<ModType, IReadOnlyList<Mod>>();
--- a/osu.Game/Overlays/Comments/CommentsHeader.cs
+++ b/osu.Game/Overlays/Comments/CommentsHeader.cs
@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.

 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics;
 using osu.Framework.Bindables;
@ -66,6 +68,8 @@ namespace osu.Game.Overlays.Comments
            public readonly BindableBool Checked = new BindableBool();

            private readonly SpriteIcon checkboxIcon;
+            private Sample sampleChecked;
+            private Sample sampleUnchecked;

            public ShowDeletedButton()
            {
@ -93,6 +97,13 @@ namespace osu.Game.Overlays.Comments
                });
            }

+            [BackgroundDependencyLoader]
+            private void load(AudioManager audio)
+            {
+                sampleChecked = audio.Samples.Get(@"UI/check-on");
+                sampleUnchecked = audio.Samples.Get(@"UI/check-off");
+            }
+
            protected override void LoadComplete()
            {
                Checked.BindValueChanged(isChecked => checkboxIcon.Icon = isChecked.NewValue ? FontAwesome.Solid.CheckSquare : FontAwesome.Regular.Square, true);
@ -102,6 +113,12 @@ namespace osu.Game.Overlays.Comments
            protected override bool OnClick(ClickEvent e)
            {
                Checked.Value = !Checked.Value;
+
+                if (Checked.Value)
+                    sampleChecked?.Play();
+                else
+                    sampleUnchecked?.Play();
+
                return true;
            }
        }
--- a/osu.Game/Overlays/Comments/HeaderButton.cs
+++ b/osu.Game/Overlays/Comments/HeaderButton.cs
@ -6,7 +6,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
-using osu.Game.Graphics.UserInterface;

 namespace osu.Game.Overlays.Comments
 {
@ -39,7 +38,6 @@ namespace osu.Game.Overlays.Comments
                    Origin = Anchor.Centre,
                    Margin = new MarginPadding { Horizontal = 10 }
                },
-                new HoverClickSounds(),
            });
        }

--- a/osu.Game/Overlays/KeyBinding/KeyBindingRow.cs
+++ b/osu.Game/Overlays/KeyBinding/KeyBindingRow.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 System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
@ -13,6 +14,7 @@ using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
@ -27,7 +29,7 @@ namespace osu.Game.Overlays.KeyBinding
    public class KeyBindingRow : Container, IFilterable
    {
        private readonly object action;
-        private readonly IEnumerable<Framework.Input.Bindings.KeyBinding> bindings;
+        private readonly IEnumerable<RealmKeyBinding> bindings;

        private const float transition_time = 150;

@ -62,7 +64,7 @@ namespace osu.Game.Overlays.KeyBinding

        public IEnumerable<string> FilterTerms => bindings.Select(b => b.KeyCombination.ReadableString()).Prepend(text.Text.ToString());

-        public KeyBindingRow(object action, IEnumerable<Framework.Input.Bindings.KeyBinding> bindings)
+        public KeyBindingRow(object action, List<RealmKeyBinding> bindings)
        {
            this.action = action;
            this.bindings = bindings;
@ -72,7 +74,7 @@ namespace osu.Game.Overlays.KeyBinding
        }

        [Resolved]
-        private KeyBindingStore store { get; set; }
+        private RealmContextFactory realmFactory { get; set; }

        [BackgroundDependencyLoader]
        private void load(OsuColour colours)
@ -153,7 +155,8 @@ namespace osu.Game.Overlays.KeyBinding
            {
                var button = buttons[i++];
                button.UpdateKeyCombination(d);
-                store.Update(button.KeyBinding);
+
+                updateStoreFromButton(button);
            }

            isDefault.Value = true;
@ -314,7 +317,7 @@ namespace osu.Game.Overlays.KeyBinding
        {
            if (bindTarget != null)
            {
-                store.Update(bindTarget.KeyBinding);
+                updateStoreFromButton(bindTarget);

                updateIsDefaultValue();

@ -361,6 +364,17 @@ namespace osu.Game.Overlays.KeyBinding
            if (bindTarget != null) bindTarget.IsBinding = true;
        }

+        private void updateStoreFromButton(KeyButton button)
+        {
+            using (var usage = realmFactory.GetForWrite())
+            {
+                var binding = usage.Realm.Find<RealmKeyBinding>(((IHasGuidPrimaryKey)button.KeyBinding).ID);
+                binding.KeyCombinationString = button.KeyBinding.KeyCombinationString;
+
+                usage.Commit();
+            }
+        }
+
        private void updateIsDefaultValue()
        {
            isDefault.Value = bindings.Select(b => b.KeyCombination).SequenceEqual(Defaults);
@ -386,7 +400,7 @@ namespace osu.Game.Overlays.KeyBinding

        public class KeyButton : Container
        {
-            public readonly Framework.Input.Bindings.KeyBinding KeyBinding;
+            public readonly RealmKeyBinding KeyBinding;

            private readonly Box box;
            public readonly OsuSpriteText Text;
@ -408,8 +422,11 @@ namespace osu.Game.Overlays.KeyBinding
                }
            }

-            public KeyButton(Framework.Input.Bindings.KeyBinding keyBinding)
+            public KeyButton(RealmKeyBinding keyBinding)
            {
+                if (keyBinding.IsManaged)
+                    throw new ArgumentException("Key binding should not be attached as we make temporary changes", nameof(keyBinding));
+
                KeyBinding = keyBinding;

                Margin = new MarginPadding(padding);
@ -478,7 +495,7 @@ namespace osu.Game.Overlays.KeyBinding

            public void UpdateKeyCombination(KeyCombination newCombination)
            {
-                if ((KeyBinding as DatabasedKeyBinding)?.RulesetID != null && !KeyBindingStore.CheckValidForGameplay(newCombination))
+                if (KeyBinding.RulesetID != null && !RealmKeyBindingStore.CheckValidForGameplay(newCombination))
                    return;

                KeyBinding.KeyCombination = newCombination;
--- a/osu.Game/Overlays/KeyBinding/KeyBindingsSubsection.cs
+++ b/osu.Game/Overlays/KeyBinding/KeyBindingsSubsection.cs
@ -6,8 +6,9 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Input;
+using osu.Game.Input.Bindings;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets;
 using osuTK;
@ -31,16 +32,21 @@ namespace osu.Game.Overlays.KeyBinding
        }

        [BackgroundDependencyLoader]
-        private void load(KeyBindingStore store)
+        private void load(RealmContextFactory realmFactory)
        {
-            var bindings = store.Query(Ruleset?.ID, variant);
+            var rulesetId = Ruleset?.ID;
+
+            List<RealmKeyBinding> bindings;
+
+            using (var usage = realmFactory.GetForRead())
+                bindings = usage.Realm.All<RealmKeyBinding>().Where(b => b.RulesetID == rulesetId && b.Variant == variant).Detach();

            foreach (var defaultGroup in Defaults.GroupBy(d => d.Action))
            {
                int intKey = (int)defaultGroup.Key;

                // one row per valid action.
-                Add(new KeyBindingRow(defaultGroup.Key, bindings.Where(b => ((int)b.Action).Equals(intKey)))
+                Add(new KeyBindingRow(defaultGroup.Key, bindings.Where(b => b.ActionInt.Equals(intKey)).ToList())
                {
                    AllowMainMouseButtons = Ruleset != null,
                    Defaults = defaultGroup.Select(d => d.KeyCombination)
--- a/osu.Game/Overlays/Mods/LocalPlayerModSelectOverlay.cs
+++ b/osu.Game/Overlays/Mods/LocalPlayerModSelectOverlay.cs
@ -12,7 +12,7 @@ namespace osu.Game.Overlays.Mods
            base.OnModSelected(mod);

            foreach (var section in ModSectionsContainer.Children)
-                section.DeselectTypes(mod.IncompatibleMods, true);
+                section.DeselectTypes(mod.IncompatibleMods, true, mod);
        }
    }
 }
--- a/osu.Game/Overlays/Mods/ModButton.cs
+++ b/osu.Game/Overlays/Mods/ModButton.cs
@ -302,7 +302,7 @@ namespace osu.Game.Overlays.Mods
                    Anchor = Anchor.TopCentre,
                    Font = OsuFont.GetFont(size: 18)
                },
-                new HoverClickSounds(buttons: new[] { MouseButton.Left, MouseButton.Right })
+                new HoverSounds()
            };

            Mod = mod;
--- a/osu.Game/Overlays/Mods/ModSection.cs
+++ b/osu.Game/Overlays/Mods/ModSection.cs
@ -159,12 +159,16 @@ namespace osu.Game.Overlays.Mods
        /// </summary>
        /// <param name="modTypes">The types of <see cref="Mod"/>s which should be deselected.</param>
        /// <param name="immediate">Whether the deselection should happen immediately. Should only be used when required to ensure correct selection flow.</param>
-        public void DeselectTypes(IEnumerable<Type> modTypes, bool immediate = false)
+        /// <param name="newSelection">If this deselection is triggered by a user selection, this should contain the newly selected type. This type will never be deselected, even if it matches one provided in <paramref name="modTypes"/>.</param>
+        public void DeselectTypes(IEnumerable<Type> modTypes, bool immediate = false, Mod newSelection = null)
        {
            foreach (var button in Buttons)
            {
                if (button.SelectedMod == null) continue;

+                if (button.SelectedMod == newSelection)
+                    continue;
+
                foreach (var type in modTypes)
                {
                    if (type.IsInstanceOfType(button.SelectedMod))
--- a/osu.Game/Overlays/OverlayScrollContainer.cs
+++ b/osu.Game/Overlays/OverlayScrollContainer.cs
@ -11,6 +11,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
 using osuTK;
 using osuTK.Graphics;

@ -84,6 +85,7 @@ namespace osu.Game.Overlays
            private readonly Box background;

            public ScrollToTopButton()
+                : base(HoverSampleSet.ScrollToTop)
            {
                Size = new Vector2(50);
                Alpha = 0;
--- a/osu.Game/Overlays/OverlaySortTabControl.cs
+++ b/osu.Game/Overlays/OverlaySortTabControl.cs
@ -148,6 +148,8 @@ namespace osu.Game.Overlays
                        }
                    }
                });
+
+                AddInternal(new HoverClickSounds());
            }

            protected override void LoadComplete()
--- a/osu.Game/Overlays/OverlayTabControl.cs
+++ b/osu.Game/Overlays/OverlayTabControl.cs
@ -99,7 +99,7 @@ namespace osu.Game.Overlays
                        ExpandedSize = 5f,
                        CollapsedSize = 0
                    },
-                    new HoverClickSounds()
+                    new HoverClickSounds(HoverSampleSet.TabSelect)
                };
            }

--- a/osu.Game/Overlays/Toolbar/ToolbarButton.cs
+++ b/osu.Game/Overlays/Toolbar/ToolbarButton.cs
@ -1,8 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Caching;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
@ -13,13 +13,13 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Game.Database;
 using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Input;
 using osu.Game.Input.Bindings;
 using osuTK;
 using osuTK.Graphics;
@ -76,7 +76,7 @@ namespace osu.Game.Overlays.Toolbar
        protected FillFlowContainer Flow;

        [Resolved]
-        private KeyBindingStore keyBindings { get; set; }
+        private RealmContextFactory realmFactory { get; set; }

        protected ToolbarButton()
            : base(HoverSampleSet.Toolbar)
@ -159,27 +159,28 @@ namespace osu.Game.Overlays.Toolbar
            };
        }

-        private readonly Cached tooltipKeyBinding = new Cached();
+        private RealmKeyBinding realmKeyBinding;

-        [BackgroundDependencyLoader]
-        private void load()
+        protected override void LoadComplete()
        {
-            keyBindings.KeyBindingChanged += () => tooltipKeyBinding.Invalidate();
+            base.LoadComplete();
+
+            if (Hotkey == null) return;
+
+            realmKeyBinding = realmFactory.Context.All<RealmKeyBinding>().FirstOrDefault(rkb => rkb.RulesetID == null && rkb.ActionInt == (int)Hotkey.Value);
+
+            if (realmKeyBinding != null)
+            {
+                realmKeyBinding.PropertyChanged += (sender, args) =>
+                {
+                    if (args.PropertyName == nameof(realmKeyBinding.KeyCombinationString))
+                        updateKeyBindingTooltip();
+                };
+            }
+
            updateKeyBindingTooltip();
        }

-        private void updateKeyBindingTooltip()
-        {
-            if (tooltipKeyBinding.IsValid)
-                return;
-
-            var binding = keyBindings.Query().Find(b => (GlobalAction)b.Action == Hotkey);
-            var keyBindingString = binding?.KeyCombination.ReadableString();
-            keyBindingTooltip.Text = !string.IsNullOrEmpty(keyBindingString) ? $" ({keyBindingString})" : string.Empty;
-
-            tooltipKeyBinding.Validate();
-        }
-
        protected override bool OnMouseDown(MouseDownEvent e) => true;

        protected override bool OnClick(ClickEvent e)
@ -218,6 +219,17 @@ namespace osu.Game.Overlays.Toolbar
        public void OnReleased(GlobalAction action)
        {
        }
+
+        private void updateKeyBindingTooltip()
+        {
+            if (realmKeyBinding != null)
+            {
+                var keyBindingString = realmKeyBinding.KeyCombination.ReadableString();
+
+                if (!string.IsNullOrEmpty(keyBindingString))
+                    keyBindingTooltip.Text = $" ({keyBindingString})";
+            }
+        }
    }

    public class OpaqueBackground : Container
--- a/osu.Game/Performance/HighPerformanceSession.cs
+++ b/osu.Game/Performance/HighPerformanceSession.cs
@ -1,7 +1,6 @@
 // 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.Runtime;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@ -11,7 +10,6 @@ namespace osu.Game.Performance
    public class HighPerformanceSession : Component
    {
        private readonly IBindable<bool> localUserPlaying = new Bindable<bool>();
-        private GCLatencyMode originalGCMode;

        [BackgroundDependencyLoader]
        private void load(OsuGame game)
@ -34,14 +32,10 @@ namespace osu.Game.Performance

        protected virtual void EnableHighPerformanceSession()
        {
-            originalGCMode = GCSettings.LatencyMode;
-            GCSettings.LatencyMode = GCLatencyMode.LowLatency;
        }

        protected virtual void DisableHighPerformanceSession()
        {
-            if (GCSettings.LatencyMode == GCLatencyMode.LowLatency)
-                GCSettings.LatencyMode = originalGCMode;
        }
    }
 }
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@ -156,10 +156,11 @@ namespace osu.Game.Rulesets.Objects.Drawables
        /// If <c>null</c>, a hitobject is expected to be later applied via <see cref="PoolableDrawableWithLifetime{TEntry}.Apply"/> (or automatically via pooling).
        /// </param>
        protected DrawableHitObject([CanBeNull] HitObject initialHitObject = null)
-            : base(initialHitObject != null ? new SyntheticHitObjectEntry(initialHitObject) : null)
        {
-            if (Entry != null)
-                ensureEntryHasResult();
+            if (initialHitObject == null) return;
+
+            Entry = new SyntheticHitObjectEntry(initialHitObject);
+            ensureEntryHasResult();
        }

        [BackgroundDependencyLoader]
--- a/osu.Game/Rulesets/Objects/Pooling/PoolableDrawableWithLifetime.cs
+++ b/osu.Game/Rulesets/Objects/Pooling/PoolableDrawableWithLifetime.cs
@ -5,6 +5,7 @@

 using System;
 using System.Diagnostics;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Performance;
 using osu.Framework.Graphics.Pooling;

@ -16,14 +17,32 @@ namespace osu.Game.Rulesets.Objects.Pooling
    /// <typeparam name="TEntry">The <see cref="LifetimeEntry"/> type storing state and controlling this drawable.</typeparam>
    public abstract class PoolableDrawableWithLifetime<TEntry> : PoolableDrawable where TEntry : LifetimeEntry
    {
+        private TEntry? entry;
+
        /// <summary>
        /// The entry holding essential state of this <see cref="PoolableDrawableWithLifetime{TEntry}"/>.
        /// </summary>
-        public TEntry? Entry { get; private set; }
+        /// <remarks>
+        /// If a non-null value is set before loading is started, the entry is applied when the loading is completed.
+        /// It is not valid to set an entry while this <see cref="PoolableDrawableWithLifetime{TEntry}"/> is loading.
+        /// </remarks>
+        public TEntry? Entry
+        {
+            get => entry;
+            set
+            {
+                if (LoadState == LoadState.NotLoaded)
+                    entry = value;
+                else if (value != null)
+                    Apply(value);
+                else if (HasEntryApplied)
+                    free();
+            }
+        }

        /// <summary>
        /// Whether <see cref="Entry"/> is applied to this <see cref="PoolableDrawableWithLifetime{TEntry}"/>.
-        /// When an initial entry is specified in the constructor, <see cref="Entry"/> is set but not applied until loading is completed.
+        /// When an <see cref="Entry"/> is set during initialization, it is not applied until loading is completed.
        /// </summary>
        protected bool HasEntryApplied { get; private set; }

@ -65,9 +84,9 @@ namespace osu.Game.Rulesets.Objects.Pooling
        {
            base.LoadAsyncComplete();

-            // Apply the initial entry given in the constructor.
+            // Apply the initial entry.
            if (Entry != null && !HasEntryApplied)
-                Apply(Entry);
+                apply(Entry);
        }

        /// <summary>
@ -76,16 +95,10 @@ namespace osu.Game.Rulesets.Objects.Pooling
        /// </summary>
        public void Apply(TEntry entry)
        {
-            if (HasEntryApplied)
-                free();
+            if (LoadState == LoadState.Loading)
+                throw new InvalidOperationException($"Cannot apply a new {nameof(TEntry)} while currently loading.");

-            Entry = entry;
-            entry.LifetimeChanged += setLifetimeFromEntry;
-            setLifetimeFromEntry(entry);
-
-            OnApply(entry);
-
-            HasEntryApplied = true;
+            apply(entry);
        }

        protected sealed override void FreeAfterUse()
@ -111,6 +124,20 @@ namespace osu.Game.Rulesets.Objects.Pooling
        {
        }

+        private void apply(TEntry entry)
+        {
+            if (HasEntryApplied)
+                free();
+
+            this.entry = entry;
+            entry.LifetimeChanged += setLifetimeFromEntry;
+            setLifetimeFromEntry(entry);
+
+            OnApply(entry);
+
+            HasEntryApplied = true;
+        }
+
        private void free()
        {
            Debug.Assert(Entry != null && HasEntryApplied);
@ -118,7 +145,7 @@ namespace osu.Game.Rulesets.Objects.Pooling
            OnFree(Entry);

            Entry.LifetimeChanged -= setLifetimeFromEntry;
-            Entry = null;
+            entry = null;
            base.LifetimeStart = double.MinValue;
            base.LifetimeEnd = double.MaxValue;

--- a/osu.Game/Rulesets/RulesetStore.cs
+++ b/osu.Game/Rulesets/RulesetStore.cs
@ -96,13 +96,25 @@ namespace osu.Game.Rulesets

                context.SaveChanges();

-                // add any other modes
                var existingRulesets = context.RulesetInfo.ToList();

+                // add any other rulesets which have assemblies present but are not yet in the database.
                foreach (var r in instances.Where(r => !(r is ILegacyRuleset)))
                {
                    if (existingRulesets.FirstOrDefault(ri => ri.InstantiationInfo.Equals(r.RulesetInfo.InstantiationInfo, StringComparison.Ordinal)) == null)
-                        context.RulesetInfo.Add(r.RulesetInfo);
+                    {
+                        var existingSameShortName = existingRulesets.FirstOrDefault(ri => ri.ShortName == r.RulesetInfo.ShortName);
+
+                        if (existingSameShortName != null)
+                        {
+                            // even if a matching InstantiationInfo was not found, there may be an existing ruleset with the same ShortName.
+                            // this generally means the user or ruleset provider has renamed their dll but the underlying ruleset is *likely* the same one.
+                            // in such cases, update the instantiation info of the existing entry to point to the new one.
+                            existingSameShortName.InstantiationInfo = r.RulesetInfo.InstantiationInfo;
+                        }
+                        else
+                            context.RulesetInfo.Add(r.RulesetInfo);
+                    }
                }

                context.SaveChanges();
--- a/osu.Game/Rulesets/UI/RulesetInputManager.cs
+++ b/osu.Game/Rulesets/UI/RulesetInputManager.cs
@ -177,7 +177,7 @@ namespace osu.Game.Rulesets.UI
            {
                base.ReloadMappings();

-                KeyBindings = KeyBindings.Where(b => KeyBindingStore.CheckValidForGameplay(b.KeyCombination)).ToList();
+                KeyBindings = KeyBindings.Where(b => RealmKeyBindingStore.CheckValidForGameplay(b.KeyCombination)).ToList();
            }
        }
    }
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@ -295,12 +295,12 @@ namespace osu.Game.Screens.Play

            DimmableStoryboard.HasStoryboardEnded.ValueChanged += storyboardEnded =>
            {
-                if (storyboardEnded.NewValue && resultsDisplayDelegate == null)
-                    updateCompletionState();
+                if (storyboardEnded.NewValue)
+                    progressToResults(true);
            };

            // Bind the judgement processors to ourselves
-            ScoreProcessor.HasCompleted.BindValueChanged(_ => updateCompletionState());
+            ScoreProcessor.HasCompleted.BindValueChanged(scoreCompletionChanged);
            HealthProcessor.Failed += onFail;

            foreach (var mod in Mods.Value.OfType<IApplicableToScoreProcessor>())
@ -374,7 +374,7 @@ namespace osu.Game.Screens.Play
                    },
                    skipOutroOverlay = new SkipOverlay(Beatmap.Value.Storyboard.LatestEventTime ?? 0)
                    {
-                        RequestSkip = () => updateCompletionState(true),
+                        RequestSkip = () => progressToResults(false),
                        Alpha = 0
                    },
                    FailOverlay = new FailOverlay
@ -643,9 +643,8 @@ namespace osu.Game.Screens.Play
        /// <summary>
        /// Handles changes in player state which may progress the completion of gameplay / this screen's lifetime.
        /// </summary>
-        /// <param name="skipStoryboardOutro">If in a state where a storyboard outro is to be played, offers the choice of skipping beyond it.</param>
        /// <exception cref="InvalidOperationException">Thrown if this method is called more than once without changing state.</exception>
-        private void updateCompletionState(bool skipStoryboardOutro = false)
+        private void scoreCompletionChanged(ValueChangedEvent<bool> completed)
        {
            // If this player instance is in the middle of an exit, don't attempt any kind of state update.
            if (!this.IsCurrentScreen())
@ -656,7 +655,7 @@ namespace osu.Game.Screens.Play
            // Currently, even if this scenario is hit, prepareScoreForDisplay has already been queued (and potentially run).
            // In scenarios where rewinding is possible (replay, spectating) this is a non-issue as no submission/import work is done,
            // but it still doesn't feel right that this exists here.
-            if (!ScoreProcessor.HasCompleted.Value)
+            if (!completed.NewValue)
            {
                resultsDisplayDelegate?.Cancel();
                resultsDisplayDelegate = null;
@ -666,9 +665,6 @@ namespace osu.Game.Screens.Play
                return;
            }

-            if (resultsDisplayDelegate != null)
-                throw new InvalidOperationException(@$"{nameof(updateCompletionState)} should never be fired more than once.");
-
            // Only show the completion screen if the player hasn't failed
            if (HealthProcessor.HasFailed)
                return;
@ -683,27 +679,25 @@ namespace osu.Game.Screens.Play
            if (!Configuration.ShowResults)
                return;

-            // Asynchronously run score preparation operations (database import, online submission etc.).
            prepareScoreForDisplayTask ??= Task.Run(prepareScoreForResults);

-            if (skipStoryboardOutro)
-            {
-                scheduleCompletion();
-                return;
-            }
-
            bool storyboardHasOutro = DimmableStoryboard.ContentDisplayed && !DimmableStoryboard.HasStoryboardEnded.Value;

            if (storyboardHasOutro)
            {
+                // if the current beatmap has a storyboard, the progression to results will be handled by the storyboard ending
+                // or the user pressing the skip outro button.
                skipOutroOverlay.Show();
                return;
            }

-            using (BeginDelayedSequence(RESULTS_DISPLAY_DELAY))
-                scheduleCompletion();
+            progressToResults(true);
        }

+        /// <summary>
+        /// Asynchronously run score preparation operations (database import, online submission etc.).
+        /// </summary>
+        /// <returns>The final score.</returns>
        private async Task<ScoreInfo> prepareScoreForResults()
        {
            try
@ -727,18 +721,44 @@ namespace osu.Game.Screens.Play
            return Score.ScoreInfo;
        }

-        private void scheduleCompletion() => resultsDisplayDelegate = Schedule(() =>
+        /// <summary>
+        /// Queue the results screen for display.
+        /// </summary>
+        /// <remarks>
+        /// A final display will only occur once all work is completed in <see cref="PrepareScoreForResultsAsync"/>. This means that even after calling this method, the results screen will never be shown until <see cref="JudgementProcessor.HasCompleted">ScoreProcessor.HasCompleted</see> becomes <see langword="true"/>.
+        ///
+        /// Calling this method multiple times will have no effect.
+        /// </remarks>
+        /// <param name="withDelay">Whether a minimum delay (<see cref="RESULTS_DISPLAY_DELAY"/>) should be added before the screen is displayed.</param>
+        private void progressToResults(bool withDelay)
        {
-            if (!prepareScoreForDisplayTask.IsCompleted)
-            {
-                scheduleCompletion();
+            if (resultsDisplayDelegate != null)
+                // Note that if progressToResults is called one withDelay=true and then withDelay=false, this no-delay timing will not be
+                // accounted for. shouldn't be a huge concern (a user pressing the skip button after a results progression has already been queued
+                // may take x00 more milliseconds than expected in the very rare edge case).
+                //
+                // If required we can handle this more correctly by rescheduling here.
                return;
-            }

-            // screen may be in the exiting transition phase.
-            if (this.IsCurrentScreen())
+            double delay = withDelay ? RESULTS_DISPLAY_DELAY : 0;
+
+            resultsDisplayDelegate = new ScheduledDelegate(() =>
+            {
+                if (prepareScoreForDisplayTask?.IsCompleted != true)
+                    // If the asynchronous preparation has not completed, keep repeating this delegate.
+                    return;
+
+                resultsDisplayDelegate?.Cancel();
+
+                if (!this.IsCurrentScreen())
+                    // This player instance may already be in the process of exiting.
+                    return;
+
                this.Push(CreateResults(prepareScoreForDisplayTask.Result));
-        });
+            }, Time.Current + delay, 50);
+
+            Scheduler.Add(resultsDisplayDelegate);
+        }

        protected override bool OnScroll(ScrollEvent e) => mouseWheelDisabled.Value && !GameplayClockContainer.IsPaused.Value;

@ -936,14 +956,6 @@ namespace osu.Game.Screens.Play
        {
            screenSuspension?.Expire();

-            // if the results screen is prepared to be displayed, forcefully show it on an exit request.
-            // usually if a user has completed a play session they do want to see results. and if they don't they can hit the same key a second time.
-            if (resultsDisplayDelegate != null && !resultsDisplayDelegate.Cancelled && !resultsDisplayDelegate.Completed)
-            {
-                resultsDisplayDelegate.RunTask();
-                return true;
-            }
-
            // EndPlaying() is typically called from ReplayRecorder.Dispose(). Disposal is currently asynchronous.
            // To resolve test failures, forcefully end playing synchronously when this screen exits.
            // Todo: Replace this with a more permanent solution once osu-framework has a synchronous cleanup method.
--- a/osu.Game/Screens/Select/FooterButton.cs
+++ b/osu.Game/Screens/Select/FooterButton.cs
@ -66,7 +66,7 @@ namespace osu.Game.Screens.Select
        private readonly Box light;

        public FooterButton()
-            : base(HoverSampleSet.SongSelect)
+            : base(HoverSampleSet.Button)
        {
            AutoSizeAxes = Axes.Both;
            Shear = SHEAR;
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs
@ -25,7 +25,7 @@ namespace osu.Game.Storyboards.Drawables
        /// </summary>
        public IBindable<bool> HasStoryboardEnded => hasStoryboardEnded;

-        private readonly BindableBool hasStoryboardEnded = new BindableBool();
+        private readonly BindableBool hasStoryboardEnded = new BindableBool(true);

        protected override Container<DrawableStoryboardLayer> Content { get; }

--- a/osu.Game/Utils/ModUtils.cs
+++ b/osu.Game/Utils/ModUtils.cs
@ -60,6 +60,9 @@ namespace osu.Game.Utils
                {
                    foreach (var invalid in combination.Where(m => type.IsInstanceOfType(m)))
                    {
+                        if (invalid == mod)
+                            continue;
+
                        invalidMods ??= new List<Mod>();
                        invalidMods.Add(invalid);
                    }
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@ -18,6 +18,7 @@
    </None>
  </ItemGroup>
  <ItemGroup Label="Package References">
+    <PackageReference Include="AutoMapper" Version="10.1.1" />
    <PackageReference Include="DiffPlex" Version="1.7.0" />
    <PackageReference Include="HtmlAgilityPack" Version="1.11.33" />
    <PackageReference Include="Humanizer" Version="2.10.1" />
@ -34,8 +35,9 @@
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
+    <PackageReference Include="Realm" Version="10.2.0" />
    <PackageReference Include="ppy.osu.Framework" Version="2021.616.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.614.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.618.0" />
    <PackageReference Include="Sentry" Version="3.4.0" />
    <PackageReference Include="SharpCompress" Version="0.28.2" />
    <PackageReference Include="NUnit" Version="3.13.2" />