Merge pull request #18702 from nekodex/new-dialog-sfx

Add new dialog popup SFX

.config/dotnet-tools.json

@@ -21,7 +21,7 @@
       ]
     },
     "ppy.localisationanalyser.tools": {
-      "version": "2022.417.0",
+      "version": "2022.607.0",
       "commands": [
         "localisation"
       ]

osu.Android.props

@@ -51,8 +51,8 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.527.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.605.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2022.615.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.615.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
     <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->

osu.Desktop/DiscordRichPresence.cs

@@ -9,6 +9,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Logging;
+using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Extensions;
 using osu.Game.Online.API;
@@ -30,6 +31,9 @@ namespace osu.Desktop
 
         private IBindable<APIUser> user;
 
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
         private readonly IBindable<UserStatus> status = new Bindable<UserStatus>();
         private readonly IBindable<UserActivity> activity = new Bindable<UserActivity>();
 
@@ -41,7 +45,7 @@ namespace osu.Desktop
         };
 
         [BackgroundDependencyLoader]
-        private void load(IAPIProvider provider, OsuConfigManager config)
+        private void load(OsuConfigManager config)
         {
             client = new DiscordRpcClient(client_id)
             {
@@ -57,7 +61,8 @@ namespace osu.Desktop
 
             config.BindWith(OsuSetting.DiscordRichPresence, privacyMode);
 
-            (user = provider.LocalUser.GetBoundCopy()).BindValueChanged(u =>
+            user = api.LocalUser.GetBoundCopy();
+            user.BindValueChanged(u =>
             {
                 status.UnbindBindings();
                 status.BindTo(u.NewValue.Status);
@@ -95,6 +100,22 @@ namespace osu.Desktop
             {
                 presence.State = truncate(activity.Value.Status);
                 presence.Details = truncate(getDetails(activity.Value));
+
+                if (getBeatmap(activity.Value) is IBeatmapInfo beatmap && beatmap.OnlineID > 0)
+                {
+                    presence.Buttons = new[]
+                    {
+                        new Button
+                        {
+                            Label = "View beatmap",
+                            Url = $@"{api.WebsiteRootUrl}/beatmapsets/{beatmap.BeatmapSet?.OnlineID}#{ruleset.Value.ShortName}/{beatmap.OnlineID}"
+                        }
+                    };
+                }
+                else
+                {
+                    presence.Buttons = null;
+                }
             }
             else
             {
@@ -106,7 +127,12 @@ namespace osu.Desktop
             if (privacyMode.Value == DiscordRichPresenceMode.Limited)
                 presence.Assets.LargeImageText = string.Empty;
             else
-                presence.Assets.LargeImageText = $"{user.Value.Username}" + (user.Value.Statistics?.GlobalRank > 0 ? $" (rank #{user.Value.Statistics.GlobalRank:N0})" : string.Empty);
+            {
+                if (user.Value.RulesetsStatistics != null && user.Value.RulesetsStatistics.TryGetValue(ruleset.Value.ShortName, out UserStatistics statistics))
+                    presence.Assets.LargeImageText = $"{user.Value.Username}" + (statistics.GlobalRank > 0 ? $" (rank #{statistics.GlobalRank:N0})" : string.Empty);
+                else
+                    presence.Assets.LargeImageText = $"{user.Value.Username}" + (user.Value.Statistics?.GlobalRank > 0 ? $" (rank #{user.Value.Statistics.GlobalRank:N0})" : string.Empty);
+            }
 
             // update ruleset
             presence.Assets.SmallImageKey = ruleset.Value.IsLegacyRuleset() ? $"mode_{ruleset.Value.OnlineID}" : "mode_custom";
@@ -136,6 +162,20 @@ namespace osu.Desktop
             });
         }
 
+        private IBeatmapInfo getBeatmap(UserActivity activity)
+        {
+            switch (activity)
+            {
+                case UserActivity.InGame game:
+                    return game.BeatmapInfo;
+
+                case UserActivity.Editing edit:
+                    return edit.BeatmapInfo;
+            }
+
+            return null;
+        }
+
         private string getDetails(UserActivity activity)
         {
             switch (activity)

osu.Desktop/Program.cs

@@ -113,6 +113,9 @@ namespace osu.Desktop
             {
                 tools.CreateShortcutForThisExe();
                 tools.CreateUninstallerRegistryEntry();
+            }, onAppUpdate: (version, tools) =>
+            {
+                tools.CreateUninstallerRegistryEntry();
             }, onAppUninstall: (version, tools) =>
             {
                 tools.RemoveShortcutForThisExe();

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

@@ -49,6 +49,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         {
             CatchHitObject lastObject = null;
 
+            List<DifficultyHitObject> objects = new List<DifficultyHitObject>();
+
             // In 2B beatmaps, it is possible that a normal Fruit is placed in the middle of a JuiceStream.
             foreach (var hitObject in beatmap.HitObjects
                                              .SelectMany(obj => obj is JuiceStream stream ? stream.NestedHitObjects.AsEnumerable() : new[] { obj })
@@ -60,10 +62,12 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                     continue;
 
                 if (lastObject != null)
-                    yield return new CatchDifficultyHitObject(hitObject, lastObject, clockRate, halfCatcherWidth);
+                    objects.Add(new CatchDifficultyHitObject(hitObject, lastObject, clockRate, halfCatcherWidth, objects, objects.Count));
 
                 lastObject = hitObject;
             }
+
+            return objects;
         }
 
         protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clockRate)

osu.Game.Rulesets.Catch/Difficulty/Preprocessing/CatchDifficultyHitObject.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Objects;
@@ -24,8 +25,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
         /// </summary>
         public readonly double StrainTime;
 
-        public CatchDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, float halfCatcherWidth)
-            : base(hitObject, lastObject, clockRate)
+        public CatchDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, float halfCatcherWidth, List<DifficultyHitObject> objects, int index)
+            : base(hitObject, lastObject, clockRate, objects, index)
         {
             // We will scale everything by this factor, so we can assume a uniform CircleSize among beatmaps.
             float scalingFactor = normalized_hitobject_radius / halfCatcherWidth;

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs

@@ -70,8 +70,12 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             LegacySortHelper<HitObject>.Sort(sortedObjects, Comparer<HitObject>.Create((a, b) => (int)Math.Round(a.StartTime) - (int)Math.Round(b.StartTime)));
 
+            List<DifficultyHitObject> objects = new List<DifficultyHitObject>();
+
             for (int i = 1; i < sortedObjects.Length; i++)
-                yield return new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate);
+                objects.Add(new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate, objects, objects.Count));
+
+            return objects;
         }
 
         // Sorting is done in CreateDifficultyHitObjects, since the full list of hitobjects is required.

osu.Game.Rulesets.Mania/Difficulty/Preprocessing/ManiaDifficultyHitObject.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
@@ -11,8 +12,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Preprocessing
     {
         public new ManiaHitObject BaseObject => (ManiaHitObject)base.BaseObject;
 
-        public ManiaDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate)
-            : base(hitObject, lastObject, clockRate)
+        public ManiaDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, List<DifficultyHitObject> objects, int index)
+            : base(hitObject, lastObject, clockRate, objects, index)
         {
         }
     }

osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs

@@ -84,9 +84,9 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
             return individualStrain + overallStrain - CurrentStrain;
         }
 
-        protected override double CalculateInitialStrain(double offset)
-            => applyDecay(individualStrain, offset - Previous[0].StartTime, individual_decay_base)
-               + applyDecay(overallStrain, offset - Previous[0].StartTime, overall_decay_base);
+        protected override double CalculateInitialStrain(double offset, DifficultyHitObject current)
+            => applyDecay(individualStrain, offset - current.Previous(0).StartTime, individual_decay_base)
+               + applyDecay(overallStrain, offset - current.Previous(0).StartTime, overall_decay_base);
 
         private double applyDecay(double value, double deltaTime, double decayBase)
             => value * Math.Pow(decayBase, deltaTime / 1000);

osu.Game.Rulesets.Osu/Difficulty/Evaluators/AimEvaluator.cs

@@ -0,0 +1,141 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
+{
+    public static class AimEvaluator
+    {
+        private const double wide_angle_multiplier = 1.5;
+        private const double acute_angle_multiplier = 2.0;
+        private const double slider_multiplier = 1.5;
+        private const double velocity_change_multiplier = 0.75;
+
+        /// <summary>
+        /// Evaluates the difficulty of aiming the current object, based on:
+        /// <list type="bullet">
+        /// <item><description>cursor velocity to the current object,</description></item>
+        /// <item><description>angle difficulty,</description></item>
+        /// <item><description>sharp velocity increases,</description></item>
+        /// <item><description>and slider difficulty.</description></item>
+        /// </list>
+        /// </summary>
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, bool withSliders)
+        {
+            if (current.BaseObject is Spinner || current.Index <= 1 || current.Previous(0).BaseObject is Spinner)
+                return 0;
+
+            var osuCurrObj = (OsuDifficultyHitObject)current;
+            var osuLastObj = (OsuDifficultyHitObject)current.Previous(0);
+            var osuLastLastObj = (OsuDifficultyHitObject)current.Previous(1);
+
+            // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
+            double currVelocity = osuCurrObj.LazyJumpDistance / osuCurrObj.StrainTime;
+
+            // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
+            if (osuLastObj.BaseObject is Slider && withSliders)
+            {
+                double travelVelocity = osuLastObj.TravelDistance / osuLastObj.TravelTime; // calculate the slider velocity from slider head to slider end.
+                double movementVelocity = osuCurrObj.MinimumJumpDistance / osuCurrObj.MinimumJumpTime; // calculate the movement velocity from slider end to current object
+
+                currVelocity = Math.Max(currVelocity, movementVelocity + travelVelocity); // take the larger total combined velocity.
+            }
+
+            // As above, do the same for the previous hitobject.
+            double prevVelocity = osuLastObj.LazyJumpDistance / osuLastObj.StrainTime;
+
+            if (osuLastLastObj.BaseObject is Slider && withSliders)
+            {
+                double travelVelocity = osuLastLastObj.TravelDistance / osuLastLastObj.TravelTime;
+                double movementVelocity = osuLastObj.MinimumJumpDistance / osuLastObj.MinimumJumpTime;
+
+                prevVelocity = Math.Max(prevVelocity, movementVelocity + travelVelocity);
+            }
+
+            double wideAngleBonus = 0;
+            double acuteAngleBonus = 0;
+            double sliderBonus = 0;
+            double velocityChangeBonus = 0;
+
+            double aimStrain = currVelocity; // Start strain with regular velocity.
+
+            if (Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime) < 1.25 * Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime)) // If rhythms are the same.
+            {
+                if (osuCurrObj.Angle != null && osuLastObj.Angle != null && osuLastLastObj.Angle != null)
+                {
+                    double currAngle = osuCurrObj.Angle.Value;
+                    double lastAngle = osuLastObj.Angle.Value;
+                    double lastLastAngle = osuLastLastObj.Angle.Value;
+
+                    // Rewarding angles, take the smaller velocity as base.
+                    double angleBonus = Math.Min(currVelocity, prevVelocity);
+
+                    wideAngleBonus = calcWideAngleBonus(currAngle);
+                    acuteAngleBonus = calcAcuteAngleBonus(currAngle);
+
+                    if (osuCurrObj.StrainTime > 100) // Only buff deltaTime exceeding 300 bpm 1/2.
+                        acuteAngleBonus = 0;
+                    else
+                    {
+                        acuteAngleBonus *= calcAcuteAngleBonus(lastAngle) // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
+                                           * Math.Min(angleBonus, 125 / osuCurrObj.StrainTime) // The maximum velocity we buff is equal to 125 / strainTime
+                                           * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, (100 - osuCurrObj.StrainTime) / 25)), 2) // scale buff from 150 bpm 1/4 to 200 bpm 1/4
+                                           * Math.Pow(Math.Sin(Math.PI / 2 * (Math.Clamp(osuCurrObj.LazyJumpDistance, 50, 100) - 50) / 50), 2); // Buff distance exceeding 50 (radius) up to 100 (diameter).
+                    }
+
+                    // Penalize wide angles if they're repeated, reducing the penalty as the lastAngle gets more acute.
+                    wideAngleBonus *= angleBonus * (1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3)));
+                    // Penalize acute angles if they're repeated, reducing the penalty as the lastLastAngle gets more obtuse.
+                    acuteAngleBonus *= 0.5 + 0.5 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastLastAngle), 3)));
+                }
+            }
+
+            if (Math.Max(prevVelocity, currVelocity) != 0)
+            {
+                // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
+                prevVelocity = (osuLastObj.LazyJumpDistance + osuLastLastObj.TravelDistance) / osuLastObj.StrainTime;
+                currVelocity = (osuCurrObj.LazyJumpDistance + osuLastObj.TravelDistance) / osuCurrObj.StrainTime;
+
+                // Scale with ratio of difference compared to 0.5 * max dist.
+                double distRatio = Math.Pow(Math.Sin(Math.PI / 2 * Math.Abs(prevVelocity - currVelocity) / Math.Max(prevVelocity, currVelocity)), 2);
+
+                // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
+                double overlapVelocityBuff = Math.Min(125 / Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime), Math.Abs(prevVelocity - currVelocity));
+
+                // Reward for % distance slowed down compared to previous, paying attention to not award overlap
+                double nonOverlapVelocityBuff = Math.Abs(prevVelocity - currVelocity)
+                                                // do not award overlap
+                                                * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, Math.Min(osuCurrObj.LazyJumpDistance, osuLastObj.LazyJumpDistance) / 100)), 2);
+
+                // Choose the largest bonus, multiplied by ratio.
+                velocityChangeBonus = Math.Max(overlapVelocityBuff, nonOverlapVelocityBuff) * distRatio;
+
+                // Penalize for rhythm changes.
+                velocityChangeBonus *= Math.Pow(Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime) / Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime), 2);
+            }
+
+            if (osuLastObj.TravelTime != 0)
+            {
+                // Reward sliders based on velocity.
+                sliderBonus = osuLastObj.TravelDistance / osuLastObj.TravelTime;
+            }
+
+            // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
+            aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier + velocityChangeBonus * velocity_change_multiplier);
+
+            // Add in additional slider velocity bonus.
+            if (withSliders)
+                aimStrain += sliderBonus * slider_multiplier;
+
+            return aimStrain;
+        }
+
+        private static double calcWideAngleBonus(double angle) => Math.Pow(Math.Sin(3.0 / 4 * (Math.Min(5.0 / 6 * Math.PI, Math.Max(Math.PI / 6, angle)) - Math.PI / 6)), 2);
+
+        private static double calcAcuteAngleBonus(double angle) => 1 - calcWideAngleBonus(angle);
+    }
+}

osu.Game.Rulesets.Osu/Difficulty/Evaluators/FlashlightEvaluator.cs

@@ -0,0 +1,77 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
+{
+    public static class FlashlightEvaluator
+    {
+        private const double max_opacity_bonus = 0.4;
+        private const double hidden_bonus = 0.2;
+
+        /// <summary>
+        /// Evaluates the difficulty of memorising and hitting an object, based on:
+        /// <list type="bullet">
+        /// <item><description>distance between the previous and current object,</description></item>
+        /// <item><description>the visual opacity of the current object,</description></item>
+        /// <item><description>and whether the hidden mod is enabled.</description></item>
+        /// </list>
+        /// </summary>
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, bool hidden)
+        {
+            if (current.BaseObject is Spinner)
+                return 0;
+
+            var osuCurrent = (OsuDifficultyHitObject)current;
+            var osuHitObject = (OsuHitObject)(osuCurrent.BaseObject);
+
+            double scalingFactor = 52.0 / osuHitObject.Radius;
+            double smallDistNerf = 1.0;
+            double cumulativeStrainTime = 0.0;
+
+            double result = 0.0;
+
+            OsuDifficultyHitObject lastObj = osuCurrent;
+
+            // This is iterating backwards in time from the current object.
+            for (int i = 0; i < Math.Min(current.Index, 10); i++)
+            {
+                var currentObj = (OsuDifficultyHitObject)current.Previous(i);
+                var currentHitObject = (OsuHitObject)(currentObj.BaseObject);
+
+                if (!(currentObj.BaseObject is Spinner))
+                {
+                    double jumpDistance = (osuHitObject.StackedPosition - currentHitObject.EndPosition).Length;
+
+                    cumulativeStrainTime += lastObj.StrainTime;
+
+                    // We want to nerf objects that can be easily seen within the Flashlight circle radius.
+                    if (i == 0)
+                        smallDistNerf = Math.Min(1.0, jumpDistance / 75.0);
+
+                    // We also want to nerf stacks so that only the first object of the stack is accounted for.
+                    double stackNerf = Math.Min(1.0, (currentObj.LazyJumpDistance / scalingFactor) / 25.0);
+
+                    // Bonus based on how visible the object is.
+                    double opacityBonus = 1.0 + max_opacity_bonus * (1.0 - osuCurrent.OpacityAt(currentHitObject.StartTime, hidden));
+
+                    result += stackNerf * opacityBonus * scalingFactor * jumpDistance / cumulativeStrainTime;
+                }
+
+                lastObj = currentObj;
+            }
+
+            result = Math.Pow(smallDistNerf * result, 2.0);
+
+            // Additional bonus for Hidden due to there being no approach circles.
+            if (hidden)
+                result *= 1.0 + hidden_bonus;
+
+            return result;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs

@@ -0,0 +1,108 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
+{
+    public static class RhythmEvaluator
+    {
+        private const int history_time_max = 5000; // 5 seconds of calculatingRhythmBonus max.
+        private const double rhythm_multiplier = 0.75;
+
+        /// <summary>
+        /// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current <see cref="OsuDifficultyHitObject"/>.
+        /// </summary>
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, double greatWindow)
+        {
+            if (current.BaseObject is Spinner)
+                return 0;
+
+            int previousIslandSize = 0;
+
+            double rhythmComplexitySum = 0;
+            int islandSize = 1;
+            double startRatio = 0; // store the ratio of the current start of an island to buff for tighter rhythms
+
+            bool firstDeltaSwitch = false;
+
+            int historicalNoteCount = Math.Min(current.Index, 32);
+
+            int rhythmStart = 0;
+
+            while (rhythmStart < historicalNoteCount - 2 && current.StartTime - current.Previous(rhythmStart).StartTime < history_time_max)
+                rhythmStart++;
+
+            for (int i = rhythmStart; i > 0; i--)
+            {
+                OsuDifficultyHitObject currObj = (OsuDifficultyHitObject)current.Previous(i - 1);
+                OsuDifficultyHitObject prevObj = (OsuDifficultyHitObject)current.Previous(i);
+                OsuDifficultyHitObject lastObj = (OsuDifficultyHitObject)current.Previous(i + 1);
+
+                double currHistoricalDecay = (history_time_max - (current.StartTime - currObj.StartTime)) / history_time_max; // scales note 0 to 1 from history to now
+
+                currHistoricalDecay = Math.Min((double)(historicalNoteCount - i) / historicalNoteCount, currHistoricalDecay); // either we're limited by time or limited by object count.
+
+                double currDelta = currObj.StrainTime;
+                double prevDelta = prevObj.StrainTime;
+                double lastDelta = lastObj.StrainTime;
+                double currRatio = 1.0 + 6.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
+
+                double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - greatWindow * 0.6) / (greatWindow * 0.6));
+
+                windowPenalty = Math.Min(1, windowPenalty);
+
+                double effectiveRatio = windowPenalty * currRatio;
+
+                if (firstDeltaSwitch)
+                {
+                    if (!(prevDelta > 1.25 * currDelta || prevDelta * 1.25 < currDelta))
+                    {
+                        if (islandSize < 7)
+                            islandSize++; // island is still progressing, count size.
+                    }
+                    else
+                    {
+                        if (current.Previous(i - 1).BaseObject is Slider) // bpm change is into slider, this is easy acc window
+                            effectiveRatio *= 0.125;
+
+                        if (current.Previous(i).BaseObject is Slider) // bpm change was from a slider, this is easier typically than circle -> circle
+                            effectiveRatio *= 0.25;
+
+                        if (previousIslandSize == islandSize) // repeated island size (ex: triplet -> triplet)
+                            effectiveRatio *= 0.25;
+
+                        if (previousIslandSize % 2 == islandSize % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
+                            effectiveRatio *= 0.50;
+
+                        if (lastDelta > prevDelta + 10 && prevDelta > currDelta + 10) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
+                            effectiveRatio *= 0.125;
+
+                        rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay * Math.Sqrt(4 + islandSize) / 2 * Math.Sqrt(4 + previousIslandSize) / 2;
+
+                        startRatio = effectiveRatio;
+
+                        previousIslandSize = islandSize; // log the last island size.
+
+                        if (prevDelta * 1.25 < currDelta) // we're slowing down, stop counting
+                            firstDeltaSwitch = false; // if we're speeding up, this stays true and  we keep counting island size.
+
+                        islandSize = 1;
+                    }
+                }
+                else if (prevDelta > 1.25 * currDelta) // we want to be speeding up.
+                {
+                    // Begin counting island until we change speed again.
+                    firstDeltaSwitch = true;
+                    startRatio = effectiveRatio;
+                    islandSize = 1;
+                }
+            }
+
+            return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
+        }
+    }
+}

osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs

@@ -0,0 +1,59 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
+{
+    public static class SpeedEvaluator
+    {
+        private const double single_spacing_threshold = 125;
+        private const double min_speed_bonus = 75; // ~200BPM
+        private const double speed_balancing_factor = 40;
+
+        /// <summary>
+        /// Evaluates the difficulty of tapping the current object, based on:
+        /// <list type="bullet">
+        /// <item><description>time between pressing the previous and current object,</description></item>
+        /// <item><description>distance between those objects,</description></item>
+        /// <item><description>and how easily they can be cheesed.</description></item>
+        /// </list>
+        /// </summary>
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, double greatWindow)
+        {
+            if (current.BaseObject is Spinner)
+                return 0;
+
+            // derive strainTime for calculation
+            var osuCurrObj = (OsuDifficultyHitObject)current;
+            var osuPrevObj = current.Index > 0 ? (OsuDifficultyHitObject)current.Previous(0) : null;
+
+            double strainTime = osuCurrObj.StrainTime;
+            double greatWindowFull = greatWindow * 2;
+            double speedWindowRatio = strainTime / greatWindowFull;
+
+            // Aim to nerf cheesy rhythms (Very fast consecutive doubles with large deltatimes between)
+            if (osuPrevObj != null && strainTime < greatWindowFull && osuPrevObj.StrainTime > strainTime)
+                strainTime = Interpolation.Lerp(osuPrevObj.StrainTime, strainTime, speedWindowRatio);
+
+            // Cap deltatime to the OD 300 hitwindow.
+            // 0.93 is derived from making sure 260bpm OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
+            strainTime /= Math.Clamp((strainTime / greatWindowFull) / 0.93, 0.92, 1);
+
+            // derive speedBonus for calculation
+            double speedBonus = 1.0;
+
+            if (strainTime < min_speed_bonus)
+                speedBonus = 1 + 0.75 * Math.Pow((min_speed_bonus - strainTime) / speed_balancing_factor, 2);
+
+            double travelDistance = osuPrevObj?.TravelDistance ?? 0;
+            double distance = Math.Min(single_spacing_threshold, travelDistance + osuCurrObj.MinimumJumpDistance);
+
+            return (speedBonus + speedBonus * Math.Pow(distance / single_spacing_threshold, 3.5)) / strainTime;
+        }
+    }
+}

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

@@ -87,16 +87,17 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
+            List<DifficultyHitObject> objects = new List<DifficultyHitObject>();
+
             // The first jump is formed by the first two hitobjects of the map.
             // If the map has less than two OsuHitObjects, the enumerator will not return anything.
             for (int i = 1; i < beatmap.HitObjects.Count; i++)
             {
                 var lastLast = i > 1 ? beatmap.HitObjects[i - 2] : null;
-                var last = beatmap.HitObjects[i - 1];
-                var current = beatmap.HitObjects[i];
-
-                yield return new OsuDifficultyHitObject(current, lastLast, last, clockRate);
+                objects.Add(new OsuDifficultyHitObject(beatmap.HitObjects[i], beatmap.HitObjects[i - 1], lastLast, clockRate, objects, objects.Count));
             }
+
+            return objects;
         }
 
         protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clockRate)

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Mods;
@@ -74,8 +75,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         private readonly OsuHitObject lastLastObject;
         private readonly OsuHitObject lastObject;
 
-        public OsuDifficultyHitObject(HitObject hitObject, HitObject lastLastObject, HitObject lastObject, double clockRate)
-            : base(hitObject, lastObject, clockRate)
+        public OsuDifficultyHitObject(HitObject hitObject, HitObject lastObject, HitObject lastLastObject, double clockRate, List<DifficultyHitObject> objects, int index)
+            : base(hitObject, lastObject, clockRate, objects, index)
         {
             this.lastLastObject = (OsuHitObject)lastLastObject;
             this.lastObject = (OsuHitObject)lastObject;

osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs

@@ -4,8 +4,7 @@
 using System;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Difficulty.Evaluators;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 {
@@ -22,142 +21,19 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 
         private readonly bool withSliders;
 
-        protected override int HistoryLength => 2;
-
-        private const double wide_angle_multiplier = 1.5;
-        private const double acute_angle_multiplier = 2.0;
-        private const double slider_multiplier = 1.5;
-        private const double velocity_change_multiplier = 0.75;
-
         private double currentStrain;
 
         private double skillMultiplier => 23.25;
         private double strainDecayBase => 0.15;
 
-        private double strainValueOf(DifficultyHitObject current)
-        {
-            if (current.BaseObject is Spinner || Previous.Count <= 1 || Previous[0].BaseObject is Spinner)
-                return 0;
-
-            var osuCurrObj = (OsuDifficultyHitObject)current;
-            var osuLastObj = (OsuDifficultyHitObject)Previous[0];
-            var osuLastLastObj = (OsuDifficultyHitObject)Previous[1];
-
-            // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
-            double currVelocity = osuCurrObj.LazyJumpDistance / osuCurrObj.StrainTime;
-
-            // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
-            if (osuLastObj.BaseObject is Slider && withSliders)
-            {
-                double travelVelocity = osuLastObj.TravelDistance / osuLastObj.TravelTime; // calculate the slider velocity from slider head to slider end.
-                double movementVelocity = osuCurrObj.MinimumJumpDistance / osuCurrObj.MinimumJumpTime; // calculate the movement velocity from slider end to current object
-
-                currVelocity = Math.Max(currVelocity, movementVelocity + travelVelocity); // take the larger total combined velocity.
-            }
-
-            // As above, do the same for the previous hitobject.
-            double prevVelocity = osuLastObj.LazyJumpDistance / osuLastObj.StrainTime;
-
-            if (osuLastLastObj.BaseObject is Slider && withSliders)
-            {
-                double travelVelocity = osuLastLastObj.TravelDistance / osuLastLastObj.TravelTime;
-                double movementVelocity = osuLastObj.MinimumJumpDistance / osuLastObj.MinimumJumpTime;
-
-                prevVelocity = Math.Max(prevVelocity, movementVelocity + travelVelocity);
-            }
-
-            double wideAngleBonus = 0;
-            double acuteAngleBonus = 0;
-            double sliderBonus = 0;
-            double velocityChangeBonus = 0;
-
-            double aimStrain = currVelocity; // Start strain with regular velocity.
-
-            if (Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime) < 1.25 * Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime)) // If rhythms are the same.
-            {
-                if (osuCurrObj.Angle != null && osuLastObj.Angle != null && osuLastLastObj.Angle != null)
-                {
-                    double currAngle = osuCurrObj.Angle.Value;
-                    double lastAngle = osuLastObj.Angle.Value;
-                    double lastLastAngle = osuLastLastObj.Angle.Value;
-
-                    // Rewarding angles, take the smaller velocity as base.
-                    double angleBonus = Math.Min(currVelocity, prevVelocity);
-
-                    wideAngleBonus = calcWideAngleBonus(currAngle);
-                    acuteAngleBonus = calcAcuteAngleBonus(currAngle);
-
-                    if (osuCurrObj.StrainTime > 100) // Only buff deltaTime exceeding 300 bpm 1/2.
-                        acuteAngleBonus = 0;
-                    else
-                    {
-                        acuteAngleBonus *= calcAcuteAngleBonus(lastAngle) // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
-                                           * Math.Min(angleBonus, 125 / osuCurrObj.StrainTime) // The maximum velocity we buff is equal to 125 / strainTime
-                                           * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, (100 - osuCurrObj.StrainTime) / 25)), 2) // scale buff from 150 bpm 1/4 to 200 bpm 1/4
-                                           * Math.Pow(Math.Sin(Math.PI / 2 * (Math.Clamp(osuCurrObj.LazyJumpDistance, 50, 100) - 50) / 50), 2); // Buff distance exceeding 50 (radius) up to 100 (diameter).
-                    }
-
-                    // Penalize wide angles if they're repeated, reducing the penalty as the lastAngle gets more acute.
-                    wideAngleBonus *= angleBonus * (1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3)));
-                    // Penalize acute angles if they're repeated, reducing the penalty as the lastLastAngle gets more obtuse.
-                    acuteAngleBonus *= 0.5 + 0.5 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastLastAngle), 3)));
-                }
-            }
-
-            if (Math.Max(prevVelocity, currVelocity) != 0)
-            {
-                // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
-                prevVelocity = (osuLastObj.LazyJumpDistance + osuLastLastObj.TravelDistance) / osuLastObj.StrainTime;
-                currVelocity = (osuCurrObj.LazyJumpDistance + osuLastObj.TravelDistance) / osuCurrObj.StrainTime;
-
-                // Scale with ratio of difference compared to 0.5 * max dist.
-                double distRatio = Math.Pow(Math.Sin(Math.PI / 2 * Math.Abs(prevVelocity - currVelocity) / Math.Max(prevVelocity, currVelocity)), 2);
-
-                // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
-                double overlapVelocityBuff = Math.Min(125 / Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime), Math.Abs(prevVelocity - currVelocity));
-
-                // Reward for % distance slowed down compared to previous, paying attention to not award overlap
-                double nonOverlapVelocityBuff = Math.Abs(prevVelocity - currVelocity)
-                                                // do not award overlap
-                                                * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, Math.Min(osuCurrObj.LazyJumpDistance, osuLastObj.LazyJumpDistance) / 100)), 2);
-
-                // Choose the largest bonus, multiplied by ratio.
-                velocityChangeBonus = Math.Max(overlapVelocityBuff, nonOverlapVelocityBuff) * distRatio;
-
-                // Penalize for rhythm changes.
-                velocityChangeBonus *= Math.Pow(Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime) / Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime), 2);
-            }
-
-            if (osuLastObj.TravelTime != 0)
-            {
-                // Reward sliders based on velocity.
-                sliderBonus = osuLastObj.TravelDistance / osuLastObj.TravelTime;
-            }
-
-            // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
-            aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier + velocityChangeBonus * velocity_change_multiplier);
-
-            // Add in additional slider velocity bonus.
-            if (withSliders)
-                aimStrain += sliderBonus * slider_multiplier;
-
-            return aimStrain;
-        }
-
-        private double calcWideAngleBonus(double angle) => Math.Pow(Math.Sin(3.0 / 4 * (Math.Min(5.0 / 6 * Math.PI, Math.Max(Math.PI / 6, angle)) - Math.PI / 6)), 2);
-
-        private double calcAcuteAngleBonus(double angle) => 1 - calcWideAngleBonus(angle);
-
-        private double applyDiminishingExp(double val) => Math.Pow(val, 0.99);
-
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
 
-        protected override double CalculateInitialStrain(double time) => currentStrain * strainDecay(time - Previous[0].StartTime);
+        protected override double CalculateInitialStrain(double time, DifficultyHitObject current) => currentStrain * strainDecay(time - current.Previous(0).StartTime);
 
         protected override double StrainValueAt(DifficultyHitObject current)
         {
             currentStrain *= strainDecay(current.DeltaTime);
-            currentStrain += strainValueOf(current) * skillMultiplier;
+            currentStrain += AimEvaluator.EvaluateDifficultyOf(current, withSliders) * skillMultiplier;
 
             return currentStrain;
         }

osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs

@@ -5,9 +5,8 @@ using System;
 using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Difficulty.Evaluators;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 {
@@ -16,85 +15,28 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Flashlight : OsuStrainSkill
     {
+        private readonly bool hasHiddenMod;
+
         public Flashlight(Mod[] mods)
             : base(mods)
         {
-            hidden = mods.Any(m => m is OsuModHidden);
+            hasHiddenMod = mods.Any(m => m is OsuModHidden);
         }
 
         private double skillMultiplier => 0.05;
         private double strainDecayBase => 0.15;
         protected override double DecayWeight => 1.0;
-        protected override int HistoryLength => 10; // Look back for 10 notes is added for the sake of flashlight calculations.
-
-        private readonly bool hidden;
-
-        private const double max_opacity_bonus = 0.4;
-        private const double hidden_bonus = 0.2;
 
         private double currentStrain;
 
-        private double strainValueOf(DifficultyHitObject current)
-        {
-            if (current.BaseObject is Spinner)
-                return 0;
-
-            var osuCurrent = (OsuDifficultyHitObject)current;
-            var osuHitObject = (OsuHitObject)(osuCurrent.BaseObject);
-
-            double scalingFactor = 52.0 / osuHitObject.Radius;
-            double smallDistNerf = 1.0;
-            double cumulativeStrainTime = 0.0;
-
-            double result = 0.0;
-
-            OsuDifficultyHitObject lastObj = osuCurrent;
-
-            // This is iterating backwards in time from the current object.
-            for (int i = 0; i < Previous.Count; i++)
-            {
-                var currentObj = (OsuDifficultyHitObject)Previous[i];
-                var currentHitObject = (OsuHitObject)(currentObj.BaseObject);
-
-                if (!(currentObj.BaseObject is Spinner))
-                {
-                    double jumpDistance = (osuHitObject.StackedPosition - currentHitObject.EndPosition).Length;
-
-                    cumulativeStrainTime += lastObj.StrainTime;
-
-                    // We want to nerf objects that can be easily seen within the Flashlight circle radius.
-                    if (i == 0)
-                        smallDistNerf = Math.Min(1.0, jumpDistance / 75.0);
-
-                    // We also want to nerf stacks so that only the first object of the stack is accounted for.
-                    double stackNerf = Math.Min(1.0, (currentObj.LazyJumpDistance / scalingFactor) / 25.0);
-
-                    // Bonus based on how visible the object is.
-                    double opacityBonus = 1.0 + max_opacity_bonus * (1.0 - osuCurrent.OpacityAt(currentHitObject.StartTime, hidden));
-
-                    result += stackNerf * opacityBonus * scalingFactor * jumpDistance / cumulativeStrainTime;
-                }
-
-                lastObj = currentObj;
-            }
-
-            result = Math.Pow(smallDistNerf * result, 2.0);
-
-            // Additional bonus for Hidden due to there being no approach circles.
-            if (hidden)
-                result *= 1.0 + hidden_bonus;
-
-            return result;
-        }
-
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
 
-        protected override double CalculateInitialStrain(double time) => currentStrain * strainDecay(time - Previous[0].StartTime);
+        protected override double CalculateInitialStrain(double time, DifficultyHitObject current) => currentStrain * strainDecay(time - current.Previous(0).StartTime);
 
         protected override double StrainValueAt(DifficultyHitObject current)
         {
             currentStrain *= strainDecay(current.DeltaTime);
-            currentStrain += strainValueOf(current) * skillMultiplier;
+            currentStrain += FlashlightEvaluator.EvaluateDifficultyOf(current, hasHiddenMod) * skillMultiplier;
 
             return currentStrain;
         }

osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs

@@ -4,9 +4,7 @@
 using System;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Framework.Utils;
+using osu.Game.Rulesets.Osu.Difficulty.Evaluators;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 {
@@ -15,12 +13,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Speed : OsuStrainSkill
     {
-        private const double single_spacing_threshold = 125;
-        private const double rhythm_multiplier = 0.75;
-        private const int history_time_max = 5000; // 5 seconds of calculatingRhythmBonus max.
-        private const double min_speed_bonus = 75; // ~200BPM
-        private const double speed_balancing_factor = 40;
-
         private double skillMultiplier => 1375;
         private double strainDecayBase => 0.3;
 
@@ -29,8 +21,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 
         protected override int ReducedSectionCount => 5;
         protected override double DifficultyMultiplier => 1.04;
-        protected override int HistoryLength => 32;
-
         private readonly double greatWindow;
 
         public Speed(Mod[] mods, double hitWindowGreat)
@@ -39,139 +29,16 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
             greatWindow = hitWindowGreat;
         }
 
-        /// <summary>
-        /// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current <see cref="OsuDifficultyHitObject"/>.
-        /// </summary>
-        private double calculateRhythmBonus(DifficultyHitObject current)
-        {
-            if (current.BaseObject is Spinner)
-                return 0;
-
-            int previousIslandSize = 0;
-
-            double rhythmComplexitySum = 0;
-            int islandSize = 1;
-            double startRatio = 0; // store the ratio of the current start of an island to buff for tighter rhythms
-
-            bool firstDeltaSwitch = false;
-
-            int rhythmStart = 0;
-
-            while (rhythmStart < Previous.Count - 2 && current.StartTime - Previous[rhythmStart].StartTime < history_time_max)
-                rhythmStart++;
-
-            for (int i = rhythmStart; i > 0; i--)
-            {
-                OsuDifficultyHitObject currObj = (OsuDifficultyHitObject)Previous[i - 1];
-                OsuDifficultyHitObject prevObj = (OsuDifficultyHitObject)Previous[i];
-                OsuDifficultyHitObject lastObj = (OsuDifficultyHitObject)Previous[i + 1];
-
-                double currHistoricalDecay = (history_time_max - (current.StartTime - currObj.StartTime)) / history_time_max; // scales note 0 to 1 from history to now
-
-                currHistoricalDecay = Math.Min((double)(Previous.Count - i) / Previous.Count, currHistoricalDecay); // either we're limited by time or limited by object count.
-
-                double currDelta = currObj.StrainTime;
-                double prevDelta = prevObj.StrainTime;
-                double lastDelta = lastObj.StrainTime;
-                double currRatio = 1.0 + 6.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
-
-                double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - greatWindow * 0.6) / (greatWindow * 0.6));
-
-                windowPenalty = Math.Min(1, windowPenalty);
-
-                double effectiveRatio = windowPenalty * currRatio;
-
-                if (firstDeltaSwitch)
-                {
-                    if (!(prevDelta > 1.25 * currDelta || prevDelta * 1.25 < currDelta))
-                    {
-                        if (islandSize < 7)
-                            islandSize++; // island is still progressing, count size.
-                    }
-                    else
-                    {
-                        if (Previous[i - 1].BaseObject is Slider) // bpm change is into slider, this is easy acc window
-                            effectiveRatio *= 0.125;
-
-                        if (Previous[i].BaseObject is Slider) // bpm change was from a slider, this is easier typically than circle -> circle
-                            effectiveRatio *= 0.25;
-
-                        if (previousIslandSize == islandSize) // repeated island size (ex: triplet -> triplet)
-                            effectiveRatio *= 0.25;
-
-                        if (previousIslandSize % 2 == islandSize % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
-                            effectiveRatio *= 0.50;
-
-                        if (lastDelta > prevDelta + 10 && prevDelta > currDelta + 10) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
-                            effectiveRatio *= 0.125;
-
-                        rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay * Math.Sqrt(4 + islandSize) / 2 * Math.Sqrt(4 + previousIslandSize) / 2;
-
-                        startRatio = effectiveRatio;
-
-                        previousIslandSize = islandSize; // log the last island size.
-
-                        if (prevDelta * 1.25 < currDelta) // we're slowing down, stop counting
-                            firstDeltaSwitch = false; // if we're speeding up, this stays true and  we keep counting island size.
-
-                        islandSize = 1;
-                    }
-                }
-                else if (prevDelta > 1.25 * currDelta) // we want to be speeding up.
-                {
-                    // Begin counting island until we change speed again.
-                    firstDeltaSwitch = true;
-                    startRatio = effectiveRatio;
-                    islandSize = 1;
-                }
-            }
-
-            return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
-        }
-
-        private double strainValueOf(DifficultyHitObject current)
-        {
-            if (current.BaseObject is Spinner)
-                return 0;
-
-            // derive strainTime for calculation
-            var osuCurrObj = (OsuDifficultyHitObject)current;
-            var osuPrevObj = Previous.Count > 0 ? (OsuDifficultyHitObject)Previous[0] : null;
-
-            double strainTime = osuCurrObj.StrainTime;
-            double greatWindowFull = greatWindow * 2;
-            double speedWindowRatio = strainTime / greatWindowFull;
-
-            // Aim to nerf cheesy rhythms (Very fast consecutive doubles with large deltatimes between)
-            if (osuPrevObj != null && strainTime < greatWindowFull && osuPrevObj.StrainTime > strainTime)
-                strainTime = Interpolation.Lerp(osuPrevObj.StrainTime, strainTime, speedWindowRatio);
-
-            // Cap deltatime to the OD 300 hitwindow.
-            // 0.93 is derived from making sure 260bpm OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
-            strainTime /= Math.Clamp((strainTime / greatWindowFull) / 0.93, 0.92, 1);
-
-            // derive speedBonus for calculation
-            double speedBonus = 1.0;
-
-            if (strainTime < min_speed_bonus)
-                speedBonus = 1 + 0.75 * Math.Pow((min_speed_bonus - strainTime) / speed_balancing_factor, 2);
-
-            double travelDistance = osuPrevObj?.TravelDistance ?? 0;
-            double distance = Math.Min(single_spacing_threshold, travelDistance + osuCurrObj.MinimumJumpDistance);
-
-            return (speedBonus + speedBonus * Math.Pow(distance / single_spacing_threshold, 3.5)) / strainTime;
-        }
-
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
 
-        protected override double CalculateInitialStrain(double time) => (currentStrain * currentRhythm) * strainDecay(time - Previous[0].StartTime);
+        protected override double CalculateInitialStrain(double time, DifficultyHitObject current) => (currentStrain * currentRhythm) * strainDecay(time - current.Previous(0).StartTime);
 
         protected override double StrainValueAt(DifficultyHitObject current)
         {
             currentStrain *= strainDecay(current.DeltaTime);
-            currentStrain += strainValueOf(current) * skillMultiplier;
+            currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current, greatWindow) * skillMultiplier;
 
-            currentRhythm = calculateRhythmBonus(current);
+            currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current, greatWindow);
 
             return currentStrain * currentRhythm;
         }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -79,7 +79,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 {
                     Result = { BindTarget = SpinsPerMinute },
                 },
-                ticks = new Container<DrawableSpinnerTick>(),
+                ticks = new Container<DrawableSpinnerTick>
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
                 new AspectContainer
                 {
                     Anchor = Anchor.Centre,

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Graphics;
+
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableSpinnerTick : DrawableOsuHitObject
@@ -10,13 +12,15 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected DrawableSpinner DrawableSpinner => (DrawableSpinner)ParentHitObject;
 
         public DrawableSpinnerTick()
-            : base(null)
+            : this(null)
         {
         }
 
         public DrawableSpinnerTick(SpinnerTick spinnerTick)
             : base(spinnerTick)
         {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
         }
 
         protected override double MaximumJudgementOffset => DrawableSpinner.HitObject.Duration;

osu.Game.Rulesets.Osu/Objects/Spinner.cs

@@ -69,8 +69,8 @@ namespace osu.Game.Rulesets.Osu.Objects
                 double startTime = StartTime + (float)(i + 1) / totalSpins * Duration;
 
                 AddNested(i < SpinsRequired
-                    ? new SpinnerTick { StartTime = startTime, Position = Position }
-                    : new SpinnerBonusTick { StartTime = startTime, Position = Position });
+                    ? new SpinnerTick { StartTime = startTime }
+                    : new SpinnerBonusTick { StartTime = startTime });
             }
         }
 

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/TaikoDifficultyHitObject.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Objects;
@@ -24,11 +25,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
         /// </summary>
         public readonly HitType? HitType;
 
-        /// <summary>
-        /// The index of the object in the beatmap.
-        /// </summary>
-        public readonly int ObjectIndex;
-
         /// <summary>
         /// Whether the object should carry a penalty due to being hittable using special techniques
         /// making it easier to do so.
@@ -42,16 +38,15 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
         /// <param name="lastObject">The gameplay <see cref="HitObject"/> preceding <paramref name="hitObject"/>.</param>
         /// <param name="lastLastObject">The gameplay <see cref="HitObject"/> preceding <paramref name="lastObject"/>.</param>
         /// <param name="clockRate">The rate of the gameplay clock. Modified by speed-changing mods.</param>
-        /// <param name="objectIndex">The index of the object in the beatmap.</param>
-        public TaikoDifficultyHitObject(HitObject hitObject, HitObject lastObject, HitObject lastLastObject, double clockRate, int objectIndex)
-            : base(hitObject, lastObject, clockRate)
+        /// <param name="objects">The list of <see cref="DifficultyHitObject"/>s in the current beatmap.</param>
+        /// /// <param name="index">The position of this <see cref="DifficultyHitObject"/> in the <paramref name="objects"/> list.</param>
+        public TaikoDifficultyHitObject(HitObject hitObject, HitObject lastObject, HitObject lastLastObject, double clockRate, List<DifficultyHitObject> objects, int index)
+            : base(hitObject, lastObject, clockRate, objects, index)
         {
             var currentHit = hitObject as Hit;
 
             Rhythm = getClosestRhythm(lastObject, lastLastObject, clockRate);
             HitType = currentHit?.Type;
-
-            ObjectIndex = objectIndex;
         }
 
         /// <summary>

osu.Game.Rulesets.Taiko/Difficulty/Skills/Rhythm.cs

@@ -106,7 +106,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
                     if (!samePattern(start, mostRecentPatternsToCompare))
                         continue;
 
-                    int notesSince = hitObject.ObjectIndex - rhythmHistory[start].ObjectIndex;
+                    int notesSince = hitObject.Index - rhythmHistory[start].Index;
                     penalty *= repetitionPenalty(notesSince);
                     break;
                 }

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs

@@ -46,13 +46,13 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
-            List<TaikoDifficultyHitObject> taikoDifficultyHitObjects = new List<TaikoDifficultyHitObject>();
+            List<DifficultyHitObject> taikoDifficultyHitObjects = new List<DifficultyHitObject>();
 
             for (int i = 2; i < beatmap.HitObjects.Count; i++)
             {
                 taikoDifficultyHitObjects.Add(
                     new TaikoDifficultyHitObject(
-                        beatmap.HitObjects[i], beatmap.HitObjects[i - 1], beatmap.HitObjects[i - 2], clockRate, i
+                        beatmap.HitObjects[i], beatmap.HitObjects[i - 1], beatmap.HitObjects[i - 2], clockRate, taikoDifficultyHitObjects, taikoDifficultyHitObjects.Count
                     )
                 );
             }

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -8,6 +8,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Primitives;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Judgements;
@@ -321,12 +322,14 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         private class ProxyContainer : LifetimeManagementContainer
         {
-            public new MarginPadding Padding
-            {
-                set => base.Padding = value;
-            }
-
             public void Add(Drawable proxy) => AddInternal(proxy);
+
+            public override bool UpdateSubTreeMasking(Drawable source, RectangleF maskingBounds)
+            {
+                // DrawableHitObject disables masking.
+                // Hitobject content is proxied and unproxied based on hit status and the IsMaskedAway value could get stuck because of this.
+                return false;
+            }
         }
     }
 }

osu.Game.Tests/Chat/TestSceneChannelManager.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Chat
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            var container = new ChannelManagerContainer();
+            var container = new ChannelManagerContainer(API);
             Child = container;
             channelManager = container.ChannelManager;
         });
@@ -145,11 +145,11 @@ namespace osu.Game.Tests.Chat
         private class ChannelManagerContainer : CompositeDrawable
         {
             [Cached]
-            public ChannelManager ChannelManager { get; } = new ChannelManager();
+            public ChannelManager ChannelManager { get; }
 
-            public ChannelManagerContainer()
+            public ChannelManagerContainer(IAPIProvider apiProvider)
             {
-                InternalChild = ChannelManager;
+                InternalChild = ChannelManager = new ChannelManager(apiProvider);
             }
         }
     }

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

@@ -49,11 +49,16 @@ namespace osu.Game.Tests.Collections.IO
 
                     Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
 
+                    // Even with no beatmaps imported, collections are tracking the hashes and will continue to.
+                    // In the future this whole mechanism will be replaced with having the collections in realm,
+                    // but until that happens it makes rough sense that we want to track not-yet-imported beatmaps
+                    // and have them associate with collections if/when they become available.
+
                     Assert.That(osu.CollectionManager.Collections[0].Name.Value, Is.EqualTo("First"));
-                    Assert.That(osu.CollectionManager.Collections[0].Beatmaps.Count, Is.Zero);
+                    Assert.That(osu.CollectionManager.Collections[0].BeatmapHashes.Count, Is.EqualTo(1));
 
                     Assert.That(osu.CollectionManager.Collections[1].Name.Value, Is.EqualTo("Second"));
-                    Assert.That(osu.CollectionManager.Collections[1].Beatmaps.Count, Is.Zero);
+                    Assert.That(osu.CollectionManager.Collections[1].BeatmapHashes.Count, Is.EqualTo(12));
                 }
                 finally
                 {
@@ -76,10 +81,10 @@ namespace osu.Game.Tests.Collections.IO
                     Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
 
                     Assert.That(osu.CollectionManager.Collections[0].Name.Value, Is.EqualTo("First"));
-                    Assert.That(osu.CollectionManager.Collections[0].Beatmaps.Count, Is.EqualTo(1));
+                    Assert.That(osu.CollectionManager.Collections[0].BeatmapHashes.Count, Is.EqualTo(1));
 
                     Assert.That(osu.CollectionManager.Collections[1].Name.Value, Is.EqualTo("Second"));
-                    Assert.That(osu.CollectionManager.Collections[1].Beatmaps.Count, Is.EqualTo(12));
+                    Assert.That(osu.CollectionManager.Collections[1].BeatmapHashes.Count, Is.EqualTo(12));
                 }
                 finally
                 {
@@ -142,8 +147,8 @@ namespace osu.Game.Tests.Collections.IO
                     await importCollectionsFromStream(osu, TestResources.OpenResource("Collections/collections.db"));
 
                     // Move first beatmap from second collection into the first.
-                    osu.CollectionManager.Collections[0].Beatmaps.Add(osu.CollectionManager.Collections[1].Beatmaps[0]);
-                    osu.CollectionManager.Collections[1].Beatmaps.RemoveAt(0);
+                    osu.CollectionManager.Collections[0].BeatmapHashes.Add(osu.CollectionManager.Collections[1].BeatmapHashes[0]);
+                    osu.CollectionManager.Collections[1].BeatmapHashes.RemoveAt(0);
 
                     // Rename the second collecction.
                     osu.CollectionManager.Collections[1].Name.Value = "Another";
@@ -164,10 +169,10 @@ namespace osu.Game.Tests.Collections.IO
                     Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
 
                     Assert.That(osu.CollectionManager.Collections[0].Name.Value, Is.EqualTo("First"));
-                    Assert.That(osu.CollectionManager.Collections[0].Beatmaps.Count, Is.EqualTo(2));
+                    Assert.That(osu.CollectionManager.Collections[0].BeatmapHashes.Count, Is.EqualTo(2));
 
                     Assert.That(osu.CollectionManager.Collections[1].Name.Value, Is.EqualTo("Another"));
-                    Assert.That(osu.CollectionManager.Collections[1].Beatmaps.Count, Is.EqualTo(11));
+                    Assert.That(osu.CollectionManager.Collections[1].BeatmapHashes.Count, Is.EqualTo(11));
                 }
                 finally
                 {

osu.Game.Tests/Database/BeatmapImporterTests.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable enable
+
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -12,7 +14,6 @@ using NUnit.Framework;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Logging;
-using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Extensions;
@@ -28,8 +29,6 @@ using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
 using SharpCompress.Writers.Zip;
 
-#nullable enable
-
 namespace osu.Game.Tests.Database
 {
     [TestFixture]
@@ -394,7 +393,6 @@ namespace osu.Game.Tests.Database
         }
 
         [Test]
-        [Ignore("intentionally broken by import optimisations")]
         public void TestImportThenImportWithChangedFile()
         {
             RunTestWithRealmAsync(async (realm, storage) =>
@@ -491,7 +489,6 @@ namespace osu.Game.Tests.Database
         }
 
         [Test]
-        [Ignore("intentionally broken by import optimisations")]
         public void TestImportCorruptThenImport()
         {
             RunTestWithRealmAsync(async (realm, storage) =>
@@ -503,16 +500,18 @@ namespace osu.Game.Tests.Database
 
                 var firstFile = imported.Files.First();
 
+                var fileStorage = storage.GetStorageForDirectory("files");
+
                 long originalLength;
-                using (var stream = storage.GetStream(firstFile.File.GetStoragePath()))
+                using (var stream = fileStorage.GetStream(firstFile.File.GetStoragePath()))
                     originalLength = stream.Length;
 
-                using (var stream = storage.CreateFileSafely(firstFile.File.GetStoragePath()))
+                using (var stream = fileStorage.CreateFileSafely(firstFile.File.GetStoragePath()))
                     stream.WriteByte(0);
 
                 var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
-                using (var stream = storage.GetStream(firstFile.File.GetStoragePath()))
+                using (var stream = fileStorage.GetStream(firstFile.File.GetStoragePath()))
                     Assert.AreEqual(stream.Length, originalLength, "Corruption was not fixed on second import");
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
@@ -622,7 +621,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapModelManager(realm, storage);
                 using var store = new RealmRulesetStore(realm, storage);
 
-                var imported = await LoadOszIntoStore(importer, realm.Realm);
+                var imported = await LoadOszIntoStore(importer, realm.Realm, batchImport: true);
 
                 deleteBeatmapSet(imported, realm.Realm);
 
@@ -678,7 +677,7 @@ namespace osu.Game.Tests.Database
         {
             RunTestWithRealmAsync(async (realm, storage) =>
             {
-                using var importer = new NonOptimisedBeatmapImporter(realm, storage);
+                using var importer = new BeatmapModelManager(realm, storage);
                 using var store = new RealmRulesetStore(realm, storage);
 
                 var imported = await LoadOszIntoStore(importer, realm.Realm);
@@ -960,11 +959,11 @@ namespace osu.Game.Tests.Database
             return realm.All<BeatmapSetInfo>().FirstOrDefault(beatmapSet => beatmapSet.ID == importedSet!.ID);
         }
 
-        public static async Task<BeatmapSetInfo> LoadOszIntoStore(BeatmapImporter importer, Realm realm, string? path = null, bool virtualTrack = false)
+        public static async Task<BeatmapSetInfo> LoadOszIntoStore(BeatmapImporter importer, Realm realm, string? path = null, bool virtualTrack = false, bool batchImport = false)
         {
             string? temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
 
-            var importedSet = await importer.Import(new ImportTask(temp));
+            var importedSet = await importer.Import(new ImportTask(temp), batchImport);
 
             Assert.NotNull(importedSet);
             Debug.Assert(importedSet != null);
@@ -1081,15 +1080,5 @@ namespace osu.Game.Tests.Database
 
             Assert.Fail(failureMessage);
         }
-
-        public class NonOptimisedBeatmapImporter : BeatmapImporter
-        {
-            public NonOptimisedBeatmapImporter(RealmAccess realm, Storage storage)
-                : base(realm, storage)
-            {
-            }
-
-            protected override bool HasCustomHashFunction => true;
-        }
     }
 }

osu.Game.Tests/Database/LegacyBeatmapImporterTest.cs

@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Database;
+using osu.Game.IO;
+
+namespace osu.Game.Tests.Database
+{
+    [TestFixture]
+    public class LegacyBeatmapImporterTest
+    {
+        private readonly TestLegacyBeatmapImporter importer = new TestLegacyBeatmapImporter();
+
+        [Test]
+        public void TestSongsSubdirectories()
+        {
+            using (var storage = new TemporaryNativeStorage("stable-songs-folder"))
+            {
+                var songsStorage = storage.GetStorageForDirectory(StableStorage.STABLE_DEFAULT_SONGS_PATH);
+
+                // normal beatmap folder
+                var beatmap1 = songsStorage.GetStorageForDirectory("beatmap1");
+                createFile(beatmap1, "beatmap.osu");
+
+                // songs subdirectory
+                var subdirectory = songsStorage.GetStorageForDirectory("subdirectory");
+                createFile(subdirectory, Path.Combine("beatmap2", "beatmap.osu"));
+                createFile(subdirectory, Path.Combine("beatmap3", "beatmap.osu"));
+                createFile(subdirectory, Path.Combine("sub-subdirectory", "beatmap4", "beatmap.osu"));
+
+                // songs subdirectory with system file
+                var subdirectory2 = songsStorage.GetStorageForDirectory("subdirectory2");
+                createFile(subdirectory2, ".DS_Store");
+                createFile(subdirectory2, Path.Combine("beatmap5", "beatmap.osu"));
+                createFile(subdirectory2, Path.Combine("beatmap6", "beatmap.osu"));
+
+                // empty songs subdirectory
+                songsStorage.GetStorageForDirectory("subdirectory3");
+
+                string[] paths = importer.GetStableImportPaths(songsStorage).ToArray();
+                Assert.That(paths.Length, Is.EqualTo(6));
+                Assert.That(paths.Contains(songsStorage.GetFullPath("beatmap1")));
+                Assert.That(paths.Contains(songsStorage.GetFullPath(Path.Combine("subdirectory", "beatmap2"))));
+                Assert.That(paths.Contains(songsStorage.GetFullPath(Path.Combine("subdirectory", "beatmap3"))));
+                Assert.That(paths.Contains(songsStorage.GetFullPath(Path.Combine("subdirectory", "sub-subdirectory", "beatmap4"))));
+                Assert.That(paths.Contains(songsStorage.GetFullPath(Path.Combine("subdirectory2", "beatmap5"))));
+                Assert.That(paths.Contains(songsStorage.GetFullPath(Path.Combine("subdirectory2", "beatmap6"))));
+            }
+
+            static void createFile(Storage storage, string path)
+            {
+                using (var stream = storage.CreateFileSafely(path))
+                    stream.WriteByte(0);
+            }
+        }
+
+        private class TestLegacyBeatmapImporter : LegacyBeatmapImporter
+        {
+            public TestLegacyBeatmapImporter()
+                : base(null)
+            {
+            }
+
+            public new IEnumerable<string> GetStableImportPaths(Storage storage) => base.GetStableImportPaths(storage);
+        }
+    }
+}

osu.Game.Tests/Gameplay/TestSceneScoreProcessor.cs

@@ -59,12 +59,14 @@ namespace osu.Game.Tests.Gameplay
             scoreProcessor.ApplyResult(new JudgementResult(beatmap.HitObjects[0], new TestJudgement(HitResult.Great)) { Type = HitResult.Great });
             Assert.That(scoreProcessor.TotalScore.Value, Is.EqualTo(1_000_000));
             Assert.That(scoreProcessor.JudgedHits, Is.EqualTo(1));
+            Assert.That(scoreProcessor.Combo.Value, Is.EqualTo(1));
 
             // No header shouldn't cause any change
             scoreProcessor.ResetFromReplayFrame(new OsuReplayFrame());
 
             Assert.That(scoreProcessor.TotalScore.Value, Is.EqualTo(1_000_000));
             Assert.That(scoreProcessor.JudgedHits, Is.EqualTo(1));
+            Assert.That(scoreProcessor.Combo.Value, Is.EqualTo(1));
 
             // Reset with a miss instead.
             scoreProcessor.ResetFromReplayFrame(new OsuReplayFrame
@@ -74,6 +76,7 @@ namespace osu.Game.Tests.Gameplay
 
             Assert.That(scoreProcessor.TotalScore.Value, Is.Zero);
             Assert.That(scoreProcessor.JudgedHits, Is.EqualTo(1));
+            Assert.That(scoreProcessor.Combo.Value, Is.EqualTo(0));
 
             // Reset with no judged hit.
             scoreProcessor.ResetFromReplayFrame(new OsuReplayFrame
@@ -83,6 +86,7 @@ namespace osu.Game.Tests.Gameplay
 
             Assert.That(scoreProcessor.TotalScore.Value, Is.Zero);
             Assert.That(scoreProcessor.JudgedHits, Is.Zero);
+            Assert.That(scoreProcessor.Combo.Value, Is.EqualTo(0));
         }
 
         private class TestJudgement : Judgement

osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs

@@ -225,10 +225,10 @@ namespace osu.Game.Tests.Online
                     this.testBeatmapManager = testBeatmapManager;
                 }
 
-                public override Live<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
+                public override Live<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool batchImport = false, CancellationToken cancellationToken = default)
                 {
                     testBeatmapManager.AllowImport.Task.WaitSafely();
-                    return (testBeatmapManager.CurrentImport = base.Import(item, archive, lowPriority, cancellationToken));
+                    return (testBeatmapManager.CurrentImport = base.Import(item, archive, batchImport, cancellationToken));
                 }
             }
         }

osu.Game.Tests/Skins/TestSceneSkinConfigurationLookup.cs

@@ -59,11 +59,13 @@ namespace osu.Game.Tests.Skins
             AddAssert("Check float parse lookup", () => requester.GetConfig<string, float>("FloatTest")?.Value == 1.1f);
         }
 
-        [Test]
-        public void TestBoolLookup()
+        [TestCase("0", false)]
+        [TestCase("1", true)]
+        [TestCase("2", true)] // https://github.com/ppy/osu/issues/18579
+        public void TestBoolLookup(string originalValue, bool expectedParsedValue)
         {
-            AddStep("Add config values", () => userSource.Configuration.ConfigDictionary["BoolTest"] = "1");
-            AddAssert("Check bool parse lookup", () => requester.GetConfig<string, bool>("BoolTest")?.Value == true);
+            AddStep("Add config values", () => userSource.Configuration.ConfigDictionary["BoolTest"] = originalValue);
+            AddAssert("Check bool parse lookup", () => requester.GetConfig<string, bool>("BoolTest")?.Value == expectedParsedValue);
         }
 
         [Test]

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

@@ -152,7 +152,7 @@ namespace osu.Game.Tests.Visual.Collections
             AddStep("add two collections with same name", () => manager.Collections.AddRange(new[]
             {
                 new BeatmapCollection { Name = { Value = "1" } },
-                new BeatmapCollection { Name = { Value = "1" }, Beatmaps = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0] } },
+                new BeatmapCollection { Name = { Value = "1" }, BeatmapHashes = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0].MD5Hash } },
             }));
         }
 
@@ -162,7 +162,7 @@ namespace osu.Game.Tests.Visual.Collections
             AddStep("add two collections", () => manager.Collections.AddRange(new[]
             {
                 new BeatmapCollection { Name = { Value = "1" } },
-                new BeatmapCollection { Name = { Value = "2" }, Beatmaps = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0] } },
+                new BeatmapCollection { Name = { Value = "2" }, BeatmapHashes = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0].MD5Hash } },
             }));
 
             assertCollectionCount(2);
@@ -198,7 +198,7 @@ namespace osu.Game.Tests.Visual.Collections
         {
             AddStep("add two collections", () => manager.Collections.AddRange(new[]
             {
-                new BeatmapCollection { Name = { Value = "1" }, Beatmaps = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0] } },
+                new BeatmapCollection { Name = { Value = "1" }, BeatmapHashes = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0].MD5Hash } },
             }));
 
             assertCollectionCount(1);

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

@@ -10,6 +10,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
@@ -61,6 +62,21 @@ namespace osu.Game.Tests.Visual.Editing
             AddUntilStep("context menu is visible", () => contextMenuContainer.ChildrenOfType<OsuContextMenu>().Single().State == MenuState.Open);
         }
 
+        [Test]
+        public void TestSelectAndShowContextMenuOutsideBounds()
+        {
+            var addedObject = new HitCircle { StartTime = 100, Position = OsuPlayfield.BASE_SIZE };
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("descale blueprint container", () => this.ChildrenOfType<HitObjectComposer>().Single().Scale = new Vector2(0.5f));
+            AddStep("move mouse to bottom-right", () => InputManager.MoveMouseTo(blueprintContainer.ToScreenSpace(blueprintContainer.LayoutRectangle.BottomRight + new Vector2(10))));
+
+            AddStep("right click", () => InputManager.Click(MouseButton.Right));
+
+            AddUntilStep("hitobject selected", () => EditorBeatmap.SelectedHitObjects.Single() == addedObject);
+            AddUntilStep("context menu is visible", () => contextMenuContainer.ChildrenOfType<OsuContextMenu>().Single().State == MenuState.Open);
+        }
+
         [Test]
         public void TestNudgeSelection()
         {

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

@@ -78,6 +78,21 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("Inner container width matches scroll container", () => innerBox.DrawWidth == scrollContainer.DrawWidth);
         }
 
+        [Test]
+        public void TestZoomRangeUpdate()
+        {
+            AddStep("set zoom to 2", () => scrollContainer.Zoom = 2);
+            AddStep("set min zoom to 5", () => scrollContainer.MinZoom = 5);
+            AddAssert("zoom = 5", () => scrollContainer.Zoom == 5);
+
+            AddStep("set max zoom to 10", () => scrollContainer.MaxZoom = 10);
+            AddAssert("zoom = 5", () => scrollContainer.Zoom == 5);
+
+            AddStep("set min zoom to 20", () => scrollContainer.MinZoom = 20);
+            AddStep("set max zoom to 40", () => scrollContainer.MaxZoom = 40);
+            AddAssert("zoom = 20", () => scrollContainer.Zoom == 20);
+        }
+
         [Test]
         public void TestZoom0()
         {

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

@@ -14,6 +14,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD.HitErrorMeters;
 using osu.Game.Skinning;
 using osu.Game.Tests.Gameplay;
 using osuTK.Input;
@@ -145,6 +146,26 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("key counters still hidden", () => !keyCounterFlow.IsPresent);
         }
 
+        [Test]
+        public void TestHiddenHUDDoesntBlockComponentUpdates()
+        {
+            int updateCount = 0;
+
+            AddStep("set hud to never show", () => localConfig.SetValue(OsuSetting.HUDVisibilityMode, HUDVisibilityMode.Never));
+
+            createNew();
+
+            AddUntilStep("wait for hud load", () => hudOverlay.IsLoaded);
+            AddUntilStep("wait for components to be hidden", () => hudOverlay.ChildrenOfType<SkinnableTargetContainer>().Single().Alpha == 0);
+
+            AddStep("bind on update", () =>
+            {
+                hudOverlay.ChildrenOfType<BarHitErrorMeter>().First().OnUpdate += _ => updateCount++;
+            });
+
+            AddUntilStep("wait for updates", () => updateCount > 0);
+        }
+
         [Test]
         public void TestHiddenHUDDoesntBlockSkinnableComponentsLoad()
         {
@@ -153,7 +174,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             createNew();
 
             AddUntilStep("wait for hud load", () => hudOverlay.IsLoaded);
-            AddUntilStep("wait for components to be hidden", () => !hudOverlay.ChildrenOfType<SkinnableTargetContainer>().Single().IsPresent);
+            AddUntilStep("wait for components to be hidden", () => hudOverlay.ChildrenOfType<SkinnableTargetContainer>().Single().Alpha == 0);
 
             AddStep("reload components", () => hudOverlay.ChildrenOfType<SkinnableTargetContainer>().Single().Reload());
             AddUntilStep("skinnable components loaded", () => hudOverlay.ChildrenOfType<SkinnableTargetContainer>().Single().ComponentsLoaded);

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

@@ -142,6 +142,36 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("no circle added", () => !this.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Any());
         }
 
+        [Test]
+        public void TestProcessingWhileHidden()
+        {
+            AddStep("OD 1", () => recreateDisplay(new OsuHitWindows(), 1));
+
+            AddStep("hide displays", () =>
+            {
+                foreach (var hitErrorMeter in this.ChildrenOfType<HitErrorMeter>())
+                    hitErrorMeter.Hide();
+            });
+
+            AddRepeatStep("hit", () => newJudgement(), ColourHitErrorMeter.MAX_DISPLAYED_JUDGEMENTS * 2);
+
+            AddAssert("bars added", () => this.ChildrenOfType<BarHitErrorMeter.JudgementLine>().Any());
+            AddAssert("circle added", () => this.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Any());
+
+            AddUntilStep("wait for bars to disappear", () => !this.ChildrenOfType<BarHitErrorMeter.JudgementLine>().Any());
+            AddUntilStep("ensure max circles not exceeded", () =>
+            {
+                return this.ChildrenOfType<ColourHitErrorMeter>()
+                           .All(m => m.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Count() <= ColourHitErrorMeter.MAX_DISPLAYED_JUDGEMENTS);
+            });
+
+            AddStep("show displays", () =>
+            {
+                foreach (var hitErrorMeter in this.ChildrenOfType<HitErrorMeter>())
+                    hitErrorMeter.Show();
+            });
+        }
+
         [Test]
         public void TestClear()
         {

osu.Game.Tests/Visual/Menus/TestSceneToolbar.cs

@@ -2,15 +2,22 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using JetBrains.Annotations;
 using Moq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Testing;
+using osu.Game.Graphics.Containers;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
 using osu.Game.Overlays.Toolbar;
 using osu.Game.Rulesets;
+using osuTK.Graphics;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Menus
@@ -23,21 +30,44 @@ namespace osu.Game.Tests.Visual.Menus
         [Resolved]
         private IRulesetStore rulesets { get; set; }
 
-        private readonly Mock<INotificationOverlay> notifications = new Mock<INotificationOverlay>();
+        [Cached]
+        private readonly NowPlayingOverlay nowPlayingOverlay = new NowPlayingOverlay
+        {
+            Anchor = Anchor.TopRight,
+            Origin = Anchor.TopRight,
+            Y = Toolbar.HEIGHT,
+        };
+
+        [Cached]
+        private readonly VolumeOverlay volumeOverlay = new VolumeOverlay
+        {
+            Anchor = Anchor.CentreLeft,
+            Origin = Anchor.CentreLeft,
+        };
+
+        private readonly Mock<TestNotificationOverlay> notifications = new Mock<TestNotificationOverlay>();
 
         private readonly BindableInt unreadNotificationCount = new BindableInt();
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            Dependencies.CacheAs(notifications.Object);
+            Dependencies.CacheAs<INotificationOverlay>(notifications.Object);
             notifications.SetupGet(n => n.UnreadCount).Returns(unreadNotificationCount);
         }
 
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            Child = toolbar = new TestToolbar { State = { Value = Visibility.Visible } };
+            Remove(nowPlayingOverlay);
+            Remove(volumeOverlay);
+
+            Children = new Drawable[]
+            {
+                nowPlayingOverlay,
+                volumeOverlay,
+                toolbar = new TestToolbar { State = { Value = Visibility.Visible } },
+            };
         });
 
         [Test]
@@ -95,9 +125,73 @@ namespace osu.Game.Tests.Visual.Menus
                 AddAssert("toolbar is visible", () => toolbar.State.Value == Visibility.Visible);
         }
 
+        [Test]
+        public void TestScrollInput()
+        {
+            OsuScrollContainer scroll = null;
+
+            AddStep("add scroll layer", () => Add(scroll = new OsuScrollContainer
+            {
+                Depth = 1f,
+                RelativeSizeAxes = Axes.Both,
+                Child = new Box
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = DrawHeight * 2,
+                    Colour = ColourInfo.GradientVertical(Color4.Gray, Color4.DarkGray),
+                }
+            }));
+
+            AddStep("hover toolbar", () => InputManager.MoveMouseTo(toolbar));
+            AddStep("perform scroll", () => InputManager.ScrollVerticalBy(500));
+            AddAssert("not scrolled", () => scroll.Current == 0);
+        }
+
+        [Test]
+        public void TestVolumeControlViaMusicButtonScroll()
+        {
+            AddStep("hover toolbar music button", () => InputManager.MoveMouseTo(this.ChildrenOfType<ToolbarMusicButton>().Single()));
+
+            AddStep("reset volume", () => Audio.Volume.Value = 1);
+
+            AddRepeatStep("scroll down", () => InputManager.ScrollVerticalBy(-10), 5);
+            AddAssert("volume lowered down", () => Audio.Volume.Value < 1);
+            AddRepeatStep("scroll up", () => InputManager.ScrollVerticalBy(10), 5);
+            AddAssert("volume raised up", () => Audio.Volume.Value == 1);
+        }
+
+        [Test]
+        public void TestVolumeControlViaMusicButtonArrowKeys()
+        {
+            AddStep("hover toolbar music button", () => InputManager.MoveMouseTo(this.ChildrenOfType<ToolbarMusicButton>().Single()));
+
+            AddStep("reset volume", () => Audio.Volume.Value = 1);
+
+            AddRepeatStep("arrow down", () => InputManager.Key(Key.Down), 5);
+            AddAssert("volume lowered down", () => Audio.Volume.Value < 1);
+            AddRepeatStep("arrow up", () => InputManager.Key(Key.Up), 5);
+            AddAssert("volume raised up", () => Audio.Volume.Value == 1);
+        }
+
         public class TestToolbar : Toolbar
         {
             public new Bindable<OverlayActivation> OverlayActivationMode => base.OverlayActivationMode as Bindable<OverlayActivation>;
         }
+
+        // interface mocks break hot reload, mocking this stub implementation instead works around it.
+        // see: https://github.com/moq/moq4/issues/1252
+        [UsedImplicitly]
+        public class TestNotificationOverlay : INotificationOverlay
+        {
+            public virtual void Post(Notification notification)
+            {
+            }
+
+            public virtual void Hide()
+            {
+            }
+
+            public virtual IBindable<int> UnreadCount => null;
+        }
     }
 }

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

@@ -18,7 +18,6 @@ using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Spectator;
 using osu.Game.Replays.Legacy;
-using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play.HUD;
@@ -27,7 +26,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
     public abstract class MultiplayerGameplayLeaderboardTestScene : OsuTestScene
     {
-        private const int total_users = 16;
+        protected const int TOTAL_USERS = 16;
 
         protected readonly BindableList<MultiplayerRoomUser> MultiplayerUsers = new BindableList<MultiplayerRoomUser>();
 
@@ -35,9 +34,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         protected virtual MultiplayerRoomUser CreateUser(int userId) => new MultiplayerRoomUser(userId);
 
-        protected abstract MultiplayerGameplayLeaderboard CreateLeaderboard(OsuScoreProcessor scoreProcessor);
+        protected abstract MultiplayerGameplayLeaderboard CreateLeaderboard();
 
         private readonly BindableList<int> multiplayerUserIds = new BindableList<int>();
+        private readonly BindableDictionary<int, SpectatorState> watchedUserStates = new BindableDictionary<int, SpectatorState>();
 
         private OsuConfigManager config;
 
@@ -81,6 +81,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             multiplayerClient.SetupGet(c => c.CurrentMatchPlayingUserIds)
                              .Returns(() => multiplayerUserIds);
+
+            spectatorClient.SetupGet(c => c.WatchedUserStates)
+                           .Returns(() => watchedUserStates);
         }
 
         [SetUpSteps]
@@ -100,8 +103,26 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("populate users", () =>
             {
                 MultiplayerUsers.Clear();
-                for (int i = 0; i < total_users; i++)
-                    MultiplayerUsers.Add(CreateUser(i));
+
+                for (int i = 0; i < TOTAL_USERS; i++)
+                {
+                    var user = CreateUser(i);
+
+                    MultiplayerUsers.Add(user);
+
+                    watchedUserStates[i] = new SpectatorState
+                    {
+                        BeatmapID = 0,
+                        RulesetID = 0,
+                        Mods = user.Mods,
+                        MaximumScoringValues = new ScoringValues
+                        {
+                            BaseScore = 10000,
+                            MaxCombo = 1000,
+                            CountBasicHitObjects = 1000
+                        }
+                    };
+                }
             });
 
             AddStep("create leaderboard", () =>
@@ -109,13 +130,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 Leaderboard?.Expire();
 
                 Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
-                var playableBeatmap = Beatmap.Value.GetPlayableBeatmap(Ruleset.Value);
-                OsuScoreProcessor scoreProcessor = new OsuScoreProcessor();
-                scoreProcessor.ApplyBeatmap(playableBeatmap);
 
-                Child = scoreProcessor;
-
-                LoadComponentAsync(Leaderboard = CreateLeaderboard(scoreProcessor), Add);
+                LoadComponentAsync(Leaderboard = CreateLeaderboard(), Add);
             });
 
             AddUntilStep("wait for load", () => Leaderboard.IsLoaded);

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

@@ -4,11 +4,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
-using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
 using osu.Game.Screens.Play.HUD;
 
@@ -24,7 +24,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("reset", () =>
             {
-                Clear();
+                leaderboard?.RemoveAndDisposeImmediately();
 
                 clocks = new Dictionary<int, ManualClock>
                 {
@@ -32,21 +32,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     { PLAYER_2_ID, new ManualClock() }
                 };
 
-                foreach ((int userId, var _) in clocks)
+                foreach ((int userId, _) in clocks)
                 {
                     SpectatorClient.SendStartPlay(userId, 0);
-                    OnlinePlayDependencies.MultiplayerClient.AddUser(new APIUser { Id = userId });
+                    OnlinePlayDependencies.MultiplayerClient.AddUser(new APIUser { Id = userId }, true);
                 }
             });
 
             AddStep("create leaderboard", () =>
             {
                 Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
-                var playable = Beatmap.Value.GetPlayableBeatmap(Ruleset.Value);
-                var scoreProcessor = new OsuScoreProcessor();
-                scoreProcessor.ApplyBeatmap(playable);
 
-                LoadComponentAsync(leaderboard = new MultiSpectatorLeaderboard(Ruleset.Value, scoreProcessor, clocks.Keys.Select(id => new MultiplayerRoomUser(id)).ToArray())
+                LoadComponentAsync(leaderboard = new MultiSpectatorLeaderboard(clocks.Keys.Select(id => new MultiplayerRoomUser(id)).ToArray())
                 {
                     Expanded = { Value = true }
                 }, Add);

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

@@ -1,22 +1,58 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using System.Linq;
+using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Online.API;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Play.HUD;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
     public class TestSceneMultiplayerGameplayLeaderboard : MultiplayerGameplayLeaderboardTestScene
     {
-        protected override MultiplayerGameplayLeaderboard CreateLeaderboard(OsuScoreProcessor scoreProcessor)
+        protected override MultiplayerRoomUser CreateUser(int userId)
         {
-            return new MultiplayerGameplayLeaderboard(Ruleset.Value, scoreProcessor, MultiplayerUsers.ToArray())
+            var user = base.CreateUser(userId);
+
+            if (userId == TOTAL_USERS - 1)
+                user.Mods = new[] { new APIMod(new OsuModNoFail()) };
+
+            return user;
+        }
+
+        protected override MultiplayerGameplayLeaderboard CreateLeaderboard()
+        {
+            return new TestLeaderboard(MultiplayerUsers.ToArray())
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             };
         }
+
+        [Test]
+        public void TestPerUserMods()
+        {
+            AddStep("first user has no mods", () => Assert.That(((TestLeaderboard)Leaderboard).UserMods[0], Is.Empty));
+            AddStep("last user has NF mod", () =>
+            {
+                Assert.That(((TestLeaderboard)Leaderboard).UserMods[TOTAL_USERS - 1], Has.One.Items);
+                Assert.That(((TestLeaderboard)Leaderboard).UserMods[TOTAL_USERS - 1].Single(), Is.TypeOf<OsuModNoFail>());
+            });
+        }
+
+        private class TestLeaderboard : MultiplayerGameplayLeaderboard
+        {
+            public Dictionary<int, IReadOnlyList<Mod>> UserMods => UserScores.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ScoreProcessor.Mods);
+
+            public TestLeaderboard(MultiplayerRoomUser[] users)
+                : base(users)
+            {
+            }
+        }
     }
 }

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

@@ -5,7 +5,6 @@ using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
-using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.Play.HUD;
 
@@ -25,8 +24,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
             return user;
         }
 
-        protected override MultiplayerGameplayLeaderboard CreateLeaderboard(OsuScoreProcessor scoreProcessor) =>
-            new MultiplayerGameplayLeaderboard(Ruleset.Value, scoreProcessor, MultiplayerUsers.ToArray())
+        protected override MultiplayerGameplayLeaderboard CreateLeaderboard() =>
+            new MultiplayerGameplayLeaderboard(MultiplayerUsers.ToArray())
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,

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

@@ -609,8 +609,6 @@ namespace osu.Game.Tests.Visual.Navigation
             public ModSelectOverlay ModSelectOverlay => ModSelect;
 
             public BeatmapOptionsOverlay BeatmapOptionsOverlay => BeatmapOptions;
-
-            protected override bool DisplayStableImportPrompt => false;
         }
     }
 }

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

@@ -18,13 +18,10 @@ using APIUser = osu.Game.Online.API.Requests.Responses.APIUser;
 
 namespace osu.Game.Tests.Visual.Online
 {
-    [TestFixture]
     public class TestSceneBeatmapSetOverlay : OsuTestScene
     {
         private readonly TestBeatmapSetOverlay overlay;
 
-        protected override bool UseOnlineAPI => true;
-
         private int nextBeatmapSetId = 1;
 
         public TestSceneBeatmapSetOverlay()
@@ -41,12 +38,6 @@ namespace osu.Game.Tests.Visual.Online
             AddStep(@"show loading", () => overlay.ShowBeatmapSet(null));
         }
 
-        [Test]
-        public void TestOnline()
-        {
-            AddStep(@"show online", () => overlay.FetchAndShowBeatmapSet(55));
-        }
-
         [Test]
         public void TestLocalBeatmaps()
         {
@@ -107,6 +98,7 @@ namespace osu.Game.Tests.Visual.Online
 
             AddAssert("status is loved", () => overlay.ChildrenOfType<BeatmapSetOnlineStatusPill>().Single().Status == BeatmapOnlineStatus.Loved);
             AddAssert("scores container is visible", () => overlay.ChildrenOfType<ScoresContainer>().Single().Alpha == 1);
+            AddAssert("mod selector is visible", () => overlay.ChildrenOfType<LeaderboardModSelector>().Single().Alpha == 1);
 
             AddStep("go to second beatmap", () => overlay.ChildrenOfType<BeatmapPicker.DifficultySelectorButton>().ElementAt(1).TriggerClick());
 

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

@@ -39,7 +39,7 @@ namespace osu.Game.Tests.Visual.Online
         {
             linkColour = colours.Blue;
 
-            var chatManager = new ChannelManager();
+            var chatManager = new ChannelManager(API);
             BindableList<Channel> availableChannels = (BindableList<Channel>)chatManager.AvailableChannels;
             availableChannels.Add(new Channel { Name = "#english" });
             availableChannels.Add(new Channel { Name = "#japanese" });

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

@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Visual.Online
                 RelativeSizeAxes = Axes.Both,
                 CachedDependencies = new (Type, object)[]
                 {
-                    (typeof(ChannelManager), channelManager = new ChannelManager()),
+                    (typeof(ChannelManager), channelManager = new ChannelManager(API)),
                 },
                 Children = new Drawable[]
                 {
@@ -572,15 +572,15 @@ namespace osu.Game.Tests.Visual.Online
 
             public SlowLoadingDrawableChannel GetSlowLoadingChannel(Channel channel) => DrawableChannels.OfType<SlowLoadingDrawableChannel>().Single(c => c.Channel == channel);
 
-            protected override ChatOverlayDrawableChannel CreateDrawableChannel(Channel newChannel)
+            protected override DrawableChannel CreateDrawableChannel(Channel newChannel)
             {
                 return SlowLoading
                     ? new SlowLoadingDrawableChannel(newChannel)
-                    : new ChatOverlayDrawableChannel(newChannel);
+                    : new DrawableChannel(newChannel);
             }
         }
 
-        private class SlowLoadingDrawableChannel : ChatOverlayDrawableChannel
+        private class SlowLoadingDrawableChannel : DrawableChannel
         {
             public readonly ManualResetEventSlim LoadEvent = new ManualResetEventSlim();
 

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -43,7 +44,7 @@ namespace osu.Game.Tests.Visual.Online
 
             Schedule(() =>
             {
-                Child = testContainer = new TestContainer(new[] { publicChannel, privateMessageChannel })
+                Child = testContainer = new TestContainer(API, new[] { publicChannel, privateMessageChannel })
                 {
                     RelativeSizeAxes = Axes.Both,
                 };
@@ -178,6 +179,36 @@ namespace osu.Game.Tests.Visual.Online
             AddAssert("1 notification fired", () => testContainer.NotificationOverlay.UnreadCount.Value == 1);
         }
 
+        /// <summary>
+        /// Ensures that <see cref="MessageNotifier"/> handles channels which have not been or could not be resolved (i.e. <see cref="Channel.Id"/> = 0).
+        /// </summary>
+        [Test]
+        public void TestSendInUnresolvedChannel()
+        {
+            int i = 1;
+            Channel unresolved = null;
+
+            AddRepeatStep("join unresolved channels", () => testContainer.ChannelManager.JoinChannel(unresolved = new Channel(new APIUser
+            {
+                Id = 100 + i,
+                Username = $"Foreign #{i++}",
+            })), 5);
+
+            AddStep("send message in unresolved channel", () =>
+            {
+                Debug.Assert(unresolved.Id == 0);
+
+                unresolved.AddLocalEcho(new LocalEchoMessage
+                {
+                    Sender = API.LocalUser.Value,
+                    ChannelId = unresolved.Id,
+                    Content = "Some message",
+                });
+            });
+
+            AddAssert("no notifications fired", () => testContainer.NotificationOverlay.UnreadCount.Value == 0);
+        }
+
         private void receiveMessage(APIUser sender, Channel channel, string content) => channel.AddNewMessages(createMessage(sender, channel, content));
 
         private Message createMessage(APIUser sender, Channel channel, string content) => new Message(messageIdCounter++)
@@ -198,7 +229,7 @@ namespace osu.Game.Tests.Visual.Online
         private class TestContainer : Container
         {
             [Cached]
-            public ChannelManager ChannelManager { get; } = new ChannelManager();
+            public ChannelManager ChannelManager { get; }
 
             [Cached(typeof(INotificationOverlay))]
             public NotificationOverlay NotificationOverlay { get; } = new NotificationOverlay
@@ -214,9 +245,10 @@ namespace osu.Game.Tests.Visual.Online
 
             private readonly Channel[] channels;
 
-            public TestContainer(Channel[] channels)
+            public TestContainer(IAPIProvider api, Channel[] channels)
             {
                 this.channels = channels;
+                ChannelManager = new ChannelManager(api);
             }
 
             [BackgroundDependencyLoader]

osu.Game.Tests/Visual/Online/TestSceneOnlineBeatmapSetOverlay.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 NUnit.Framework;
+using osu.Game.Overlays;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneOnlineBeatmapSetOverlay : OsuTestScene
+    {
+        private readonly BeatmapSetOverlay overlay;
+
+        protected override bool UseOnlineAPI => true;
+
+        public TestSceneOnlineBeatmapSetOverlay()
+        {
+            Add(overlay = new BeatmapSetOverlay());
+        }
+
+        [Test]
+        public void TestOnline()
+        {
+            AddStep(@"show online", () => overlay.FetchAndShowBeatmapSet(55));
+        }
+    }
+}

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

@@ -11,6 +11,7 @@ using NUnit.Framework;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
+using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.Chat;
 using osuTK.Input;
@@ -44,17 +45,22 @@ namespace osu.Game.Tests.Visual.Online
             Id = 5,
         };
 
-        [Cached]
-        private ChannelManager channelManager = new ChannelManager();
+        private ChannelManager channelManager;
 
         private TestStandAloneChatDisplay chatDisplay;
         private int messageIdSequence;
 
         private Channel testChannel;
 
-        public TestSceneStandAloneChatDisplay()
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
-            Add(channelManager);
+            Add(channelManager = new ChannelManager(parent.Get<IAPIProvider>()));
+
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
+            dependencies.Cache(channelManager);
+
+            return dependencies;
         }
 
         [SetUp]
@@ -128,11 +134,11 @@ namespace osu.Game.Tests.Visual.Online
 
             AddAssert("Ensure no adjacent day separators", () =>
             {
-                var indices = chatDisplay.FillFlow.OfType<DrawableChannel.DaySeparator>().Select(ds => chatDisplay.FillFlow.IndexOf(ds));
+                var indices = chatDisplay.FillFlow.OfType<DaySeparator>().Select(ds => chatDisplay.FillFlow.IndexOf(ds));
 
                 foreach (int i in indices)
                 {
-                    if (i < chatDisplay.FillFlow.Count && chatDisplay.FillFlow[i + 1] is DrawableChannel.DaySeparator)
+                    if (i < chatDisplay.FillFlow.Count && chatDisplay.FillFlow[i + 1] is DaySeparator)
                         return false;
                 }
 

osu.Game.Tests/Visual/Ranking/TestSceneExpandedPanelMiddleContent.cs

@@ -96,6 +96,7 @@ namespace osu.Game.Tests.Visual.Ranking
             beatmap.Metadata.Author = author;
             beatmap.Metadata.Title = "Verrrrrrrrrrrrrrrrrrry looooooooooooooooooooooooong beatmap title";
             beatmap.Metadata.Artist = "Verrrrrrrrrrrrrrrrrrry looooooooooooooooooooooooong beatmap artist";
+            beatmap.DifficultyName = "Verrrrrrrrrrrrrrrrrrry looooooooooooooooooooooooong difficulty name";
 
             return beatmap;
         }

osu.Game.Tests/Visual/Settings/TestSceneLatencyCertifierScreen.cs

@@ -0,0 +1,96 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Utility;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Settings
+{
+    public class TestSceneLatencyCertifierScreen : ScreenTestScene
+    {
+        private LatencyCertifierScreen latencyCertifier = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("Load screen", () => LoadScreen(latencyCertifier = new LatencyCertifierScreen()));
+            AddUntilStep("wait for load", () => latencyCertifier.IsLoaded);
+        }
+
+        [Test]
+        public void TestSimple()
+        {
+            AddStep("set visual mode to simple", () => latencyCertifier.VisualMode.Value = LatencyVisualMode.Simple);
+        }
+
+        [Test]
+        public void TestCircleGameplay()
+        {
+            AddStep("set visual mode to circles", () => latencyCertifier.VisualMode.Value = LatencyVisualMode.CircleGameplay);
+        }
+
+        [Test]
+        public void TestScrollingGameplay()
+        {
+            AddStep("set visual mode to scrolling", () => latencyCertifier.VisualMode.Value = LatencyVisualMode.ScrollingGameplay);
+        }
+
+        [Test]
+        public void TestCycleVisualModes()
+        {
+            AddRepeatStep("cycle mode", () => InputManager.Key(Key.Space), 6);
+        }
+
+        [Test]
+        public void TestCertification()
+        {
+            checkDifficulty(1);
+            clickUntilResults(true);
+            continueFromResults();
+            checkDifficulty(2);
+
+            clickUntilResults(false);
+            continueFromResults();
+            checkDifficulty(1);
+
+            clickUntilResults(true);
+            AddAssert("check at results", () => !latencyCertifier.ChildrenOfType<LatencyArea>().Any());
+            checkDifficulty(1);
+        }
+
+        private void continueFromResults()
+        {
+            AddAssert("check at results", () => !latencyCertifier.ChildrenOfType<LatencyArea>().Any());
+            AddStep("hit enter to continue", () => InputManager.Key(Key.Enter));
+        }
+
+        private void checkDifficulty(int difficulty)
+        {
+            AddAssert($"difficulty is {difficulty}", () => latencyCertifier.DifficultyLevel == difficulty);
+        }
+
+        private void clickUntilResults(bool clickCorrect)
+        {
+            AddUntilStep("click correct button until results", () =>
+            {
+                var latencyArea = latencyCertifier
+                                  .ChildrenOfType<LatencyArea>()
+                                  .SingleOrDefault(a => clickCorrect ? a.TargetFrameRate == null : a.TargetFrameRate != null);
+
+                // reached results
+                if (latencyArea == null)
+                    return true;
+
+                latencyArea.ChildrenOfType<OsuButton>().Single().TriggerClick();
+                return false;
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapRecommendations.cs

@@ -5,12 +5,11 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Extensions;
-using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
-using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mania;
@@ -23,38 +22,28 @@ namespace osu.Game.Tests.Visual.SongSelect
 {
     public class TestSceneBeatmapRecommendations : OsuGameTestScene
     {
+        [Resolved]
+        private IRulesetStore rulesetStore { get; set; }
+
         [SetUpSteps]
         public override void SetUpSteps()
         {
-            AddStep("register request handling", () =>
-            {
-                ((DummyAPIAccess)API).HandleRequest = req =>
-                {
-                    switch (req)
-                    {
-                        case GetUserRequest userRequest:
-                            userRequest.TriggerSuccess(getUser(userRequest.Ruleset.OnlineID));
-                            return true;
-                    }
-
-                    return false;
-                };
-            });
-
             base.SetUpSteps();
 
-            APIUser getUser(int? rulesetID)
+            AddStep("populate ruleset statistics", () =>
             {
-                return new APIUser
+                Dictionary<string, UserStatistics> rulesetStatistics = new Dictionary<string, UserStatistics>();
+
+                rulesetStore.AvailableRulesets.Where(ruleset => ruleset.IsLegacyRuleset()).ForEach(rulesetInfo =>
                 {
-                    Username = @"Dummy",
-                    Id = 1001,
-                    Statistics = new UserStatistics
+                    rulesetStatistics[rulesetInfo.ShortName] = new UserStatistics
                     {
-                        PP = getNecessaryPP(rulesetID)
-                    }
-                };
-            }
+                        PP = getNecessaryPP(rulesetInfo.OnlineID)
+                    };
+                });
+
+                API.LocalUser.Value.RulesetsStatistics = rulesetStatistics;
+            });
 
             decimal getNecessaryPP(int? rulesetID)
             {

osu.Game.Tests/Visual/SongSelect/TestSceneFilterControl.cs

@@ -151,10 +151,10 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("add collection", () => collectionManager.Collections.Add(new BeatmapCollection { Name = { Value = "1" } }));
             AddAssert("button is plus", () => getAddOrRemoveButton(1).Icon.Equals(FontAwesome.Solid.PlusSquare));
 
-            AddStep("add beatmap to collection", () => collectionManager.Collections[0].Beatmaps.Add(Beatmap.Value.BeatmapInfo));
+            AddStep("add beatmap to collection", () => collectionManager.Collections[0].BeatmapHashes.Add(Beatmap.Value.BeatmapInfo.MD5Hash));
             AddAssert("button is minus", () => getAddOrRemoveButton(1).Icon.Equals(FontAwesome.Solid.MinusSquare));
 
-            AddStep("remove beatmap from collection", () => collectionManager.Collections[0].Beatmaps.Clear());
+            AddStep("remove beatmap from collection", () => collectionManager.Collections[0].BeatmapHashes.Clear());
             AddAssert("button is plus", () => getAddOrRemoveButton(1).Icon.Equals(FontAwesome.Solid.PlusSquare));
         }
 
@@ -169,11 +169,11 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("button is plus", () => getAddOrRemoveButton(1).Icon.Equals(FontAwesome.Solid.PlusSquare));
 
             addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection contains beatmap", () => collectionManager.Collections[0].Beatmaps.Contains(Beatmap.Value.BeatmapInfo));
+            AddAssert("collection contains beatmap", () => collectionManager.Collections[0].BeatmapHashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
             AddAssert("button is minus", () => getAddOrRemoveButton(1).Icon.Equals(FontAwesome.Solid.MinusSquare));
 
             addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection does not contain beatmap", () => !collectionManager.Collections[0].Beatmaps.Contains(Beatmap.Value.BeatmapInfo));
+            AddAssert("collection does not contain beatmap", () => !collectionManager.Collections[0].BeatmapHashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
             AddAssert("button is plus", () => getAddOrRemoveButton(1).Icon.Equals(FontAwesome.Solid.PlusSquare));
         }
 

osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs

@@ -18,6 +18,7 @@ using osu.Game.Database;
 using osu.Game.Extensions;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Chat;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
@@ -80,6 +81,37 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("delete all beatmaps", () => manager?.Delete());
         }
 
+        [Test]
+        public void TestPlaceholderBeatmapPresence()
+        {
+            createSongSelect();
+
+            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
+
+            addRulesetImportStep(0);
+            AddUntilStep("wait for placeholder hidden", () => getPlaceholder()?.State.Value == Visibility.Hidden);
+
+            AddStep("delete all beatmaps", () => manager?.Delete());
+            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
+        }
+
+        [Test]
+        public void TestPlaceholderConvertSetting()
+        {
+            changeRuleset(2);
+            addRulesetImportStep(0);
+            AddStep("change convert setting", () => config.SetValue(OsuSetting.ShowConvertedBeatmaps, false));
+
+            createSongSelect();
+
+            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Visible);
+
+            AddStep("click link in placeholder", () => getPlaceholder().ChildrenOfType<DrawableLinkCompiler>().First().TriggerClick());
+
+            AddUntilStep("convert setting changed", () => config.Get<bool>(OsuSetting.ShowConvertedBeatmaps));
+            AddUntilStep("wait for placeholder visible", () => getPlaceholder()?.State.Value == Visibility.Hidden);
+        }
+
         [Test]
         public void TestSingleFilterOnEnter()
         {
@@ -941,6 +973,8 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private int getBeatmapIndex(BeatmapSetInfo set, BeatmapInfo info) => set.Beatmaps.IndexOf(info);
 
+        private NoResultsPlaceholder getPlaceholder() => songSelect.ChildrenOfType<NoResultsPlaceholder>().FirstOrDefault();
+
         private int getCurrentBeatmapIndex() => getBeatmapIndex(songSelect.Carousel.SelectedBeatmapSet, songSelect.Carousel.SelectedBeatmapInfo);
 
         private int getDifficultyIconIndex(DrawableCarouselBeatmapSet set, FilterableDifficultyIcon icon)

osu.Game.Tournament/Components/TournamentMatchChatDisplay.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Online.API;
 using osu.Game.Online.Chat;
 using osu.Game.Overlays.Chat;
 using osu.Game.Tournament.IPC;
@@ -29,7 +30,7 @@ namespace osu.Game.Tournament.Components
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(MatchIPCInfo ipc)
+        private void load(MatchIPCInfo ipc, IAPIProvider api)
         {
             if (ipc != null)
             {
@@ -45,7 +46,7 @@ namespace osu.Game.Tournament.Components
 
                     if (manager == null)
                     {
-                        AddInternal(manager = new ChannelManager { HighPollRate = { Value = true } });
+                        AddInternal(manager = new ChannelManager(api) { HighPollRate = { Value = true } });
                         Channel.BindTo(manager.CurrentChannel);
                     }
 

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -90,6 +90,7 @@ namespace osu.Game.Beatmaps
 
         public double StarRating { get; set; }
 
+        [Indexed]
         public string MD5Hash { get; set; } = string.Empty;
 
         [JsonIgnore]

osu.Game/Beatmaps/BeatmapManager.cs

@@ -319,6 +319,15 @@ namespace osu.Game.Beatmaps
             });
         }
 
+        public void DeleteAllVideos()
+        {
+            realm.Write(r =>
+            {
+                var items = r.All<BeatmapSetInfo>().Where(s => !s.DeletePending && !s.Protected);
+                beatmapModelManager.DeleteVideos(items.ToList());
+            });
+        }
+
         public void UndeleteAll()
         {
             realm.Run(r => beatmapModelManager.Undelete(r.All<BeatmapSetInfo>().Where(s => s.DeletePending).ToList()));
@@ -338,35 +347,17 @@ namespace osu.Game.Beatmaps
 
         #region Implementation of ICanAcceptFiles
 
-        public Task Import(params string[] paths)
-        {
-            return beatmapModelManager.Import(paths);
-        }
+        public Task Import(params string[] paths) => beatmapModelManager.Import(paths);
 
-        public Task Import(params ImportTask[] tasks)
-        {
-            return beatmapModelManager.Import(tasks);
-        }
+        public Task Import(params ImportTask[] tasks) => beatmapModelManager.Import(tasks);
 
-        public Task<IEnumerable<Live<BeatmapSetInfo>>> Import(ProgressNotification notification, params ImportTask[] tasks)
-        {
-            return beatmapModelManager.Import(notification, tasks);
-        }
+        public Task<IEnumerable<Live<BeatmapSetInfo>>> Import(ProgressNotification notification, params ImportTask[] tasks) => beatmapModelManager.Import(notification, tasks);
 
-        public Task<Live<BeatmapSetInfo>?> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default)
-        {
-            return beatmapModelManager.Import(task, lowPriority, cancellationToken);
-        }
+        public Task<Live<BeatmapSetInfo>?> Import(ImportTask task, bool batchImport = false, CancellationToken cancellationToken = default) => beatmapModelManager.Import(task, batchImport, cancellationToken);
 
-        public Task<Live<BeatmapSetInfo>?> Import(ArchiveReader archive, bool lowPriority = false, CancellationToken cancellationToken = default)
-        {
-            return beatmapModelManager.Import(archive, lowPriority, cancellationToken);
-        }
+        public Task<Live<BeatmapSetInfo>?> Import(ArchiveReader archive, bool batchImport = false, CancellationToken cancellationToken = default) => beatmapModelManager.Import(archive, batchImport, cancellationToken);
 
-        public Live<BeatmapSetInfo>? Import(BeatmapSetInfo item, ArchiveReader? archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
-        {
-            return beatmapModelManager.Import(item, archive, lowPriority, cancellationToken);
-        }
+        public Live<BeatmapSetInfo>? Import(BeatmapSetInfo item, ArchiveReader? archive = null, CancellationToken cancellationToken = default) => beatmapModelManager.Import(item, archive, false, cancellationToken);
 
         public IEnumerable<string> HandledExtensions => beatmapModelManager.HandledExtensions;
 

osu.Game/Beatmaps/BeatmapModelManager.cs

@@ -16,6 +16,7 @@ using osu.Game.Database;
 using osu.Game.Extensions;
 using osu.Game.Skinning;
 using osu.Game.Stores;
+using osu.Game.Overlays.Notifications;
 
 #nullable enable
 
@@ -33,6 +34,8 @@ namespace osu.Game.Beatmaps
 
         protected override string[] HashableFileTypes => new[] { ".osu" };
 
+        public static readonly string[] VIDEO_EXTENSIONS = { ".mp4", ".mov", ".avi", ".flv" };
+
         public BeatmapModelManager(RealmAccess realm, Storage storage, BeatmapOnlineLookupQueue? onlineLookupQueue = null)
             : base(realm, storage, onlineLookupQueue)
         {
@@ -114,5 +117,50 @@ namespace osu.Game.Beatmaps
                 item.CopyChangesToRealm(existing);
             });
         }
+
+        /// <summary>
+        /// Delete videos from a list of beatmaps.
+        /// This will post notifications tracking progress.
+        /// </summary>
+        public void DeleteVideos(List<BeatmapSetInfo> items, bool silent = false)
+        {
+            if (items.Count == 0) return;
+
+            var notification = new ProgressNotification
+            {
+                Progress = 0,
+                Text = $"Preparing to delete all {HumanisedModelName} videos...",
+                CompletionText = "No videos found to delete!",
+                State = ProgressNotificationState.Active,
+            };
+
+            if (!silent)
+                PostNotification?.Invoke(notification);
+
+            int i = 0;
+            int deleted = 0;
+
+            foreach (var b in items)
+            {
+                if (notification.State == ProgressNotificationState.Cancelled)
+                    // user requested abort
+                    return;
+
+                var video = b.Files.FirstOrDefault(f => VIDEO_EXTENSIONS.Any(ex => f.Filename.EndsWith(ex, StringComparison.Ordinal)));
+
+                if (video != null)
+                {
+                    DeleteFile(b, video);
+                    deleted++;
+                    notification.CompletionText = $"Deleted {deleted} {HumanisedModelName} video(s)!";
+                }
+
+                notification.Text = $"Deleting videos from {HumanisedModelName}s ({deleted} deleted)";
+
+                notification.Progress = (float)++i / items.Count;
+            }
+
+            notification.State = ProgressNotificationState.Completed;
+        }
     }
 }

osu.Game/Beatmaps/DifficultyRecommender.cs

@@ -7,11 +7,8 @@ using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
-using osu.Game.Extensions;
 using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
 using osu.Game.Rulesets;
 
 namespace osu.Game.Beatmaps
@@ -25,26 +22,15 @@ namespace osu.Game.Beatmaps
         [Resolved]
         private IAPIProvider api { get; set; }
 
-        [Resolved]
-        private IRulesetStore rulesets { get; set; }
-
         [Resolved]
         private Bindable<RulesetInfo> ruleset { get; set; }
 
-        /// <summary>
-        /// The user for which the last requests were run.
-        /// </summary>
-        private int? requestedUserId;
-
-        private readonly Dictionary<IRulesetInfo, double> recommendedDifficultyMapping = new Dictionary<IRulesetInfo, double>();
-
-        private readonly IBindable<APIState> apiState = new Bindable<APIState>();
+        private readonly Dictionary<string, double> recommendedDifficultyMapping = new Dictionary<string, double>();
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            apiState.BindTo(api.State);
-            apiState.BindValueChanged(onlineStateChanged, true);
+            api.LocalUser.BindValueChanged(_ => populateValues(), true);
         }
 
         /// <summary>
@@ -58,12 +44,12 @@ namespace osu.Game.Beatmaps
         [CanBeNull]
         public BeatmapInfo GetRecommendedBeatmap(IEnumerable<BeatmapInfo> beatmaps)
         {
-            foreach (var r in orderedRulesets)
+            foreach (string r in orderedRulesets)
             {
                 if (!recommendedDifficultyMapping.TryGetValue(r, out double recommendation))
                     continue;
 
-                BeatmapInfo beatmapInfo = beatmaps.Where(b => b.Ruleset.Equals(r)).OrderBy(b =>
+                BeatmapInfo beatmapInfo = beatmaps.Where(b => b.Ruleset.ShortName.Equals(r)).OrderBy(b =>
                 {
                     double difference = b.StarRating - recommendation;
                     return difference >= 0 ? difference * 2 : difference * -1; // prefer easier over harder
@@ -76,55 +62,35 @@ namespace osu.Game.Beatmaps
             return null;
         }
 
-        private void fetchRecommendedValues()
+        private void populateValues()
         {
-            if (recommendedDifficultyMapping.Count > 0 && api.LocalUser.Value.Id == requestedUserId)
+            if (api.LocalUser.Value.RulesetsStatistics == null)
                 return;
 
-            requestedUserId = api.LocalUser.Value.Id;
-
-            // only query API for built-in rulesets
-            rulesets.AvailableRulesets.Where(ruleset => ruleset.IsLegacyRuleset()).ForEach(rulesetInfo =>
+            foreach (var kvp in api.LocalUser.Value.RulesetsStatistics)
             {
-                var req = new GetUserRequest(api.LocalUser.Value.Id, rulesetInfo);
-
-                req.Success += result =>
-                {
-                    // algorithm taken from https://github.com/ppy/osu-web/blob/e6e2825516449e3d0f3f5e1852c6bdd3428c3437/app/Models/User.php#L1505
-                    recommendedDifficultyMapping[rulesetInfo] = Math.Pow((double)(result.Statistics.PP ?? 0), 0.4) * 0.195;
-                };
-
-                api.Queue(req);
-            });
+                // algorithm taken from https://github.com/ppy/osu-web/blob/e6e2825516449e3d0f3f5e1852c6bdd3428c3437/app/Models/User.php#L1505
+                recommendedDifficultyMapping[kvp.Key] = Math.Pow((double)(kvp.Value.PP ?? 0), 0.4) * 0.195;
+            }
         }
 
         /// <returns>
         /// Rulesets ordered descending by their respective recommended difficulties.
         /// The currently selected ruleset will always be first.
         /// </returns>
-        private IEnumerable<IRulesetInfo> orderedRulesets
+        private IEnumerable<string> orderedRulesets
         {
             get
             {
                 if (LoadState < LoadState.Ready || ruleset.Value == null)
-                    return Enumerable.Empty<RulesetInfo>();
+                    return Enumerable.Empty<string>();
 
                 return recommendedDifficultyMapping
                        .OrderByDescending(pair => pair.Value)
                        .Select(pair => pair.Key)
-                       .Where(r => !r.Equals(ruleset.Value))
-                       .Prepend(ruleset.Value);
+                       .Where(r => !r.Equals(ruleset.Value.ShortName))
+                       .Prepend(ruleset.Value.ShortName);
             }
         }
-
-        private void onlineStateChanged(ValueChangedEvent<APIState> state) => Schedule(() =>
-        {
-            switch (state.NewValue)
-            {
-                case APIState.Online:
-                    fetchRecommendedValues();
-                    break;
-            }
-        });
     }
 }

osu.Game/Collections/BeatmapCollection.cs

@@ -23,9 +23,9 @@ namespace osu.Game.Collections
         public readonly Bindable<string> Name = new Bindable<string>();
 
         /// <summary>
-        /// The beatmaps contained by the collection.
+        /// The <see cref="BeatmapInfo.MD5Hash"/>es of beatmaps contained by the collection.
         /// </summary>
-        public readonly BindableList<BeatmapInfo> Beatmaps = new BindableList<BeatmapInfo>();
+        public readonly BindableList<string> BeatmapHashes = new BindableList<string>();
 
         /// <summary>
         /// The date when this collection was last modified.
@@ -34,7 +34,7 @@ namespace osu.Game.Collections
 
         public BeatmapCollection()
         {
-            Beatmaps.CollectionChanged += (_, __) => onChange();
+            BeatmapHashes.CollectionChanged += (_, __) => onChange();
             Name.ValueChanged += _ => onChange();
         }
 

osu.Game/Collections/CollectionFilterDropdown.cs

@@ -38,7 +38,7 @@ namespace osu.Game.Collections
         }
 
         private readonly IBindableList<BeatmapCollection> collections = new BindableList<BeatmapCollection>();
-        private readonly IBindableList<BeatmapInfo> beatmaps = new BindableList<BeatmapInfo>();
+        private readonly IBindableList<string> beatmaps = new BindableList<string>();
         private readonly BindableList<CollectionFilterMenuItem> filters = new BindableList<CollectionFilterMenuItem>();
 
         [Resolved(CanBeNull = true)]
@@ -95,10 +95,10 @@ namespace osu.Game.Collections
             beatmaps.CollectionChanged -= filterBeatmapsChanged;
 
             if (filter.OldValue?.Collection != null)
-                beatmaps.UnbindFrom(filter.OldValue.Collection.Beatmaps);
+                beatmaps.UnbindFrom(filter.OldValue.Collection.BeatmapHashes);
 
             if (filter.NewValue?.Collection != null)
-                beatmaps.BindTo(filter.NewValue.Collection.Beatmaps);
+                beatmaps.BindTo(filter.NewValue.Collection.BeatmapHashes);
 
             beatmaps.CollectionChanged += filterBeatmapsChanged;
 
@@ -196,7 +196,7 @@ namespace osu.Game.Collections
             private IBindable<WorkingBeatmap> beatmap { get; set; }
 
             [CanBeNull]
-            private readonly BindableList<BeatmapInfo> collectionBeatmaps;
+            private readonly BindableList<string> collectionBeatmaps;
 
             [NotNull]
             private readonly Bindable<string> collectionName;
@@ -208,7 +208,7 @@ namespace osu.Game.Collections
             public CollectionDropdownMenuItem(MenuItem item)
                 : base(item)
             {
-                collectionBeatmaps = Item.Collection?.Beatmaps.GetBoundCopy();
+                collectionBeatmaps = Item.Collection?.BeatmapHashes.GetBoundCopy();
                 collectionName = Item.CollectionName.GetBoundCopy();
             }
 
@@ -258,7 +258,7 @@ namespace osu.Game.Collections
             {
                 Debug.Assert(collectionBeatmaps != null);
 
-                beatmapInCollection = collectionBeatmaps.Contains(beatmap.Value.BeatmapInfo);
+                beatmapInCollection = collectionBeatmaps.Contains(beatmap.Value.BeatmapInfo.MD5Hash);
 
                 addOrRemoveButton.Enabled.Value = !beatmap.IsDefault;
                 addOrRemoveButton.Icon = beatmapInCollection ? FontAwesome.Solid.MinusSquare : FontAwesome.Solid.PlusSquare;
@@ -285,8 +285,8 @@ namespace osu.Game.Collections
             {
                 Debug.Assert(collectionBeatmaps != null);
 
-                if (!collectionBeatmaps.Remove(beatmap.Value.BeatmapInfo))
-                    collectionBeatmaps.Add(beatmap.Value.BeatmapInfo);
+                if (!collectionBeatmaps.Remove(beatmap.Value.BeatmapInfo.MD5Hash))
+                    collectionBeatmaps.Add(beatmap.Value.BeatmapInfo.MD5Hash);
             }
 
             protected override Drawable CreateContent() => content = (Content)base.CreateContent();

osu.Game/Collections/CollectionManager.cs

@@ -13,7 +13,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
-using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.IO;
 using osu.Game.IO.Legacy;
@@ -40,9 +39,6 @@ namespace osu.Game.Collections
 
         public readonly BindableList<BeatmapCollection> Collections = new BindableList<BeatmapCollection>();
 
-        [Resolved]
-        private BeatmapManager beatmaps { get; set; }
-
         private readonly Storage storage;
 
         public CollectionManager(Storage storage)
@@ -173,10 +169,10 @@ namespace osu.Game.Collections
                         if (existing == null)
                             Collections.Add(existing = new BeatmapCollection { Name = { Value = newCol.Name.Value } });
 
-                        foreach (var newBeatmap in newCol.Beatmaps)
+                        foreach (string newBeatmap in newCol.BeatmapHashes)
                         {
-                            if (!existing.Beatmaps.Contains(newBeatmap))
-                                existing.Beatmaps.Add(newBeatmap);
+                            if (!existing.BeatmapHashes.Contains(newBeatmap))
+                                existing.BeatmapHashes.Add(newBeatmap);
                         }
                     }
 
@@ -226,9 +222,7 @@ namespace osu.Game.Collections
 
                             string checksum = sr.ReadString();
 
-                            var beatmap = beatmaps.QueryBeatmap(b => b.MD5Hash == checksum);
-                            if (beatmap != null)
-                                collection.Beatmaps.Add(beatmap);
+                            collection.BeatmapHashes.Add(checksum);
                         }
 
                         if (notification != null)
@@ -299,11 +293,12 @@ namespace osu.Game.Collections
                             {
                                 sw.Write(c.Name.Value);
 
-                                var beatmapsCopy = c.Beatmaps.ToArray();
+                                string[] beatmapsCopy = c.BeatmapHashes.ToArray();
+
                                 sw.Write(beatmapsCopy.Length);
 
-                                foreach (var b in beatmapsCopy)
-                                    sw.Write(b.MD5Hash);
+                                foreach (string b in beatmapsCopy)
+                                    sw.Write(b);
                             }
                         }
 

osu.Game/Collections/DeleteCollectionDialog.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Collections
         public DeleteCollectionDialog(BeatmapCollection collection, Action deleteAction)
         {
             HeaderText = "Confirm deletion of";
-            BodyText = $"{collection.Name.Value} ({"beatmap".ToQuantity(collection.Beatmaps.Count)})";
+            BodyText = $"{collection.Name.Value} ({"beatmap".ToQuantity(collection.BeatmapHashes.Count)})";
 
             Icon = FontAwesome.Regular.TrashAlt;
 

osu.Game/Collections/DrawableCollectionListItem.cs

@@ -225,7 +225,7 @@ namespace osu.Game.Collections
             {
                 background.FlashColour(Color4.White, 150);
 
-                if (collection.Beatmaps.Count == 0)
+                if (collection.BeatmapHashes.Count == 0)
                     deleteCollection();
                 else
                     dialogOverlay?.Push(new DeleteCollectionDialog(collection, deleteCollection));

osu.Game/Database/ICanAcceptFiles.cs

@@ -12,14 +12,22 @@ namespace osu.Game.Database
     public interface ICanAcceptFiles
     {
         /// <summary>
-        /// Import the specified paths.
+        /// Import one or more items from filesystem <paramref name="paths"/>.
         /// </summary>
+        /// <remarks>
+        /// This will be treated as a low priority batch import if more than one path is specified.
+        /// This will post notifications tracking progress.
+        /// </remarks>
         /// <param name="paths">The files which should be imported.</param>
         Task Import(params string[] paths);
 
         /// <summary>
         /// Import the specified files from the given import tasks.
         /// </summary>
+        /// <remarks>
+        /// This will be treated as a low priority batch import if more than one path is specified.
+        /// This will post notifications tracking progress.
+        /// </remarks>
         /// <param name="tasks">The import tasks from which the files should be imported.</param>
         Task Import(params ImportTask[] tasks);
 

osu.Game/Database/IModelImporter.cs

@@ -1,14 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using osu.Game.IO.Archives;
-using osu.Game.Overlays.Notifications;
-
 #nullable enable
 
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using osu.Game.Overlays.Notifications;
+
 namespace osu.Game.Database
 {
     /// <summary>
@@ -18,35 +16,14 @@ namespace osu.Game.Database
     public interface IModelImporter<TModel> : IPostNotifications, IPostImports<TModel>, ICanAcceptFiles
         where TModel : class, IHasGuidPrimaryKey
     {
+        /// <summary>
+        /// Process multiple import tasks, updating a tracking notification with progress.
+        /// </summary>
+        /// <param name="notification">The notification to update.</param>
+        /// <param name="tasks">The import tasks.</param>
+        /// <returns>The imported models.</returns>
         Task<IEnumerable<Live<TModel>>> Import(ProgressNotification notification, params ImportTask[] tasks);
 
-        /// <summary>
-        /// Import one <typeparamref name="TModel"/> from the filesystem and delete the file on success.
-        /// Note that this bypasses the UI flow and should only be used for special cases or testing.
-        /// </summary>
-        /// <param name="task">The <see cref="ImportTask"/> containing data about the <typeparamref name="TModel"/> to import.</param>
-        /// <param name="lowPriority">Whether this is a low priority import.</param>
-        /// <param name="cancellationToken">An optional cancellation token.</param>
-        /// <returns>The imported model, if successful.</returns>
-        Task<Live<TModel>?> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default);
-
-        /// <summary>
-        /// Silently import an item from an <see cref="ArchiveReader"/>.
-        /// </summary>
-        /// <param name="archive">The archive to be imported.</param>
-        /// <param name="lowPriority">Whether this is a low priority import.</param>
-        /// <param name="cancellationToken">An optional cancellation token.</param>
-        Task<Live<TModel>?> Import(ArchiveReader archive, bool lowPriority = false, CancellationToken cancellationToken = default);
-
-        /// <summary>
-        /// Silently import an item from a <typeparamref name="TModel"/>.
-        /// </summary>
-        /// <param name="item">The model to be imported.</param>
-        /// <param name="archive">An optional archive to use for model population.</param>
-        /// <param name="lowPriority">Whether this is a low priority import.</param>
-        /// <param name="cancellationToken">An optional cancellation token.</param>
-        Live<TModel>? Import(TModel item, ArchiveReader? archive = null, bool lowPriority = false, CancellationToken cancellationToken = default);
-
         /// <summary>
         /// A user displayable name for the model type associated with this manager.
         /// </summary>

osu.Game/Database/LegacyBeatmapImporter.cs

@@ -1,6 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.IO.Stores;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.IO;
@@ -13,6 +16,24 @@ namespace osu.Game.Database
 
         protected override Storage PrepareStableStorage(StableStorage stableStorage) => stableStorage.GetSongStorage();
 
+        protected override IEnumerable<string> GetStableImportPaths(Storage storage)
+        {
+            foreach (string directory in storage.GetDirectories(string.Empty))
+            {
+                var directoryStorage = storage.GetStorageForDirectory(directory);
+
+                if (!directoryStorage.GetFiles(string.Empty).ExcludeSystemFileNames().Any())
+                {
+                    // if a directory doesn't contain files, attempt looking for beatmaps inside of that directory.
+                    // this is a special behaviour in stable for beatmaps only, see https://github.com/ppy/osu/issues/18615.
+                    foreach (string subDirectory in GetStableImportPaths(directoryStorage))
+                        yield return subDirectory;
+                }
+                else
+                    yield return storage.GetFullPath(directory);
+            }
+        }
+
         public LegacyBeatmapImporter(IModelImporter<BeatmapSetInfo> importer)
             : base(importer)
         {

osu.Game/Graphics/Containers/ScalingContainer.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Graphics.Containers
     /// </summary>
     public class ScalingContainer : Container
     {
-        private const float duration = 500;
+        internal const float TRANSITION_DURATION = 500;
 
         private Bindable<float> sizeX;
         private Bindable<float> sizeY;
@@ -99,7 +99,7 @@ namespace osu.Game.Graphics.Containers
                 if (applyUIScale)
                 {
                     uiScale = osuConfig.GetBindable<float>(OsuSetting.UIScale);
-                    uiScale.BindValueChanged(args => this.TransformTo(nameof(CurrentScale), args.NewValue, duration, Easing.OutQuart), true);
+                    uiScale.BindValueChanged(args => this.TransformTo(nameof(CurrentScale), args.NewValue, TRANSITION_DURATION, Easing.OutQuart), true);
                 }
             }
 
@@ -163,10 +163,10 @@ namespace osu.Game.Graphics.Containers
                         backgroundStack.Push(new ScalingBackgroundScreen());
                     }
 
-                    backgroundStack.FadeIn(duration);
+                    backgroundStack.FadeIn(TRANSITION_DURATION);
                 }
                 else
-                    backgroundStack?.FadeOut(duration);
+                    backgroundStack?.FadeOut(TRANSITION_DURATION);
             }
 
             RectangleF targetRect = new RectangleF(Vector2.Zero, Vector2.One);
@@ -195,13 +195,13 @@ namespace osu.Game.Graphics.Containers
             if (requiresMasking)
                 sizableContainer.Masking = true;
 
-            sizableContainer.MoveTo(targetRect.Location, duration, Easing.OutQuart);
-            sizableContainer.ResizeTo(targetRect.Size, duration, Easing.OutQuart);
+            sizableContainer.MoveTo(targetRect.Location, TRANSITION_DURATION, Easing.OutQuart);
+            sizableContainer.ResizeTo(targetRect.Size, TRANSITION_DURATION, Easing.OutQuart);
 
             // Of note, this will not work great in the case of nested ScalingContainers where multiple are applying corner radius.
             // Masking and corner radius should likely only be applied at one point in the full game stack to fix this.
             // An example of how this can occur is when the skin editor is visible and the game screen scaling is set to "Everything".
-            sizableContainer.TransformTo(nameof(CornerRadius), requiresMasking ? corner_radius : 0, duration, requiresMasking ? Easing.OutQuart : Easing.None)
+            sizableContainer.TransformTo(nameof(CornerRadius), requiresMasking ? corner_radius : 0, TRANSITION_DURATION, requiresMasking ? Easing.OutQuart : Easing.None)
                             .OnComplete(_ => { sizableContainer.Masking = requiresMasking; });
         }
 

osu.Game/Graphics/OsuFont.cs

@@ -35,7 +35,10 @@ namespace osu.Game.Graphics
         /// <param name="fixedWidth">Whether all characters should be spaced the same distance apart.</param>
         /// <returns>The <see cref="FontUsage"/>.</returns>
         public static FontUsage GetFont(Typeface typeface = Typeface.Torus, float size = DEFAULT_FONT_SIZE, FontWeight weight = FontWeight.Medium, bool italics = false, bool fixedWidth = false)
-            => new FontUsage(GetFamilyString(typeface), size, GetWeightString(typeface, weight), getItalics(italics), fixedWidth);
+        {
+            string familyString = GetFamilyString(typeface);
+            return new FontUsage(familyString, size, GetWeightString(familyString, weight), getItalics(italics), fixedWidth);
+        }
 
         private static bool getItalics(in bool italicsRequested)
         {
@@ -54,16 +57,16 @@ namespace osu.Game.Graphics
             switch (typeface)
             {
                 case Typeface.Venera:
-                    return "Venera";
+                    return @"Venera";
 
                 case Typeface.Torus:
-                    return "Torus";
+                    return @"Torus";
 
                 case Typeface.TorusAlternate:
-                    return "Torus-Alternate";
+                    return @"Torus-Alternate";
 
                 case Typeface.Inter:
-                    return "Inter";
+                    return @"Inter";
             }
 
             return null;
@@ -72,25 +75,17 @@ namespace osu.Game.Graphics
         /// <summary>
         /// Retrieves the string representation of a <see cref="FontWeight"/>.
         /// </summary>
-        /// <param name="typeface">The <see cref="Typeface"/>.</param>
-        /// <param name="weight">The <see cref="FontWeight"/>.</param>
-        /// <returns>The string representation of <paramref name="weight"/> in the specified <paramref name="typeface"/>.</returns>
-        public static string GetWeightString(Typeface typeface, FontWeight weight)
+        /// <param name="family">The font family.</param>
+        /// <param name="weight">The font weight.</param>
+        /// <returns>The string representation of <paramref name="weight"/> in the specified <paramref name="family"/>.</returns>
+        public static string GetWeightString(string family, FontWeight weight)
         {
-            if (typeface == Typeface.Torus && weight == FontWeight.Medium)
+            if ((family == GetFamilyString(Typeface.Torus) || family == GetFamilyString(Typeface.TorusAlternate)) && weight == FontWeight.Medium)
                 // torus doesn't have a medium; fallback to regular.
                 weight = FontWeight.Regular;
 
-            return GetWeightString(GetFamilyString(typeface), weight);
+            return weight.ToString();
         }
-
-        /// <summary>
-        /// Retrieves the string representation of a <see cref="FontWeight"/>.
-        /// </summary>
-        /// <param name="family">The family string.</param>
-        /// <param name="weight">The <see cref="FontWeight"/>.</param>
-        /// <returns>The string representation of <paramref name="weight"/> in the specified <paramref name="family"/>.</returns>
-        public static string GetWeightString(string family, FontWeight weight) => weight.ToString();
     }
 
     public static class OsuFontExtensions

osu.Game/Graphics/UserInterface/HoverSampleSet.cs

@@ -20,6 +20,12 @@ namespace osu.Game.Graphics.UserInterface
         TabSelect,
 
         [Description("scrolltotop")]
-        ScrollToTop
+        ScrollToTop,
+
+        [Description("dialog-cancel")]
+        DialogCancel,
+
+        [Description("dialog-ok")]
+        DialogOk
     }
 }

osu.Game/Graphics/UserInterfaceV2/OsuFileSelector.cs

@@ -2,11 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.IO;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
@@ -65,6 +67,9 @@ namespace osu.Game.Graphics.UserInterfaceV2
             {
                 get
                 {
+                    if (BeatmapModelManager.VIDEO_EXTENSIONS.Contains(File.Extension))
+                        return FontAwesome.Regular.FileVideo;
+
                     switch (File.Extension)
                     {
                         case @".ogg":
@@ -77,12 +82,6 @@ namespace osu.Game.Graphics.UserInterfaceV2
                         case @".png":
                             return FontAwesome.Regular.FileImage;
 
-                        case @".mp4":
-                        case @".avi":
-                        case @".mov":
-                        case @".flv":
-                            return FontAwesome.Regular.FileVideo;
-
                         default:
                             return FontAwesome.Regular.File;
                     }

osu.Game/IO/StableStorage.cs

@@ -14,7 +14,7 @@ namespace osu.Game.IO
     /// </summary>
     public class StableStorage : DesktopStorage
     {
-        private const string stable_default_songs_path = "Songs";
+        public const string STABLE_DEFAULT_SONGS_PATH = "Songs";
 
         private readonly DesktopGameHost host;
         private readonly Lazy<string> songsPath;
@@ -62,7 +62,7 @@ namespace osu.Game.IO
                 }
             }
 
-            return GetFullPath(stable_default_songs_path);
+            return GetFullPath(STABLE_DEFAULT_SONGS_PATH);
         }
     }
 }

osu.Game/Localisation/AudioSettingsStrings.cs

@@ -30,12 +30,12 @@ namespace osu.Game.Localisation
         public static LocalisableString OutputDevice => new TranslatableString(getKey(@"output_device"), @"Output device");
 
         /// <summary>
-        /// "Master"
+        /// "Hitsound stereo separation"
         /// </summary>
         public static LocalisableString PositionalLevel => new TranslatableString(getKey(@"positional_hitsound_audio_level"), @"Hitsound stereo separation");
 
         /// <summary>
-        /// "Level"
+        /// "Master"
         /// </summary>
         public static LocalisableString MasterVolume => new TranslatableString(getKey(@"master_volume"), @"Master");
 
@@ -69,6 +69,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString OffsetWizard => new TranslatableString(getKey(@"offset_wizard"), @"Offset wizard");
 
-        private static string getKey(string key) => $"{prefix}:{key}";
+        private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }

osu.Game/Localisation/GlobalActionKeyBindingStrings.cs

@@ -210,7 +210,7 @@ namespace osu.Game.Localisation
         public static LocalisableString ToggleInGameInterface => new TranslatableString(getKey(@"toggle_in_game_interface"), @"Toggle in-game interface");
 
         /// <summary>
-        /// "Toggle Mod Select"
+        /// "Toggle mod select"
         /// </summary>
         public static LocalisableString ToggleModSelection => new TranslatableString(getKey(@"toggle_mod_selection"), @"Toggle mod select");
 
@@ -299,6 +299,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString ToggleChatFocus => new TranslatableString(getKey(@"toggle_chat_focus"), @"Toggle chat focus");
 
-        private static string getKey(string key) => $"{prefix}:{key}";
+        private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }

osu.Game/Localisation/GraphicsSettingsStrings.cs

@@ -34,11 +34,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString ShowFPS => new TranslatableString(getKey(@"show_fps"), @"Show FPS");
 
-        /// <summary>
-        /// "Using unlimited frame limiter can lead to stutters, bad performance and overheating. It will not improve perceived latency. "2x refresh rate" is recommended."
-        /// </summary>
-        public static LocalisableString UnlimitedFramesNote => new TranslatableString(getKey(@"unlimited_frames_note"), @"Using unlimited frame limiter can lead to stutters, bad performance and overheating. It will not improve perceived latency. ""2x refresh rate"" is recommended.");
-
         /// <summary>
         /// "Layout"
         /// </summary>

osu.Game/Localisation/JoystickSettingsStrings.cs

@@ -15,10 +15,10 @@ namespace osu.Game.Localisation
         public static LocalisableString JoystickGamepad => new TranslatableString(getKey(@"joystick_gamepad"), @"Joystick / Gamepad");
 
         /// <summary>
-        /// "Deadzone Threshold"
+        /// "Deadzone"
         /// </summary>
         public static LocalisableString DeadzoneThreshold => new TranslatableString(getKey(@"deadzone_threshold"), @"Deadzone");
 
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
-}
+}

osu.Game/Localisation/MaintenanceSettingsStrings.cs

@@ -29,6 +29,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString DeleteAllBeatmaps => new TranslatableString(getKey(@"delete_all_beatmaps"), @"Delete ALL beatmaps");
 
+        /// <summary>
+        /// "Delete ALL beatmap videos"
+        /// </summary>
+        public static LocalisableString DeleteAllBeatmapVideos => new TranslatableString(getKey(@"delete_all_beatmap_videos"), @"Delete ALL beatmap videos");
+
         /// <summary>
         /// "Import scores from stable"
         /// </summary>

osu.Game/Localisation/SkinSettingsStrings.cs

@@ -54,6 +54,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString ExportSkinButton => new TranslatableString(getKey(@"export_skin_button"), @"Export selected skin");
 
+        /// <summary>
+        /// "Delete selected skin"
+        /// </summary>
+        public static LocalisableString DeleteSkinButton => new TranslatableString(getKey(@"delete_skin_button"), @"Delete selected skin");
+
         private static string getKey(string key) => $"{prefix}:{key}";
     }
 }

osu.Game/Online/Chat/ChannelManager.cs

@@ -61,8 +61,7 @@ namespace osu.Game.Online.Chat
         /// </summary>
         public IBindableList<Channel> AvailableChannels => availableChannels;
 
-        [Resolved]
-        private IAPIProvider api { get; set; }
+        private readonly IAPIProvider api;
 
         [Resolved]
         private UserLookupCache users { get; set; }
@@ -71,8 +70,9 @@ namespace osu.Game.Online.Chat
 
         private readonly IBindable<bool> isIdle = new BindableBool();
 
-        public ChannelManager()
+        public ChannelManager(IAPIProvider api)
         {
+            this.api = api;
             CurrentChannel.ValueChanged += currentChannelChanged;
         }
 

osu.Game/Online/Chat/MessageNotifier.cs

@@ -77,7 +77,7 @@ namespace osu.Game.Online.Chat
             if (!messages.Any())
                 return;
 
-            var channel = channelManager.JoinedChannels.SingleOrDefault(c => c.Id == messages.First().ChannelId);
+            var channel = channelManager.JoinedChannels.SingleOrDefault(c => c.Id > 0 && c.Id == messages.First().ChannelId);
 
             if (channel == null)
                 return;

osu.Game/Online/Chat/StandAloneChatDisplay.cs

@@ -155,39 +155,42 @@ namespace osu.Game.Online.Chat
         {
             public Func<Message, ChatLine> CreateChatLineAction;
 
-            [Resolved]
-            private OsuColour colours { get; set; }
-
             public StandAloneDrawableChannel(Channel channel)
                 : base(channel)
             {
             }
 
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                ChatLineFlow.Padding = new MarginPadding { Horizontal = 0 };
-            }
-
             protected override ChatLine CreateChatLine(Message m) => CreateChatLineAction(m);
 
-            protected override Drawable CreateDaySeparator(DateTimeOffset time) => new DaySeparator(time)
+            protected override DaySeparator CreateDaySeparator(DateTimeOffset time) => new StandAloneDaySeparator(time);
+        }
+
+        protected class StandAloneDaySeparator : DaySeparator
+        {
+            protected override float TextSize => 14;
+            protected override float LineHeight => 1;
+            protected override float Spacing => 5;
+            protected override float DateAlign => 125;
+
+            public StandAloneDaySeparator(DateTimeOffset time)
+                : base(time)
             {
-                TextSize = 14,
-                Colour = colours.Yellow,
-                LineHeight = 1,
-                Padding = new MarginPadding { Horizontal = 10 },
-                Margin = new MarginPadding { Vertical = 5 },
-            };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                Height = 25;
+                Colour = colours.Yellow;
+            }
         }
 
         protected class StandAloneMessage : ChatLine
         {
             protected override float TextSize => 15;
-
-            protected override float HorizontalPadding => 10;
-            protected override float MessagePadding => 120;
-            protected override float TimestampPadding => 50;
+            protected override float Spacing => 5;
+            protected override float TimestampWidth => 45;
+            protected override float UsernameWidth => 75;
 
             public StandAloneMessage(Message message)
                 : base(message)

osu.Game/Online/Multiplayer/MultiplayerClient.cs

@@ -197,6 +197,7 @@ namespace osu.Game.Online.Multiplayer
 
                     APIRoom.Playlist.Clear();
                     APIRoom.Playlist.AddRange(joinedRoom.Playlist.Select(createPlaylistItem));
+                    APIRoom.CurrentPlaylistItem.Value = APIRoom.Playlist.Single(item => item.ID == joinedRoom.Settings.PlaylistItemId);
 
                     Debug.Assert(LocalUser != null);
                     addUserToAPIRoom(LocalUser);
@@ -737,6 +738,7 @@ namespace osu.Game.Online.Multiplayer
             APIRoom.Type.Value = Room.Settings.MatchType;
             APIRoom.QueueMode.Value = Room.Settings.QueueMode;
             APIRoom.AutoStartDuration.Value = Room.Settings.AutoStartDuration;
+            APIRoom.CurrentPlaylistItem.Value = APIRoom.Playlist.Single(item => item.ID == settings.PlaylistItemId);
 
             RoomUpdated?.Invoke();
         }

osu.Game/Online/ProductionEndpointConfiguration.cs

@@ -10,8 +10,8 @@ namespace osu.Game.Online
             WebsiteRootUrl = APIEndpointUrl = @"https://osu.ppy.sh";
             APIClientSecret = @"FGc9GAtyHzeQDshWP5Ah7dega8hJACAJpQtw6OXk";
             APIClientID = "5";
-            SpectatorEndpointUrl = "https://spectator2.ppy.sh/spectator";
-            MultiplayerEndpointUrl = "https://spectator2.ppy.sh/multiplayer";
+            SpectatorEndpointUrl = "https://spectator.ppy.sh/spectator";
+            MultiplayerEndpointUrl = "https://spectator.ppy.sh/multiplayer";
         }
     }
 }

osu.Game/Online/Rooms/PlaylistItem.cs

@@ -61,7 +61,13 @@ namespace osu.Game.Online.Rooms
         /// Used for serialising to the API.
         /// </summary>
         [JsonProperty("beatmap_id")]
-        private int onlineBeatmapId => Beatmap.OnlineID;
+        private int onlineBeatmapId
+        {
+            get => Beatmap.OnlineID;
+            // This setter is only required for client-side serialise-then-deserialise operations.
+            // Serialisation is supposed to emit only a `beatmap_id`, but a (non-null) `beatmap` is required on deserialise.
+            set => Beatmap = new APIBeatmap { OnlineID = value };
+        }
 
         /// <summary>
         /// A beatmap representing this playlist item.

osu.Game/Online/Rooms/Room.cs

@@ -162,6 +162,13 @@ namespace osu.Game.Online.Rooms
             Password.BindValueChanged(p => HasPassword.Value = !string.IsNullOrEmpty(p.NewValue));
         }
 
+        /// <summary>
+        /// Copies values from another <see cref="Room"/> into this one.
+        /// </summary>
+        /// <remarks>
+        /// **Beware**: This will store references between <see cref="Room"/>s.
+        /// </remarks>
+        /// <param name="other">The <see cref="Room"/> to copy values from.</param>
         public void CopyFrom(Room other)
         {
             RoomID.Value = other.RoomID.Value;

osu.Game/Online/Spectator/SpectatorClient.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Online.Spectator
         /// <summary>
         /// The states of all users currently being watched.
         /// </summary>
-        public IBindableDictionary<int, SpectatorState> WatchedUserStates => watchedUserStates;
+        public virtual IBindableDictionary<int, SpectatorState> WatchedUserStates => watchedUserStates;
 
         /// <summary>
         /// A global list of all players currently playing.
@@ -172,6 +172,7 @@ namespace osu.Game.Online.Spectator
                 currentState.RulesetID = score.ScoreInfo.RulesetID;
                 currentState.Mods = score.ScoreInfo.Mods.Select(m => new APIMod(m)).ToArray();
                 currentState.State = SpectatedUserState.Playing;
+                currentState.MaximumScoringValues = state.ScoreProcessor.MaximumScoringValues;
 
                 currentBeatmap = state.Beatmap;
                 currentScore = score;

osu.Game/Online/Spectator/SpectatorScoreProcessor.cs

@@ -0,0 +1,192 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Timing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+
+namespace osu.Game.Online.Spectator
+{
+    /// <summary>
+    /// A wrapper over a <see cref="ScoreProcessor"/> for spectated users.
+    /// This should be used when a local "playable" beatmap is unavailable or expensive to generate for the spectated user.
+    /// </summary>
+    public class SpectatorScoreProcessor : Component
+    {
+        /// <summary>
+        /// The current total score.
+        /// </summary>
+        public readonly BindableDouble TotalScore = new BindableDouble { MinValue = 0 };
+
+        /// <summary>
+        /// The current accuracy.
+        /// </summary>
+        public readonly BindableDouble Accuracy = new BindableDouble(1) { MinValue = 0, MaxValue = 1 };
+
+        /// <summary>
+        /// The current combo.
+        /// </summary>
+        public readonly BindableInt Combo = new BindableInt();
+
+        /// <summary>
+        /// The <see cref="ScoringMode"/> used to calculate scores.
+        /// </summary>
+        public readonly Bindable<ScoringMode> Mode = new Bindable<ScoringMode>();
+
+        /// <summary>
+        /// The applied <see cref="Mod"/>s.
+        /// </summary>
+        public IReadOnlyList<Mod> Mods => scoreProcessor?.Mods.Value ?? Array.Empty<Mod>();
+
+        private IClock? referenceClock;
+
+        /// <summary>
+        /// The clock used to determine the current score.
+        /// </summary>
+        public IClock ReferenceClock
+        {
+            get => referenceClock ?? Clock;
+            set => referenceClock = value;
+        }
+
+        [Resolved]
+        private SpectatorClient spectatorClient { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesetStore { get; set; } = null!;
+
+        private readonly IBindableDictionary<int, SpectatorState> spectatorStates = new BindableDictionary<int, SpectatorState>();
+        private readonly List<TimedFrame> replayFrames = new List<TimedFrame>();
+        private readonly int userId;
+
+        private SpectatorState? spectatorState;
+        private ScoreProcessor? scoreProcessor;
+        private ScoreInfo? scoreInfo;
+
+        public SpectatorScoreProcessor(int userId)
+        {
+            this.userId = userId;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Mode.BindValueChanged(_ => UpdateScore());
+
+            spectatorStates.BindTo(spectatorClient.WatchedUserStates);
+            spectatorStates.BindCollectionChanged(onSpectatorStatesChanged, true);
+
+            spectatorClient.OnNewFrames += onNewFrames;
+        }
+
+        private void onSpectatorStatesChanged(object? sender, NotifyDictionaryChangedEventArgs<int, SpectatorState> e)
+        {
+            if (!spectatorStates.TryGetValue(userId, out var userState) || userState.BeatmapID == null || userState.RulesetID == null)
+            {
+                scoreProcessor?.RemoveAndDisposeImmediately();
+                scoreProcessor = null;
+                scoreInfo = null;
+                spectatorState = null;
+                replayFrames.Clear();
+                return;
+            }
+
+            if (scoreProcessor != null)
+                return;
+
+            Debug.Assert(scoreInfo == null);
+
+            RulesetInfo? rulesetInfo = rulesetStore.GetRuleset(userState.RulesetID.Value);
+            if (rulesetInfo == null)
+                return;
+
+            Ruleset ruleset = rulesetInfo.CreateInstance();
+
+            spectatorState = userState;
+            scoreInfo = new ScoreInfo { Ruleset = rulesetInfo };
+            scoreProcessor = ruleset.CreateScoreProcessor();
+            scoreProcessor.Mods.Value = userState.Mods.Select(m => m.ToMod(ruleset)).ToArray();
+        }
+
+        private void onNewFrames(int incomingUserId, FrameDataBundle bundle)
+        {
+            if (incomingUserId != userId)
+                return;
+
+            Schedule(() =>
+            {
+                if (scoreProcessor == null)
+                    return;
+
+                replayFrames.Add(new TimedFrame(bundle.Frames.First().Time, bundle.Header));
+                UpdateScore();
+            });
+        }
+
+        public void UpdateScore()
+        {
+            if (scoreInfo == null || replayFrames.Count == 0)
+                return;
+
+            Debug.Assert(spectatorState != null);
+            Debug.Assert(scoreProcessor != null);
+
+            int frameIndex = replayFrames.BinarySearch(new TimedFrame(ReferenceClock.CurrentTime));
+            if (frameIndex < 0)
+                frameIndex = ~frameIndex;
+            frameIndex = Math.Clamp(frameIndex - 1, 0, replayFrames.Count - 1);
+
+            TimedFrame frame = replayFrames[frameIndex];
+            Debug.Assert(frame.Header != null);
+
+            scoreInfo.MaxCombo = frame.Header.MaxCombo;
+            scoreInfo.Statistics = frame.Header.Statistics;
+
+            Accuracy.Value = frame.Header.Accuracy;
+            Combo.Value = frame.Header.Combo;
+
+            scoreProcessor.ExtractScoringValues(frame.Header, out var currentScoringValues, out _);
+            TotalScore.Value = scoreProcessor.ComputeScore(Mode.Value, currentScoringValues, spectatorState.MaximumScoringValues);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (spectatorClient.IsNotNull())
+                spectatorClient.OnNewFrames -= onNewFrames;
+        }
+
+        private class TimedFrame : IComparable<TimedFrame>
+        {
+            public readonly double Time;
+            public readonly FrameHeader? Header;
+
+            public TimedFrame(double time)
+            {
+                Time = time;
+            }
+
+            public TimedFrame(double time, FrameHeader header)
+            {
+                Time = time;
+                Header = header;
+            }
+
+            public int CompareTo(TimedFrame other) => Time.CompareTo(other.Time);
+        }
+    }
+}

osu.Game/Online/Spectator/SpectatorState.cs

@@ -7,6 +7,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using MessagePack;
 using osu.Game.Online.API;
+using osu.Game.Scoring;
 
 namespace osu.Game.Online.Spectator
 {
@@ -27,6 +28,9 @@ namespace osu.Game.Online.Spectator
         [Key(3)]
         public SpectatedUserState State { get; set; }
 
+        [Key(4)]
+        public ScoringValues MaximumScoringValues { get; set; }
+
         public bool Equals(SpectatorState other)
         {
             if (ReferenceEquals(null, other)) return false;

osu.Game/OsuGame.cs

@@ -851,7 +851,7 @@ namespace osu.Game
             loadComponentSingleFile(dashboard = new DashboardOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(news = new NewsOverlay(), overlayContent.Add, true);
             var rankingsOverlay = loadComponentSingleFile(new RankingsOverlay(), overlayContent.Add, true);
-            loadComponentSingleFile(channelManager = new ChannelManager(), AddInternal, true);
+            loadComponentSingleFile(channelManager = new ChannelManager(API), AddInternal, true);
             loadComponentSingleFile(chatOverlay = new ChatOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(new MessageNotifier(), AddInternal, true);
             loadComponentSingleFile(Settings = new SettingsOverlay(), leftFloatingOverlayContent.Add, true);

osu.Game/Overlays/BeatmapSet/Scores/ScoresContainer.cs

@@ -242,8 +242,6 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
                 modSelector.DeselectAll();
             else
                 getScores();
-
-            modSelector.FadeTo(userIsSupporter ? 1 : 0);
         }
 
         private void getScores()
@@ -260,7 +258,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
                 return;
             }
 
-            if (scope.Value != BeatmapLeaderboardScope.Global && !userIsSupporter)
+            if ((scope.Value != BeatmapLeaderboardScope.Global || modSelector.SelectedMods.Count > 0) && !userIsSupporter)
             {
                 Scores = null;
                 notSupporterPlaceholder.Show();

osu.Game/Overlays/Chat/ChatLine.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable enable
+
 using System;
 using System.Linq;
 using System.Collections.Generic;
@@ -26,42 +28,6 @@ namespace osu.Game.Overlays.Chat
 {
     public class ChatLine : CompositeDrawable
     {
-        public const float LEFT_PADDING = default_message_padding + default_horizontal_padding * 2;
-
-        private const float default_message_padding = 200;
-
-        protected virtual float MessagePadding => default_message_padding;
-
-        private const float default_timestamp_padding = 65;
-
-        protected virtual float TimestampPadding => default_timestamp_padding;
-
-        private const float default_horizontal_padding = 15;
-
-        protected virtual float HorizontalPadding => default_horizontal_padding;
-
-        protected virtual float TextSize => 20;
-
-        private Color4 usernameColour;
-
-        private OsuSpriteText timestamp;
-
-        public ChatLine(Message message)
-        {
-            Message = message;
-            Padding = new MarginPadding { Left = HorizontalPadding, Right = HorizontalPadding };
-            RelativeSizeAxes = Axes.X;
-            AutoSizeAxes = Axes.Y;
-        }
-
-        [Resolved(CanBeNull = true)]
-        private ChannelManager chatManager { get; set; }
-
-        private Message message;
-        private OsuSpriteText username;
-
-        public LinkFlowContainer ContentFlow { get; private set; }
-
         public Message Message
         {
             get => message;
@@ -78,119 +44,101 @@ namespace osu.Game.Overlays.Chat
             }
         }
 
+        public LinkFlowContainer ContentFlow { get; private set; } = null!;
+
+        protected virtual float TextSize => 20;
+
+        protected virtual float Spacing => 15;
+
+        protected virtual float TimestampWidth => 60;
+
+        protected virtual float UsernameWidth => 130;
+
+        private Color4 usernameColour;
+
+        private OsuSpriteText timestamp = null!;
+
+        private Message message = null!;
+
+        private OsuSpriteText username = null!;
+
+        private Container? highlight;
+
         private bool senderHasColour => !string.IsNullOrEmpty(message.Sender.Colour);
 
+        private bool messageHasColour => Message.IsAction && senderHasColour;
+
         [Resolved]
-        private OsuColour colours { get; set; }
+        private ChannelManager? chatManager { get; set; }
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        public ChatLine(Message message)
+        {
+            Message = message;
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+        }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OverlayColourProvider? colourProvider)
         {
             usernameColour = senderHasColour
                 ? Color4Extensions.FromHex(message.Sender.Colour)
                 : username_colours[message.Sender.Id % username_colours.Length];
 
-            Drawable effectedUsername = username = new OsuSpriteText
+            InternalChild = new GridContainer
             {
-                Shadow = false,
-                Colour = senderHasColour ? colours.ChatBlue : usernameColour,
-                Truncate = true,
-                EllipsisString = "… :",
-                Font = OsuFont.GetFont(size: TextSize, weight: FontWeight.Bold, italics: true),
-                Anchor = Anchor.TopRight,
-                Origin = Anchor.TopRight,
-                MaxWidth = MessagePadding - TimestampPadding
-            };
-
-            if (senderHasColour)
-            {
-                // Background effect
-                effectedUsername = new Container
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
+                ColumnDimensions = new[]
                 {
-                    AutoSizeAxes = Axes.Both,
-                    Masking = true,
-                    CornerRadius = 4,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Roundness = 1,
-                        Radius = 1,
-                        Colour = Color4.Black.Opacity(0.3f),
-                        Offset = new Vector2(0, 1),
-                        Type = EdgeEffectType.Shadow,
-                    },
-                    Child = new Container
-                    {
-                        AutoSizeAxes = Axes.Both,
-                        Y = 0,
-                        Masking = true,
-                        CornerRadius = 4,
-                        Children = new Drawable[]
-                        {
-                            new Box
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Colour = usernameColour,
-                            },
-                            new Container
-                            {
-                                AutoSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Left = 4, Right = 4, Bottom = 1, Top = -2 },
-                                Child = username
-                            }
-                        }
-                    }
-                };
-            }
-
-            InternalChildren = new Drawable[]
-            {
-                new Container
-                {
-                    Size = new Vector2(MessagePadding, TextSize),
-                    Children = new Drawable[]
-                    {
-                        timestamp = new OsuSpriteText
-                        {
-                            Shadow = false,
-                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.CentreLeft,
-                            Font = OsuFont.GetFont(size: TextSize * 0.75f, weight: FontWeight.SemiBold, fixedWidth: true)
-                        },
-                        new MessageSender(message.Sender)
-                        {
-                            AutoSizeAxes = Axes.Both,
-                            Origin = Anchor.TopRight,
-                            Anchor = Anchor.TopRight,
-                            Child = effectedUsername,
-                        },
-                    }
+                    new Dimension(GridSizeMode.Absolute, TimestampWidth + Spacing + UsernameWidth + Spacing),
+                    new Dimension(),
                 },
-                new Container
+                Content = new[]
                 {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
-                    Padding = new MarginPadding { Left = MessagePadding + HorizontalPadding },
-                    Children = new Drawable[]
+                    new Drawable[]
                     {
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Children = new Drawable[]
+                            {
+                                timestamp = new OsuSpriteText
+                                {
+                                    Shadow = false,
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Font = OsuFont.GetFont(size: TextSize * 0.75f, weight: FontWeight.SemiBold, fixedWidth: true),
+                                    MaxWidth = TimestampWidth,
+                                    Colour = colourProvider?.Background1 ?? Colour4.White,
+                                },
+                                new MessageSender(message.Sender)
+                                {
+                                    Width = UsernameWidth,
+                                    AutoSizeAxes = Axes.Y,
+                                    Origin = Anchor.TopRight,
+                                    Anchor = Anchor.TopRight,
+                                    Child = createUsername(),
+                                    Margin = new MarginPadding { Horizontal = Spacing },
+                                },
+                            },
+                        },
                         ContentFlow = new LinkFlowContainer(t =>
                         {
                             t.Shadow = false;
-
-                            if (Message.IsAction)
-                            {
-                                t.Font = OsuFont.GetFont(italics: true);
-
-                                if (senderHasColour)
-                                    t.Colour = Color4Extensions.FromHex(message.Sender.Colour);
-                            }
-
-                            t.Font = t.Font.With(size: TextSize);
+                            t.Font = t.Font.With(size: TextSize, italics: Message.IsAction);
+                            t.Colour = messageHasColour ? Color4Extensions.FromHex(message.Sender.Colour) : colourProvider?.Content1 ?? Colour4.White;
                         })
                         {
                             AutoSizeAxes = Axes.Y,
                             RelativeSizeAxes = Axes.X,
                         }
-                    }
+                    },
                 }
             };
         }
@@ -203,8 +151,6 @@ namespace osu.Game.Overlays.Chat
             FinishTransforms(true);
         }
 
-        private Container highlight;
-
         /// <summary>
         /// Performs a highlight animation on this <see cref="ChatLine"/>.
         /// </summary>
@@ -233,7 +179,7 @@ namespace osu.Game.Overlays.Chat
             timestamp.FadeTo(message is LocalEchoMessage ? 0 : 1, 500, Easing.OutQuint);
 
             timestamp.Text = $@"{message.Timestamp.LocalDateTime:HH:mm:ss}";
-            username.Text = $@"{message.Sender.Username}" + (senderHasColour || message.IsAction ? "" : ":");
+            username.Text = $@"{message.Sender.Username}";
 
             // remove non-existent channels from the link list
             message.Links.RemoveAll(link => link.Action == LinkAction.OpenChannel && chatManager?.AvailableChannels.Any(c => c.Name == link.Argument.ToString()) != true);
@@ -242,22 +188,78 @@ namespace osu.Game.Overlays.Chat
             ContentFlow.AddLinks(message.DisplayContent, message.Links);
         }
 
+        private Drawable createUsername()
+        {
+            username = new OsuSpriteText
+            {
+                Shadow = false,
+                Colour = senderHasColour ? colours.ChatBlue : usernameColour,
+                Truncate = true,
+                EllipsisString = "…",
+                Font = OsuFont.GetFont(size: TextSize, weight: FontWeight.Bold, italics: true),
+                Anchor = Anchor.TopRight,
+                Origin = Anchor.TopRight,
+                MaxWidth = UsernameWidth,
+            };
+
+            if (!senderHasColour)
+                return username;
+
+            // Background effect
+            return new Container
+            {
+                Anchor = Anchor.TopRight,
+                Origin = Anchor.TopRight,
+                AutoSizeAxes = Axes.Both,
+                Masking = true,
+                CornerRadius = 4,
+                EdgeEffect = new EdgeEffectParameters
+                {
+                    Roundness = 1,
+                    Radius = 1,
+                    Colour = Color4.Black.Opacity(0.3f),
+                    Offset = new Vector2(0, 1),
+                    Type = EdgeEffectType.Shadow,
+                },
+                Child = new Container
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Masking = true,
+                    CornerRadius = 4,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = usernameColour,
+                        },
+                        new Container
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Left = 4, Right = 4, Bottom = 1, Top = -2 },
+                            Child = username
+                        }
+                    }
+                }
+            };
+        }
+
         private class MessageSender : OsuClickableContainer, IHasContextMenu
         {
             private readonly APIUser sender;
 
-            private Action startChatAction;
+            private Action startChatAction = null!;
 
             [Resolved]
-            private IAPIProvider api { get; set; }
+            private IAPIProvider api { get; set; } = null!;
 
             public MessageSender(APIUser sender)
             {
                 this.sender = sender;
             }
 
-            [BackgroundDependencyLoader(true)]
-            private void load(UserProfileOverlay profile, ChannelManager chatManager)
+            [BackgroundDependencyLoader]
+            private void load(UserProfileOverlay? profile, ChannelManager? chatManager)
             {
                 Action = () => profile?.ShowUser(sender);
                 startChatAction = () => chatManager?.OpenPrivateChannel(sender);

osu.Game/Overlays/Chat/ChatOverlayDrawableChannel.cs

@@ -1,109 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-#nullable enable
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Online.Chat;
-
-namespace osu.Game.Overlays.Chat
-{
-    public class ChatOverlayDrawableChannel : DrawableChannel
-    {
-        public ChatOverlayDrawableChannel(Channel channel)
-            : base(channel)
-        {
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            ChatLineFlow.Padding = new MarginPadding(0);
-        }
-
-        protected override Drawable CreateDaySeparator(DateTimeOffset time) => new ChatOverlayDaySeparator(time);
-
-        private class ChatOverlayDaySeparator : Container
-        {
-            private readonly DateTimeOffset time;
-
-            public ChatOverlayDaySeparator(DateTimeOffset time)
-            {
-                this.time = time;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OverlayColourProvider colourProvider)
-            {
-                RelativeSizeAxes = Axes.X;
-                AutoSizeAxes = Axes.Y;
-                Padding = new MarginPadding { Horizontal = 15, Vertical = 20 };
-                Child = new GridContainer
-                {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
-                    ColumnDimensions = new[]
-                    {
-                        new Dimension(GridSizeMode.Absolute, 200),
-                        new Dimension(GridSizeMode.Absolute, 15),
-                        new Dimension(),
-                    },
-                    Content = new[]
-                    {
-                        new[]
-                        {
-                            new GridContainer
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                ColumnDimensions = new[]
-                                {
-                                    new Dimension(),
-                                    new Dimension(GridSizeMode.Absolute, 15),
-                                    new Dimension(GridSizeMode.AutoSize),
-                                },
-                                Content = new[]
-                                {
-                                    new[]
-                                    {
-                                        new Circle
-                                        {
-                                            Anchor = Anchor.CentreRight,
-                                            Origin = Anchor.CentreRight,
-                                            Colour = colourProvider.Background5,
-                                            RelativeSizeAxes = Axes.X,
-                                            Height = 2,
-                                        },
-                                        Drawable.Empty(),
-                                        new OsuSpriteText
-                                        {
-                                            Anchor = Anchor.CentreRight,
-                                            Origin = Anchor.CentreRight,
-                                            Text = time.ToLocalTime().ToString("dd MMMM yyyy").ToUpper(),
-                                            Font = OsuFont.Torus.With(size: 15, weight: FontWeight.SemiBold),
-                                            Colour = colourProvider.Content1,
-                                        },
-                                    },
-                                },
-                            },
-                            Drawable.Empty(),
-                            new Circle
-                            {
-                                Anchor = Anchor.CentreLeft,
-                                Origin = Anchor.CentreLeft,
-                                Colour = colourProvider.Background5,
-                                RelativeSizeAxes = Axes.X,
-                                Height = 2,
-                            },
-                        },
-                    },
-                };
-            }
-        }
-    }
-}

osu.Game/Overlays/Chat/DaySeparator.cs

@@ -0,0 +1,105 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Overlays.Chat
+{
+    public class DaySeparator : Container
+    {
+        protected virtual float TextSize => 15;
+
+        protected virtual float LineHeight => 2;
+
+        protected virtual float DateAlign => 205;
+
+        protected virtual float Spacing => 15;
+
+        private readonly DateTimeOffset time;
+
+        [Resolved(CanBeNull = true)]
+        private OverlayColourProvider? colourProvider { get; set; }
+
+        public DaySeparator(DateTimeOffset time)
+        {
+            this.time = time;
+            Height = 40;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.X;
+            Child = new GridContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.CentreLeft,
+                RowDimensions = new[] { new Dimension() },
+                ColumnDimensions = new[]
+                {
+                    new Dimension(GridSizeMode.Absolute, DateAlign),
+                    new Dimension(GridSizeMode.Absolute, Spacing),
+                    new Dimension(),
+                },
+                Content = new[]
+                {
+                    new[]
+                    {
+                        new GridContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            RowDimensions = new[] { new Dimension() },
+                            ColumnDimensions = new[]
+                            {
+                                new Dimension(),
+                                new Dimension(GridSizeMode.Absolute, Spacing),
+                                new Dimension(GridSizeMode.AutoSize),
+                            },
+                            Content = new[]
+                            {
+                                new[]
+                                {
+                                    new Circle
+                                    {
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        RelativeSizeAxes = Axes.X,
+                                        Height = LineHeight,
+                                        Colour = colourProvider?.Background5 ?? Colour4.White,
+                                    },
+                                    Drawable.Empty(),
+                                    new OsuSpriteText
+                                    {
+                                        Anchor = Anchor.CentreRight,
+                                        Origin = Anchor.CentreRight,
+                                        Text = time.ToLocalTime().ToString("dd MMMM yyyy").ToUpper(),
+                                        Font = OsuFont.Torus.With(size: TextSize, weight: FontWeight.SemiBold),
+                                        Colour = colourProvider?.Content1 ?? Colour4.White,
+                                    },
+                                }
+                            },
+                        },
+                        Drawable.Empty(),
+                        new Circle
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.X,
+                            Height = LineHeight,
+                            Colour = colourProvider?.Background5 ?? Colour4.White,
+                        },
+                    }
+                }
+            };
+        }
+    }
+}

osu.Game/Overlays/Chat/DrawableChannel.cs

@@ -7,14 +7,9 @@ using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Game.Graphics;
 using osu.Game.Graphics.Cursor;
-using osu.Game.Graphics.Sprites;
 using osu.Game.Online.Chat;
 using osuTK.Graphics;
 
@@ -40,9 +35,6 @@ namespace osu.Game.Overlays.Chat
             }
         }
 
-        [Resolved]
-        private OsuColour colours { get; set; }
-
         public DrawableChannel(Channel channel)
         {
             Channel = channel;
@@ -67,7 +59,7 @@ namespace osu.Game.Overlays.Chat
                     Padding = new MarginPadding { Bottom = 5 },
                     Child = ChatLineFlow = new FillFlowContainer
                     {
-                        Padding = new MarginPadding { Left = 20, Right = 20 },
+                        Padding = new MarginPadding { Horizontal = 10 },
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
                         Direction = FillDirection.Vertical,
@@ -121,11 +113,7 @@ namespace osu.Game.Overlays.Chat
 
         protected virtual ChatLine CreateChatLine(Message m) => new ChatLine(m);
 
-        protected virtual Drawable CreateDaySeparator(DateTimeOffset time) => new DaySeparator(time)
-        {
-            Colour = colours.ChatBlue.Lighten(0.7f),
-            Margin = new MarginPadding { Vertical = 10 },
-        };
+        protected virtual DaySeparator CreateDaySeparator(DateTimeOffset time) => new DaySeparator(time);
 
         private void newMessagesArrived(IEnumerable<Message> newMessages) => Schedule(() =>
         {
@@ -203,69 +191,5 @@ namespace osu.Game.Overlays.Chat
         });
 
         private IEnumerable<ChatLine> chatLines => ChatLineFlow.Children.OfType<ChatLine>();
-
-        public class DaySeparator : Container
-        {
-            public float TextSize
-            {
-                get => text.Font.Size;
-                set => text.Font = text.Font.With(size: value);
-            }
-
-            private float lineHeight = 2;
-
-            public float LineHeight
-            {
-                get => lineHeight;
-                set => lineHeight = leftBox.Height = rightBox.Height = value;
-            }
-
-            private readonly SpriteText text;
-            private readonly Box leftBox;
-            private readonly Box rightBox;
-
-            public DaySeparator(DateTimeOffset time)
-            {
-                RelativeSizeAxes = Axes.X;
-                AutoSizeAxes = Axes.Y;
-                Child = new GridContainer
-                {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
-                    ColumnDimensions = new[]
-                    {
-                        new Dimension(),
-                        new Dimension(GridSizeMode.AutoSize),
-                        new Dimension(),
-                    },
-                    RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize), },
-                    Content = new[]
-                    {
-                        new Drawable[]
-                        {
-                            leftBox = new Box
-                            {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                RelativeSizeAxes = Axes.X,
-                                Height = lineHeight,
-                            },
-                            text = new OsuSpriteText
-                            {
-                                Margin = new MarginPadding { Horizontal = 10 },
-                                Text = time.ToLocalTime().ToString("dd MMM yyyy"),
-                            },
-                            rightBox = new Box
-                            {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                RelativeSizeAxes = Axes.X,
-                                Height = lineHeight,
-                            },
-                        }
-                    }
-                };
-            }
-        }
     }
 }

osu.Game/Overlays/ChatOverlay.cs

@@ -38,9 +38,9 @@ namespace osu.Game.Overlays
         private LoadingLayer loading = null!;
         private ChannelListing channelListing = null!;
         private ChatTextBar textBar = null!;
-        private Container<ChatOverlayDrawableChannel> currentChannelContainer = null!;
+        private Container<DrawableChannel> currentChannelContainer = null!;
 
-        private readonly Dictionary<Channel, ChatOverlayDrawableChannel> loadedChannels = new Dictionary<Channel, ChatOverlayDrawableChannel>();
+        private readonly Dictionary<Channel, DrawableChannel> loadedChannels = new Dictionary<Channel, DrawableChannel>();
 
         protected IEnumerable<DrawableChannel> DrawableChannels => loadedChannels.Values;
 
@@ -126,7 +126,7 @@ namespace osu.Game.Overlays
                             RelativeSizeAxes = Axes.Both,
                             Colour = colourProvider.Background4,
                         },
-                        currentChannelContainer = new Container<ChatOverlayDrawableChannel>
+                        currentChannelContainer = new Container<DrawableChannel>
                         {
                             RelativeSizeAxes = Axes.Both,
                         },
@@ -313,7 +313,7 @@ namespace osu.Game.Overlays
                     loading.Show();
 
                     // Ensure the drawable channel is stored before async load to prevent double loading
-                    ChatOverlayDrawableChannel drawableChannel = CreateDrawableChannel(newChannel);
+                    DrawableChannel drawableChannel = CreateDrawableChannel(newChannel);
                     loadedChannels.Add(newChannel, drawableChannel);
 
                     LoadComponentAsync(drawableChannel, loadedDrawable =>
@@ -338,7 +338,7 @@ namespace osu.Game.Overlays
                 channelManager.MarkChannelAsRead(newChannel);
         }
 
-        protected virtual ChatOverlayDrawableChannel CreateDrawableChannel(Channel newChannel) => new ChatOverlayDrawableChannel(newChannel);
+        protected virtual DrawableChannel CreateDrawableChannel(Channel newChannel) => new DrawableChannel(newChannel);
 
         private void joinedChannelsChanged(object sender, NotifyCollectionChangedEventArgs args)
         {
@@ -361,7 +361,7 @@ namespace osu.Game.Overlays
 
                         if (loadedChannels.ContainsKey(channel))
                         {
-                            ChatOverlayDrawableChannel loaded = loadedChannels[channel];
+                            DrawableChannel loaded = loadedChannels[channel];
                             loadedChannels.Remove(channel);
                             // DrawableChannel removed from cache must be manually disposed
                             loaded.Dispose();

osu.Game/Overlays/Dialog/PopupDialogButton.cs

@@ -8,7 +8,8 @@ namespace osu.Game.Overlays.Dialog
 {
     public class PopupDialogButton : DialogButton
     {
-        public PopupDialogButton()
+        public PopupDialogButton(HoverSampleSet sampleSet = HoverSampleSet.Button)
+            : base(sampleSet)
         {
             Height = 50;
             BackgroundColour = Color4Extensions.FromHex(@"150e14");

osu.Game/Overlays/Dialog/PopupDialogCancelButton.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Dialog
 {
@@ -13,5 +14,10 @@ namespace osu.Game.Overlays.Dialog
         {
             ButtonColour = colours.Blue;
         }
+
+        public PopupDialogCancelButton()
+            : base(HoverSampleSet.DialogCancel)
+        {
+        }
     }
 }

osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs

@@ -2,9 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
+using osu.Game.Audio.Effects;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 
@@ -47,6 +51,33 @@ namespace osu.Game.Overlays.Dialog
             {
             }
 
+            private Sample tickSample;
+            private Sample confirmSample;
+            private double lastTickPlaybackTime;
+            private AudioFilter lowPassFilter = null!;
+
+            [BackgroundDependencyLoader]
+            private void load(AudioManager audio)
+            {
+                tickSample = audio.Samples.Get(@"UI/dialog-dangerous-tick");
+                confirmSample = audio.Samples.Get(@"UI/dialog-dangerous-select");
+
+                AddInternal(lowPassFilter = new AudioFilter(audio.SampleMixer));
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                Progress.BindValueChanged(progressChanged);
+            }
+
+            protected override void Confirm()
+            {
+                lowPassFilter.CutoffTo(AudioFilter.MAX_LOWPASS_CUTOFF);
+                confirmSample?.Play();
+                base.Confirm();
+            }
+
             protected override bool OnMouseDown(MouseDownEvent e)
             {
                 BeginConfirm();
@@ -56,7 +87,28 @@ namespace osu.Game.Overlays.Dialog
             protected override void OnMouseUp(MouseUpEvent e)
             {
                 if (!e.HasAnyButtonPressed)
+                {
+                    lowPassFilter.CutoffTo(AudioFilter.MAX_LOWPASS_CUTOFF);
                     AbortConfirm();
+                }
+            }
+
+            private void progressChanged(ValueChangedEvent<double> progress)
+            {
+                if (progress.NewValue < progress.OldValue) return;
+
+                if (Clock.CurrentTime - lastTickPlaybackTime < 30) return;
+
+                lowPassFilter.CutoffTo((int)(progress.NewValue * AudioFilter.MAX_LOWPASS_CUTOFF * 0.5));
+
+                var channel = tickSample.GetChannel();
+
+                channel.Frequency.Value = 1 + progress.NewValue * 0.5f;
+                channel.Volume.Value = 0.5f + progress.NewValue / 2f;
+
+                channel.Play();
+
+                lastTickPlaybackTime = Clock.CurrentTime;
             }
         }
     }

osu.Game/Overlays/Dialog/PopupDialogOkButton.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Dialog
 {
@@ -13,5 +14,10 @@ namespace osu.Game.Overlays.Dialog
         {
             ButtonColour = colours.Pink;
         }
+
+        public PopupDialogOkButton()
+            : base(HoverSampleSet.DialogOk)
+        {
+        }
     }
 }

osu.Game/Overlays/FirstRunSetup/ScreenUIScale.cs

@@ -126,6 +126,7 @@ namespace osu.Game.Overlays.FirstRunSetup
         private class SampleScreenContainer : CompositeDrawable
         {
             private readonly OsuScreen screen;
+
             // Minimal isolation from main game.
 
             [Cached]
@@ -151,6 +152,9 @@ namespace osu.Game.Overlays.FirstRunSetup
                 RelativeSizeAxes = Axes.Both;
             }
 
+            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
+                new DependencyContainer(new DependencyIsolationContainer(base.CreateChildDependencies(parent)));
+
             [BackgroundDependencyLoader]
             private void load(AudioManager audio, TextureStore textures, RulesetStore rulesets)
             {
@@ -197,5 +201,41 @@ namespace osu.Game.Overlays.FirstRunSetup
                 stack.PushSynchronously(screen);
             }
         }
+
+        private class DependencyIsolationContainer : IReadOnlyDependencyContainer
+        {
+            private readonly IReadOnlyDependencyContainer parentDependencies;
+
+            private readonly Type[] isolatedTypes =
+            {
+                typeof(OsuGame)
+            };
+
+            public DependencyIsolationContainer(IReadOnlyDependencyContainer parentDependencies)
+            {
+                this.parentDependencies = parentDependencies;
+            }
+
+            public object Get(Type type)
+            {
+                if (isolatedTypes.Contains(type))
+                    return null;
+
+                return parentDependencies.Get(type);
+            }
+
+            public object Get(Type type, CacheInfo info)
+            {
+                if (isolatedTypes.Contains(type))
+                    return null;
+
+                return parentDependencies.Get(type, info);
+            }
+
+            public void Inject<T>(T instance) where T : class
+            {
+                parentDependencies.Inject(instance);
+            }
+        }
     }
 }