Merge branch 'master' into catch-scoring

osu.Desktop/NVAPI.cs

@@ -0,0 +1,739 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable disable
+
+#pragma warning disable IDE1006 // Naming rule violation
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using osu.Framework.Logging;
+
+namespace osu.Desktop
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    internal static class NVAPI
+    {
+        private const string osu_filename = "osu!.exe";
+
+        // This is a good reference:
+        // https://github.com/errollw/Warp-and-Blend-Quadros/blob/master/WarpBlend-Quadros/UnwarpAll-Quadros/include/nvapi.h
+        // Note our Stride == their VERSION (e.g. NVDRS_SETTING_VER)
+
+        public const int MAX_PHYSICAL_GPUS = 64;
+        public const int UNICODE_STRING_MAX = 2048;
+
+        public const string APPLICATION_NAME = @"osu!";
+        public const string PROFILE_NAME = @"osu!";
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus EnumPhysicalGPUsDelegate([Out] IntPtr[] gpuHandles, out int gpuCount);
+
+        public static readonly EnumPhysicalGPUsDelegate EnumPhysicalGPUs;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus EnumLogicalGPUsDelegate([Out] IntPtr[] gpuHandles, out int gpuCount);
+
+        public static readonly EnumLogicalGPUsDelegate EnumLogicalGPUs;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetSystemTypeDelegate(IntPtr gpuHandle, out NvSystemType systemType);
+
+        public static readonly GetSystemTypeDelegate GetSystemType;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetGPUTypeDelegate(IntPtr gpuHandle, out NvGpuType gpuType);
+
+        public static readonly GetGPUTypeDelegate GetGPUType;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus CreateSessionDelegate(out IntPtr sessionHandle);
+
+        public static CreateSessionDelegate CreateSession;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus LoadSettingsDelegate(IntPtr sessionHandle);
+
+        public static LoadSettingsDelegate LoadSettings;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus FindApplicationByNameDelegate(IntPtr sessionHandle, [MarshalAs(UnmanagedType.BStr)] string appName, out IntPtr profileHandle, ref NvApplication application);
+
+        public static FindApplicationByNameDelegate FindApplicationByName;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetCurrentGlobalProfileDelegate(IntPtr sessionHandle, out IntPtr profileHandle);
+
+        public static GetCurrentGlobalProfileDelegate GetCurrentGlobalProfile;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetProfileInfoDelegate(IntPtr sessionHandle, IntPtr profileHandle, ref NvProfile profile);
+
+        public static GetProfileInfoDelegate GetProfileInfo;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetSettingDelegate(IntPtr sessionHandle, IntPtr profileHandle, NvSettingID settingID, ref NvSetting setting);
+
+        public static GetSettingDelegate GetSetting;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus CreateProfileDelegate(IntPtr sessionHandle, ref NvProfile profile, out IntPtr profileHandle);
+
+        private static readonly CreateProfileDelegate CreateProfile;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus SetSettingDelegate(IntPtr sessionHandle, IntPtr profileHandle, ref NvSetting setting);
+
+        private static readonly SetSettingDelegate SetSetting;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus EnumApplicationsDelegate(IntPtr sessionHandle, IntPtr profileHandle, uint startIndex, ref uint appCount, [In, Out, MarshalAs(UnmanagedType.LPArray)] NvApplication[] applications);
+
+        private static readonly EnumApplicationsDelegate EnumApplications;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus CreateApplicationDelegate(IntPtr sessionHandle, IntPtr profileHandle, ref NvApplication application);
+
+        private static readonly CreateApplicationDelegate CreateApplication;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus SaveSettingsDelegate(IntPtr sessionHandle);
+
+        private static readonly SaveSettingsDelegate SaveSettings;
+
+        public static NvStatus Status { get; private set; } = NvStatus.OK;
+        public static bool Available { get; private set; }
+
+        private static IntPtr sessionHandle;
+
+        public static bool IsUsingOptimusDedicatedGpu
+        {
+            get
+            {
+                if (!Available)
+                    return false;
+
+                if (!IsLaptop)
+                    return false;
+
+                IntPtr profileHandle;
+                if (!getProfile(out profileHandle, out _, out bool _))
+                    return false;
+
+                // Get the optimus setting
+                NvSetting setting;
+                if (!getSetting(NvSettingID.SHIM_RENDERING_MODE_ID, profileHandle, out setting))
+                    return false;
+
+                return (setting.U32CurrentValue & (uint)NvShimSetting.SHIM_RENDERING_MODE_ENABLE) > 0;
+            }
+        }
+
+        public static bool IsLaptop
+        {
+            get
+            {
+                if (!Available)
+                    return false;
+
+                // Make sure that this is a laptop.
+                var gpus = new IntPtr[64];
+                if (checkError(EnumPhysicalGPUs(gpus, out int gpuCount)))
+                    return false;
+
+                for (int i = 0; i < gpuCount; i++)
+                {
+                    if (checkError(GetSystemType(gpus[i], out var type)))
+                        return false;
+
+                    if (type == NvSystemType.LAPTOP)
+                        return true;
+                }
+
+                return false;
+            }
+        }
+
+        public static NvThreadControlSetting ThreadedOptimisations
+        {
+            get
+            {
+                if (!Available)
+                    return NvThreadControlSetting.OGL_THREAD_CONTROL_DEFAULT;
+
+                IntPtr profileHandle;
+                if (!getProfile(out profileHandle, out _, out bool _))
+                    return NvThreadControlSetting.OGL_THREAD_CONTROL_DEFAULT;
+
+                // Get the threaded optimisations setting
+                NvSetting setting;
+                if (!getSetting(NvSettingID.OGL_THREAD_CONTROL_ID, profileHandle, out setting))
+                    return NvThreadControlSetting.OGL_THREAD_CONTROL_DEFAULT;
+
+                return (NvThreadControlSetting)setting.U32CurrentValue;
+            }
+            set
+            {
+                if (!Available)
+                    return;
+
+                bool success = setSetting(NvSettingID.OGL_THREAD_CONTROL_ID, (uint)value);
+
+                Logger.Log(success ? $"Threaded optimizations set to \"{value}\"!" : "Threaded optimizations set failed!");
+            }
+        }
+
+        /// <summary>
+        /// Checks if the profile contains the current application.
+        /// </summary>
+        /// <returns>If the profile contains the current application.</returns>
+        private static bool containsApplication(IntPtr profileHandle, NvProfile profile, out NvApplication application)
+        {
+            application = new NvApplication
+            {
+                Version = NvApplication.Stride
+            };
+
+            if (profile.NumOfApps == 0)
+                return false;
+
+            NvApplication[] applications = new NvApplication[profile.NumOfApps];
+            applications[0].Version = NvApplication.Stride;
+
+            uint numApps = profile.NumOfApps;
+
+            if (checkError(EnumApplications(sessionHandle, profileHandle, 0, ref numApps, applications)))
+                return false;
+
+            for (uint i = 0; i < numApps; i++)
+            {
+                if (applications[i].AppName == osu_filename)
+                {
+                    application = applications[i];
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Retrieves the profile of the current application.
+        /// </summary>
+        /// <param name="profileHandle">The profile handle.</param>
+        /// <param name="application">The current application description.</param>
+        /// <param name="isApplicationSpecific">If this profile is not a global (default) profile.</param>
+        /// <returns>If the operation succeeded.</returns>
+        private static bool getProfile(out IntPtr profileHandle, out NvApplication application, out bool isApplicationSpecific)
+        {
+            application = new NvApplication
+            {
+                Version = NvApplication.Stride
+            };
+
+            isApplicationSpecific = true;
+
+            if (checkError(FindApplicationByName(sessionHandle, osu_filename, out profileHandle, ref application)))
+            {
+                isApplicationSpecific = false;
+                if (checkError(GetCurrentGlobalProfile(sessionHandle, out profileHandle)))
+                    return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Creates a profile.
+        /// </summary>
+        /// <param name="profileHandle">The profile handle.</param>
+        /// <returns>If the operation succeeded.</returns>
+        private static bool createProfile(out IntPtr profileHandle)
+        {
+            NvProfile newProfile = new NvProfile
+            {
+                Version = NvProfile.Stride,
+                IsPredefined = 0,
+                ProfileName = PROFILE_NAME,
+                GPUSupport = new uint[32]
+            };
+
+            newProfile.GPUSupport[0] = 1;
+
+            if (checkError(CreateProfile(sessionHandle, ref newProfile, out profileHandle)))
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Retrieves a setting from the profile.
+        /// </summary>
+        /// <param name="settingId">The setting to retrieve.</param>
+        /// <param name="profileHandle">The profile handle to retrieve the setting from.</param>
+        /// <param name="setting">The setting.</param>
+        /// <returns>If the operation succeeded.</returns>
+        private static bool getSetting(NvSettingID settingId, IntPtr profileHandle, out NvSetting setting)
+        {
+            setting = new NvSetting
+            {
+                Version = NvSetting.Stride,
+                SettingID = settingId
+            };
+
+            if (checkError(GetSetting(sessionHandle, profileHandle, settingId, ref setting)))
+                return false;
+
+            return true;
+        }
+
+        private static bool setSetting(NvSettingID settingId, uint settingValue)
+        {
+            NvApplication application;
+            IntPtr profileHandle;
+            bool isApplicationSpecific;
+            if (!getProfile(out profileHandle, out application, out isApplicationSpecific))
+                return false;
+
+            if (!isApplicationSpecific)
+            {
+                // We don't want to interfere with the user's other settings, so let's create a separate config for osu!
+                if (!createProfile(out profileHandle))
+                    return false;
+            }
+
+            NvSetting newSetting = new NvSetting
+            {
+                Version = NvSetting.Stride,
+                SettingID = settingId,
+                U32CurrentValue = settingValue
+            };
+
+            // Set the thread state
+            if (checkError(SetSetting(sessionHandle, profileHandle, ref newSetting)))
+                return false;
+
+            // Get the profile (needed to check app count)
+            NvProfile profile = new NvProfile
+            {
+                Version = NvProfile.Stride
+            };
+            if (checkError(GetProfileInfo(sessionHandle, profileHandle, ref profile)))
+                return false;
+
+            if (!containsApplication(profileHandle, profile, out application))
+            {
+                // Need to add the current application to the profile
+                application.IsPredefined = 0;
+
+                application.AppName = osu_filename;
+                application.UserFriendlyName = APPLICATION_NAME;
+
+                if (checkError(CreateApplication(sessionHandle, profileHandle, ref application)))
+                    return false;
+            }
+
+            // Save!
+            return !checkError(SaveSettings(sessionHandle));
+        }
+
+        /// <summary>
+        /// Creates a session to access the driver configuration.
+        /// </summary>
+        /// <returns>If the operation succeeded.</returns>
+        private static bool createSession()
+        {
+            if (checkError(CreateSession(out sessionHandle)))
+                return false;
+
+            // Load settings into session
+            if (checkError(LoadSettings(sessionHandle)))
+                return false;
+
+            return true;
+        }
+
+        private static bool checkError(NvStatus status)
+        {
+            Status = status;
+            return status != NvStatus.OK;
+        }
+
+        static NVAPI()
+        {
+            // TODO: check whether gpu vendor contains NVIDIA before attempting load?
+
+            try
+            {
+                // Try to load NVAPI
+                if ((IntPtr.Size == 4 && loadLibrary(@"nvapi.dll") == IntPtr.Zero)
+                    || (IntPtr.Size == 8 && loadLibrary(@"nvapi64.dll") == IntPtr.Zero))
+                {
+                    return;
+                }
+
+                InitializeDelegate initialize;
+                getDelegate(0x0150E828, out initialize);
+
+                if (initialize?.Invoke() == NvStatus.OK)
+                {
+                    // IDs can be found here: https://github.com/jNizM/AHK_NVIDIA_NvAPI/blob/master/info/NvAPI_IDs.txt
+
+                    getDelegate(0xE5AC921F, out EnumPhysicalGPUs);
+                    getDelegate(0x48B3EA59, out EnumLogicalGPUs);
+                    getDelegate(0xBAAABFCC, out GetSystemType);
+                    getDelegate(0xC33BAEB1, out GetGPUType);
+                    getDelegate(0x0694D52E, out CreateSession);
+                    getDelegate(0x375DBD6B, out LoadSettings);
+                    getDelegate(0xEEE566B2, out FindApplicationByName);
+                    getDelegate(0x617BFF9F, out GetCurrentGlobalProfile);
+                    getDelegate(0x577DD202, out SetSetting);
+                    getDelegate(0x61CD6FD6, out GetProfileInfo);
+                    getDelegate(0x73BF8338, out GetSetting);
+                    getDelegate(0xCC176068, out CreateProfile);
+                    getDelegate(0x7FA2173A, out EnumApplications);
+                    getDelegate(0x4347A9DE, out CreateApplication);
+                    getDelegate(0xFCBC7E14, out SaveSettings);
+                }
+
+                if (createSession())
+                    Available = true;
+            }
+            catch { }
+        }
+
+        private static void getDelegate<T>(uint id, out T newDelegate) where T : class
+        {
+            IntPtr ptr = IntPtr.Size == 4 ? queryInterface32(id) : queryInterface64(id);
+            newDelegate = ptr == IntPtr.Zero ? null : Marshal.GetDelegateForFunctionPointer(ptr, typeof(T)) as T;
+        }
+
+        [DllImport("kernel32.dll", EntryPoint = "LoadLibrary")]
+        private static extern IntPtr loadLibrary(string dllToLoad);
+
+        [DllImport(@"nvapi.dll", EntryPoint = "nvapi_QueryInterface", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr queryInterface32(uint id);
+
+        [DllImport(@"nvapi64.dll", EntryPoint = "nvapi_QueryInterface", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr queryInterface64(uint id);
+
+        private delegate NvStatus InitializeDelegate();
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    internal struct NvSetting
+    {
+        public uint Version;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string SettingName;
+
+        public NvSettingID SettingID;
+        public uint SettingType;
+        public uint SettingLocation;
+        public uint IsCurrentPredefined;
+        public uint IsPredefinedValid;
+
+        public uint U32PredefinedValue;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string StringPredefinedValue;
+
+        public uint U32CurrentValue;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string StringCurrentValue;
+
+        public static uint Stride => (uint)Marshal.SizeOf(typeof(NvSetting)) | (1 << 16);
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 8, CharSet = CharSet.Unicode)]
+    internal struct NvProfile
+    {
+        public uint Version;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string ProfileName;
+
+        [MarshalAs(UnmanagedType.ByValArray)]
+        public uint[] GPUSupport;
+
+        public uint IsPredefined;
+        public uint NumOfApps;
+        public uint NumOfSettings;
+
+        public static uint Stride => (uint)Marshal.SizeOf(typeof(NvProfile)) | (1 << 16);
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 8, CharSet = CharSet.Unicode)]
+    internal struct NvApplication
+    {
+        public uint Version;
+        public uint IsPredefined;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string AppName;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string UserFriendlyName;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string Launcher;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string FileInFolder;
+
+        public static uint Stride => (uint)Marshal.SizeOf(typeof(NvApplication)) | (2 << 16);
+    }
+
+    internal enum NvStatus
+    {
+        OK = 0, // Success. Request is completed.
+        ERROR = -1, // Generic error
+        LIBRARY_NOT_FOUND = -2, // NVAPI support library cannot be loaded.
+        NO_IMPLEMENTATION = -3, // not implemented in current driver installation
+        API_NOT_INITIALIZED = -4, // Initialize has not been called (successfully)
+        INVALID_ARGUMENT = -5, // The argument/parameter value is not valid or NULL.
+        NVIDIA_DEVICE_NOT_FOUND = -6, // No NVIDIA display driver, or NVIDIA GPU driving a display, was found.
+        END_ENUMERATION = -7, // No more items to enumerate
+        INVALID_HANDLE = -8, // Invalid handle
+        INCOMPATIBLE_STRUCT_VERSION = -9, // An argument's structure version is not supported
+        HANDLE_INVALIDATED = -10, // The handle is no longer valid (likely due to GPU or display re-configuration)
+        OPENGL_CONTEXT_NOT_CURRENT = -11, // No NVIDIA OpenGL context is current (but needs to be)
+        INVALID_POINTER = -14, // An invalid pointer, usually NULL, was passed as a parameter
+        NO_GL_EXPERT = -12, // OpenGL Expert is not supported by the current drivers
+        INSTRUMENTATION_DISABLED = -13, // OpenGL Expert is supported, but driver instrumentation is currently disabled
+        NO_GL_NSIGHT = -15, // OpenGL does not support Nsight
+
+        EXPECTED_LOGICAL_GPU_HANDLE = -100, // Expected a logical GPU handle for one or more parameters
+        EXPECTED_PHYSICAL_GPU_HANDLE = -101, // Expected a physical GPU handle for one or more parameters
+        EXPECTED_DISPLAY_HANDLE = -102, // Expected an NV display handle for one or more parameters
+        INVALID_COMBINATION = -103, // The combination of parameters is not valid.
+        NOT_SUPPORTED = -104, // Requested feature is not supported in the selected GPU
+        PORTID_NOT_FOUND = -105, // No port ID was found for the I2C transaction
+        EXPECTED_UNATTACHED_DISPLAY_HANDLE = -106, // Expected an unattached display handle as one of the input parameters.
+        INVALID_PERF_LEVEL = -107, // Invalid perf level
+        DEVICE_BUSY = -108, // Device is busy; request not fulfilled
+        NV_PERSIST_FILE_NOT_FOUND = -109, // NV persist file is not found
+        PERSIST_DATA_NOT_FOUND = -110, // NV persist data is not found
+        EXPECTED_TV_DISPLAY = -111, // Expected a TV output display
+        EXPECTED_TV_DISPLAY_ON_DCONNECTOR = -112, // Expected a TV output on the D Connector - HDTV_EIAJ4120.
+        NO_ACTIVE_SLI_TOPOLOGY = -113, // SLI is not active on this device.
+        SLI_RENDERING_MODE_NOTALLOWED = -114, // Setup of SLI rendering mode is not possible right now.
+        EXPECTED_DIGITAL_FLAT_PANEL = -115, // Expected a digital flat panel.
+        ARGUMENT_EXCEED_MAX_SIZE = -116, // Argument exceeds the expected size.
+        DEVICE_SWITCHING_NOT_ALLOWED = -117, // Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active.
+        TESTING_CLOCKS_NOT_SUPPORTED = -118, // Testing of clocks is not supported.
+        UNKNOWN_UNDERSCAN_CONFIG = -119, // The specified underscan config is from an unknown source (e.g. INF)
+        TIMEOUT_RECONFIGURING_GPU_TOPO = -120, // Timeout while reconfiguring GPUs
+        DATA_NOT_FOUND = -121, // Requested data was not found
+        EXPECTED_ANALOG_DISPLAY = -122, // Expected an analog display
+        NO_VIDLINK = -123, // No SLI video bridge is present
+        REQUIRES_REBOOT = -124, // NVAPI requires a reboot for the settings to take effect
+        INVALID_HYBRID_MODE = -125, // The function is not supported with the current Hybrid mode.
+        MIXED_TARGET_TYPES = -126, // The target types are not all the same
+        SYSWOW64_NOT_SUPPORTED = -127, // The function is not supported from 32-bit on a 64-bit system.
+        IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED = -128, // There is no implicit GPU topology active. Use SetHybridMode to change topology.
+        REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS = -129, // Prompt the user to close all non-migratable applications.
+        OUT_OF_MEMORY = -130, // Could not allocate sufficient memory to complete the call.
+        WAS_STILL_DRAWING = -131, // The previous operation that is transferring information to or from this surface is incomplete.
+        FILE_NOT_FOUND = -132, // The file was not found.
+        TOO_MANY_UNIQUE_STATE_OBJECTS = -133, // There are too many unique instances of a particular type of state object.
+        INVALID_CALL = -134, // The method call is invalid. For example, a method's parameter may not be a valid pointer.
+        D3D10_1_LIBRARY_NOT_FOUND = -135, // d3d10_1.dll cannot be loaded.
+        FUNCTION_NOT_FOUND = -136, // Couldn't find the function in the loaded DLL.
+        INVALID_USER_PRIVILEGE = -137, // Current User is not Admin.
+        EXPECTED_NON_PRIMARY_DISPLAY_HANDLE = -138, // The handle corresponds to GDIPrimary.
+        EXPECTED_COMPUTE_GPU_HANDLE = -139, // Setting Physx GPU requires that the GPU is compute-capable.
+        STEREO_NOT_INITIALIZED = -140, // The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed.
+        STEREO_REGISTRY_ACCESS_FAILED = -141, // Access to stereo-related registry keys or values has failed.
+        STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED = -142, // The given registry profile type is not supported.
+        STEREO_REGISTRY_VALUE_NOT_SUPPORTED = -143, // The given registry value is not supported.
+        STEREO_NOT_ENABLED = -144, // Stereo is not enabled and the function needed it to execute completely.
+        STEREO_NOT_TURNED_ON = -145, // Stereo is not turned on and the function needed it to execute completely.
+        STEREO_INVALID_DEVICE_INTERFACE = -146, // Invalid device interface.
+        STEREO_PARAMETER_OUT_OF_RANGE = -147, // Separation percentage or JPEG image capture quality is out of [0-100] range.
+        STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED = -148, // The given frustum adjust mode is not supported.
+        TOPO_NOT_POSSIBLE = -149, // The mosaic topology is not possible given the current state of the hardware.
+        MODE_CHANGE_FAILED = -150, // An attempt to do a display resolution mode change has failed.
+        D3D11_LIBRARY_NOT_FOUND = -151, // d3d11.dll/d3d11_beta.dll cannot be loaded.
+        INVALID_ADDRESS = -152, // Address is outside of valid range.
+        STRING_TOO_SMALL = -153, // The pre-allocated string is too small to hold the result.
+        MATCHING_DEVICE_NOT_FOUND = -154, // The input does not match any of the available devices.
+        DRIVER_RUNNING = -155, // Driver is running.
+        DRIVER_NOTRUNNING = -156, // Driver is not running.
+        ERROR_DRIVER_RELOAD_REQUIRED = -157, // A driver reload is required to apply these settings.
+        SET_NOT_ALLOWED = -158, // Intended setting is not allowed.
+        ADVANCED_DISPLAY_TOPOLOGY_REQUIRED = -159, // Information can't be returned due to "advanced display topology".
+        SETTING_NOT_FOUND = -160, // Setting is not found.
+        SETTING_SIZE_TOO_LARGE = -161, // Setting size is too large.
+        TOO_MANY_SETTINGS_IN_PROFILE = -162, // There are too many settings for a profile.
+        PROFILE_NOT_FOUND = -163, // Profile is not found.
+        PROFILE_NAME_IN_USE = -164, // Profile name is duplicated.
+        PROFILE_NAME_EMPTY = -165, // Profile name is empty.
+        EXECUTABLE_NOT_FOUND = -166, // Application not found in the Profile.
+        EXECUTABLE_ALREADY_IN_USE = -167, // Application already exists in the other profile.
+        DATATYPE_MISMATCH = -168, // Data Type mismatch
+        PROFILE_REMOVED = -169, // The profile passed as parameter has been removed and is no longer valid.
+        UNREGISTERED_RESOURCE = -170, // An unregistered resource was passed as a parameter.
+        ID_OUT_OF_RANGE = -171, // The DisplayId corresponds to a display which is not within the normal outputId range.
+        DISPLAYCONFIG_VALIDATION_FAILED = -172, // Display topology is not valid so the driver cannot do a mode set on this configuration.
+        DPMST_CHANGED = -173, // Display Port Multi-Stream topology has been changed.
+        INSUFFICIENT_BUFFER = -174, // Input buffer is insufficient to hold the contents.
+        ACCESS_DENIED = -175, // No access to the caller.
+        MOSAIC_NOT_ACTIVE = -176, // The requested action cannot be performed without Mosaic being enabled.
+        SHARE_RESOURCE_RELOCATED = -177, // The surface is relocated away from video memory.
+        REQUEST_USER_TO_DISABLE_DWM = -178, // The user should disable DWM before calling NvAPI.
+        D3D_DEVICE_LOST = -179, // D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device.
+        INVALID_CONFIGURATION = -180, // The requested action cannot be performed in the current state.
+        STEREO_HANDSHAKE_NOT_DONE = -181, // Call failed as stereo handshake not completed.
+        EXECUTABLE_PATH_IS_AMBIGUOUS = -182, // The path provided was too short to determine the correct NVDRS_APPLICATION
+        DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED = -183, // Default stereo profile is not currently defined
+        DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST = -184, // Default stereo profile does not exist
+        CLUSTER_ALREADY_EXISTS = -185, // A cluster is already defined with the given configuration.
+        DPMST_DISPLAY_ID_EXPECTED = -186, // The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology
+        INVALID_DISPLAY_ID = -187, // The input display id is not valid or the monitor associated to it does not support the current operation
+        STREAM_IS_OUT_OF_SYNC = -188, // While playing secure audio stream, stream goes out of sync
+        INCOMPATIBLE_AUDIO_DRIVER = -189, // Older audio driver version than required
+        VALUE_ALREADY_SET = -190, // Value already set, setting again not allowed.
+        TIMEOUT = -191, // Requested operation timed out
+        GPU_WORKSTATION_FEATURE_INCOMPLETE = -192, // The requested workstation feature set has incomplete driver internal allocation resources
+        STEREO_INIT_ACTIVATION_NOT_DONE = -193, // Call failed because InitActivation was not called.
+        SYNC_NOT_ACTIVE = -194, // The requested action cannot be performed without Sync being enabled.
+        SYNC_MASTER_NOT_FOUND = -195, // The requested action cannot be performed without Sync Master being enabled.
+        INVALID_SYNC_TOPOLOGY = -196, // Invalid displays passed in the NV_GSYNC_DISPLAY pointer.
+        ECID_SIGN_ALGO_UNSUPPORTED = -197, // The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value.
+        ECID_KEY_VERIFICATION_FAILED = -198, // The encrypted public key verification has failed.
+        FIRMWARE_OUT_OF_DATE = -199, // The device's firmware is out of date.
+        FIRMWARE_REVISION_NOT_SUPPORTED = -200, // The device's firmware is not supported.
+    }
+
+    internal enum NvSystemType
+    {
+        UNKNOWN = 0,
+        LAPTOP = 1,
+        DESKTOP = 2
+    }
+
+    internal enum NvGpuType
+    {
+        UNKNOWN = 0,
+        IGPU = 1, // Integrated
+        DGPU = 2, // Discrete
+    }
+
+    internal enum NvSettingID : uint
+    {
+        OGL_AA_LINE_GAMMA_ID = 0x2089BF6C,
+        OGL_DEEP_COLOR_SCANOUT_ID = 0x2097C2F6,
+        OGL_DEFAULT_SWAP_INTERVAL_ID = 0x206A6582,
+        OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL_ID = 0x206C4581,
+        OGL_DEFAULT_SWAP_INTERVAL_SIGN_ID = 0x20655CFA,
+        OGL_EVENT_LOG_SEVERITY_THRESHOLD_ID = 0x209DF23E,
+        OGL_EXTENSION_STRING_VERSION_ID = 0x20FF7493,
+        OGL_FORCE_BLIT_ID = 0x201F619F,
+        OGL_FORCE_STEREO_ID = 0x204D9A0C,
+        OGL_IMPLICIT_GPU_AFFINITY_ID = 0x20D0F3E6,
+        OGL_MAX_FRAMES_ALLOWED_ID = 0x208E55E3,
+        OGL_MULTIMON_ID = 0x200AEBFC,
+        OGL_OVERLAY_PIXEL_TYPE_ID = 0x209AE66F,
+        OGL_OVERLAY_SUPPORT_ID = 0x206C28C4,
+        OGL_QUALITY_ENHANCEMENTS_ID = 0x20797D6C,
+        OGL_SINGLE_BACKDEPTH_BUFFER_ID = 0x20A29055,
+        OGL_THREAD_CONTROL_ID = 0x20C1221E,
+        OGL_TRIPLE_BUFFER_ID = 0x20FDD1F9,
+        OGL_VIDEO_EDITING_MODE_ID = 0x20EE02B4,
+        AA_BEHAVIOR_FLAGS_ID = 0x10ECDB82,
+        AA_MODE_ALPHATOCOVERAGE_ID = 0x10FC2D9C,
+        AA_MODE_GAMMACORRECTION_ID = 0x107D639D,
+        AA_MODE_METHOD_ID = 0x10D773D2,
+        AA_MODE_REPLAY_ID = 0x10D48A85,
+        AA_MODE_SELECTOR_ID = 0x107EFC5B,
+        AA_MODE_SELECTOR_SLIAA_ID = 0x107AFC5B,
+        ANISO_MODE_LEVEL_ID = 0x101E61A9,
+        ANISO_MODE_SELECTOR_ID = 0x10D2BB16,
+        APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_ID = 0x104554B6,
+        APPLICATION_STEAM_ID_ID = 0x107CDDBC,
+        CPL_HIDDEN_PROFILE_ID = 0x106D5CFF,
+        CUDA_EXCLUDED_GPUS_ID = 0x10354FF8,
+        D3DOGL_GPU_MAX_POWER_ID = 0x10D1EF29,
+        EXPORT_PERF_COUNTERS_ID = 0x108F0841,
+        FXAA_ALLOW_ID = 0x1034CB89,
+        FXAA_ENABLE_ID = 0x1074C972,
+        FXAA_INDICATOR_ENABLE_ID = 0x1068FB9C,
+        MCSFRSHOWSPLIT_ID = 0x10287051,
+        OPTIMUS_MAXAA_ID = 0x10F9DC83,
+        PHYSXINDICATOR_ID = 0x1094F16F,
+        PREFERRED_PSTATE_ID = 0x1057EB71,
+        PREVENT_UI_AF_OVERRIDE_ID = 0x103BCCB5,
+        PS_FRAMERATE_LIMITER_ID = 0x10834FEE,
+        PS_FRAMERATE_LIMITER_GPS_CTRL_ID = 0x10834F01,
+        SHIM_MAXRES_ID = 0x10F9DC82,
+        SHIM_MCCOMPAT_ID = 0x10F9DC80,
+        SHIM_RENDERING_MODE_ID = 0x10F9DC81,
+        SHIM_RENDERING_OPTIONS_ID = 0x10F9DC84,
+        SLI_GPU_COUNT_ID = 0x1033DCD1,
+        SLI_PREDEFINED_GPU_COUNT_ID = 0x1033DCD2,
+        SLI_PREDEFINED_GPU_COUNT_DX10_ID = 0x1033DCD3,
+        SLI_PREDEFINED_MODE_ID = 0x1033CEC1,
+        SLI_PREDEFINED_MODE_DX10_ID = 0x1033CEC2,
+        SLI_RENDERING_MODE_ID = 0x1033CED1,
+        VRRFEATUREINDICATOR_ID = 0x1094F157,
+        VRROVERLAYINDICATOR_ID = 0x1095F16F,
+        VRRREQUESTSTATE_ID = 0x1094F1F7,
+        VSYNCSMOOTHAFR_ID = 0x101AE763,
+        VSYNCVRRCONTROL_ID = 0x10A879CE,
+        VSYNC_BEHAVIOR_FLAGS_ID = 0x10FDEC23,
+        WKS_API_STEREO_EYES_EXCHANGE_ID = 0x11AE435C,
+        WKS_API_STEREO_MODE_ID = 0x11E91A61,
+        WKS_MEMORY_ALLOCATION_POLICY_ID = 0x11112233,
+        WKS_STEREO_DONGLE_SUPPORT_ID = 0x112493BD,
+        WKS_STEREO_SUPPORT_ID = 0x11AA9E99,
+        WKS_STEREO_SWAP_MODE_ID = 0x11333333,
+        AO_MODE_ID = 0x00667329,
+        AO_MODE_ACTIVE_ID = 0x00664339,
+        AUTO_LODBIASADJUST_ID = 0x00638E8F,
+        ICAFE_LOGO_CONFIG_ID = 0x00DB1337,
+        LODBIASADJUST_ID = 0x00738E8F,
+        PRERENDERLIMIT_ID = 0x007BA09E,
+        PS_DYNAMIC_TILING_ID = 0x00E5C6C0,
+        PS_SHADERDISKCACHE_ID = 0x00198FFF,
+        PS_TEXFILTER_ANISO_OPTS2_ID = 0x00E73211,
+        PS_TEXFILTER_BILINEAR_IN_ANISO_ID = 0x0084CD70,
+        PS_TEXFILTER_DISABLE_TRILIN_SLOPE_ID = 0x002ECAF2,
+        PS_TEXFILTER_NO_NEG_LODBIAS_ID = 0x0019BB68,
+        QUALITY_ENHANCEMENTS_ID = 0x00CE2691,
+        REFRESH_RATE_OVERRIDE_ID = 0x0064B541,
+        SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_ID = 0x00AE785C,
+        SET_VAB_DATA_ID = 0x00AB8687,
+        VSYNCMODE_ID = 0x00A879CF,
+        VSYNCTEARCONTROL_ID = 0x005A375C,
+        TOTAL_DWORD_SETTING_NUM = 80,
+        TOTAL_WSTRING_SETTING_NUM = 4,
+        TOTAL_SETTING_NUM = 84,
+        INVALID_SETTING_ID = 0xFFFFFFFF
+    }
+
+    internal enum NvShimSetting : uint
+    {
+        SHIM_RENDERING_MODE_INTEGRATED = 0x00000000,
+        SHIM_RENDERING_MODE_ENABLE = 0x00000001,
+        SHIM_RENDERING_MODE_USER_EDITABLE = 0x00000002,
+        SHIM_RENDERING_MODE_MASK = 0x00000003,
+        SHIM_RENDERING_MODE_VIDEO_MASK = 0x00000004,
+        SHIM_RENDERING_MODE_VARYING_BIT = 0x00000008,
+        SHIM_RENDERING_MODE_AUTO_SELECT = 0x00000010,
+        SHIM_RENDERING_MODE_OVERRIDE_BIT = 0x80000000,
+        SHIM_RENDERING_MODE_NUM_VALUES = 8,
+        SHIM_RENDERING_MODE_DEFAULT = SHIM_RENDERING_MODE_AUTO_SELECT
+    }
+
+    internal enum NvThreadControlSetting : uint
+    {
+        OGL_THREAD_CONTROL_ENABLE = 0x00000001,
+        OGL_THREAD_CONTROL_DISABLE = 0x00000002,
+        OGL_THREAD_CONTROL_NUM_VALUES = 2,
+        OGL_THREAD_CONTROL_DEFAULT = 0
+    }
+}

osu.Desktop/Program.cs

@@ -30,6 +30,11 @@ namespace osu.Desktop
         [STAThread]
         public static void Main(string[] args)
         {
+            // NVIDIA profiles are based on the executable name of a process.
+            // Lazer and stable share the same executable name.
+            // Stable sets this setting to "Off", which may not be what we want, so let's force it back to the default "Auto" on startup.
+            NVAPI.ThreadedOptimisations = NvThreadControlSetting.OGL_THREAD_CONTROL_DEFAULT;
+
             // run Squirrel first, as the app may exit after these run
             if (OperatingSystem.IsWindows())
             {

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

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                 Mod = new CatchModHidden(),
                 PassCondition = () => Player.Results.Count > 0
                                       && Player.ChildrenOfType<DrawableJuiceStream>().Single().Alpha > 0
-                                      && Player.ChildrenOfType<DrawableFruit>().Last().Alpha > 0
+                                      && Player.ChildrenOfType<DrawableFruit>().First().Alpha > 0
             });
         }
 

osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBananaShower.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
 
-            AddInternal(bananaContainer = new Container { RelativeSizeAxes = Axes.Both });
+            AddInternal(bananaContainer = new NestedFruitContainer { RelativeSizeAxes = Axes.Both });
         }
 
         protected override void AddNestedHitObject(DrawableHitObject hitObject)

osu.Game.Rulesets.Catch/Objects/Drawables/DrawableJuiceStream.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
 
-            AddInternal(dropletContainer = new Container { RelativeSizeAxes = Axes.Both, });
+            AddInternal(dropletContainer = new NestedFruitContainer { RelativeSizeAxes = Axes.Both, });
         }
 
         protected override void AddNestedHitObject(DrawableHitObject hitObject)

osu.Game.Rulesets.Catch/Objects/Drawables/NestedFruitContainer.cs

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public partial class NestedFruitContainer : Container
+    {
+        /// <remarks>
+        /// This comparison logic is a copy of <see cref="HitObjectContainer"/> comparison logic,
+        /// which can't be easily extracted to a more common place.
+        /// </remarks>
+        /// <seealso cref="HitObjectContainer.Compare"/>
+        protected override int Compare(Drawable x, Drawable y)
+        {
+            if (x is not DrawableCatchHitObject xObj || y is not DrawableCatchHitObject yObj)
+                return base.Compare(x, y);
+
+            int result = yObj.HitObject.StartTime.CompareTo(xObj.HitObject.StartTime);
+            return result == 0 ? CompareReverseChildID(x, y) : result;
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneEditorAutoplayFastStreams.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.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    /// <summary>
+    /// This test covers autoplay working correctly in the editor on fast streams.
+    /// Might seem like a weird test, but frame stability being toggled can cause autoplay to operation incorrectly.
+    /// This is clearly a bug with the autoplay algorithm, but is worked around at an editor level for now.
+    /// </summary>
+    public partial class TestSceneEditorAutoplayFastStreams : EditorTestScene
+    {
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
+        {
+            var testBeatmap = new TestBeatmap(ruleset, false);
+            testBeatmap.HitObjects.AddRange(new[]
+            {
+                new HitCircle { StartTime = 500 },
+                new HitCircle { StartTime = 530 },
+                new HitCircle { StartTime = 560 },
+                new HitCircle { StartTime = 590 },
+                new HitCircle { StartTime = 620 },
+            });
+
+            return testBeatmap;
+        }
+
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        [Test]
+        public void TestAllHit()
+        {
+            AddStep("start playback", () => EditorClock.Start());
+            AddUntilStep("wait for all hit", () =>
+            {
+                DrawableHitCircle[] hitCircles = Editor.ChildrenOfType<DrawableHitCircle>().OrderBy(s => s.HitObject.StartTime).ToArray();
+
+                return hitCircles.Length == 5 && hitCircles.All(h => h.IsHit);
+            });
+        }
+    }
+}

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

@@ -46,10 +46,12 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             moveMouseToObject(() => slider);
 
             AddStep("seek after end", () => EditorClock.Seek(750));
+            AddUntilStep("wait for seek", () => !EditorClock.IsSeeking);
             AddStep("left click", () => InputManager.Click(MouseButton.Left));
             AddAssert("slider not selected", () => EditorBeatmap.SelectedHitObjects.Count == 0);
 
             AddStep("seek to visible", () => EditorClock.Seek(650));
+            AddUntilStep("wait for seek", () => !EditorClock.IsSeeking);
             AddStep("left click", () => InputManager.Click(MouseButton.Left));
             AddUntilStep("slider selected", () => EditorBeatmap.SelectedHitObjects.Single() == slider);
         }

osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerProgressArc.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
                     RelativeSizeAxes = Axes.Both,
                     InnerRadius = arc_radius,
                     RoundedCaps = true,
-                    GlowColour = new Color4(171, 255, 255, 255)
+                    GlowColour = new Color4(171, 255, 255, 180)
                 }
             };
         }

osu.Game.Tests/Chat/TestSceneChannelManager.cs

@@ -112,7 +112,7 @@ namespace osu.Game.Tests.Chat
             });
 
             AddStep("post message", () => channelManager.PostMessage("Something interesting"));
-            AddUntilStep("message postesd", () => !channel.Messages.Any(m => m is LocalMessage));
+            AddUntilStep("message posted", () => !channel.Messages.Any(m => m is LocalMessage));
 
             AddStep("post /help command", () => channelManager.PostCommand("help", channel));
             AddStep("post /me command with no action", () => channelManager.PostCommand("me", channel));
@@ -146,6 +146,23 @@ namespace osu.Game.Tests.Chat
             AddAssert("channel has no more messages", () => channel.Messages, () => Is.Empty);
         }
 
+        [Test]
+        public void TestCommandNameCaseInsensitivity()
+        {
+            Channel channel = null;
+
+            AddStep("join channel and select it", () =>
+            {
+                channelManager.JoinChannel(channel = createChannel(1, ChannelType.Public));
+                channelManager.CurrentChannel.Value = channel;
+            });
+
+            AddStep("post /me command", () => channelManager.PostCommand("ME DANCES"));
+            AddUntilStep("/me command received", () => channel.Messages.Last().Content.Contains("DANCES"));
+            AddStep("post /help command", () => channelManager.PostCommand("HeLp"));
+            AddUntilStep("/help command received", () => channel.Messages.Last().Content.Contains("Supported commands"));
+        }
+
         private void handlePostMessageRequest(PostMessageRequest request)
         {
             var message = new Message(++currentMessageId)

osu.Game.Tests/Database/BackgroundDataStoreProcessorTests.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.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -182,9 +183,63 @@ namespace osu.Game.Tests.Database
             AddAssert("Score version not upgraded", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.TotalScoreVersion), () => Is.EqualTo(30000002));
         }
 
+        [Test]
+        public void TestCustomRulesetScoreNotSubjectToUpgrades([Values] bool available)
+        {
+            RulesetInfo rulesetInfo = null!;
+            ScoreInfo scoreInfo = null!;
+            TestBackgroundDataStoreProcessor processor = null!;
+
+            AddStep("Add unavailable ruleset", () => Realm.Write(r => r.Add(rulesetInfo = new RulesetInfo
+            {
+                ShortName = Guid.NewGuid().ToString(),
+                Available = available
+            })));
+
+            AddStep("Add score for unavailable ruleset", () => Realm.Write(r => r.Add(scoreInfo = new ScoreInfo(
+                ruleset: rulesetInfo,
+                beatmap: r.All<BeatmapInfo>().First())
+            {
+                TotalScoreVersion = 30000001
+            })));
+
+            AddStep("Run background processor", () => Add(processor = new TestBackgroundDataStoreProcessor()));
+            AddUntilStep("Wait for completion", () => processor.Completed);
+
+            AddAssert("Score not marked as failed", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.BackgroundReprocessingFailed), () => Is.False);
+            AddAssert("Score version not upgraded", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.TotalScoreVersion), () => Is.EqualTo(30000001));
+        }
+
+        [Test]
+        public void TestNonLegacyScoreNotSubjectToUpgrades()
+        {
+            ScoreInfo scoreInfo = null!;
+            TestBackgroundDataStoreProcessor processor = null!;
+
+            AddStep("Add score which requires upgrade (and has beatmap)", () =>
+            {
+                Realm.Write(r =>
+                {
+                    r.Add(scoreInfo = new ScoreInfo(ruleset: r.All<RulesetInfo>().First(), beatmap: r.All<BeatmapInfo>().First())
+                    {
+                        TotalScoreVersion = 30000005,
+                        LegacyTotalScore = 123456,
+                    });
+                });
+            });
+
+            AddStep("Run background processor", () => Add(processor = new TestBackgroundDataStoreProcessor()));
+            AddUntilStep("Wait for completion", () => processor.Completed);
+
+            AddAssert("Score not marked as failed", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.BackgroundReprocessingFailed), () => Is.False);
+            AddAssert("Score version not upgraded", () => Realm.Run(r => r.Find<ScoreInfo>(scoreInfo.ID)!.TotalScoreVersion), () => Is.EqualTo(30000005));
+        }
+
         public partial class TestBackgroundDataStoreProcessor : BackgroundDataStoreProcessor
         {
             protected override int TimeToSleepDuringGameplay => 10;
+
+            public bool Completed => ProcessingTask.IsCompleted;
         }
     }
 }

osu.Game.Tests/Mods/ModUtilsTest.cs

@@ -310,6 +310,26 @@ namespace osu.Game.Tests.Mods
                 Assert.That(invalid?.Select(t => t.GetType()), Is.EquivalentTo(expectedInvalid));
         }
 
+        [Test]
+        public void TestFormatScoreMultiplier()
+        {
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.9999).ToString(), "0.99x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.0).ToString(), "1.00x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.0001).ToString(), "1.01x");
+
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.899999999999999).ToString(), "0.90x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.9).ToString(), "0.90x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.900000000000001).ToString(), "0.90x");
+
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.099999999999999).ToString(), "1.10x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.1).ToString(), "1.10x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.100000000000001).ToString(), "1.10x");
+
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.045).ToString(), "1.05x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.05).ToString(), "1.05x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.055).ToString(), "1.06x");
+        }
+
         public abstract class CustomMod1 : Mod, IModCompatibilitySpecification
         {
         }
@@ -339,6 +359,16 @@ namespace osu.Game.Tests.Mods
             public override bool ValidForMultiplayerAsFreeMod => false;
         }
 
+        public class EditableMod : Mod
+        {
+            public override string Name => string.Empty;
+            public override LocalisableString Description => string.Empty;
+            public override string Acronym => string.Empty;
+            public override double ScoreMultiplier => Multiplier;
+
+            public double Multiplier = 1;
+        }
+
         public interface IModCompatibilitySpecification
         {
         }

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

@@ -104,7 +104,7 @@ namespace osu.Game.Tests.Visual.Editing
             if (sameRuleset)
             {
                 AddUntilStep("prompt for save dialog shown", () => DialogOverlay.CurrentDialog is PromptForSaveDialog);
-                AddStep("discard changes", () => ((PromptForSaveDialog)DialogOverlay.CurrentDialog).PerformOkAction());
+                AddStep("discard changes", () => ((PromptForSaveDialog)DialogOverlay.CurrentDialog)?.PerformOkAction());
             }
 
             // ensure editor loader didn't resume.

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

@@ -21,6 +21,7 @@ using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko;
 using osu.Game.Scoring;
+using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Tests.Beatmaps;
 
@@ -359,6 +360,11 @@ namespace osu.Game.Tests.Visual.Gameplay
                 AllowImportCompletion = new SemaphoreSlim(1);
             }
 
+            protected override GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new MasterGameplayClockContainer(beatmap, gameplayStart)
+            {
+                ShouldValidatePlaybackRate = false,
+            };
+
             protected override async Task ImportScore(Score score)
             {
                 ScoreImportStarted = true;

osu.Game.Tests/Visual/Menus/TestSceneIntroMusicActionHandling.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.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Input.Bindings;
+using osu.Game.Screens.Menu;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    public partial class TestSceneIntroMusicActionHandling : OsuGameTestScene
+    {
+        private GlobalActionContainer globalActionContainer => Game.ChildrenOfType<GlobalActionContainer>().First();
+
+        public override void SetUpSteps()
+        {
+            CreateNewGame();
+            // we do not want to progress to main menu immediately, hence the override and lack of `ConfirmAtMainMenu()` call here.
+        }
+
+        [Test]
+        public void TestPauseDuringIntro()
+        {
+            AddUntilStep("Wait for music", () => Game?.MusicController.IsPlaying == true);
+
+            // Check that pause doesn't work during intro sequence.
+            AddStep("Toggle playback", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPlay));
+            AddAssert("Still playing before menu", () => Game?.MusicController.IsPlaying == true);
+            AddUntilStep("Wait for main menu", () => Game?.ScreenStack.CurrentScreen is MainMenu menu && menu.IsLoaded);
+
+            // Check that toggling after intro still works.
+            AddStep("Toggle playback", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPlay));
+            AddUntilStep("Music paused", () => Game?.MusicController.IsPlaying == false && Game?.MusicController.UserPauseRequested == true);
+            AddStep("Toggle playback", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPlay));
+            AddUntilStep("Music resumed", () => Game?.MusicController.IsPlaying == true && Game?.MusicController.UserPauseRequested == false);
+        }
+    }
+}

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

@@ -29,6 +29,7 @@ using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Scoring;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
@@ -690,6 +691,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
             }
 
             AddUntilStep("wait for results", () => multiplayerComponents.CurrentScreen is ResultsScreen);
+
+            AddAssert("check is fail", () =>
+            {
+                var scoreInfo = ((ResultsScreen)multiplayerComponents.CurrentScreen).Score;
+
+                return !scoreInfo.Passed && scoreInfo.Rank == ScoreRank.F;
+            });
         }
 
         [Test]

osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs

@@ -799,11 +799,7 @@ namespace osu.Game.Tests.Visual.Navigation
                 });
             });
 
-            AddStep("attempt exit", () =>
-            {
-                for (int i = 0; i < 2; ++i)
-                    Game.ScreenStack.CurrentScreen.Exit();
-            });
+            AddRepeatStep("attempt force exit", () => Game.ScreenStack.CurrentScreen.Exit(), 2);
             AddUntilStep("stopped at exit confirm", () => Game.ChildrenOfType<DialogOverlay>().Single().CurrentDialog is ConfirmExitDialog);
         }
 
@@ -942,6 +938,35 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("touch device mod still active", () => Game.SelectedMods.Value, () => Has.One.InstanceOf<ModTouchDevice>());
         }
 
+        [Test]
+        public void TestExitSongSelectAndImmediatelyClickLogo()
+        {
+            Screens.Select.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
+            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("press escape and then click logo immediately", () =>
+            {
+                InputManager.Key(Key.Escape);
+                clickLogoWhenNotCurrent();
+            });
+
+            void clickLogoWhenNotCurrent()
+            {
+                if (songSelect.IsCurrentScreen())
+                    Scheduler.AddOnce(clickLogoWhenNotCurrent);
+                else
+                {
+                    InputManager.MoveMouseTo(Game.ChildrenOfType<OsuLogo>().Single());
+                    InputManager.Click(MouseButton.Left);
+                }
+            }
+        }
+
         private Func<Player> playToResults()
         {
             var player = playToCompletion();

osu.Game.Tests/Visual/Online/TestSceneBeatmapListingOverlay.cs

@@ -368,7 +368,7 @@ namespace osu.Game.Tests.Visual.Online
             {
                 var cardContainer = this.ChildrenOfType<ReverseChildIDFillFlowContainer<BeatmapCard>>().Single().Parent;
                 var expandedContent = this.ChildrenOfType<ExpandedContentScrollContainer>().Single();
-                return expandedContent.ScreenSpaceDrawQuad.GetVertices().ToArray().All(v => cardContainer.ScreenSpaceDrawQuad.Contains(v));
+                return expandedContent.ScreenSpaceDrawQuad.GetVertices().ToArray().All(v => cardContainer!.ScreenSpaceDrawQuad.Contains(v));
             });
         }
 

osu.Game.Tests/Visual/Online/TestSceneWikiHeader.cs

@@ -24,8 +24,8 @@ namespace osu.Game.Tests.Visual.Online
         [Cached]
         private readonly Bindable<APIWikiPage> wikiPageData = new Bindable<APIWikiPage>(new APIWikiPage
         {
-            Title = "Main Page",
-            Path = "Main_Page",
+            Title = "Main page",
+            Path = WikiOverlay.INDEX_PATH,
         });
 
         private TestHeader header;

osu.Game.Tests/Visual/Online/TestSceneWikiMainPage.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Tests.Visual.Online
             };
         }
 
-        // From https://osu.ppy.sh/api/v2/wiki/en/Main_Page
+        // From https://osu.ppy.sh/api/v2/wiki/en/Main_page
         private const string main_page_markdown =
             "---\nlayout: main_page\n---\n\n<!-- Do not add any empty lines inside this div. -->\n\n<div class=\"wiki-main-page__blurb\">\nWelcome to the osu! wiki, a project containing a wide range of osu! related information.\n</div>\n\n<div class=\"wiki-main-page__panels\">\n<div class=\"wiki-main-page-panel wiki-main-page-panel--full\">\n\n# Getting started\n\n[Welcome](/wiki/Welcome) • [Installation](/wiki/Installation) • [Registration](/wiki/Registration) • [Help Centre](/wiki/Help_Centre) • [FAQ](/wiki/FAQ)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# Game client\n\n[Interface](/wiki/Interface) • [Options](/wiki/Options) • [Visual settings](/wiki/Visual_Settings) • [Shortcut key reference](/wiki/Shortcut_key_reference) • [Configuration file](/wiki/osu!_Program_Files/User_Configuration_File) • [Program files](/wiki/osu!_Program_Files)\n\n[File formats](/wiki/osu!_File_Formats): [.osz](/wiki/osu!_File_Formats/Osz_(file_format)) • [.osk](/wiki/osu!_File_Formats/Osk_(file_format)) • [.osr](/wiki/osu!_File_Formats/Osr_(file_format)) • [.osu](/wiki/osu!_File_Formats/Osu_(file_format)) • [.osb](/wiki/osu!_File_Formats/Osb_(file_format)) • [.db](/wiki/osu!_File_Formats/Db_(file_format))\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# Gameplay\n\n[Game modes](/wiki/Game_mode): [osu!](/wiki/Game_mode/osu!) • [osu!taiko](/wiki/Game_mode/osu!taiko) • [osu!catch](/wiki/Game_mode/osu!catch) • [osu!mania](/wiki/Game_mode/osu!mania)\n\n[Beatmap](/wiki/Beatmap) • [Hit object](/wiki/Hit_object) • [Mods](/wiki/Game_modifier) • [Score](/wiki/Score) • [Replay](/wiki/Replay) • [Multi](/wiki/Multi)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# [Beatmap editor](/wiki/Beatmap_Editor)\n\nSections: [Compose](/wiki/Beatmap_Editor/Compose) • [Design](/wiki/Beatmap_Editor/Design) • [Timing](/wiki/Beatmap_Editor/Timing) • [Song setup](/wiki/Beatmap_Editor/Song_Setup)\n\nComponents: [AiMod](/wiki/Beatmap_Editor/AiMod) • [Beat snap divisor](/wiki/Beatmap_Editor/Beat_Snap_Divisor) • [Distance snap](/wiki/Beatmap_Editor/Distance_Snap) • [Menu](/wiki/Beatmap_Editor/Menu) • [SB load](/wiki/Beatmap_Editor/SB_Load) • [Timelines](/wiki/Beatmap_Editor/Timelines)\n\n[Beatmapping](/wiki/Beatmapping) • [Difficulty](/wiki/Beatmap/Difficulty) • [Mapping techniques](/wiki/Mapping_Techniques) • [Storyboarding](/wiki/Storyboarding)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# Beatmap submission and ranking\n\n[Submission](/wiki/Submission) • [Modding](/wiki/Modding) • [Ranking procedure](/wiki/Beatmap_ranking_procedure) • [Mappers' Guild](/wiki/Mappers_Guild) • [Project Loved](/wiki/Project_Loved)\n\n[Ranking criteria](/wiki/Ranking_Criteria): [osu!](/wiki/Ranking_Criteria/osu!) • [osu!taiko](/wiki/Ranking_Criteria/osu!taiko) • [osu!catch](/wiki/Ranking_Criteria/osu!catch) • [osu!mania](/wiki/Ranking_Criteria/osu!mania)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# Community\n\n[Tournaments](/wiki/Tournaments) • [Skinning](/wiki/Skinning) • [Projects](/wiki/Projects) • [Guides](/wiki/Guides) • [osu!dev Discord server](/wiki/osu!dev_Discord_server) • [How you can help](/wiki/How_You_Can_Help!) • [Glossary](/wiki/Glossary)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# People\n\n[The Team](/wiki/People/The_Team): [Developers](/wiki/People/The_Team/Developers) • [Global Moderation Team](/wiki/People/The_Team/Global_Moderation_Team) • [Support Team](/wiki/People/The_Team/Support_Team) • [Nomination Assessment Team](/wiki/People/The_Team/Nomination_Assessment_Team) • [Beatmap Nominators](/wiki/People/The_Team/Beatmap_Nominators) • [osu! Alumni](/wiki/People/The_Team/osu!_Alumni) • [Project Loved Team](/wiki/People/The_Team/Project_Loved_Team)\n\nOrganisations: [osu! UCI](/wiki/Organisations/osu!_UCI)\n\n[Community Contributors](/wiki/People/Community_Contributors) • [Users with unique titles](/wiki/People/Users_with_unique_titles)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# For developers\n\n[API](/wiki/osu!api) • [Bot account](/wiki/Bot_account) • [Brand identity guidelines](/wiki/Brand_identity_guidelines)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# About the wiki\n\n[Sitemap](/wiki/Sitemap) • [Contribution guide](/wiki/osu!_wiki_Contribution_Guide) • [Article styling criteria](/wiki/Article_Styling_Criteria) • [News styling criteria](/wiki/News_Styling_Criteria)\n\n</div>\n</div>\n";
     }

osu.Game.Tests/Visual/Online/TestSceneWikiMarkdownContainer.cs

@@ -69,8 +69,8 @@ namespace osu.Game.Tests.Visual.Online
         {
             AddStep("set current path", () => markdownContainer.CurrentPath = $"{API.WebsiteRootUrl}/wiki/Article_styling_criteria/");
 
-            AddStep("set '/wiki/Main_Page''", () => markdownContainer.Text = "[wiki main page](/wiki/Main_Page)");
-            AddAssert("check url", () => markdownContainer.Link.Url == $"{API.WebsiteRootUrl}/wiki/Main_Page");
+            AddStep("set '/wiki/Main_page''", () => markdownContainer.Text = "[wiki main page](/wiki/Main_page)");
+            AddAssert("check url", () => markdownContainer.Link.Url == $"{API.WebsiteRootUrl}/wiki/Main_page");
 
             AddStep("set '../FAQ''", () => markdownContainer.Text = "[FAQ](../FAQ)");
             AddAssert("check url", () => markdownContainer.Link.Url == $"{API.WebsiteRootUrl}/wiki/FAQ");
@@ -275,7 +275,7 @@ Phasellus eu nunc nec ligula semper fringilla. Aliquam magna neque, placerat sed
             AddStep("set content", () =>
             {
                 markdownContainer.Text = @"
-This is a paragraph containing `inline code` synatax.
+This is a paragraph containing `inline code` syntax.
 Oh wow I do love the `WikiMarkdownContainer`, it is very cool!
 
 This is a line before the fenced code block:

osu.Game.Tests/Visual/Online/TestSceneWikiOverlay.cs

@@ -107,12 +107,12 @@ namespace osu.Game.Tests.Visual.Online
                 };
             });
 
-        // From https://osu.ppy.sh/api/v2/wiki/en/Main_Page
+        // From https://osu.ppy.sh/api/v2/wiki/en/Main_page
         private APIWikiPage responseMainPage => new APIWikiPage
         {
-            Title = "Main Page",
-            Layout = "main_page",
-            Path = "Main_Page",
+            Title = "Main page",
+            Layout = WikiOverlay.INDEX_PATH.ToLowerInvariant(), // custom classes are always lower snake.
+            Path = WikiOverlay.INDEX_PATH,
             Locale = "en",
             Subtitle = null,
             Markdown =

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

@@ -9,6 +9,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Select;
+using osu.Game.Utils;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
@@ -74,7 +75,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         private bool assertModsMultiplier(IEnumerable<Mod> mods)
         {
             double multiplier = mods.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier);
-            string expectedValue = multiplier.Equals(1.0) ? string.Empty : $"{multiplier:N2}x";
+            string expectedValue = multiplier == 1 ? string.Empty : ModUtils.FormatScoreMultiplier(multiplier).ToString();
 
             return expectedValue == footerButtonMods.MultiplierText.Current.Value;
         }

osu.Game/BackgroundDataStoreProcessor.cs

@@ -13,6 +13,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
+using osu.Game.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
@@ -28,6 +29,8 @@ namespace osu.Game
     /// </summary>
     public partial class BackgroundDataStoreProcessor : Component
     {
+        protected Task ProcessingTask { get; private set; } = null!;
+
         [Resolved]
         private RulesetStore rulesetStore { get; set; } = null!;
 
@@ -61,7 +64,7 @@ namespace osu.Game
         {
             base.LoadComplete();
 
-            Task.Factory.StartNew(() =>
+            ProcessingTask = Task.Factory.StartNew(() =>
             {
                 Logger.Log("Beginning background data store processing..");
 
@@ -314,10 +317,17 @@ namespace osu.Game
         {
             Logger.Log("Querying for scores that need total score conversion...");
 
-            HashSet<Guid> scoreIds = realmAccess.Run(r => new HashSet<Guid>(r.All<ScoreInfo>()
-                                                                             .Where(s => !s.BackgroundReprocessingFailed && s.BeatmapInfo != null
-                                                                                                                         && s.TotalScoreVersion < LegacyScoreEncoder.LATEST_VERSION)
-                                                                             .AsEnumerable().Select(s => s.ID)));
+            HashSet<Guid> scoreIds = realmAccess.Run(r => new HashSet<Guid>(
+                r.All<ScoreInfo>()
+                 .Where(s => !s.BackgroundReprocessingFailed
+                             && s.BeatmapInfo != null
+                             && s.IsLegacyScore
+                             && s.TotalScoreVersion < LegacyScoreEncoder.LATEST_VERSION)
+                 .AsEnumerable()
+                 // must be done after materialisation, as realm doesn't want to support
+                 // nested property predicates
+                 .Where(s => s.Ruleset.IsLegacyRuleset())
+                 .Select(s => s.ID)));
 
             Logger.Log($"Found {scoreIds.Count} scores which require total score conversion.");
 

osu.Game/Configuration/OsuConfigManager.cs

@@ -20,6 +20,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Skinning;
+using osu.Game.Users;
 
 namespace osu.Game.Configuration
 {
@@ -193,6 +194,7 @@ namespace osu.Game.Configuration
             SetDefault(OsuSetting.LastProcessedMetadataId, -1);
 
             SetDefault(OsuSetting.ComboColourNormalisationAmount, 0.2f, 0f, 1f, 0.01f);
+            SetDefault<UserStatus?>(OsuSetting.UserOnlineStatus, null);
         }
 
         protected override bool CheckLookupContainsPrivateInformation(OsuSetting lookup)
@@ -420,5 +422,6 @@ namespace osu.Game.Configuration
         EditorShowSpeedChanges,
         TouchDisableGameplayTaps,
         ModSelectTextSearchStartsActive,
+        UserOnlineStatus,
     }
 }

osu.Game/Database/RealmFileStore.cs

@@ -2,8 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics;
 using System.IO;
-using System.Linq;
 using osu.Framework.Extensions;
 using osu.Framework.IO.Stores;
 using osu.Framework.Logging;
@@ -98,15 +98,11 @@ namespace osu.Game.Database
             // can potentially be run asynchronously, although we will need to consider operation order for disk deletion vs realm removal.
             realm.Write(r =>
             {
-                // TODO: consider using a realm native query to avoid iterating all files (https://github.com/realm/realm-dotnet/issues/2659#issuecomment-927823707)
-                var files = r.All<RealmFile>().ToList();
-
-                foreach (var file in files)
+                foreach (var file in r.All<RealmFile>().Filter(@$"{nameof(RealmFile.Usages)}.@count = 0"))
                 {
                     totalFiles++;
 
-                    if (file.BacklinksCount > 0)
-                        continue;
+                    Debug.Assert(file.BacklinksCount == 0);
 
                     try
                     {

osu.Game/Database/StandardisedScoreMigrationTools.cs

@@ -311,13 +311,22 @@ namespace osu.Game.Database
             long maximumLegacyBonusScore = attributes.BonusScore;
 
             double legacyAccScore = maximumLegacyAccuracyScore * score.Accuracy;
-            // We can not separate the ComboScore from the BonusScore, so we keep the bonus in the ratio.
-            // Note that `maximumLegacyComboScore + maximumLegacyBonusScore` can actually be 0
-            // when playing a beatmap with no bonus objects, with mods that have a 0.0x multiplier on stable (relax/autopilot).
-            // In such cases, just assume 0.
-            double comboProportion = maximumLegacyComboScore + maximumLegacyBonusScore > 0
-                ? Math.Max((double)score.LegacyTotalScore - legacyAccScore, 0) / (maximumLegacyComboScore + maximumLegacyBonusScore)
-                : 0;
+
+            double comboProportion;
+
+            if (maximumLegacyComboScore + maximumLegacyBonusScore > 0)
+            {
+                // We can not separate the ComboScore from the BonusScore, so we keep the bonus in the ratio.
+                comboProportion = Math.Max((double)score.LegacyTotalScore - legacyAccScore, 0) / (maximumLegacyComboScore + maximumLegacyBonusScore);
+            }
+            else
+            {
+                // Two possible causes:
+                // the beatmap has no bonus objects *AND*
+                // either the active mods have a zero mod multiplier, in which case assume 0,
+                // or the *beatmap* has a zero `difficultyPeppyStars` (or just no combo-giving objects), in which case assume 1.
+                comboProportion = legacyModMultiplier == 0 ? 0 : 1;
+            }
 
             // We assume the bonus proportion only makes up the rest of the score that exceeds maximumLegacyBaseScore.
             long maximumLegacyBaseScore = maximumLegacyAccuracyScore + maximumLegacyComboScore;
@@ -465,9 +474,14 @@ namespace osu.Game.Database
                     break;
 
                 case 3:
+                    // in the mania case accuracy actually changes between score V1 and score V2 / standardised
+                    // (PERFECT weighting changes from 300 to 305),
+                    // so for better accuracy recompute accuracy locally based on hit statistics and use that instead,
+                    double scoreV2Accuracy = ComputeAccuracy(score);
+
                     convertedTotalScore = (long)Math.Round((
                         850000 * comboProportion
-                        + 150000 * Math.Pow(score.Accuracy, 2 + 2 * score.Accuracy)
+                        + 150000 * Math.Pow(scoreV2Accuracy, 2 + 2 * scoreV2Accuracy)
                         + bonusProportion) * modMultiplier);
                     break;
 

osu.Game/Models/RealmFile.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.Linq;
 using osu.Game.IO;
 using Realms;
 
@@ -11,5 +12,8 @@ namespace osu.Game.Models
     {
         [PrimaryKey]
         public string Hash { get; set; } = string.Empty;
+
+        [Backlink(nameof(RealmNamedFileUsage.File))]
+        public IQueryable<RealmNamedFileUsage> Usages { get; } = null!;
     }
 }

osu.Game/Online/API/APIAccess.cs

@@ -62,6 +62,9 @@ namespace osu.Game.Online.API
 
         private Bindable<UserActivity> activity { get; } = new Bindable<UserActivity>();
 
+        private Bindable<UserStatus?> configStatus { get; } = new Bindable<UserStatus?>();
+        private Bindable<UserStatus?> localUserStatus { get; } = new Bindable<UserStatus?>();
+
         protected bool HasLogin => authentication.Token.Value != null || (!string.IsNullOrEmpty(ProvidedUsername) && !string.IsNullOrEmpty(password));
 
         private readonly CancellationTokenSource cancellationToken = new CancellationTokenSource();
@@ -85,12 +88,20 @@ namespace osu.Game.Online.API
             authentication.TokenString = config.Get<string>(OsuSetting.Token);
             authentication.Token.ValueChanged += onTokenChanged;
 
+            config.BindWith(OsuSetting.UserOnlineStatus, configStatus);
+
             localUser.BindValueChanged(u =>
             {
                 u.OldValue?.Activity.UnbindFrom(activity);
                 u.NewValue.Activity.BindTo(activity);
+
+                if (u.OldValue != null)
+                    localUserStatus.UnbindFrom(u.OldValue.Status);
+                localUserStatus.BindTo(u.NewValue.Status);
             }, true);
 
+            localUserStatus.BindValueChanged(val => configStatus.Value = val.NewValue);
+
             var thread = new Thread(run)
             {
                 Name = "APIAccess",
@@ -200,6 +211,7 @@ namespace osu.Game.Online.API
                 setLocalUser(new APIUser
                 {
                     Username = ProvidedUsername,
+                    Status = { Value = configStatus.Value ?? UserStatus.Online }
                 });
             }
 
@@ -246,8 +258,7 @@ namespace osu.Game.Online.API
             };
             userReq.Success += user =>
             {
-                // todo: save/pull from settings
-                user.Status.Value = UserStatus.Online;
+                user.Status.Value = configStatus.Value ?? UserStatus.Online;
 
                 setLocalUser(user);
 

osu.Game/Online/Chat/ChannelManager.cs

@@ -247,7 +247,7 @@ namespace osu.Game.Online.Chat
             string command = parameters[0];
             string content = parameters.Length == 2 ? parameters[1] : string.Empty;
 
-            switch (command)
+            switch (command.ToLowerInvariant())
             {
                 case "np":
                     AddInternal(new NowPlayingCommand(target));

osu.Game/Online/Leaderboards/Leaderboard.cs

@@ -152,6 +152,15 @@ namespace osu.Game.Online.Leaderboards
         /// </summary>
         public void RefetchScores() => Scheduler.AddOnce(refetchScores);
 
+        /// <summary>
+        /// Clear all scores from the display.
+        /// </summary>
+        public void ClearScores()
+        {
+            cancelPendingWork();
+            SetScores(null);
+        }
+
         /// <summary>
         /// Call when a retrieval or display failure happened to show a relevant message to the user.
         /// </summary>
@@ -220,9 +229,7 @@ namespace osu.Game.Online.Leaderboards
         {
             Debug.Assert(ThreadSafety.IsUpdateThread);
 
-            cancelPendingWork();
-
-            SetScores(null);
+            ClearScores();
             setState(LeaderboardState.Retrieving);
 
             currentFetchCancellationSource = new CancellationTokenSource();

osu.Game/Online/Metadata/OnlineMetadataClient.cs

@@ -23,7 +23,6 @@ namespace osu.Game.Online.Metadata
         public override IBindable<bool> IsWatchingUserPresence => isWatchingUserPresence;
         private readonly BindableBool isWatchingUserPresence = new BindableBool();
 
-        // ReSharper disable once InconsistentlySynchronizedField
         public override IBindableDictionary<int, UserPresence> UserStates => userStates;
         private readonly BindableDictionary<int, UserPresence> userStates = new BindableDictionary<int, UserPresence>();
 
@@ -192,7 +191,7 @@ namespace osu.Game.Online.Metadata
         {
             Schedule(() =>
             {
-                if (presence != null)
+                if (presence?.Status != null)
                     userStates[userId] = presence.Value;
                 else
                     userStates.Remove(userId);

osu.Game/Overlays/Dialog/PopupDialog.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Overlays.Dialog
         private readonly Vector2 ringMinifiedSize = new Vector2(20f);
 
         private readonly Box flashLayer;
-        private Sample flashSample = null!;
+        private Sample? flashSample;
 
         private readonly Container content;
         private readonly Container ring;
@@ -267,7 +267,7 @@ namespace osu.Game.Overlays.Dialog
             flashLayer.FadeInFromZero(80, Easing.OutQuint)
                       .Then()
                       .FadeOutFromOne(1500, Easing.OutQuint);
-            flashSample.Play();
+            flashSample?.Play();
         }
 
         protected override bool OnKeyDown(KeyDownEvent e)

osu.Game/Overlays/Login/LoginPanel.cs

@@ -143,6 +143,8 @@ namespace osu.Game.Overlays.Login
                     panel.Status.BindTo(api.LocalUser.Value.Status);
                     panel.Activity.BindTo(api.LocalUser.Value.Activity);
 
+                    panel.Status.BindValueChanged(_ => updateDropdownCurrent(), true);
+
                     dropdown.Current.BindValueChanged(action =>
                     {
                         switch (action.NewValue)
@@ -174,6 +176,24 @@ namespace osu.Game.Overlays.Login
                 ScheduleAfterChildren(() => GetContainingInputManager()?.ChangeFocus(form));
         });
 
+        private void updateDropdownCurrent()
+        {
+            switch (panel.Status.Value)
+            {
+                case UserStatus.Online:
+                    dropdown.Current.Value = UserAction.Online;
+                    break;
+
+                case UserStatus.DoNotDisturb:
+                    dropdown.Current.Value = UserAction.DoNotDisturb;
+                    break;
+
+                case UserStatus.Offline:
+                    dropdown.Current.Value = UserAction.AppearOffline;
+                    break;
+            }
+        }
+
         public override bool AcceptsFocus => true;
 
         protected override bool OnClick(ClickEvent e) => true;

osu.Game/Overlays/Mods/ScoreMultiplierDisplay.cs

@@ -4,7 +4,6 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -15,6 +14,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Utils;
 using osuTK;
 
 namespace osu.Game.Overlays.Mods
@@ -147,7 +147,7 @@ namespace osu.Game.Overlays.Mods
         {
             protected override double RollingDuration => 500;
 
-            protected override LocalisableString FormatCount(double count) => count.ToLocalisableString(@"0.00x");
+            protected override LocalisableString FormatCount(double count) => ModUtils.FormatScoreMultiplier(count);
 
             protected override OsuSpriteText CreateSpriteText() => new OsuSpriteText
             {

osu.Game/Overlays/SettingsToolboxGroup.cs

@@ -151,9 +151,12 @@ namespace osu.Game.Overlays
             base.Update();
 
             if (!headerTextVisibilityCache.IsValid)
+            {
                 // These toolbox grouped may be contracted to only show icons.
                 // For now, let's hide the header to avoid text truncation weirdness in such cases.
                 headerText.FadeTo(headerText.DrawWidth < DrawWidth ? 1 : 0, 150, Easing.OutQuint);
+                headerTextVisibilityCache.Validate();
+            }
         }
 
         protected override bool OnInvalidate(Invalidation invalidation, InvalidationSource source)

osu.Game/Overlays/Wiki/WikiHeader.cs

@@ -17,8 +17,6 @@ namespace osu.Game.Overlays.Wiki
 {
     public partial class WikiHeader : BreadcrumbControlOverlayHeader
     {
-        private const string index_path = "Main_Page";
-
         public static LocalisableString IndexPageString => LayoutStrings.HeaderHelpIndex;
 
         public readonly Bindable<APIWikiPage> WikiPageData = new Bindable<APIWikiPage>();
@@ -45,7 +43,7 @@ namespace osu.Game.Overlays.Wiki
 
             TabControl.AddItem(IndexPageString);
 
-            if (e.NewValue.Path == index_path)
+            if (e.NewValue.Path == WikiOverlay.INDEX_PATH)
             {
                 Current.Value = IndexPageString;
                 return;

osu.Game/Overlays/WikiOverlay.cs

@@ -19,11 +19,11 @@ namespace osu.Game.Overlays
 {
     public partial class WikiOverlay : OnlineOverlay<WikiHeader>
     {
-        private const string index_path = @"main_page";
+        public const string INDEX_PATH = @"Main_page";
 
         public string CurrentPath => path.Value;
 
-        private readonly Bindable<string> path = new Bindable<string>(index_path);
+        private readonly Bindable<string> path = new Bindable<string>(INDEX_PATH);
 
         private readonly Bindable<APIWikiPage> wikiData = new Bindable<APIWikiPage>();
 
@@ -43,7 +43,7 @@ namespace osu.Game.Overlays
         {
         }
 
-        public void ShowPage(string pagePath = index_path)
+        public void ShowPage(string pagePath = INDEX_PATH)
         {
             path.Value = pagePath.Trim('/');
             Show();
@@ -137,7 +137,7 @@ namespace osu.Game.Overlays
             wikiData.Value = response;
             path.Value = response.Path;
 
-            if (response.Layout == index_path)
+            if (response.Layout.Equals(INDEX_PATH, StringComparison.OrdinalIgnoreCase))
             {
                 LoadDisplay(new WikiMainPage
                 {
@@ -161,7 +161,7 @@ namespace osu.Game.Overlays
             path.Value = "error";
 
             LoadDisplay(articlePage = new WikiArticlePage($@"{api.WebsiteRootUrl}/wiki/",
-                $"Something went wrong when trying to fetch page \"{originalPath}\".\n\n[Return to the main page](Main_Page)."));
+                $"Something went wrong when trying to fetch page \"{originalPath}\".\n\n[Return to the main page]({INDEX_PATH})."));
         }
 
         private void showParentPage()

osu.Game/Rulesets/Edit/DrawableEditorRulesetWrapper.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.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
@@ -26,6 +27,9 @@ namespace osu.Game.Rulesets.Edit
         [Resolved]
         private EditorBeatmap beatmap { get; set; } = null!;
 
+        [Resolved]
+        private EditorClock editorClock { get; set; } = null!;
+
         public DrawableEditorRulesetWrapper(DrawableRuleset<TObject> drawableRuleset)
         {
             this.drawableRuleset = drawableRuleset;
@@ -38,7 +42,6 @@ namespace osu.Game.Rulesets.Edit
         [BackgroundDependencyLoader]
         private void load()
         {
-            drawableRuleset.FrameStablePlayback = false;
             Playfield.DisplayJudgements.Value = false;
         }
 
@@ -65,6 +68,22 @@ namespace osu.Game.Rulesets.Edit
             Scheduler.AddOnce(regenerateAutoplay);
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            // Whenever possible, we want to stay in frame stability playback.
+            // Without doing so, we run into bugs with some gameplay elements not behaving as expected.
+            //
+            // Note that this is not using EditorClock.IsSeeking as that would exit frame stability
+            // on all seeks. The intention here is to retain frame stability for small seeks.
+            //
+            // I still think no gameplay elements should require frame stability in the first place, but maybe that ship has sailed already..
+            bool shouldBypassFrameStability = Math.Abs(drawableRuleset.FrameStableClock.CurrentTime - editorClock.CurrentTime) > 1000;
+
+            drawableRuleset.FrameStablePlayback = !shouldBypassFrameStability;
+        }
+
         private void regenerateAutoplay()
         {
             var autoplayMod = drawableRuleset.Mods.OfType<ModAutoplay>().Single();

osu.Game/Rulesets/Mods/ModCinema.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModCinema;
         public override LocalisableString Description => "Watch the video without visual distractions.";
 
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(ModAutoplay), typeof(ModNoFail) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(ModAutoplay), typeof(ModNoFail), typeof(ModFailCondition) }).ToArray();
 
         public void ApplyToHUD(HUDOverlay overlay)
         {

osu.Game/Rulesets/Mods/ModFailCondition.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Mods
 {
     public abstract class ModFailCondition : Mod, IApplicableToHealthProcessor, IApplicableFailOverride
     {
-        public override Type[] IncompatibleMods => new[] { typeof(ModNoFail) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModNoFail), typeof(ModCinema) };
 
         [SettingSource("Restart on fail", "Automatically restarts when failed.")]
         public BindableBool Restart { get; } = new BindableBool();

osu.Game/Rulesets/Mods/ModFlashlight.cs

@@ -56,9 +56,6 @@ namespace osu.Game.Rulesets.Mods
         public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
         {
             Combo.BindTo(scoreProcessor.Combo);
-
-            // Default value of ScoreProcessor's Rank in Flashlight Mod should be SS+
-            scoreProcessor.Rank.Value = ScoreRank.XH;
         }
 
         public ScoreRank AdjustRank(ScoreRank rank, double accuracy)

osu.Game/Rulesets/Mods/ModHidden.cs

@@ -17,8 +17,6 @@ namespace osu.Game.Rulesets.Mods
 
         public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
         {
-            // Default value of ScoreProcessor's Rank in Hidden Mod should be SS+
-            scoreProcessor.Rank.Value = ScoreRank.XH;
         }
 
         public ScoreRank AdjustRank(ScoreRank rank, double accuracy)

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -86,7 +86,9 @@ namespace osu.Game.Rulesets.Scoring
         /// <summary>
         /// The current rank.
         /// </summary>
-        public readonly Bindable<ScoreRank> Rank = new Bindable<ScoreRank>(ScoreRank.X);
+        public IBindable<ScoreRank> Rank => rank;
+
+        private readonly Bindable<ScoreRank> rank = new Bindable<ScoreRank>(ScoreRank.X);
 
         /// <summary>
         /// The highest combo achieved by this score.
@@ -186,9 +188,13 @@ namespace osu.Game.Rulesets.Scoring
             Combo.ValueChanged += combo => HighestCombo.Value = Math.Max(HighestCombo.Value, combo.NewValue);
             Accuracy.ValueChanged += accuracy =>
             {
-                Rank.Value = RankFromAccuracy(accuracy.NewValue);
+                // Once failed, we shouldn't update the rank anymore.
+                if (rank.Value == ScoreRank.F)
+                    return;
+
+                rank.Value = RankFromAccuracy(accuracy.NewValue);
                 foreach (var mod in Mods.Value.OfType<IApplicableToScoreProcessor>())
-                    Rank.Value = mod.AdjustRank(Rank.Value, accuracy.NewValue);
+                    rank.Value = mod.AdjustRank(Rank.Value, accuracy.NewValue);
             };
 
             Mods.ValueChanged += mods =>
@@ -411,8 +417,7 @@ namespace osu.Game.Rulesets.Scoring
             TotalScore.Value = 0;
             Accuracy.Value = 1;
             Combo.Value = 0;
-            Rank.Disabled = false;
-            Rank.Value = ScoreRank.X;
+            rank.Value = ScoreRank.X;
             HighestCombo.Value = 0;
         }
 
@@ -448,7 +453,7 @@ namespace osu.Game.Rulesets.Scoring
                 return;
 
             score.Passed = false;
-            Rank.Value = ScoreRank.F;
+            rank.Value = ScoreRank.F;
 
             PopulateScore(score);
         }

osu.Game/Scoring/Legacy/LegacyScoreEncoder.cs

@@ -36,10 +36,11 @@ namespace osu.Game.Scoring.Legacy
         /// <item><description>30000007: Adjust osu!mania combo and accuracy portions and judgement scoring values. Reconvert all scores.</description></item>
         /// <item><description>30000008: Add accuracy conversion. Reconvert all scores.</description></item>
         /// <item><description>30000009: Fix edge cases in conversion for scores which have 0.0x mod multiplier on stable. Reconvert all scores.</description></item>
-        /// <item><description>30000010: Re-do catch scoring to mirror stable Score V2 as closely as feasible. Reconvert all scores.</description></item>
+        /// <item><description>30000010: Fix mania score V1 conversion using score V1 accuracy rather than V2 accuracy. Reconvert all scores.</description></item>
+        /// <item><description>30000011: Re-do catch scoring to mirror stable Score V2 as closely as feasible. Reconvert all scores.</description></item>
         /// </list>
         /// </remarks>
-        public const int LATEST_VERSION = 30000010;
+        public const int LATEST_VERSION = 30000011;
 
         /// <summary>
         /// The first stable-compatible YYYYMMDD format version given to lazer usage of replays.

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

@@ -62,6 +62,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         protected override bool OnDragStart(DragStartEvent e)
         {
+            if (e.Button != MouseButton.Left)
+                return false;
+
             if (rotationHandler == null) return false;
 
             rotationHandler.Begin();

osu.Game/Screens/Menu/IntroScreen.cs

@@ -95,6 +95,8 @@ namespace osu.Game.Screens.Menu
             Colour = Color4.Black
         };
 
+        public override bool? AllowGlobalTrackControl => false;
+
         protected IntroScreen([CanBeNull] Func<MainMenu> createNextScreen = null)
         {
             this.createNextScreen = createNextScreen;

osu.Game/Screens/Menu/MainMenu.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Diagnostics;
+using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -25,6 +26,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.IO;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Dialog;
 using osu.Game.Overlays.SkinEditor;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Backgrounds;
@@ -49,6 +51,8 @@ namespace osu.Game.Screens.Menu
 
         public override bool AllowExternalScreenChange => true;
 
+        public override bool? AllowGlobalTrackControl => true;
+
         private Screen songSelect;
 
         private MenuSideFlashes sideFlashes;
@@ -390,7 +394,12 @@ namespace osu.Game.Screens.Menu
             if (requiresConfirmation)
             {
                 if (dialogOverlay.CurrentDialog is ConfirmExitDialog exitDialog)
-                    exitDialog.PerformOkAction();
+                {
+                    if (exitDialog.Buttons.OfType<PopupDialogOkButton>().FirstOrDefault() != null)
+                        exitDialog.PerformOkAction();
+                    else
+                        exitDialog.Flash();
+                }
                 else
                 {
                     dialogOverlay.Push(new ConfirmExitDialog(() =>

osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs

@@ -349,6 +349,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             addItemButton.Alpha = localUserCanAddItem ? 1 : 0;
 
             Scheduler.AddOnce(UpdateMods);
+
+            Activity.Value = new UserActivity.InLobby(Room);
         }
 
         private bool localUserCanAddItem => client.IsHost || Room.QueueMode.Value != QueueMode.HostOnly;

osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs

@@ -26,9 +26,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
     {
         protected override bool PauseOnFocusLost => false;
 
-        // Disallow fails in multiplayer for now.
-        protected override bool CheckModsAllowFailure() => false;
-
         protected override UserActivity InitialActivity => new UserActivity.InMultiplayerGame(Beatmap.Value.BeatmapInfo, Ruleset.Value);
 
         [Resolved]
@@ -55,6 +52,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             {
                 AllowPause = false,
                 AllowRestart = false,
+                AllowFailAnimation = false,
                 AllowSkipping = room.AutoSkip.Value,
                 AutomaticallySkipIntro = room.AutoSkip.Value,
                 AlwaysShowLeaderboard = true,

osu.Game/Screens/Play/BreakOverlay.cs

@@ -4,12 +4,14 @@
 #nullable disable
 
 using System.Collections.Generic;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Screens.Play.Break;
 
 namespace osu.Game.Screens.Play
@@ -113,7 +115,7 @@ namespace osu.Game.Screens.Play
             if (scoreProcessor != null)
             {
                 info.AccuracyDisplay.Current.BindTo(scoreProcessor.Accuracy);
-                info.GradeDisplay.Current.BindTo(scoreProcessor.Rank);
+                ((IBindable<ScoreRank>)info.GradeDisplay.Current).BindTo(scoreProcessor.Rank);
             }
         }
 

osu.Game/Screens/Play/GameplayState.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Screens.Play
         public bool HasPassed { get; set; }
 
         /// <summary>
-        /// Whether the user failed during gameplay.
+        /// Whether the user failed during gameplay. This is only set when the gameplay session has completed due to the fail.
         /// </summary>
         public bool HasFailed { get; set; }
 

osu.Game/Screens/Play/MasterGameplayClockContainer.cs

@@ -40,6 +40,12 @@ namespace osu.Game.Screens.Play
             Precision = 0.1,
         };
 
+        /// <summary>
+        /// Whether the audio playback rate should be validated.
+        /// Mostly disabled for tests.
+        /// </summary>
+        internal bool ShouldValidatePlaybackRate { get; init; } = true;
+
         /// <summary>
         /// Whether the audio playback is within acceptable ranges.
         /// Will become false if audio playback is not going as expected.
@@ -223,6 +229,9 @@ namespace osu.Game.Screens.Play
 
         private void checkPlaybackValidity()
         {
+            if (!ShouldValidatePlaybackRate)
+                return;
+
             if (GameplayClock.IsRunning)
             {
                 elapsedGameplayClockTime += GameplayClock.ElapsedFrameTime;

osu.Game/Screens/Play/Player.cs

@@ -735,7 +735,7 @@ namespace osu.Game.Screens.Play
             }
 
             // Only show the completion screen if the player hasn't failed
-            if (HealthProcessor.HasFailed)
+            if (GameplayState.HasFailed)
                 return;
 
             GameplayState.HasPassed = true;
@@ -801,8 +801,6 @@ namespace osu.Game.Screens.Play
                     // This player instance may already be in the process of exiting.
                     return;
 
-                Debug.Assert(ScoreProcessor.Rank.Value != ScoreRank.F);
-
                 this.Push(CreateResults(prepareScoreForDisplayTask.GetResultSafely()));
             }, Time.Current + delay, 50);
 
@@ -924,37 +922,44 @@ namespace osu.Game.Screens.Play
             if (!CheckModsAllowFailure())
                 return false;
 
-            Debug.Assert(!GameplayState.HasFailed);
-            Debug.Assert(!GameplayState.HasPassed);
-            Debug.Assert(!GameplayState.HasQuit);
+            if (Configuration.AllowFailAnimation)
+            {
+                Debug.Assert(!GameplayState.HasFailed);
+                Debug.Assert(!GameplayState.HasPassed);
+                Debug.Assert(!GameplayState.HasQuit);
 
-            GameplayState.HasFailed = true;
+                GameplayState.HasFailed = true;
 
-            updateGameplayState();
+                updateGameplayState();
 
-            // There is a chance that we could be in a paused state as the ruleset's internal clock (see FrameStabilityContainer)
-            // could process an extra frame after the GameplayClock is stopped.
-            // In such cases we want the fail state to precede a user triggered pause.
-            if (PauseOverlay.State.Value == Visibility.Visible)
-                PauseOverlay.Hide();
+                // There is a chance that we could be in a paused state as the ruleset's internal clock (see FrameStabilityContainer)
+                // could process an extra frame after the GameplayClock is stopped.
+                // In such cases we want the fail state to precede a user triggered pause.
+                if (PauseOverlay.State.Value == Visibility.Visible)
+                    PauseOverlay.Hide();
 
-            failAnimationContainer.Start();
+                failAnimationContainer.Start();
 
-            // Failures can be triggered either by a judgement, or by a mod.
-            //
-            // For the case of a judgement, due to ordering considerations, ScoreProcessor will not have received
-            // the final judgement which triggered the failure yet (see DrawableRuleset.NewResult handling above).
-            //
-            // A schedule here ensures that any lingering judgements from the current frame are applied before we
-            // finalise the score as "failed".
-            Schedule(() =>
+                // Failures can be triggered either by a judgement, or by a mod.
+                //
+                // For the case of a judgement, due to ordering considerations, ScoreProcessor will not have received
+                // the final judgement which triggered the failure yet (see DrawableRuleset.NewResult handling above).
+                //
+                // A schedule here ensures that any lingering judgements from the current frame are applied before we
+                // finalise the score as "failed".
+                Schedule(() =>
+                {
+                    ScoreProcessor.FailScore(Score.ScoreInfo);
+                    OnFail();
+
+                    if (GameplayState.Mods.OfType<IApplicableFailOverride>().Any(m => m.RestartOnFail))
+                        Restart(true);
+                });
+            }
+            else
             {
                 ScoreProcessor.FailScore(Score.ScoreInfo);
-                OnFail();
-
-                if (GameplayState.Mods.OfType<IApplicableFailOverride>().Any(m => m.RestartOnFail))
-                    Restart(true);
-            });
+            }
 
             return true;
         }

osu.Game/Screens/Play/PlayerConfiguration.cs

@@ -15,6 +15,12 @@ namespace osu.Game.Screens.Play
         /// </summary>
         public bool ShowResults { get; set; } = true;
 
+        /// <summary>
+        /// Whether the fail animation / screen should be triggered on failing.
+        /// If false, the score will still be marked as failed but gameplay will continue.
+        /// </summary>
+        public bool AllowFailAnimation { get; set; } = true;
+
         /// <summary>
         /// Whether the player should be allowed to trigger a restart.
         /// </summary>

osu.Game/Screens/Play/SubmittingPlayer.cs

@@ -41,6 +41,7 @@ namespace osu.Game.Screens.Play
         [Resolved]
         private SessionStatics statics { get; set; }
 
+        private readonly object scoreSubmissionLock = new object();
         private TaskCompletionSource<bool> scoreSubmissionSource;
 
         protected SubmittingPlayer(PlayerConfiguration configuration = null)
@@ -228,16 +229,19 @@ namespace osu.Game.Screens.Play
                 return Task.CompletedTask;
             }
 
-            if (scoreSubmissionSource != null)
-                return scoreSubmissionSource.Task;
+            lock (scoreSubmissionLock)
+            {
+                if (scoreSubmissionSource != null)
+                    return scoreSubmissionSource.Task;
+
+                scoreSubmissionSource = new TaskCompletionSource<bool>();
+            }
 
             // if the user never hit anything, this score should not be counted in any way.
             if (!score.ScoreInfo.Statistics.Any(s => s.Key.IsHit() && s.Value > 0))
                 return Task.CompletedTask;
 
             Logger.Log($"Beginning score submission (token:{token.Value})...");
-
-            scoreSubmissionSource = new TaskCompletionSource<bool>();
             var request = CreateSubmissionRequest(score, token.Value);
 
             request.Success += s =>

osu.Game/Screens/Ranking/Statistics/SoloStatisticsPanel.cs

@@ -37,7 +37,6 @@ namespace osu.Game.Screens.Ranking.Statistics
                     RelativeSizeAxes = Axes.X,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Width = 0.5f,
                     StatisticsUpdate = { BindTarget = StatisticsUpdate }
                 })).ToArray();
             }

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -96,18 +96,19 @@ namespace osu.Game.Screens.Select
         /// <summary>
         /// Extend the range to retain already loaded pooled drawables.
         /// </summary>
-        private const float distance_offscreen_before_unload = 1024;
+        private const float distance_offscreen_before_unload = 2048;
 
         /// <summary>
         /// Extend the range to update positions / retrieve pooled drawables outside of visible range.
         /// </summary>
-        private const float distance_offscreen_to_preload = 512; // todo: adjust this appropriately once we can make set panel contents load while off-screen.
+        private const float distance_offscreen_to_preload = 768;
 
         /// <summary>
         /// Whether carousel items have completed asynchronously loaded.
         /// </summary>
         public bool BeatmapSetsLoaded { get; private set; }
 
+        [Cached]
         protected readonly CarouselScrollContainer Scroll;
 
         private readonly NoResultsPlaceholder noResultsPlaceholder;
@@ -1251,7 +1252,7 @@ namespace osu.Game.Screens.Select
             }
         }
 
-        protected partial class CarouselScrollContainer : UserTrackingScrollContainer<DrawableCarouselItem>
+        public partial class CarouselScrollContainer : UserTrackingScrollContainer<DrawableCarouselItem>
         {
             private bool rightMouseScrollBlocked;
 

osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs

@@ -5,11 +5,14 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -46,6 +49,8 @@ namespace osu.Game.Screens.Select.Carousel
 
         private MenuItem[]? mainMenuItems;
 
+        private double timeSinceUnpool;
+
         [Resolved]
         private BeatmapManager manager { get; set; } = null!;
 
@@ -54,6 +59,7 @@ namespace osu.Game.Screens.Select.Carousel
             base.FreeAfterUse();
 
             Item = null;
+            timeSinceUnpool = 0;
 
             ClearTransforms();
         }
@@ -92,13 +98,21 @@ namespace osu.Game.Screens.Select.Carousel
                 // algorithm for this is taken from ScrollContainer.
                 // while it doesn't necessarily need to match 1:1, as we are emulating scroll in some cases this feels most correct.
                 Y = (float)Interpolation.Lerp(targetY, Y, Math.Exp(-0.01 * Time.Elapsed));
+
+            loadContentIfRequired();
         }
 
+        private CancellationTokenSource? loadCancellation;
+
         protected override void UpdateItem()
         {
+            loadCancellation?.Cancel();
+            loadCancellation = null;
+
             base.UpdateItem();
 
             Content.Clear();
+            Header.Clear();
 
             beatmapContainer = null;
             beatmapsLoadTask = null;
@@ -107,32 +121,8 @@ namespace osu.Game.Screens.Select.Carousel
                 return;
 
             beatmapSet = ((CarouselBeatmapSet)Item).BeatmapSet;
-
-            DelayedLoadWrapper background;
-            DelayedLoadWrapper mainFlow;
-
-            Header.Children = new Drawable[]
-            {
-                // Choice of background image matches BSS implementation (always uses the lowest `beatmap_id` from the set).
-                background = new DelayedLoadWrapper(() => new SetPanelBackground(manager.GetWorkingBeatmap(beatmapSet.Beatmaps.MinBy(b => b.OnlineID)))
-                {
-                    RelativeSizeAxes = Axes.Both,
-                }, 200)
-                {
-                    RelativeSizeAxes = Axes.Both
-                },
-                mainFlow = new DelayedLoadWrapper(() => new SetPanelContent((CarouselBeatmapSet)Item), 50)
-                {
-                    RelativeSizeAxes = Axes.Both
-                },
-            };
-
-            background.DelayedLoadComplete += fadeContentIn;
-            mainFlow.DelayedLoadComplete += fadeContentIn;
         }
 
-        private void fadeContentIn(Drawable d) => d.FadeInFromZero(150);
-
         protected override void Deselected()
         {
             base.Deselected();
@@ -190,6 +180,56 @@ namespace osu.Game.Screens.Select.Carousel
             }
         }
 
+        [Resolved]
+        private BeatmapCarousel.CarouselScrollContainer scrollContainer { get; set; } = null!;
+
+        private void loadContentIfRequired()
+        {
+            Quad containingSsdq = scrollContainer.ScreenSpaceDrawQuad;
+
+            // Using DelayedLoadWrappers would only allow us to load content when on screen, but we want to preload while off-screen
+            // to provide a better user experience.
+
+            // This is tracking time that this drawable is updating since the last pool.
+            // This is intended to provide a debounce so very fast scrolls (from one end to the other of the carousel)
+            // don't cause huge overheads.
+            //
+            // We increase the delay based on distance from centre, so the beatmaps the user is currently looking at load first.
+            float timeUpdatingBeforeLoad = 50 + Math.Abs(containingSsdq.Centre.Y - ScreenSpaceDrawQuad.Centre.Y) / containingSsdq.Height * 100;
+
+            Debug.Assert(Item != null);
+
+            // A load is already in progress if the cancellation token is non-null.
+            if (loadCancellation != null)
+                return;
+
+            timeSinceUnpool += Time.Elapsed;
+
+            // We only trigger a load after this set has been in an updating state for a set amount of time.
+            if (timeSinceUnpool <= timeUpdatingBeforeLoad)
+                return;
+
+            loadCancellation = new CancellationTokenSource();
+
+            LoadComponentsAsync(new CompositeDrawable[]
+            {
+                // Choice of background image matches BSS implementation (always uses the lowest `beatmap_id` from the set).
+                new SetPanelBackground(manager.GetWorkingBeatmap(beatmapSet.Beatmaps.MinBy(b => b.OnlineID)))
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new SetPanelContent((CarouselBeatmapSet)Item)
+                {
+                    Depth = float.MinValue,
+                    RelativeSizeAxes = Axes.Both,
+                }
+            }, drawables =>
+            {
+                Header.AddRange(drawables);
+                drawables.ForEach(d => d.FadeInFromZero(150));
+            }, loadCancellation.Token);
+        }
+
         private void updateBeatmapYPositions()
         {
             if (beatmapContainer == null)

osu.Game/Screens/Select/FooterButtonMods.cs

@@ -19,6 +19,7 @@ using osu.Game.Graphics.Sprites;
 using osuTK;
 using osuTK.Graphics;
 using osu.Game.Input.Bindings;
+using osu.Game.Utils;
 
 namespace osu.Game.Screens.Select
 {
@@ -87,12 +88,11 @@ namespace osu.Game.Screens.Select
         private void updateMultiplierText() => Schedule(() =>
         {
             double multiplier = Current.Value?.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier) ?? 1;
+            MultiplierText.Text = multiplier == 1 ? string.Empty : ModUtils.FormatScoreMultiplier(multiplier);
 
-            MultiplierText.Text = multiplier.Equals(1.0) ? string.Empty : $"{multiplier:N2}x";
-
-            if (multiplier > 1.0)
+            if (multiplier > 1)
                 MultiplierText.FadeColour(highMultiplierColour, 200);
-            else if (multiplier < 1.0)
+            else if (multiplier < 1)
                 MultiplierText.FadeColour(lowMultiplierColour, 200);
             else
                 MultiplierText.FadeColour(Color4.White, 200);

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -146,6 +146,14 @@ namespace osu.Game.Screens.Select
             }
         }
 
+        public override void OnSuspending(ScreenTransitionEvent e)
+        {
+            // Scores will be refreshed on arriving at this screen.
+            // Clear them to avoid animation overload on returning to song select.
+            playBeatmapDetailArea.Leaderboard.ClearScores();
+            base.OnSuspending(e);
+        }
+
         public override void OnResuming(ScreenTransitionEvent e)
         {
             base.OnResuming(e);

osu.Game/Screens/Select/SongSelect.cs

@@ -660,7 +660,8 @@ namespace osu.Game.Screens.Select
 
             logo.Action = () =>
             {
-                FinaliseSelection();
+                if (this.IsCurrentScreen())
+                    FinaliseSelection();
                 return false;
             };
         }

osu.Game/Tests/Beatmaps/HitObjectSampleTest.cs

@@ -132,8 +132,8 @@ namespace osu.Game.Tests.Beatmaps
         public AudioManager AudioManager => Audio;
         public IResourceStore<byte[]> Files => userSkinResourceStore;
         public new IResourceStore<byte[]> Resources => base.Resources;
-        public IResourceStore<TextureUpload> CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => null;
-        RealmAccess IStorageResourceProvider.RealmAccess => null;
+        public IResourceStore<TextureUpload> CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => null!;
+        RealmAccess IStorageResourceProvider.RealmAccess => null!;
 
         #endregion
 

osu.Game/Tests/Visual/OsuGameTestScene.cs

@@ -58,6 +58,12 @@ namespace osu.Game.Tests.Visual
 
         [SetUpSteps]
         public virtual void SetUpSteps()
+        {
+            CreateNewGame();
+            ConfirmAtMainMenu();
+        }
+
+        protected void CreateNewGame()
         {
             AddStep("Create new game instance", () =>
             {
@@ -71,8 +77,6 @@ namespace osu.Game.Tests.Visual
 
             AddUntilStep("Wait for load", () => Game.IsLoaded);
             AddUntilStep("Wait for intro", () => Game.ScreenStack.CurrentScreen is IntroScreen);
-
-            ConfirmAtMainMenu();
         }
 
         [TearDownSteps]

osu.Game/Utils/ModUtils.cs

@@ -5,6 +5,8 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
@@ -226,5 +228,21 @@ namespace osu.Game.Utils
 
             return proposedWereValid;
         }
+
+        /// <summary>
+        /// Given a value of a score multiplier, returns a string version with special handling for a value near 1.00x.
+        /// </summary>
+        /// <param name="scoreMultiplier">The value of the score multiplier.</param>
+        /// <returns>A formatted score multiplier with a trailing "x" symbol</returns>
+        public static LocalisableString FormatScoreMultiplier(double scoreMultiplier)
+        {
+            // Round multiplier values away from 1.00x to two significant digits.
+            if (scoreMultiplier > 1)
+                scoreMultiplier = Math.Ceiling(Math.Round(scoreMultiplier * 100, 12)) / 100;
+            else
+                scoreMultiplier = Math.Floor(Math.Round(scoreMultiplier * 100, 12)) / 100;
+
+            return scoreMultiplier.ToLocalisableString("0.00x");
+        }
     }
 }