Merge branch 'master' into overlay-header-refactor

README.md

@@ -5,7 +5,7 @@
 # osu!
 
 [![Build status](https://ci.appveyor.com/api/projects/status/u2p01nx7l6og8buh?svg=true)](https://ci.appveyor.com/project/peppy/osu)
-[![GitHub release](https://img.shields.io/github/release/ppy/osu.svg)]()
+[![GitHub release](https://img.shields.io/github/release/ppy/osu.svg)](https://github.com/ppy/osu/releases/latest)
 [![CodeFactor](https://www.codefactor.io/repository/github/ppy/osu/badge)](https://www.codefactor.io/repository/github/ppy/osu)
 [![dev chat](https://discordapp.com/api/guilds/188630481301012481/widget.png?style=shield)](https://discord.gg/ppy)
 

osu.Android.props

@@ -52,6 +52,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1202.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.118.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.128.0" />
   </ItemGroup>
 </Project>

osu.Desktop/osu.Desktop.csproj

@@ -24,16 +24,13 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
+    <PackageReference Include="Microsoft.NETCore.Targets" Version="5.0.0" />
     <PackageReference Include="System.IO.Packaging" Version="5.0.0" />
-    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.4" />
+    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.5" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.6" />
     <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
-    <PackageReference Include="DiscordRichPresence" Version="1.0.169" />
-    <!-- .NET 3.1 SDK seems to cause issues with a runtime specification. This will likely be resolved in .NET 5. -->
-    <PackageReference Include="System.IO.FileSystem.Primitives" Version="4.3.0" />
-    <PackageReference Include="System.Runtime.Handles" Version="4.3.0" />
-    <PackageReference Include="System.Runtime.InteropServices" Version="4.3.0" />
+    <PackageReference Include="DiscordRichPresence" Version="1.0.175" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs

@@ -45,6 +45,11 @@ namespace osu.Game.Rulesets.Catch.Replays
                 float positionChange = Math.Abs(lastPosition - h.EffectiveX);
                 double timeAvailable = h.StartTime - lastTime;
 
+                if (timeAvailable < 0)
+                {
+                    return;
+                }
+
                 // So we can either make it there without a dash or not.
                 // If positionChange is 0, we don't need to move, so speedRequired should also be 0 (could be NaN if timeAvailable is 0 too)
                 // The case where positionChange > 0 and timeAvailable == 0 results in PositiveInfinity which provides expected beheaviour.

osu.Game.Rulesets.Catch/Skinning/Default/BorderPiece.cs

@@ -29,4 +29,3 @@ namespace osu.Game.Rulesets.Catch.Skinning.Default
         }
     }
 }
-

osu.Game.Rulesets.Catch/Skinning/Default/HyperBorderPiece.cs

@@ -19,4 +19,3 @@ namespace osu.Game.Rulesets.Catch.Skinning.Default
         }
     }
 }
-

osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModConstantSpeed.cs

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests.Mods
+{
+    public class TestSceneManiaModConstantSpeed : ModTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
+
+        [Test]
+        public void TestConstantScroll() => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModConstantSpeed(),
+            PassCondition = () =>
+            {
+                var hitObject = Player.ChildrenOfType<DrawableManiaHitObject>().FirstOrDefault();
+                return hitObject?.Dependencies.Get<IScrollingInfo>().Algorithm is ConstantScrollAlgorithm;
+            }
+        });
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -238,6 +238,7 @@ namespace osu.Game.Rulesets.Mania
                         new ManiaModMirror(),
                         new ManiaModDifficultyAdjust(),
                         new ManiaModInvert(),
+                        new ManiaModConstantSpeed()
                     };
 
                 case ModType.Automation:

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

@@ -0,0 +1,35 @@
+// 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.Sprites;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mania.Mods
+{
+    public class ManiaModConstantSpeed : Mod, IApplicableToDrawableRuleset<ManiaHitObject>
+    {
+        public override string Name => "Constant Speed";
+
+        public override string Acronym => "CS";
+
+        public override double ScoreMultiplier => 1;
+
+        public override string Description => "No more tricky speed changes!";
+
+        public override IconUsage? Icon => FontAwesome.Solid.Equals;
+
+        public override ModType Type => ModType.Conversion;
+
+        public override bool Ranked => false;
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<ManiaHitObject> drawableRuleset)
+        {
+            var maniaRuleset = (DrawableManiaRuleset)drawableRuleset;
+            maniaRuleset.ScrollMethod = ScrollVisualisationMethod.Constant;
+        }
+    }
+}

osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
@@ -11,6 +12,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -49,6 +51,22 @@ namespace osu.Game.Rulesets.Mania.UI
 
         protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;
 
+        public ScrollVisualisationMethod ScrollMethod
+        {
+            get => scrollMethod;
+            set
+            {
+                if (IsLoaded)
+                    throw new InvalidOperationException($"Can't alter {nameof(ScrollMethod)} after ruleset is already loaded");
+
+                scrollMethod = value;
+            }
+        }
+
+        private ScrollVisualisationMethod scrollMethod = ScrollVisualisationMethod.Sequential;
+
+        protected override ScrollVisualisationMethod VisualisationMethod => scrollMethod;
+
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
         private readonly Bindable<double> configTimeRange = new BindableDouble();
 

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

@@ -25,7 +25,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestSceneOutOfOrderHits : RateAdjustedBeatmapTestScene
+    public class TestSceneStartTimeOrderedHitPolicy : RateAdjustedBeatmapTestScene
     {
         private const double early_miss_window = 1000; // time after -1000 to -500 is considered a miss
         private const double late_miss_window = 500; // time after +500 is considered a miss
@@ -169,7 +169,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[0], HitResult.Great);
             addJudgementAssert(hitObjects[1], HitResult.Great);
             addJudgementOffsetAssert(hitObjects[0], -200); // time_first_circle - 200
-            addJudgementOffsetAssert(hitObjects[0], -200); // time_second_circle - first_circle_time - 100
+            addJudgementOffsetAssert(hitObjects[1], -200); // time_second_circle - first_circle_time - 100
         }
 
         /// <summary>

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

@@ -243,7 +243,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.Update();
 
             if (HandleUserInput)
-                RotationTracker.Tracking = !Result.HasResult && (OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
+            {
+                bool isValidSpinningTime = Time.Current >= HitObject.StartTime && Time.Current <= HitObject.EndTime;
+                bool correctButtonPressed = (OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
+
+                RotationTracker.Tracking = !Result.HasResult
+                                           && correctButtonPressed
+                                           && isValidSpinningTime;
+            }
 
             if (spinningSample != null && spinnerFrequencyModulate)
                 spinningSample.Frequency.Value = spinning_sample_modulated_base_frequency + Progress;
@@ -255,6 +262,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             if (!SpmCounter.IsPresent && RotationTracker.Tracking)
                 SpmCounter.FadeIn(HitObject.TimeFadeIn);
+
             SpmCounter.SetRotation(Result.RateAdjustedRotation);
 
             updateBonusScore();

osu.Game.Rulesets.Osu/Skinning/Default/SpinnerSpmCounter.cs

@@ -4,16 +4,21 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Osu.Skinning.Default
 {
     public class SpinnerSpmCounter : Container
     {
+        [Resolved]
+        private DrawableHitObject drawableSpinner { get; set; }
+
         private readonly OsuSpriteText spmText;
 
         public SpinnerSpmCounter()
@@ -38,6 +43,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
             };
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            drawableSpinner.HitObjectApplied += resetState;
+        }
+
         private double spm;
 
         public double SpinsPerMinute
@@ -82,5 +93,19 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
             records.Enqueue(new RotationRecord { Rotation = currentRotation, Time = Time.Current });
         }
+
+        private void resetState(DrawableHitObject hitObject)
+        {
+            SpinsPerMinute = 0;
+            records.Clear();
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableSpinner != null)
+                drawableSpinner.HitObjectApplied -= resetState;
+        }
     }
 }

osu.Game.Rulesets.Osu/UI/IHitPolicy.cs

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public interface IHitPolicy
+    {
+        /// <summary>
+        /// The <see cref="IHitObjectContainer"/> containing the <see cref="DrawableHitObject"/>s which this <see cref="IHitPolicy"/> applies to.
+        /// </summary>
+        IHitObjectContainer HitObjectContainer { set; }
+
+        /// <summary>
+        /// Determines whether a <see cref="DrawableHitObject"/> can be hit at a point in time.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to check.</param>
+        /// <param name="time">The time to check.</param>
+        /// <returns>Whether <paramref name="hitObject"/> can be hit at the given <paramref name="time"/>.</returns>
+        bool IsHittable(DrawableHitObject hitObject, double time);
+
+        /// <summary>
+        /// Handles a <see cref="HitObject"/> being hit.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> that was hit.</param>
+        void HandleHit(DrawableHitObject hitObject);
+    }
+}

osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Osu.UI
         private readonly ProxyContainer spinnerProxies;
         private readonly JudgementContainer<DrawableOsuJudgement> judgementLayer;
         private readonly FollowPointRenderer followPoints;
-        private readonly OrderedHitPolicy hitPolicy;
+        private readonly StartTimeOrderedHitPolicy hitPolicy;
 
         public static readonly Vector2 BASE_SIZE = new Vector2(512, 384);
 
@@ -54,7 +54,7 @@ namespace osu.Game.Rulesets.Osu.UI
                 approachCircles = new ProxyContainer { RelativeSizeAxes = Axes.Both },
             };
 
-            hitPolicy = new OrderedHitPolicy(HitObjectContainer);
+            hitPolicy = new StartTimeOrderedHitPolicy { HitObjectContainer = HitObjectContainer };
 
             var hitWindows = new OsuHitWindows();
 

osu.Game.Rulesets.Osu/UI/StartTimeOrderedHitPolicy.cs

@@ -11,28 +11,17 @@ using osu.Game.Rulesets.UI;
 namespace osu.Game.Rulesets.Osu.UI
 {
     /// <summary>
-    /// Ensures that <see cref="HitObject"/>s are hit in-order. Affectionately known as "note lock".
+    /// Ensures that <see cref="HitObject"/>s are hit in-order of their start times. Affectionately known as "note lock".
     /// If a <see cref="HitObject"/> is hit out of order:
     /// <list type="number">
     /// <item><description>The hit is blocked if it occurred earlier than the previous <see cref="HitObject"/>'s start time.</description></item>
     /// <item><description>The hit causes all previous <see cref="HitObject"/>s to missed otherwise.</description></item>
     /// </list>
     /// </summary>
-    public class OrderedHitPolicy
+    public class StartTimeOrderedHitPolicy : IHitPolicy
     {
-        private readonly HitObjectContainer hitObjectContainer;
+        public IHitObjectContainer HitObjectContainer { get; set; }
 
-        public OrderedHitPolicy(HitObjectContainer hitObjectContainer)
-        {
-            this.hitObjectContainer = hitObjectContainer;
-        }
-
-        /// <summary>
-        /// Determines whether a <see cref="DrawableHitObject"/> can be hit at a point in time.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to check.</param>
-        /// <param name="time">The time to check.</param>
-        /// <returns>Whether <paramref name="hitObject"/> can be hit at the given <paramref name="time"/>.</returns>
         public bool IsHittable(DrawableHitObject hitObject, double time)
         {
             DrawableHitObject blockingObject = null;
@@ -54,10 +43,6 @@ namespace osu.Game.Rulesets.Osu.UI
             return blockingObject.Judged || time >= blockingObject.HitObject.StartTime;
         }
 
-        /// <summary>
-        /// Handles a <see cref="HitObject"/> being hit to potentially miss all earlier <see cref="HitObject"/>s.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="HitObject"/> that was hit.</param>
         public void HandleHit(DrawableHitObject hitObject)
         {
             // Hitobjects which themselves don't block future hitobjects don't cause misses (e.g. slider ticks, spinners).
@@ -67,6 +52,7 @@ namespace osu.Game.Rulesets.Osu.UI
             if (!IsHittable(hitObject, hitObject.HitObject.StartTime + hitObject.Result.TimeOffset))
                 throw new InvalidOperationException($"A {hitObject} was hit before it became hittable!");
 
+            // Miss all hitobjects prior to the hit one.
             foreach (var obj in enumerateHitObjectsUpTo(hitObject.HitObject.StartTime))
             {
                 if (obj.Judged)
@@ -86,7 +72,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         private IEnumerable<DrawableHitObject> enumerateHitObjectsUpTo(double targetTime)
         {
-            foreach (var obj in hitObjectContainer.AliveObjects)
+            foreach (var obj in HitObjectContainer.AliveObjects)
             {
                 if (obj.HitObject.StartTime >= targetTime)
                     yield break;

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

@@ -1,11 +1,45 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Taiko.Mods
 {
     public class TaikoModDifficultyAdjust : ModDifficultyAdjust
     {
+        [SettingSource("Scroll Speed", "Adjust a beatmap's set scroll speed", LAST_SETTING_ORDER + 1)]
+        public BindableNumber<float> ScrollSpeed { get; } = new BindableFloat
+        {
+            Precision = 0.05f,
+            MinValue = 0.25f,
+            MaxValue = 4,
+            Default = 1,
+            Value = 1,
+        };
+
+        public override string SettingDescription
+        {
+            get
+            {
+                string scrollSpeed = ScrollSpeed.IsDefault ? string.Empty : $"Scroll x{ScrollSpeed.Value:N1}";
+
+                return string.Join(", ", new[]
+                {
+                    base.SettingDescription,
+                    scrollSpeed
+                }.Where(s => !string.IsNullOrEmpty(s)));
+            }
+        }
+
+        protected override void ApplySettings(BeatmapDifficulty difficulty)
+        {
+            base.ApplySettings(difficulty);
+
+            ApplySetting(ScrollSpeed, scroll => difficulty.SliderMultiplier *= scroll);
+        }
     }
 }

osu.Game.Rulesets.Taiko/Mods/TaikoModEasy.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 osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Taiko.Mods
@@ -8,5 +9,16 @@ namespace osu.Game.Rulesets.Taiko.Mods
     public class TaikoModEasy : ModEasy
     {
         public override string Description => @"Beats move slower, and less accuracy required!";
+
+        /// <summary>
+        /// Multiplier factor added to the scrolling speed.
+        /// </summary>
+        private const double slider_multiplier = 0.8;
+
+        public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            base.ApplyToDifficulty(difficulty);
+            difficulty.SliderMultiplier *= slider_multiplier;
+        }
     }
 }

osu.Game.Rulesets.Taiko/Mods/TaikoModHardRock.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 osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Taiko.Mods
@@ -9,5 +10,21 @@ namespace osu.Game.Rulesets.Taiko.Mods
     {
         public override double ScoreMultiplier => 1.06;
         public override bool Ranked => true;
+
+        /// <summary>
+        /// Multiplier factor added to the scrolling speed.
+        /// </summary>
+        /// <remarks>
+        /// This factor is made up of two parts: the base part (1.4) and the aspect ratio adjustment (4/3).
+        /// Stable applies the latter by dividing the width of the user's display by the width of a display with the same height, but 4:3 aspect ratio.
+        /// TODO: Revisit if taiko playfield ever changes away from a hard-coded 16:9 (see https://github.com/ppy/osu/issues/5685).
+        /// </remarks>
+        private const double slider_multiplier = 1.4 * 4 / 3;
+
+        public override void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            base.ApplyToDifficulty(difficulty);
+            difficulty.SliderMultiplier *= slider_multiplier;
+        }
     }
 }

osu.Game.Tests.Android/osu.Game.Tests.Android.csproj

@@ -69,5 +69,9 @@
       <Name>osu.Game</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup Label="Package References">
+    <PackageReference Include="DeepEqual" Version="2.0.0" />
+    <PackageReference Include="Moq" Version="4.16.0" />
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
 </Project>

osu.Game.Tests.iOS/osu.Game.Tests.iOS.csproj

@@ -45,6 +45,7 @@
   </ItemGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="DeepEqual" Version="2.0.0" />
+    <PackageReference Include="Moq" Version="4.16.0" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\iOS\Xamarin.iOS.CSharp.targets" />
 </Project>

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

@@ -129,5 +129,25 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(3456, ((StoryboardSprite)background.Elements.Single()).InitialPosition.X);
             }
         }
+
+        [Test]
+        public void TestDecodeOutOfRangeLoopAnimationType()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+
+            using (var resStream = TestResources.OpenResource("animation-types.osb"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var storyboard = decoder.Decode(stream);
+
+                StoryboardLayer foreground = storyboard.Layers.Single(l => l.Depth == 0);
+                Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[0]).LoopType);
+                Assert.AreEqual(AnimationLoopType.LoopOnce, ((StoryboardAnimation)foreground.Elements[1]).LoopType);
+                Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[2]).LoopType);
+                Assert.AreEqual(AnimationLoopType.LoopOnce, ((StoryboardAnimation)foreground.Elements[3]).LoopType);
+                Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[4]).LoopType);
+                Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[5]).LoopType);
+            }
+        }
     }
 }

osu.Game.Tests/Mods/ModUtilsTest.cs

@@ -0,0 +1,160 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Utils;
+
+namespace osu.Game.Tests.Mods
+{
+    [TestFixture]
+    public class ModUtilsTest
+    {
+        [Test]
+        public void TestModIsCompatibleByItself()
+        {
+            var mod = new Mock<CustomMod1>();
+            Assert.That(ModUtils.CheckCompatibleSet(new[] { mod.Object }));
+        }
+
+        [Test]
+        public void TestIncompatibleThroughTopLevel()
+        {
+            var mod1 = new Mock<CustomMod1>();
+            var mod2 = new Mock<CustomMod2>();
+
+            mod1.Setup(m => m.IncompatibleMods).Returns(new[] { mod2.Object.GetType() });
+
+            // Test both orderings.
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod1.Object, mod2.Object }), Is.False);
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod2.Object, mod1.Object }), Is.False);
+        }
+
+        [Test]
+        public void TestMultiModIncompatibleWithTopLevel()
+        {
+            var mod1 = new Mock<CustomMod1>();
+
+            // The nested mod.
+            var mod2 = new Mock<CustomMod2>();
+            mod2.Setup(m => m.IncompatibleMods).Returns(new[] { mod1.Object.GetType() });
+
+            var multiMod = new MultiMod(new MultiMod(mod2.Object));
+
+            // Test both orderings.
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { multiMod, mod1.Object }), Is.False);
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod1.Object, multiMod }), Is.False);
+        }
+
+        [Test]
+        public void TestTopLevelIncompatibleWithMultiMod()
+        {
+            // The nested mod.
+            var mod1 = new Mock<CustomMod1>();
+            var multiMod = new MultiMod(new MultiMod(mod1.Object));
+
+            var mod2 = new Mock<CustomMod2>();
+            mod2.Setup(m => m.IncompatibleMods).Returns(new[] { typeof(CustomMod1) });
+
+            // Test both orderings.
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { multiMod, mod2.Object }), Is.False);
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod2.Object, multiMod }), Is.False);
+        }
+
+        [Test]
+        public void TestCompatibleMods()
+        {
+            var mod1 = new Mock<CustomMod1>();
+            var mod2 = new Mock<CustomMod2>();
+
+            // Test both orderings.
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod1.Object, mod2.Object }), Is.True);
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod2.Object, mod1.Object }), Is.True);
+        }
+
+        [Test]
+        public void TestIncompatibleThroughBaseType()
+        {
+            var mod1 = new Mock<CustomMod1>();
+            var mod2 = new Mock<CustomMod2>();
+            mod2.Setup(m => m.IncompatibleMods).Returns(new[] { typeof(Mod) });
+
+            // Test both orderings.
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod1.Object, mod2.Object }), Is.False);
+            Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod2.Object, mod1.Object }), Is.False);
+        }
+
+        [Test]
+        public void TestAllowedThroughMostDerivedType()
+        {
+            var mod = new Mock<CustomMod1>();
+            Assert.That(ModUtils.CheckAllowed(new[] { mod.Object }, new[] { mod.Object.GetType() }));
+        }
+
+        [Test]
+        public void TestNotAllowedThroughBaseType()
+        {
+            var mod = new Mock<CustomMod1>();
+            Assert.That(ModUtils.CheckAllowed(new[] { mod.Object }, new[] { typeof(Mod) }), Is.False);
+        }
+
+        private static readonly object[] invalid_mod_test_scenarios =
+        {
+            // incompatible pair.
+            new object[]
+            {
+                new Mod[] { new OsuModDoubleTime(), new OsuModHalfTime() },
+                new[] { typeof(OsuModDoubleTime), typeof(OsuModHalfTime) }
+            },
+            // incompatible pair with derived class.
+            new object[]
+            {
+                new Mod[] { new OsuModNightcore(), new OsuModHalfTime() },
+                new[] { typeof(OsuModNightcore), typeof(OsuModHalfTime) }
+            },
+            // system mod.
+            new object[]
+            {
+                new Mod[] { new OsuModDoubleTime(), new OsuModTouchDevice() },
+                new[] { typeof(OsuModTouchDevice) }
+            },
+            // multi mod.
+            new object[]
+            {
+                new Mod[] { new MultiMod(new OsuModHalfTime()), new OsuModHalfTime() },
+                new[] { typeof(MultiMod) }
+            },
+            // valid pair.
+            new object[]
+            {
+                new Mod[] { new OsuModDoubleTime(), new OsuModHardRock() },
+                null
+            }
+        };
+
+        [TestCaseSource(nameof(invalid_mod_test_scenarios))]
+        public void TestInvalidModScenarios(Mod[] inputMods, Type[] expectedInvalid)
+        {
+            bool isValid = ModUtils.CheckValidForGameplay(inputMods, out var invalid);
+
+            Assert.That(isValid, Is.EqualTo(expectedInvalid == null));
+
+            if (isValid)
+                Assert.IsNull(invalid);
+            else
+                Assert.That(invalid?.Select(t => t.GetType()), Is.EquivalentTo(expectedInvalid));
+        }
+
+        public abstract class CustomMod1 : Mod
+        {
+        }
+
+        public abstract class CustomMod2 : Mod
+        {
+        }
+    }
+}

osu.Game.Tests/NonVisual/OngoingOperationTrackerTest.cs

@@ -0,0 +1,106 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Screens;
+using osu.Game.Screens.OnlinePlay;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [HeadlessTest]
+    public class OngoingOperationTrackerTest : OsuTestScene
+    {
+        private OngoingOperationTracker tracker;
+        private IBindable<bool> operationInProgress;
+
+        [SetUpSteps]
+        public void SetUp()
+        {
+            AddStep("create tracker", () => Child = tracker = new OngoingOperationTracker());
+            AddStep("bind to operation status", () => operationInProgress = tracker.InProgress.GetBoundCopy());
+        }
+
+        [Test]
+        public void TestOperationTracking()
+        {
+            IDisposable firstOperation = null;
+            IDisposable secondOperation = null;
+
+            AddStep("begin first operation", () => firstOperation = tracker.BeginOperation());
+            AddAssert("first operation in progress", () => operationInProgress.Value);
+
+            AddStep("cannot start another operation",
+                () => Assert.Throws<InvalidOperationException>(() => tracker.BeginOperation()));
+
+            AddStep("end first operation", () => firstOperation.Dispose());
+            AddAssert("first operation is ended", () => !operationInProgress.Value);
+
+            AddStep("start second operation", () => secondOperation = tracker.BeginOperation());
+            AddAssert("second operation in progress", () => operationInProgress.Value);
+
+            AddStep("dispose first operation again", () => firstOperation.Dispose());
+            AddAssert("second operation still in progress", () => operationInProgress.Value);
+
+            AddStep("dispose second operation", () => secondOperation.Dispose());
+            AddAssert("second operation is ended", () => !operationInProgress.Value);
+        }
+
+        [Test]
+        public void TestOperationDisposalAfterTracker()
+        {
+            IDisposable operation = null;
+
+            AddStep("begin operation", () => operation = tracker.BeginOperation());
+            AddStep("dispose tracker", () => tracker.Expire());
+            AddStep("end operation", () => operation.Dispose());
+            AddAssert("operation is ended", () => !operationInProgress.Value);
+        }
+
+        [Test]
+        public void TestOperationDisposalAfterScreenExit()
+        {
+            TestScreenWithTracker screen = null;
+            OsuScreenStack stack;
+            IDisposable operation = null;
+
+            AddStep("create screen with tracker", () =>
+            {
+                Child = stack = new OsuScreenStack
+                {
+                    RelativeSizeAxes = Axes.Both
+                };
+
+                stack.Push(screen = new TestScreenWithTracker());
+            });
+            AddUntilStep("wait for loaded", () => screen.IsLoaded);
+
+            AddStep("begin operation", () => operation = screen.OngoingOperationTracker.BeginOperation());
+            AddAssert("operation in progress", () => screen.OngoingOperationTracker.InProgress.Value);
+
+            AddStep("dispose after screen exit", () =>
+            {
+                screen.Exit();
+                operation.Dispose();
+            });
+            AddAssert("operation ended", () => !screen.OngoingOperationTracker.InProgress.Value);
+        }
+
+        private class TestScreenWithTracker : OsuScreen
+        {
+            public OngoingOperationTracker OngoingOperationTracker { get; private set; }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                InternalChild = OngoingOperationTracker = new OngoingOperationTracker();
+            }
+        }
+    }
+}

osu.Game.Tests/NonVisual/TaskChainTest.cs

@@ -0,0 +1,111 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Game.Utils;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class TaskChainTest
+    {
+        private TaskChain taskChain;
+        private int currentTask;
+        private CancellationTokenSource globalCancellationToken;
+
+        [SetUp]
+        public void Setup()
+        {
+            globalCancellationToken = new CancellationTokenSource();
+            taskChain = new TaskChain();
+            currentTask = 0;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            globalCancellationToken?.Cancel();
+        }
+
+        [Test]
+        public async Task TestChainedTasksRunSequentially()
+        {
+            var task1 = addTask();
+            var task2 = addTask();
+            var task3 = addTask();
+
+            task3.mutex.Set();
+            task2.mutex.Set();
+            task1.mutex.Set();
+
+            await Task.WhenAll(task1.task, task2.task, task3.task);
+
+            Assert.That(task1.task.Result, Is.EqualTo(1));
+            Assert.That(task2.task.Result, Is.EqualTo(2));
+            Assert.That(task3.task.Result, Is.EqualTo(3));
+        }
+
+        [Test]
+        public async Task TestChainedTaskWithIntermediateCancelRunsInSequence()
+        {
+            var task1 = addTask();
+            var task2 = addTask();
+            var task3 = addTask();
+
+            // Cancel task2, allow task3 to complete.
+            task2.cancellation.Cancel();
+            task2.mutex.Set();
+            task3.mutex.Set();
+
+            // Allow task3 to potentially complete.
+            Thread.Sleep(1000);
+
+            // Allow task1 to complete.
+            task1.mutex.Set();
+
+            // Wait on both tasks.
+            await Task.WhenAll(task1.task, task3.task);
+
+            Assert.That(task1.task.Result, Is.EqualTo(1));
+            Assert.That(task2.task.IsCompleted, Is.False);
+            Assert.That(task3.task.Result, Is.EqualTo(2));
+        }
+
+        [Test]
+        public async Task TestChainedTaskDoesNotCompleteBeforeChildTasks()
+        {
+            var mutex = new ManualResetEventSlim(false);
+
+            var task = taskChain.Add(async () => await Task.Run(() => mutex.Wait(globalCancellationToken.Token)));
+
+            // Allow task to potentially complete
+            Thread.Sleep(1000);
+
+            Assert.That(task.IsCompleted, Is.False);
+
+            // Allow the task to complete.
+            mutex.Set();
+
+            await task;
+        }
+
+        private (Task<int> task, ManualResetEventSlim mutex, CancellationTokenSource cancellation) addTask()
+        {
+            var mutex = new ManualResetEventSlim(false);
+            var completionSource = new TaskCompletionSource<int>();
+
+            var cancellationSource = new CancellationTokenSource();
+            var token = CancellationTokenSource.CreateLinkedTokenSource(cancellationSource.Token, globalCancellationToken.Token);
+
+            taskChain.Add(() =>
+            {
+                mutex.Wait(globalCancellationToken.Token);
+                completionSource.SetResult(Interlocked.Increment(ref currentTask));
+            }, token.Token);
+
+            return (completionSource.Task, mutex, cancellationSource);
+        }
+    }
+}

osu.Game.Tests/Online/TestAPIModJsonSerialization.cs

@@ -16,7 +16,7 @@ using osu.Game.Rulesets.UI;
 namespace osu.Game.Tests.Online
 {
     [TestFixture]
-    public class TestAPIModSerialization
+    public class TestAPIModJsonSerialization
     {
         [Test]
         public void TestAcronymIsPreserved()

osu.Game.Tests/Online/TestAPIModMessagePackSerialization.cs

@@ -0,0 +1,139 @@
+// 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 MessagePack;
+using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Online.API;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Tests.Online
+{
+    [TestFixture]
+    public class TestAPIModMessagePackSerialization
+    {
+        [Test]
+        public void TestAcronymIsPreserved()
+        {
+            var apiMod = new APIMod(new TestMod());
+
+            var deserialized = MessagePackSerializer.Deserialize<APIMod>(MessagePackSerializer.Serialize(apiMod));
+
+            Assert.That(deserialized.Acronym, Is.EqualTo(apiMod.Acronym));
+        }
+
+        [Test]
+        public void TestRawSettingIsPreserved()
+        {
+            var apiMod = new APIMod(new TestMod { TestSetting = { Value = 2 } });
+
+            var deserialized = MessagePackSerializer.Deserialize<APIMod>(MessagePackSerializer.Serialize(apiMod));
+
+            Assert.That(deserialized.Settings, Contains.Key("test_setting").With.ContainValue(2.0));
+        }
+
+        [Test]
+        public void TestConvertedModHasCorrectSetting()
+        {
+            var apiMod = new APIMod(new TestMod { TestSetting = { Value = 2 } });
+
+            var deserialized = MessagePackSerializer.Deserialize<APIMod>(MessagePackSerializer.Serialize(apiMod));
+            var converted = (TestMod)deserialized.ToMod(new TestRuleset());
+
+            Assert.That(converted.TestSetting.Value, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestDeserialiseTimeRampMod()
+        {
+            // Create the mod with values different from default.
+            var apiMod = new APIMod(new TestModTimeRamp
+            {
+                AdjustPitch = { Value = false },
+                InitialRate = { Value = 1.25 },
+                FinalRate = { Value = 0.25 }
+            });
+
+            var deserialised = MessagePackSerializer.Deserialize<APIMod>(MessagePackSerializer.Serialize(apiMod));
+            var converted = (TestModTimeRamp)deserialised.ToMod(new TestRuleset());
+
+            Assert.That(converted.AdjustPitch.Value, Is.EqualTo(false));
+            Assert.That(converted.InitialRate.Value, Is.EqualTo(1.25));
+            Assert.That(converted.FinalRate.Value, Is.EqualTo(0.25));
+        }
+
+        private class TestRuleset : Ruleset
+        {
+            public override IEnumerable<Mod> GetModsFor(ModType type) => new Mod[]
+            {
+                new TestMod(),
+                new TestModTimeRamp(),
+            };
+
+            public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => throw new System.NotImplementedException();
+
+            public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => throw new System.NotImplementedException();
+
+            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new System.NotImplementedException();
+
+            public override string Description { get; } = string.Empty;
+            public override string ShortName { get; } = string.Empty;
+        }
+
+        private class TestMod : Mod
+        {
+            public override string Name => "Test Mod";
+            public override string Acronym => "TM";
+            public override double ScoreMultiplier => 1;
+
+            [SettingSource("Test")]
+            public BindableNumber<double> TestSetting { get; } = new BindableDouble
+            {
+                MinValue = 0,
+                MaxValue = 10,
+                Default = 5,
+                Precision = 0.01,
+            };
+        }
+
+        private class TestModTimeRamp : ModTimeRamp
+        {
+            public override string Name => "Test Mod";
+            public override string Acronym => "TMTR";
+            public override double ScoreMultiplier => 1;
+
+            [SettingSource("Initial rate", "The starting speed of the track")]
+            public override BindableNumber<double> InitialRate { get; } = new BindableDouble
+            {
+                MinValue = 1,
+                MaxValue = 2,
+                Default = 1.5,
+                Value = 1.5,
+                Precision = 0.01,
+            };
+
+            [SettingSource("Final rate", "The speed increase to ramp towards")]
+            public override BindableNumber<double> FinalRate { get; } = new BindableDouble
+            {
+                MinValue = 0,
+                MaxValue = 1,
+                Default = 0.5,
+                Value = 0.5,
+                Precision = 0.01,
+            };
+
+            [SettingSource("Adjust pitch", "Should pitch be adjusted with speed")]
+            public override BindableBool AdjustPitch { get; } = new BindableBool
+            {
+                Default = true,
+                Value = true
+            };
+        }
+    }
+}

osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs

@@ -0,0 +1,188 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.Database;
+using osu.Game.IO;
+using osu.Game.IO.Archives;
+using osu.Game.Online.API;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
+using osu.Game.Tests.Resources;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.Online
+{
+    [HeadlessTest]
+    public class TestSceneOnlinePlayBeatmapAvailabilityTracker : OsuTestScene
+    {
+        private RulesetStore rulesets;
+        private TestBeatmapManager beatmaps;
+
+        private string testBeatmapFile;
+        private BeatmapInfo testBeatmapInfo;
+        private BeatmapSetInfo testBeatmapSet;
+
+        private readonly Bindable<PlaylistItem> selectedItem = new Bindable<PlaylistItem>();
+        private OnlinePlayBeatmapAvailablilityTracker availablilityTracker;
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio, GameHost host)
+        {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.CacheAs<BeatmapManager>(beatmaps = new TestBeatmapManager(LocalStorage, ContextFactory, rulesets, API, audio, host, Beatmap.Default));
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            beatmaps.AllowImport = new TaskCompletionSource<bool>();
+
+            testBeatmapFile = TestResources.GetTestBeatmapForImport();
+
+            testBeatmapInfo = getTestBeatmapInfo(testBeatmapFile);
+            testBeatmapSet = testBeatmapInfo.BeatmapSet;
+
+            var existing = beatmaps.QueryBeatmapSet(s => s.OnlineBeatmapSetID == testBeatmapSet.OnlineBeatmapSetID);
+            if (existing != null)
+                beatmaps.Delete(existing);
+
+            selectedItem.Value = new PlaylistItem
+            {
+                Beatmap = { Value = testBeatmapInfo },
+                Ruleset = { Value = testBeatmapInfo.Ruleset },
+            };
+
+            Child = availablilityTracker = new OnlinePlayBeatmapAvailablilityTracker
+            {
+                SelectedItem = { BindTarget = selectedItem, }
+            };
+        });
+
+        [Test]
+        public void TestBeatmapDownloadingFlow()
+        {
+            AddAssert("ensure beatmap unavailable", () => !beatmaps.IsAvailableLocally(testBeatmapSet));
+            addAvailabilityCheckStep("state not downloaded", BeatmapAvailability.NotDownloaded);
+
+            AddStep("start downloading", () => beatmaps.Download(testBeatmapSet));
+            addAvailabilityCheckStep("state downloading 0%", () => BeatmapAvailability.Downloading(0.0f));
+
+            AddStep("set progress 40%", () => ((TestDownloadRequest)beatmaps.GetExistingDownload(testBeatmapSet)).SetProgress(0.4f));
+            addAvailabilityCheckStep("state downloading 40%", () => BeatmapAvailability.Downloading(0.4f));
+
+            AddStep("finish download", () => ((TestDownloadRequest)beatmaps.GetExistingDownload(testBeatmapSet)).TriggerSuccess(testBeatmapFile));
+            addAvailabilityCheckStep("state importing", BeatmapAvailability.Importing);
+
+            AddStep("allow importing", () => beatmaps.AllowImport.SetResult(true));
+            AddUntilStep("wait for import", () => beatmaps.CurrentImportTask?.IsCompleted == true);
+            addAvailabilityCheckStep("state locally available", BeatmapAvailability.LocallyAvailable);
+        }
+
+        [Test]
+        public void TestTrackerRespectsSoftDeleting()
+        {
+            AddStep("allow importing", () => beatmaps.AllowImport.SetResult(true));
+            AddStep("import beatmap", () => beatmaps.Import(testBeatmapFile).Wait());
+            addAvailabilityCheckStep("state locally available", BeatmapAvailability.LocallyAvailable);
+
+            AddStep("delete beatmap", () => beatmaps.Delete(beatmaps.QueryBeatmapSet(b => b.OnlineBeatmapSetID == testBeatmapSet.OnlineBeatmapSetID)));
+            addAvailabilityCheckStep("state not downloaded", BeatmapAvailability.NotDownloaded);
+
+            AddStep("undelete beatmap", () => beatmaps.Undelete(beatmaps.QueryBeatmapSet(b => b.OnlineBeatmapSetID == testBeatmapSet.OnlineBeatmapSetID)));
+            addAvailabilityCheckStep("state locally available", BeatmapAvailability.LocallyAvailable);
+        }
+
+        [Test]
+        public void TestTrackerRespectsChecksum()
+        {
+            AddStep("allow importing", () => beatmaps.AllowImport.SetResult(true));
+
+            AddStep("import altered beatmap", () =>
+            {
+                beatmaps.Import(TestResources.GetTestBeatmapForImport(true)).Wait();
+            });
+            addAvailabilityCheckStep("state still not downloaded", BeatmapAvailability.NotDownloaded);
+
+            AddStep("recreate tracker", () => Child = availablilityTracker = new OnlinePlayBeatmapAvailablilityTracker
+            {
+                SelectedItem = { BindTarget = selectedItem }
+            });
+            addAvailabilityCheckStep("state not downloaded as well", BeatmapAvailability.NotDownloaded);
+        }
+
+        private void addAvailabilityCheckStep(string description, Func<BeatmapAvailability> expected)
+        {
+            AddAssert(description, () => availablilityTracker.Availability.Value.Equals(expected.Invoke()));
+        }
+
+        private static BeatmapInfo getTestBeatmapInfo(string archiveFile)
+        {
+            BeatmapInfo info;
+
+            using (var archive = new ZipArchiveReader(File.OpenRead(archiveFile)))
+            using (var stream = archive.GetStream("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var reader = new LineBufferedReader(stream))
+            {
+                var decoder = Decoder.GetDecoder<Beatmap>(reader);
+                var beatmap = decoder.Decode(reader);
+
+                info = beatmap.BeatmapInfo;
+                info.BeatmapSet.Beatmaps = new List<BeatmapInfo> { info };
+                info.BeatmapSet.Metadata = info.Metadata;
+                info.MD5Hash = stream.ComputeMD5Hash();
+                info.Hash = stream.ComputeSHA2Hash();
+            }
+
+            return info;
+        }
+
+        private class TestBeatmapManager : BeatmapManager
+        {
+            public TaskCompletionSource<bool> AllowImport = new TaskCompletionSource<bool>();
+
+            public Task<BeatmapSetInfo> CurrentImportTask { get; private set; }
+
+            protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize)
+                => new TestDownloadRequest(set);
+
+            public TestBeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, GameHost host = null, WorkingBeatmap defaultBeatmap = null, bool performOnlineLookups = false)
+                : base(storage, contextFactory, rulesets, api, audioManager, host, defaultBeatmap, performOnlineLookups)
+            {
+            }
+
+            public override async Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, CancellationToken cancellationToken = default)
+            {
+                await AllowImport.Task;
+                return await (CurrentImportTask = base.Import(item, archive, cancellationToken));
+            }
+        }
+
+        private class TestDownloadRequest : ArchiveDownloadRequest<BeatmapSetInfo>
+        {
+            public new void SetProgress(float progress) => base.SetProgress(progress);
+            public new void TriggerSuccess(string filename) => base.TriggerSuccess(filename);
+
+            public TestDownloadRequest(BeatmapSetInfo model)
+                : base(model)
+            {
+            }
+
+            protected override string Target => null;
+        }
+    }
+}

osu.Game.Tests/Resources/animation-types.osb

@@ -0,0 +1,9 @@
+osu file format v14
+
+[Events]
+Animation,Foreground,Centre,"forever-string.png",330,240,10,108,LoopForever
+Animation,Foreground,Centre,"once-string.png",330,240,10,108,LoopOnce
+Animation,Foreground,Centre,"forever-number.png",330,240,10,108,0
+Animation,Foreground,Centre,"once-number.png",330,240,10,108,1
+Animation,Foreground,Centre,"undefined-number.png",330,240,10,108,16
+Animation,Foreground,Centre,"omitted.png",330,240,10,108

osu.Game.Tests/Rulesets/Mods/ModTimeRampTest.cs

@@ -0,0 +1,113 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Audio.Track;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Tests.Rulesets.Mods
+{
+    [TestFixture]
+    public class ModTimeRampTest
+    {
+        private const double start_time = 1000;
+        private const double duration = 9000;
+
+        private TrackVirtual track;
+
+        [SetUp]
+        public void SetUp()
+        {
+            track = new TrackVirtual(20_000);
+        }
+
+        [TestCase(0, 1)]
+        [TestCase(start_time, 1)]
+        [TestCase(start_time + duration * ModTimeRamp.FINAL_RATE_PROGRESS / 2, 1.25)]
+        [TestCase(start_time + duration * ModTimeRamp.FINAL_RATE_PROGRESS, 1.5)]
+        [TestCase(start_time + duration, 1.5)]
+        [TestCase(15000, 1.5)]
+        public void TestModWindUp(double time, double expectedRate)
+        {
+            var beatmap = createSingleSpinnerBeatmap();
+            var mod = new ModWindUp();
+            mod.ApplyToBeatmap(beatmap);
+            mod.ApplyToTrack(track);
+
+            seekTrackAndUpdateMod(mod, time);
+
+            Assert.That(mod.SpeedChange.Value, Is.EqualTo(expectedRate));
+        }
+
+        [TestCase(0, 1)]
+        [TestCase(start_time, 1)]
+        [TestCase(start_time + duration * ModTimeRamp.FINAL_RATE_PROGRESS / 2, 0.75)]
+        [TestCase(start_time + duration * ModTimeRamp.FINAL_RATE_PROGRESS, 0.5)]
+        [TestCase(start_time + duration, 0.5)]
+        [TestCase(15000, 0.5)]
+        public void TestModWindDown(double time, double expectedRate)
+        {
+            var beatmap = createSingleSpinnerBeatmap();
+            var mod = new ModWindDown
+            {
+                FinalRate = { Value = 0.5 }
+            };
+            mod.ApplyToBeatmap(beatmap);
+            mod.ApplyToTrack(track);
+
+            seekTrackAndUpdateMod(mod, time);
+
+            Assert.That(mod.SpeedChange.Value, Is.EqualTo(expectedRate));
+        }
+
+        [TestCase(0, 1)]
+        [TestCase(start_time, 1)]
+        [TestCase(2 * start_time, 1.5)]
+        public void TestZeroDurationMap(double time, double expectedRate)
+        {
+            var beatmap = createSingleObjectBeatmap();
+            var mod = new ModWindUp();
+            mod.ApplyToBeatmap(beatmap);
+            mod.ApplyToTrack(track);
+
+            seekTrackAndUpdateMod(mod, time);
+
+            Assert.That(mod.SpeedChange.Value, Is.EqualTo(expectedRate));
+        }
+
+        private void seekTrackAndUpdateMod(ModTimeRamp mod, double time)
+        {
+            track.Seek(time);
+            // update the mod via a fake playfield to re-calculate the current rate.
+            mod.Update(null);
+        }
+
+        private static Beatmap createSingleSpinnerBeatmap()
+        {
+            return new Beatmap
+            {
+                HitObjects =
+                {
+                    new Spinner
+                    {
+                        StartTime = start_time,
+                        Duration = duration
+                    }
+                }
+            };
+        }
+
+        private static Beatmap createSingleObjectBeatmap()
+        {
+            return new Beatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle { StartTime = start_time }
+                }
+            };
+        }
+    }
+}

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

@@ -5,6 +5,8 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osuTK;
 
@@ -13,6 +15,9 @@ namespace osu.Game.Tests.Visual.Editing
     [TestFixture]
     public class TestSceneEditorSummaryTimeline : EditorClockTestScene
     {
+        [Cached(typeof(EditorBeatmap))]
+        private readonly EditorBeatmap editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+
         [BackgroundDependencyLoader]
         private void load()
         {

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

@@ -0,0 +1,55 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osuTK;
+using osuTK.Input;
+using static osu.Game.Screens.Edit.Compose.Components.Timeline.TimelineHitObjectBlueprint;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneTimelineHitObjectBlueprint : TimelineTestScene
+    {
+        public override Drawable CreateTestComponent() => new TimelineBlueprintContainer(Composer);
+
+        [Test]
+        public void TestDisallowZeroDurationObjects()
+        {
+            DragBar dragBar;
+
+            AddStep("add spinner", () =>
+            {
+                EditorBeatmap.Clear();
+                EditorBeatmap.Add(new Spinner
+                {
+                    Position = new Vector2(256, 256),
+                    StartTime = 150,
+                    Duration = 500
+                });
+            });
+
+            AddStep("hold down drag bar", () =>
+            {
+                // distinguishes between the actual drag bar and its "underlay shadow".
+                dragBar = this.ChildrenOfType<DragBar>().Single(bar => bar.HandlePositionalInput);
+                InputManager.MoveMouseTo(dragBar);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("try to drag bar past start", () =>
+            {
+                var blueprint = this.ChildrenOfType<TimelineHitObjectBlueprint>().Single();
+                InputManager.MoveMouseTo(blueprint.SelectionQuad.TopLeft - new Vector2(100, 0));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("object has non-zero duration", () => EditorBeatmap.HitObjects.OfType<IHasDuration>().Single().Duration > 0);
+        }
+    }
+}

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

@@ -23,22 +23,24 @@ namespace osu.Game.Tests.Visual.Editing
 
         protected HitObjectComposer Composer { get; private set; }
 
+        protected EditorBeatmap EditorBeatmap { get; private set; }
+
         [BackgroundDependencyLoader]
         private void load(AudioManager audio)
         {
             Beatmap.Value = new WaveformTestBeatmap(audio);
 
             var playable = Beatmap.Value.GetPlayableBeatmap(Beatmap.Value.BeatmapInfo.Ruleset);
-            var editorBeatmap = new EditorBeatmap(playable);
+            EditorBeatmap = new EditorBeatmap(playable);
 
-            Dependencies.Cache(editorBeatmap);
-            Dependencies.CacheAs<IBeatSnapProvider>(editorBeatmap);
+            Dependencies.Cache(EditorBeatmap);
+            Dependencies.CacheAs<IBeatSnapProvider>(EditorBeatmap);
 
             Composer = playable.BeatmapInfo.Ruleset.CreateInstance().CreateHitObjectComposer().With(d => d.Alpha = 0);
 
             AddRange(new Drawable[]
             {
-                editorBeatmap,
+                EditorBeatmap,
                 Composer,
                 new FillFlowContainer
                 {

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

@@ -0,0 +1,74 @@
+// 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.Allocation;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Storyboards;
+using osu.Game.Storyboards.Drawables;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneStoryboardSamplePlayback : PlayerTestScene
+    {
+        private Storyboard storyboard;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            config.Set(OsuSetting.ShowStoryboard, true);
+
+            storyboard = new Storyboard();
+            var backgroundLayer = storyboard.GetLayer("Background");
+            backgroundLayer.Add(new StoryboardSampleInfo("Intro/welcome.mp3", time: -7000, volume: 20));
+            backgroundLayer.Add(new StoryboardSampleInfo("Intro/welcome.mp3", time: -5000, volume: 20));
+            backgroundLayer.Add(new StoryboardSampleInfo("Intro/welcome.mp3", time: 0, volume: 20));
+        }
+
+        [Test]
+        public void TestStoryboardSamplesStopDuringPause()
+        {
+            checkForFirstSamplePlayback();
+
+            AddStep("player paused", () => Player.Pause());
+            AddAssert("player is currently paused", () => Player.GameplayClockContainer.IsPaused.Value);
+            AddAssert("all storyboard samples stopped immediately", () => allStoryboardSamples.All(sound => !sound.IsPlaying));
+
+            AddStep("player resume", () => Player.Resume());
+            AddUntilStep("any storyboard samples playing after resume", () => allStoryboardSamples.Any(sound => sound.IsPlaying));
+        }
+
+        [Test]
+        public void TestStoryboardSamplesStopOnSkip()
+        {
+            checkForFirstSamplePlayback();
+
+            AddStep("skip intro", () => InputManager.Key(osuTK.Input.Key.Space));
+            AddAssert("all storyboard samples stopped immediately", () => allStoryboardSamples.All(sound => !sound.IsPlaying));
+
+            AddUntilStep("any storyboard samples playing after skip", () => allStoryboardSamples.Any(sound => sound.IsPlaying));
+        }
+
+        private void checkForFirstSamplePlayback()
+        {
+            AddUntilStep("storyboard loaded", () => Player.Beatmap.Value.StoryboardLoaded);
+            AddUntilStep("any storyboard samples playing", () => allStoryboardSamples.Any(sound => sound.IsPlaying));
+        }
+
+        private IEnumerable<DrawableStoryboardSample> allStoryboardSamples => Player.ChildrenOfType<DrawableStoryboardSample>();
+
+        protected override bool AllowFail => false;
+
+        protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
+        protected override TestPlayer CreatePlayer(Ruleset ruleset) => new TestPlayer(true, false);
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard ?? this.storyboard, Clock, Audio);
+    }
+}

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

@@ -11,8 +11,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
@@ -20,6 +20,7 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay;
 using osu.Game.Tests.Beatmaps;
+using osu.Game.Users;
 using osuTK;
 using osuTK.Input;
 
@@ -241,7 +242,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         }
 
         private void moveToItem(int index, Vector2? offset = null)
-            => AddStep($"move mouse to item {index}", () => InputManager.MoveMouseTo(playlist.ChildrenOfType<OsuRearrangeableListItem<PlaylistItem>>().ElementAt(index), offset));
+            => AddStep($"move mouse to item {index}", () => InputManager.MoveMouseTo(playlist.ChildrenOfType<DifficultyIcon>().ElementAt(index), offset));
 
         private void moveToDragger(int index, Vector2? offset = null) => AddStep($"move mouse to dragger {index}", () =>
         {
@@ -252,7 +253,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private void moveToDeleteButton(int index, Vector2? offset = null) => AddStep($"move mouse to delete button {index}", () =>
         {
             var item = playlist.ChildrenOfType<OsuRearrangeableListItem<PlaylistItem>>().ElementAt(index);
-            InputManager.MoveMouseTo(item.ChildrenOfType<IconButton>().ElementAt(0), offset);
+            InputManager.MoveMouseTo(item.ChildrenOfType<DrawableRoomPlaylistItem.PlaylistRemoveButton>().ElementAt(0), offset);
         });
 
         private void assertHandleVisibility(int index, bool visible)
@@ -260,7 +261,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 () => (playlist.ChildrenOfType<OsuRearrangeableListItem<PlaylistItem>.PlaylistItemHandle>().ElementAt(index).Alpha > 0) == visible);
 
         private void assertDeleteButtonVisibility(int index, bool visible)
-            => AddAssert($"delete button {index} {(visible ? "is" : "is not")} visible", () => (playlist.ChildrenOfType<IconButton>().ElementAt(2 + index * 2).Alpha > 0) == visible);
+            => AddAssert($"delete button {index} {(visible ? "is" : "is not")} visible", () => (playlist.ChildrenOfType<DrawableRoomPlaylistItem.PlaylistRemoveButton>().ElementAt(2 + index * 2).Alpha > 0) == visible);
 
         private void createPlaylist(bool allowEdit, bool allowSelection)
         {
@@ -278,7 +279,21 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     playlist.Items.Add(new PlaylistItem
                     {
                         ID = i,
-                        Beatmap = { Value = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo },
+                        Beatmap =
+                        {
+                            Value = i % 2 == 1
+                                ? new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo
+                                : new BeatmapInfo
+                                {
+                                    Metadata = new BeatmapMetadata
+                                    {
+                                        Artist = "Artist",
+                                        Author = new User { Username = "Creator name here" },
+                                        Title = "Long title used to check background colour",
+                                    },
+                                    BeatmapSet = new BeatmapSetInfo()
+                                }
+                        },
                         Ruleset = { Value = new OsuRuleset().RulesetInfo },
                         RequiredMods =
                         {

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

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Screens.OnlinePlay;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestSceneFreeModSelectOverlay : MultiplayerTestScene
+    {
+        [SetUp]
+        public new void Setup() => Schedule(() =>
+        {
+            Child = new FreeModSelectOverlay
+            {
+                State = { Value = Visibility.Visible }
+            };
+        });
+    }
+}

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

@@ -8,6 +8,8 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Participants;
 using osu.Game.Users;
 using osuTK;
@@ -123,5 +125,32 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 }
             });
         }
+
+        [Test]
+        public void TestUserWithMods()
+        {
+            AddStep("add user", () =>
+            {
+                Client.AddUser(new User
+                {
+                    Id = 0,
+                    Username = "User 0",
+                    CurrentModeRank = RNG.Next(1, 100000),
+                    CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                });
+
+                Client.ChangeUserMods(0, new Mod[]
+                {
+                    new OsuModHardRock(),
+                    new OsuModDifficultyAdjust { ApproachRate = { Value = 1 } }
+                });
+            });
+
+            for (var i = MultiplayerUserState.Idle; i < MultiplayerUserState.Results; i++)
+            {
+                var state = i;
+                AddStep($"set state: {state}", () => Client.ChangeUserState(0, state));
+            }
+        }
     }
 }

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

@@ -6,6 +6,7 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
@@ -26,8 +27,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
     public class TestSceneMultiplayerReadyButton : MultiplayerTestScene
     {
         private MultiplayerReadyButton button;
+        private OnlinePlayBeatmapAvailablilityTracker beatmapTracker;
         private BeatmapSetInfo importedSet;
 
+        private readonly Bindable<PlaylistItem> selectedItem = new Bindable<PlaylistItem>();
+
         private BeatmapManager beatmaps;
         private RulesetStore rulesets;
 
@@ -39,6 +43,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
             Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
             beatmaps.Import(TestResources.GetTestBeatmapForImport(true)).Wait();
+
+            Add(beatmapTracker = new OnlinePlayBeatmapAvailablilityTracker
+            {
+                SelectedItem = { BindTarget = selectedItem }
+            });
+
+            Dependencies.Cache(beatmapTracker);
         }
 
         [SetUp]
@@ -46,20 +57,20 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
             Beatmap.Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());
+            selectedItem.Value = new PlaylistItem
+            {
+                Beatmap = { Value = Beatmap.Value.BeatmapInfo },
+                Ruleset = { Value = Beatmap.Value.BeatmapInfo.Ruleset },
+            };
 
-            Child = button = new MultiplayerReadyButton
+            if (button != null)
+                Remove(button);
+
+            Add(button = new MultiplayerReadyButton
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Size = new Vector2(200, 50),
-                SelectedItem =
-                {
-                    Value = new PlaylistItem
-                    {
-                        Beatmap = { Value = Beatmap.Value.BeatmapInfo },
-                        Ruleset = { Value = Beatmap.Value.BeatmapInfo.Ruleset }
-                    }
-                },
                 OnReadyClick = async () =>
                 {
                     readyClickOperation = OngoingOperationTracker.BeginOperation();
@@ -73,7 +84,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     await Client.ToggleReady();
                     readyClickOperation.Dispose();
                 }
-            };
+            });
         });
 
         [Test]

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

@@ -101,7 +101,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 });
             });
 
-            AddAssert("multiplayer room joined", () => roomContainer.Client.Room != null);
+            AddUntilStep("multiplayer room joined", () => roomContainer.Client.Room != null);
         }
 
         [Test]
@@ -133,7 +133,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 });
             });
 
-            AddAssert("multiplayer room joined", () => roomContainer.Client.Room != null);
+            AddUntilStep("multiplayer room joined", () => roomContainer.Client.Room != null);
         }
 
         private TestMultiplayerRoomManager createRoomManager()

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

@@ -19,11 +19,11 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.OnlinePlay.Components;
-using osu.Game.Screens.Select;
+using osu.Game.Screens.OnlinePlay.Playlists;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
-    public class TestSceneMatchSongSelect : RoomTestScene
+    public class TestScenePlaylistsSongSelect : RoomTestScene
     {
         [Resolved]
         private BeatmapManager beatmapManager { get; set; }
@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private RulesetStore rulesets;
 
-        private TestMatchSongSelect songSelect;
+        private TestPlaylistsSongSelect songSelect;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -89,7 +89,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 Beatmap.SetDefault();
             });
 
-            AddStep("create song select", () => LoadScreen(songSelect = new TestMatchSongSelect()));
+            AddStep("create song select", () => LoadScreen(songSelect = new TestPlaylistsSongSelect()));
             AddUntilStep("wait for present", () => songSelect.IsCurrentScreen());
         }
 
@@ -143,6 +143,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         /// Tests that the same <see cref="Mod"/> instances are not shared between two playlist items.
         /// </summary>
         [Test]
+        [Ignore("Temporarily disabled due to a non-trivial test failure")]
         public void TestNewItemHasNewModInstances()
         {
             AddStep("set dt mod", () => SelectedMods.Value = new[] { new OsuModDoubleTime() });
@@ -176,7 +177,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("item has rate 1.5", () => Precision.AlmostEquals(1.5, ((OsuModDoubleTime)Room.Playlist.First().RequiredMods[0]).SpeedChange.Value));
         }
 
-        private class TestMatchSongSelect : MatchSongSelect
+        private class TestPlaylistsSongSelect : PlaylistsSongSelect
         {
             public new MatchBeatmapDetailArea BeatmapDetails => (MatchBeatmapDetailArea)base.BeatmapDetails;
         }

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

@@ -1,32 +1,81 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Overlays;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+using osu.Game.Overlays.BeatmapListing;
+using osu.Game.Rulesets;
 
 namespace osu.Game.Tests.Visual.Online
 {
     public class TestSceneBeatmapListingOverlay : OsuTestScene
     {
-        protected override bool UseOnlineAPI => true;
+        private readonly List<APIBeatmapSet> setsForResponse = new List<APIBeatmapSet>();
 
-        private readonly BeatmapListingOverlay overlay;
+        private BeatmapListingOverlay overlay;
 
-        public TestSceneBeatmapListingOverlay()
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            Add(overlay = new BeatmapListingOverlay());
+            Child = overlay = new BeatmapListingOverlay { State = { Value = Visibility.Visible } };
+
+            ((DummyAPIAccess)API).HandleRequest = req =>
+            {
+                if (req is SearchBeatmapSetsRequest searchBeatmapSetsRequest)
+                {
+                    searchBeatmapSetsRequest.TriggerSuccess(new SearchBeatmapSetsResponse
+                    {
+                        BeatmapSets = setsForResponse,
+                    });
+                }
+            };
         }
 
         [Test]
-        public void TestShow()
+        public void TestNoBeatmapsPlaceholder()
         {
-            AddStep("Show", overlay.Show);
+            AddStep("fetch for 0 beatmaps", () => fetchFor());
+            AddUntilStep("placeholder shown", () => overlay.ChildrenOfType<BeatmapListingOverlay.NotFoundDrawable>().SingleOrDefault()?.IsPresent == true);
+
+            AddStep("fetch for 1 beatmap", () => fetchFor(CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet));
+            AddUntilStep("placeholder hidden", () => !overlay.ChildrenOfType<BeatmapListingOverlay.NotFoundDrawable>().Any());
+
+            AddStep("fetch for 0 beatmaps", () => fetchFor());
+            AddUntilStep("placeholder shown", () => overlay.ChildrenOfType<BeatmapListingOverlay.NotFoundDrawable>().SingleOrDefault()?.IsPresent == true);
+
+            // fetch once more to ensure nothing happens in displaying placeholder again when it already is present.
+            AddStep("fetch for 0 beatmaps again", () => fetchFor());
+            AddUntilStep("placeholder shown", () => overlay.ChildrenOfType<BeatmapListingOverlay.NotFoundDrawable>().SingleOrDefault()?.IsPresent == true);
         }
 
-        [Test]
-        public void TestHide()
+        private void fetchFor(params BeatmapSetInfo[] beatmaps)
         {
-            AddStep("Hide", overlay.Hide);
+            setsForResponse.Clear();
+            setsForResponse.AddRange(beatmaps.Select(b => new TestAPIBeatmapSet(b)));
+
+            // trigger arbitrary change for fetching.
+            overlay.ChildrenOfType<BeatmapListingSearchControl>().Single().Query.TriggerChange();
+        }
+
+        private class TestAPIBeatmapSet : APIBeatmapSet
+        {
+            private readonly BeatmapSetInfo beatmapSet;
+
+            public TestAPIBeatmapSet(BeatmapSetInfo beatmapSet)
+            {
+                this.beatmapSet = beatmapSet;
+            }
+
+            public override BeatmapSetInfo ToBeatmapSet(RulesetStore rulesets) => beatmapSet;
         }
     }
 }

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

@@ -0,0 +1,33 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Overlays;
+using NUnit.Framework;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    [Description("uses online API")]
+    public class TestSceneOnlineBeatmapListingOverlay : OsuTestScene
+    {
+        protected override bool UseOnlineAPI => true;
+
+        private readonly BeatmapListingOverlay overlay;
+
+        public TestSceneOnlineBeatmapListingOverlay()
+        {
+            Add(overlay = new BeatmapListingOverlay());
+        }
+
+        [Test]
+        public void TestShow()
+        {
+            AddStep("Show", overlay.Show);
+        }
+
+        [Test]
+        public void TestHide()
+        {
+            AddStep("Hide", overlay.Hide);
+        }
+    }
+}

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

@@ -8,16 +8,16 @@ using osu.Game.Users;
 using osuTK;
 using System;
 using System.Linq;
+using NUnit.Framework;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.Containers;
 using osu.Game.Overlays.Chat;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Online
 {
-    public class TestSceneStandAloneChatDisplay : OsuTestScene
+    public class TestSceneStandAloneChatDisplay : OsuManualInputManagerTestScene
     {
-        private readonly Channel testChannel = new Channel();
-
         private readonly User admin = new User
         {
             Username = "HappyStick",
@@ -46,92 +46,97 @@ namespace osu.Game.Tests.Visual.Online
         [Cached]
         private ChannelManager channelManager = new ChannelManager();
 
-        private readonly TestStandAloneChatDisplay chatDisplay;
-        private readonly TestStandAloneChatDisplay chatDisplay2;
+        private TestStandAloneChatDisplay chatDisplay;
+        private int messageIdSequence;
+
+        private Channel testChannel;
 
         public TestSceneStandAloneChatDisplay()
         {
             Add(channelManager);
-
-            Add(chatDisplay = new TestStandAloneChatDisplay
-            {
-                Anchor = Anchor.CentreLeft,
-                Origin = Anchor.CentreLeft,
-                Margin = new MarginPadding(20),
-                Size = new Vector2(400, 80)
-            });
-
-            Add(chatDisplay2 = new TestStandAloneChatDisplay(true)
-            {
-                Anchor = Anchor.CentreRight,
-                Origin = Anchor.CentreRight,
-                Margin = new MarginPadding(20),
-                Size = new Vector2(400, 150)
-            });
         }
 
-        protected override void LoadComplete()
+        [SetUp]
+        public void SetUp() => Schedule(() =>
         {
-            base.LoadComplete();
+            messageIdSequence = 0;
+            channelManager.CurrentChannel.Value = testChannel = new Channel();
 
-            channelManager.CurrentChannel.Value = testChannel;
+            Children = new[]
+            {
+                chatDisplay = new TestStandAloneChatDisplay
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Margin = new MarginPadding(20),
+                    Size = new Vector2(400, 80),
+                    Channel = { Value = testChannel },
+                },
+                new TestStandAloneChatDisplay(true)
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    Margin = new MarginPadding(20),
+                    Size = new Vector2(400, 150),
+                    Channel = { Value = testChannel },
+                }
+            };
+        });
 
-            chatDisplay.Channel.Value = testChannel;
-            chatDisplay2.Channel.Value = testChannel;
-
-            int sequence = 0;
-
-            AddStep("message from admin", () => testChannel.AddNewMessages(new Message(sequence++)
+        [Test]
+        public void TestManyMessages()
+        {
+            AddStep("message from admin", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
             {
                 Sender = admin,
                 Content = "I am a wang!"
             }));
 
-            AddStep("message from team red", () => testChannel.AddNewMessages(new Message(sequence++)
+            AddStep("message from team red", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
             {
                 Sender = redUser,
                 Content = "I am team red."
             }));
 
-            AddStep("message from team red", () => testChannel.AddNewMessages(new Message(sequence++)
+            AddStep("message from team red", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
             {
                 Sender = redUser,
                 Content = "I plan to win!"
             }));
 
-            AddStep("message from team blue", () => testChannel.AddNewMessages(new Message(sequence++)
+            AddStep("message from team blue", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
             {
                 Sender = blueUser,
                 Content = "Not on my watch. Prepare to eat saaaaaaaaaand. Lots and lots of saaaaaaand."
             }));
 
-            AddStep("message from admin", () => testChannel.AddNewMessages(new Message(sequence++)
+            AddStep("message from admin", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
             {
                 Sender = admin,
                 Content = "Okay okay, calm down guys. Let's do this!"
             }));
 
-            AddStep("message from long username", () => testChannel.AddNewMessages(new Message(sequence++)
+            AddStep("message from long username", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
             {
                 Sender = longUsernameUser,
                 Content = "Hi guys, my new username is lit!"
             }));
 
-            AddStep("message with new date", () => testChannel.AddNewMessages(new Message(sequence++)
+            AddStep("message with new date", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
             {
                 Sender = longUsernameUser,
                 Content = "Message from the future!",
                 Timestamp = DateTimeOffset.Now
             }));
 
-            AddUntilStep("ensure still scrolled to bottom", () => chatDisplay.ScrolledToBottom);
+            checkScrolledToBottom();
 
             const int messages_per_call = 10;
             AddRepeatStep("add many messages", () =>
             {
                 for (int i = 0; i < messages_per_call; i++)
                 {
-                    testChannel.AddNewMessages(new Message(sequence++)
+                    testChannel.AddNewMessages(new Message(messageIdSequence++)
                     {
                         Sender = longUsernameUser,
                         Content = "Many messages! " + Guid.NewGuid(),
@@ -153,9 +158,133 @@ namespace osu.Game.Tests.Visual.Online
                 return true;
             });
 
-            AddUntilStep("ensure still scrolled to bottom", () => chatDisplay.ScrolledToBottom);
+            checkScrolledToBottom();
         }
 
+        /// <summary>
+        /// Tests that when a message gets wrapped by the chat display getting contracted while scrolled to bottom, the chat will still keep scrolling down.
+        /// </summary>
+        [Test]
+        public void TestMessageWrappingKeepsAutoScrolling()
+        {
+            fillChat();
+
+            // send message with short words for text wrapping to occur when contracting chat.
+            sendMessage();
+
+            AddStep("contract chat", () => chatDisplay.Width -= 100);
+            checkScrolledToBottom();
+
+            AddStep("send another message", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
+            {
+                Sender = admin,
+                Content = "As we were saying...",
+            }));
+
+            checkScrolledToBottom();
+        }
+
+        [Test]
+        public void TestUserScrollOverride()
+        {
+            fillChat();
+
+            sendMessage();
+            checkScrolledToBottom();
+
+            AddStep("User scroll up", () =>
+            {
+                InputManager.MoveMouseTo(chatDisplay.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.MoveMouseTo(chatDisplay.ScreenSpaceDrawQuad.Centre + new Vector2(0, chatDisplay.ScreenSpaceDrawQuad.Height));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            checkNotScrolledToBottom();
+            sendMessage();
+            checkNotScrolledToBottom();
+
+            AddRepeatStep("User scroll to bottom", () =>
+            {
+                InputManager.MoveMouseTo(chatDisplay.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.MoveMouseTo(chatDisplay.ScreenSpaceDrawQuad.Centre - new Vector2(0, chatDisplay.ScreenSpaceDrawQuad.Height));
+                InputManager.ReleaseButton(MouseButton.Left);
+            }, 5);
+
+            checkScrolledToBottom();
+            sendMessage();
+            checkScrolledToBottom();
+        }
+
+        [Test]
+        public void TestLocalEchoMessageResetsScroll()
+        {
+            fillChat();
+
+            sendMessage();
+            checkScrolledToBottom();
+
+            AddStep("User scroll up", () =>
+            {
+                InputManager.MoveMouseTo(chatDisplay.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.MoveMouseTo(chatDisplay.ScreenSpaceDrawQuad.Centre + new Vector2(0, chatDisplay.ScreenSpaceDrawQuad.Height));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            checkNotScrolledToBottom();
+            sendMessage();
+            checkNotScrolledToBottom();
+
+            sendLocalMessage();
+            checkScrolledToBottom();
+
+            sendMessage();
+            checkScrolledToBottom();
+        }
+
+        private void fillChat()
+        {
+            AddStep("fill chat", () =>
+            {
+                for (int i = 0; i < 10; i++)
+                {
+                    testChannel.AddNewMessages(new Message(messageIdSequence++)
+                    {
+                        Sender = longUsernameUser,
+                        Content = $"some stuff {Guid.NewGuid()}",
+                    });
+                }
+            });
+
+            checkScrolledToBottom();
+        }
+
+        private void sendMessage()
+        {
+            AddStep("send lorem ipsum", () => testChannel.AddNewMessages(new Message(messageIdSequence++)
+            {
+                Sender = longUsernameUser,
+                Content = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce et bibendum velit.",
+            }));
+        }
+
+        private void sendLocalMessage()
+        {
+            AddStep("send local echo", () => testChannel.AddLocalEcho(new LocalEchoMessage
+            {
+                Sender = longUsernameUser,
+                Content = "This is a local echo message.",
+            }));
+        }
+
+        private void checkScrolledToBottom() =>
+            AddUntilStep("is scrolled to bottom", () => chatDisplay.ScrolledToBottom);
+
+        private void checkNotScrolledToBottom() =>
+            AddUntilStep("not scrolled to bottom", () => !chatDisplay.ScrolledToBottom);
+
         private class TestStandAloneChatDisplay : StandAloneChatDisplay
         {
             public TestStandAloneChatDisplay(bool textbox = false)
@@ -165,7 +294,7 @@ namespace osu.Game.Tests.Visual.Online
 
             protected DrawableChannel DrawableChannel => InternalChildren.OfType<DrawableChannel>().First();
 
-            protected OsuScrollContainer ScrollContainer => (OsuScrollContainer)((Container)DrawableChannel.Child).Child;
+            protected UserTrackingScrollContainer ScrollContainer => (UserTrackingScrollContainer)((Container)DrawableChannel.Child).Child;
 
             public FillFlowContainer FillFlow => (FillFlowContainer)ScrollContainer.Child;
 

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

@@ -7,6 +7,8 @@ using osu.Game.Overlays.Comments;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Framework.Allocation;
 using osu.Game.Overlays;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Containers;
 
 namespace osu.Game.Tests.Visual.Online
 {
@@ -16,13 +18,33 @@ namespace osu.Game.Tests.Visual.Online
         [Cached]
         private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
 
-        private VotePill votePill;
+        [Cached]
+        private LoginOverlay login;
+
+        private TestPill votePill;
+        private readonly Container pillContainer;
+
+        public TestSceneVotePill()
+        {
+            AddRange(new Drawable[]
+            {
+                pillContainer = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    AutoSizeAxes = Axes.Both
+                },
+                login = new LoginOverlay()
+            });
+        }
 
         [Test]
         public void TestUserCommentPill()
         {
+            AddStep("Hide login overlay", () => login.Hide());
             AddStep("Log in", logIn);
             AddStep("User comment", () => addVotePill(getUserComment()));
+            AddAssert("Background is transparent", () => votePill.Background.Alpha == 0);
             AddStep("Click", () => votePill.Click());
             AddAssert("Not loading", () => !votePill.IsLoading);
         }
@@ -30,8 +52,10 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestRandomCommentPill()
         {
+            AddStep("Hide login overlay", () => login.Hide());
             AddStep("Log in", logIn);
             AddStep("Random comment", () => addVotePill(getRandomComment()));
+            AddAssert("Background is visible", () => votePill.Background.Alpha == 1);
             AddStep("Click", () => votePill.Click());
             AddAssert("Loading", () => votePill.IsLoading);
         }
@@ -39,10 +63,11 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestOfflineRandomCommentPill()
         {
+            AddStep("Hide login overlay", () => login.Hide());
             AddStep("Log out", API.Logout);
             AddStep("Random comment", () => addVotePill(getRandomComment()));
             AddStep("Click", () => votePill.Click());
-            AddAssert("Not loading", () => !votePill.IsLoading);
+            AddAssert("Login overlay is visible", () => login.State.Value == Visibility.Visible);
         }
 
         private void logIn() => API.Login("localUser", "password");
@@ -63,12 +88,22 @@ namespace osu.Game.Tests.Visual.Online
 
         private void addVotePill(Comment comment)
         {
-            Clear();
-            Add(votePill = new VotePill(comment)
+            pillContainer.Clear();
+            pillContainer.Child = votePill = new TestPill(comment)
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-            });
+            };
+        }
+
+        private class TestPill : VotePill
+        {
+            public new Box Background => base.Background;
+
+            public TestPill(Comment comment)
+                : base(comment)
+            {
+            }
         }
     }
 }

osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs

@@ -4,7 +4,6 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Graphics.Containers;
@@ -28,12 +27,7 @@ namespace osu.Game.Tests.Visual.Playlists
         {
             base.SetUpSteps();
 
-            AddStep("push screen", () => LoadScreen(loungeScreen = new PlaylistsLoungeSubScreen
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Width = 0.5f,
-            }));
+            AddStep("push screen", () => LoadScreen(loungeScreen = new PlaylistsLoungeSubScreen()));
 
             AddUntilStep("wait for present", () => loungeScreen.IsCurrentScreen());
         }

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

@@ -0,0 +1,21 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneModIcon : OsuTestScene
+    {
+        [Test]
+        public void TestChangeModType()
+        {
+            ModIcon icon = null;
+
+            AddStep("create mod icon", () => Child = icon = new ModIcon(new OsuModDoubleTime()));
+            AddStep("change mod", () => icon.Mod = new OsuModEasy());
+        }
+    }
+}

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

@@ -8,6 +8,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
@@ -38,27 +39,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         }
 
         [SetUp]
-        public void SetUp() => Schedule(() =>
-        {
-            Children = new Drawable[]
-            {
-                modSelect = new TestModSelectOverlay
-                {
-                    Origin = Anchor.BottomCentre,
-                    Anchor = Anchor.BottomCentre,
-                    SelectedMods = { BindTarget = SelectedMods }
-                },
-
-                modDisplay = new ModDisplay
-                {
-                    Anchor = Anchor.TopRight,
-                    Origin = Anchor.TopRight,
-                    AutoSizeAxes = Axes.Both,
-                    Position = new Vector2(-5, 25),
-                    Current = { BindTarget = modSelect.SelectedMods }
-                }
-            };
-        });
+        public void SetUp() => Schedule(() => createDisplay(() => new TestModSelectOverlay()));
 
         [SetUpSteps]
         public void SetUpSteps()
@@ -66,6 +47,32 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddStep("show", () => modSelect.Show());
         }
 
+        [Test]
+        public void TestAnimationFlushOnClose()
+        {
+            changeRuleset(0);
+
+            AddStep("Select all fun mods", () =>
+            {
+                modSelect.ModSectionsContainer
+                         .Single(c => c.ModType == ModType.DifficultyIncrease)
+                         .SelectAll();
+            });
+
+            AddUntilStep("many mods selected", () => modDisplay.Current.Value.Count >= 5);
+
+            AddStep("trigger deselect and close overlay", () =>
+            {
+                modSelect.ModSectionsContainer
+                         .Single(c => c.ModType == ModType.DifficultyIncrease)
+                         .DeselectAll();
+
+                modSelect.Hide();
+            });
+
+            AddAssert("all mods deselected", () => modDisplay.Current.Value.Count == 0);
+        }
+
         [Test]
         public void TestOsuMods()
         {
@@ -134,6 +141,8 @@ namespace osu.Game.Tests.Visual.UserInterface
         [Test]
         public void TestExternallySetCustomizedMod()
         {
+            changeRuleset(0);
+
             AddStep("set customized mod externally", () => SelectedMods.Value = new[] { new OsuModDoubleTime { SpeedChange = { Value = 1.01 } } });
 
             AddAssert("ensure button is selected and customized accordingly", () =>
@@ -143,6 +152,46 @@ namespace osu.Game.Tests.Visual.UserInterface
             });
         }
 
+        [Test]
+        public void TestNonStacked()
+        {
+            changeRuleset(0);
+
+            AddStep("create overlay", () => createDisplay(() => new TestNonStackedModSelectOverlay()));
+
+            AddStep("show", () => modSelect.Show());
+
+            AddAssert("ensure all buttons are spread out", () => modSelect.ChildrenOfType<ModButton>().All(m => m.Mods.Length <= 1));
+        }
+
+        [Test]
+        public void TestChangeIsValidChangesButtonVisibility()
+        {
+            changeRuleset(0);
+
+            AddAssert("double time visible", () => modSelect.ChildrenOfType<ModButton>().Any(b => b.Mods.Any(m => m is OsuModDoubleTime)));
+
+            AddStep("make double time invalid", () => modSelect.IsValidMod = m => !(m is OsuModDoubleTime));
+            AddUntilStep("double time not visible", () => modSelect.ChildrenOfType<ModButton>().All(b => !b.Mods.Any(m => m is OsuModDoubleTime)));
+            AddAssert("nightcore still visible", () => modSelect.ChildrenOfType<ModButton>().Any(b => b.Mods.Any(m => m is OsuModNightcore)));
+
+            AddStep("make double time valid again", () => modSelect.IsValidMod = m => true);
+            AddUntilStep("double time visible", () => modSelect.ChildrenOfType<ModButton>().Any(b => b.Mods.Any(m => m is OsuModDoubleTime)));
+            AddAssert("nightcore still visible", () => modSelect.ChildrenOfType<ModButton>().Any(b => b.Mods.Any(m => m is OsuModNightcore)));
+        }
+
+        [Test]
+        public void TestChangeIsValidPreservesSelection()
+        {
+            changeRuleset(0);
+
+            AddStep("select DT + HD", () => SelectedMods.Value = new Mod[] { new OsuModDoubleTime(), new OsuModHidden() });
+            AddAssert("DT + HD selected", () => modSelect.ChildrenOfType<ModButton>().Count(b => b.Selected) == 2);
+
+            AddStep("make NF invalid", () => modSelect.IsValidMod = m => !(m is ModNoFail));
+            AddAssert("DT + HD still selected", () => modSelect.ChildrenOfType<ModButton>().Count(b => b.Selected) == 2);
+        }
+
         private void testSingleMod(Mod mod)
         {
             selectNext(mod);
@@ -262,12 +311,37 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private void checkLabelColor(Func<Color4> getColour) => AddAssert("check label has expected colour", () => modSelect.MultiplierLabel.Colour.AverageColour == getColour());
 
-        private class TestModSelectOverlay : ModSelectOverlay
+        private void createDisplay(Func<TestModSelectOverlay> createOverlayFunc)
+        {
+            SelectedMods.Value = Array.Empty<Mod>();
+            Children = new Drawable[]
+            {
+                modSelect = createOverlayFunc().With(d =>
+                {
+                    d.Origin = Anchor.BottomCentre;
+                    d.Anchor = Anchor.BottomCentre;
+                    d.SelectedMods.BindTarget = SelectedMods;
+                }),
+                modDisplay = new ModDisplay
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                    AutoSizeAxes = Axes.Both,
+                    Position = new Vector2(-5, 25),
+                    Current = { BindTarget = modSelect.SelectedMods }
+                }
+            };
+        }
+
+        private class TestModSelectOverlay : LocalPlayerModSelectOverlay
         {
             public new Bindable<IReadOnlyList<Mod>> SelectedMods => base.SelectedMods;
 
             public bool AllLoaded => ModSectionsContainer.Children.All(c => c.ModIconsLoaded);
 
+            public new FillFlowContainer<ModSection> ModSectionsContainer =>
+                base.ModSectionsContainer;
+
             public ModButton GetModButton(Mod mod)
             {
                 var section = ModSectionsContainer.Children.Single(s => s.ModType == mod.Type);
@@ -280,5 +354,10 @@ namespace osu.Game.Tests.Visual.UserInterface
             public new Color4 LowMultiplierColour => base.LowMultiplierColour;
             public new Color4 HighMultiplierColour => base.HighMultiplierColour;
         }
+
+        private class TestNonStackedModSelectOverlay : TestModSelectOverlay
+        {
+            protected override bool Stacked => false;
+        }
     }
 }

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

@@ -151,7 +151,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddUntilStep("wait for ready", () => modSelect.State.Value == Visibility.Visible && modSelect.ButtonsLoaded);
         }
 
-        private class TestModSelectOverlay : ModSelectOverlay
+        private class TestModSelectOverlay : LocalPlayerModSelectOverlay
         {
             public new VisibilityContainer ModSettingsContainer => base.ModSettingsContainer;
             public new TriangleButton CustomiseButton => base.CustomiseButton;

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

@@ -0,0 +1,122 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics.Containers;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneSectionsContainer : OsuManualInputManagerTestScene
+    {
+        private readonly SectionsContainer<TestSection> container;
+        private float custom;
+        private const float header_height = 100;
+
+        public TestSceneSectionsContainer()
+        {
+            container = new SectionsContainer<TestSection>
+            {
+                RelativeSizeAxes = Axes.Y,
+                Width = 300,
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                FixedHeader = new Box
+                {
+                    Alpha = 0.5f,
+                    Width = 300,
+                    Height = header_height,
+                    Colour = Color4.Red
+                }
+            };
+            container.SelectedSection.ValueChanged += section =>
+            {
+                if (section.OldValue != null)
+                    section.OldValue.Selected = false;
+                if (section.NewValue != null)
+                    section.NewValue.Selected = true;
+            };
+            Add(container);
+        }
+
+        [Test]
+        public void TestSelection()
+        {
+            AddStep("clear", () => container.Clear());
+            AddStep("add 1/8th", () => append(1 / 8.0f));
+            AddStep("add third", () => append(1 / 3.0f));
+            AddStep("add half", () => append(1 / 2.0f));
+            AddStep("add full", () => append(1));
+            AddSliderStep("set custom", 0.1f, 1.1f, 0.5f, i => custom = i);
+            AddStep("add custom", () => append(custom));
+            AddStep("scroll to previous", () => container.ScrollTo(
+                container.Children.Reverse().SkipWhile(s => s != container.SelectedSection.Value).Skip(1).FirstOrDefault() ?? container.Children.First()
+            ));
+            AddStep("scroll to next", () => container.ScrollTo(
+                container.Children.SkipWhile(s => s != container.SelectedSection.Value).Skip(1).FirstOrDefault() ?? container.Children.Last()
+            ));
+            AddStep("scroll up", () => triggerUserScroll(1));
+            AddStep("scroll down", () => triggerUserScroll(-1));
+        }
+
+        [Test]
+        public void TestCorrectSectionSelected()
+        {
+            const int sections_count = 11;
+            float[] alternating = { 0.07f, 0.33f, 0.16f, 0.33f };
+            AddStep("clear", () => container.Clear());
+            AddStep("fill with sections", () =>
+            {
+                for (int i = 0; i < sections_count; i++)
+                    append(alternating[i % alternating.Length]);
+            });
+
+            void step(int scrollIndex)
+            {
+                AddStep($"scroll to section {scrollIndex + 1}", () => container.ScrollTo(container.Children[scrollIndex]));
+                AddUntilStep("correct section selected", () => container.SelectedSection.Value == container.Children[scrollIndex]);
+            }
+
+            for (int i = 1; i < sections_count; i++)
+                step(i);
+            for (int i = sections_count - 2; i >= 0; i--)
+                step(i);
+
+            AddStep("scroll almost to end", () => container.ScrollTo(container.Children[sections_count - 2]));
+            AddUntilStep("correct section selected", () => container.SelectedSection.Value == container.Children[sections_count - 2]);
+            AddStep("scroll down", () => triggerUserScroll(-1));
+            AddUntilStep("correct section selected", () => container.SelectedSection.Value == container.Children[sections_count - 1]);
+        }
+
+        private static readonly ColourInfo selected_colour = ColourInfo.GradientVertical(Color4.Yellow, Color4.Gold);
+        private static readonly ColourInfo default_colour = ColourInfo.GradientVertical(Color4.White, Color4.DarkGray);
+
+        private void append(float multiplier)
+        {
+            container.Add(new TestSection
+            {
+                Width = 300,
+                Height = (container.ChildSize.Y - header_height) * multiplier,
+                Colour = default_colour
+            });
+        }
+
+        private void triggerUserScroll(float direction)
+        {
+            InputManager.MoveMouseTo(container);
+            InputManager.ScrollVerticalBy(direction);
+        }
+
+        private class TestSection : Box
+        {
+            public bool Selected
+            {
+                set => Colour = value ? selected_colour : default_colour;
+            }
+        }
+    }
+}

osu.Game.Tests/osu.Game.Tests.csproj

@@ -7,6 +7,7 @@
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
+    <PackageReference Include="Moq" Version="4.16.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game.Tournament.Tests/Components/TestSceneTournamentModDisplay.cs

@@ -0,0 +1,60 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+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.Tournament.Components;
+
+namespace osu.Game.Tournament.Tests.Components
+{
+    public class TestSceneTournamentModDisplay : TournamentTestScene
+    {
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
+        private FillFlowContainer<TournamentBeatmapPanel> fillFlow;
+
+        private BeatmapInfo beatmap;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var req = new GetBeatmapRequest(new BeatmapInfo { OnlineBeatmapID = 490154 });
+            req.Success += success;
+            api.Queue(req);
+
+            Add(fillFlow = new FillFlowContainer<TournamentBeatmapPanel>
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Direction = FillDirection.Full,
+                Spacing = new osuTK.Vector2(10)
+            });
+        }
+
+        private void success(APIBeatmap apiBeatmap)
+        {
+            beatmap = apiBeatmap.ToBeatmap(rulesets);
+            var mods = rulesets.GetRuleset(Ladder.Ruleset.Value.ID ?? 0).CreateInstance().GetAllMods();
+
+            foreach (var mod in mods)
+            {
+                fillFlow.Add(new TournamentBeatmapPanel(beatmap, mod.Acronym)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                });
+            }
+        }
+    }
+}

osu.Game.Tournament.Tests/Screens/TestSceneScheduleScreen.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Tournament.Components;
@@ -16,5 +18,23 @@ namespace osu.Game.Tournament.Tests.Screens
             Add(new TourneyVideo("main") { RelativeSizeAxes = Axes.Both });
             Add(new ScheduleScreen());
         }
+
+        [Test]
+        public void TestCurrentMatchTime()
+        {
+            setMatchDate(TimeSpan.FromDays(-1));
+            setMatchDate(TimeSpan.FromSeconds(5));
+            setMatchDate(TimeSpan.FromMinutes(4));
+            setMatchDate(TimeSpan.FromHours(3));
+        }
+
+        private void setMatchDate(TimeSpan relativeTime)
+            // Humanizer cannot handle negative timespans.
+            => AddStep($"start time is {relativeTime}", () =>
+            {
+                var match = CreateSampleMatch();
+                match.Date.Value = DateTimeOffset.Now + relativeTime;
+                Ladder.CurrentMatch.Value = match;
+            });
     }
 }

osu.Game.Tournament/Components/TournamentBeatmapPanel.cs

@@ -9,7 +9,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
@@ -23,7 +22,7 @@ namespace osu.Game.Tournament.Components
     public class TournamentBeatmapPanel : CompositeDrawable
     {
         public readonly BeatmapInfo Beatmap;
-        private readonly string mods;
+        private readonly string mod;
 
         private const float horizontal_padding = 10;
         private const float vertical_padding = 10;
@@ -33,12 +32,12 @@ namespace osu.Game.Tournament.Components
         private readonly Bindable<TournamentMatch> currentMatch = new Bindable<TournamentMatch>();
         private Box flash;
 
-        public TournamentBeatmapPanel(BeatmapInfo beatmap, string mods = null)
+        public TournamentBeatmapPanel(BeatmapInfo beatmap, string mod = null)
         {
             if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
 
             Beatmap = beatmap;
-            this.mods = mods;
+            this.mod = mod;
             Width = 400;
             Height = HEIGHT;
         }
@@ -122,23 +121,15 @@ namespace osu.Game.Tournament.Components
                 },
             });
 
-            if (!string.IsNullOrEmpty(mods))
+            if (!string.IsNullOrEmpty(mod))
             {
-                AddInternal(new Container
+                AddInternal(new TournamentModIcon(mod)
                 {
-                    RelativeSizeAxes = Axes.Y,
-                    Width = 60,
                     Anchor = Anchor.CentreRight,
                     Origin = Anchor.CentreRight,
                     Margin = new MarginPadding(10),
-                    Child = new Sprite
-                    {
-                        FillMode = FillMode.Fit,
-                        RelativeSizeAxes = Axes.Both,
-                        Anchor = Anchor.CentreRight,
-                        Origin = Anchor.CentreRight,
-                        Texture = textures.Get($"mods/{mods}"),
-                    }
+                    Width = 60,
+                    RelativeSizeAxes = Axes.Y,
                 });
             }
         }

osu.Game.Tournament/Components/TournamentModIcon.cs

@@ -0,0 +1,65 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.UI;
+using osu.Game.Tournament.Models;
+using osuTK;
+
+namespace osu.Game.Tournament.Components
+{
+    /// <summary>
+    /// Mod icon displayed in tournament usages, allowing user overridden graphics.
+    /// </summary>
+    public class TournamentModIcon : CompositeDrawable
+    {
+        private readonly string modAcronym;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
+        public TournamentModIcon(string modAcronym)
+        {
+            this.modAcronym = modAcronym;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures, LadderInfo ladderInfo)
+        {
+            var customTexture = textures.Get($"mods/{modAcronym}");
+
+            if (customTexture != null)
+            {
+                AddInternal(new Sprite
+                {
+                    FillMode = FillMode.Fit,
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    Texture = customTexture
+                });
+
+                return;
+            }
+
+            var ruleset = rulesets.GetRuleset(ladderInfo.Ruleset.Value?.ID ?? 0);
+            var modIcon = ruleset?.CreateInstance().GetAllMods().FirstOrDefault(mod => mod.Acronym == modAcronym);
+
+            if (modIcon == null)
+                return;
+
+            AddInternal(new ModIcon(modIcon, false)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Scale = new Vector2(0.5f)
+            });
+        }
+    }
+}

osu.Game.Tournament/Screens/Schedule/ScheduleScreen.cs

@@ -192,12 +192,7 @@ namespace osu.Game.Tournament.Screens.Schedule
                                         Origin = Anchor.CentreLeft,
                                         Children = new Drawable[]
                                         {
-                                            new TournamentSpriteText
-                                            {
-                                                Text = "Starting ",
-                                                Font = OsuFont.Torus.With(size: 24, weight: FontWeight.Regular)
-                                            },
-                                            new DrawableDate(match.NewValue.Date.Value)
+                                            new ScheduleMatchDate(match.NewValue.Date.Value)
                                             {
                                                 Font = OsuFont.Torus.With(size: 24, weight: FontWeight.Regular)
                                             }
@@ -251,6 +246,18 @@ namespace osu.Game.Tournament.Screens.Schedule
             }
         }
 
+        public class ScheduleMatchDate : DrawableDate
+        {
+            public ScheduleMatchDate(DateTimeOffset date, float textSize = OsuFont.DEFAULT_FONT_SIZE, bool italic = true)
+                : base(date, textSize, italic)
+            {
+            }
+
+            protected override string Format() => Date < DateTimeOffset.Now
+                ? $"Started {base.Format()}"
+                : $"Starting {base.Format()}";
+        }
+
         public class ScheduleContainer : Container
         {
             protected override Container<Drawable> Content => content;

osu.Game/Beatmaps/Beatmap.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Objects;
 using System.Collections.Generic;
@@ -48,17 +49,34 @@ namespace osu.Game.Beatmaps
 
         public virtual IEnumerable<BeatmapStatistic> GetStatistics() => Enumerable.Empty<BeatmapStatistic>();
 
+        public double GetMostCommonBeatLength()
+        {
+            // The last playable time in the beatmap - the last timing point extends to this time.
+            // Note: This is more accurate and may present different results because osu-stable didn't have the ability to calculate slider durations in this context.
+            double lastTime = HitObjects.LastOrDefault()?.GetEndTime() ?? ControlPointInfo.TimingPoints.LastOrDefault()?.Time ?? 0;
+
+            var mostCommon =
+                // Construct a set of (beatLength, duration) tuples for each individual timing point.
+                ControlPointInfo.TimingPoints.Select((t, i) =>
+                                {
+                                    if (t.Time > lastTime)
+                                        return (beatLength: t.BeatLength, 0);
+
+                                    var nextTime = i == ControlPointInfo.TimingPoints.Count - 1 ? lastTime : ControlPointInfo.TimingPoints[i + 1].Time;
+                                    return (beatLength: t.BeatLength, duration: nextTime - t.Time);
+                                })
+                                // Aggregate durations into a set of (beatLength, duration) tuples for each beat length
+                                .GroupBy(t => Math.Round(t.beatLength * 1000) / 1000)
+                                .Select(g => (beatLength: g.Key, duration: g.Sum(t => t.duration)))
+                                // Get the most common one, or 0 as a suitable default
+                                .OrderByDescending(i => i.duration).FirstOrDefault();
+
+            return mostCommon.beatLength;
+        }
+
         IBeatmap IBeatmap.Clone() => Clone();
 
-        public Beatmap<T> Clone()
-        {
-            var clone = (Beatmap<T>)MemberwiseClone();
-
-            clone.ControlPointInfo = ControlPointInfo.CreateCopy();
-            // todo: deep clone other elements as required.
-
-            return clone;
-        }
+        public Beatmap<T> Clone() => (Beatmap<T>)MemberwiseClone();
     }
 
     public class Beatmap : Beatmap<HitObject>

osu.Game/Beatmaps/BeatmapManager.cs

@@ -451,7 +451,7 @@ namespace osu.Game.Beatmaps
                     // TODO: this should be done in a better place once we actually need to dynamically update it.
                     beatmap.BeatmapInfo.StarDifficulty = ruleset?.CreateInstance().CreateDifficultyCalculator(new DummyConversionBeatmap(beatmap)).Calculate().StarRating ?? 0;
                     beatmap.BeatmapInfo.Length = calculateLength(beatmap);
-                    beatmap.BeatmapInfo.BPM = beatmap.ControlPointInfo.BPMMode;
+                    beatmap.BeatmapInfo.BPM = 60000 / beatmap.GetMostCommonBeatLength();
 
                     beatmapInfos.Add(beatmap.BeatmapInfo);
                 }

osu.Game/Beatmaps/BeatmapManager_BeatmapOnlineLookupQueue.cs

@@ -7,7 +7,6 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Dapper;
 using Microsoft.Data.Sqlite;
 using osu.Framework.Development;
 using osu.Framework.IO.Network;
@@ -154,20 +153,31 @@ namespace osu.Game.Beatmaps
                 {
                     using (var db = new SqliteConnection(storage.GetDatabaseConnectionString("online")))
                     {
-                        var found = db.QuerySingleOrDefault<CachedOnlineBeatmapLookup>(
-                            "SELECT * FROM osu_beatmaps WHERE checksum = @MD5Hash OR beatmap_id = @OnlineBeatmapID OR filename = @Path", beatmap);
+                        db.Open();
 
-                        if (found != null)
+                        using (var cmd = db.CreateCommand())
                         {
-                            var status = (BeatmapSetOnlineStatus)found.approved;
+                            cmd.CommandText = "SELECT beatmapset_id, beatmap_id, approved FROM osu_beatmaps WHERE checksum = @MD5Hash OR beatmap_id = @OnlineBeatmapID OR filename = @Path";
 
-                            beatmap.Status = status;
-                            beatmap.BeatmapSet.Status = status;
-                            beatmap.BeatmapSet.OnlineBeatmapSetID = found.beatmapset_id;
-                            beatmap.OnlineBeatmapID = found.beatmap_id;
+                            cmd.Parameters.Add(new SqliteParameter("@MD5Hash", beatmap.MD5Hash));
+                            cmd.Parameters.Add(new SqliteParameter("@OnlineBeatmapID", beatmap.OnlineBeatmapID ?? (object)DBNull.Value));
+                            cmd.Parameters.Add(new SqliteParameter("@Path", beatmap.Path));
 
-                            LogForModel(set, $"Cached local retrieval for {beatmap}.");
-                            return true;
+                            using (var reader = cmd.ExecuteReader())
+                            {
+                                if (reader.Read())
+                                {
+                                    var status = (BeatmapSetOnlineStatus)reader.GetByte(2);
+
+                                    beatmap.Status = status;
+                                    beatmap.BeatmapSet.Status = status;
+                                    beatmap.BeatmapSet.OnlineBeatmapSetID = reader.GetInt32(0);
+                                    beatmap.OnlineBeatmapID = reader.GetInt32(1);
+
+                                    LogForModel(set, $"Cached local retrieval for {beatmap}.");
+                                    return true;
+                                }
+                            }
                         }
                     }
                 }

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -101,13 +101,6 @@ namespace osu.Game.Beatmaps.ControlPoints
         public double BPMMinimum =>
             60000 / (TimingPoints.OrderByDescending(c => c.BeatLength).FirstOrDefault() ?? TimingControlPoint.DEFAULT).BeatLength;
 
-        /// <summary>
-        /// Finds the mode BPM (most common BPM) represented by the control points.
-        /// </summary>
-        [JsonIgnore]
-        public double BPMMode =>
-            60000 / (TimingPoints.GroupBy(c => c.BeatLength).OrderByDescending(grp => grp.Count()).FirstOrDefault()?.FirstOrDefault() ?? TimingControlPoint.DEFAULT).BeatLength;
-
         /// <summary>
         /// Remove all <see cref="ControlPointGroup"/>s and return to a pristine state.
         /// </summary>

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -139,7 +139,7 @@ namespace osu.Game.Beatmaps.Formats
                             // this is random as hell but taken straight from osu-stable.
                             frameDelay = Math.Round(0.015 * frameDelay) * 1.186 * (1000 / 60f);
 
-                        var loopType = split.Length > 8 ? (AnimationLoopType)Enum.Parse(typeof(AnimationLoopType), split[8]) : AnimationLoopType.LoopForever;
+                        var loopType = split.Length > 8 ? parseAnimationLoopType(split[8]) : AnimationLoopType.LoopForever;
                         storyboardSprite = new StoryboardAnimation(path, origin, new Vector2(x, y), frameCount, frameDelay, loopType);
                         storyboard.GetLayer(layer).Add(storyboardSprite);
                         break;
@@ -341,6 +341,12 @@ namespace osu.Game.Beatmaps.Formats
             }
         }
 
+        private AnimationLoopType parseAnimationLoopType(string value)
+        {
+            var parsed = (AnimationLoopType)Enum.Parse(typeof(AnimationLoopType), value);
+            return Enum.IsDefined(typeof(AnimationLoopType), parsed) ? parsed : AnimationLoopType.LoopForever;
+        }
+
         private void handleVariables(string line)
         {
             var pair = SplitKeyVal(line, '=');

osu.Game/Beatmaps/IBeatmap.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// The control points in this beatmap.
         /// </summary>
-        ControlPointInfo ControlPointInfo { get; }
+        ControlPointInfo ControlPointInfo { get; set; }
 
         /// <summary>
         /// The breaks in this beatmap.
@@ -47,6 +47,11 @@ namespace osu.Game.Beatmaps
         /// <returns></returns>
         IEnumerable<BeatmapStatistic> GetStatistics();
 
+        /// <summary>
+        /// Finds the most common beat length represented by the control points in this beatmap.
+        /// </summary>
+        double GetMostCommonBeatLength();
+
         /// <summary>
         /// Creates a shallow-clone of this beatmap and returns it.
         /// </summary>

osu.Game/Database/ArchiveModelManager.cs

@@ -308,7 +308,7 @@ namespace osu.Game.Database
         /// <param name="item">The model to be imported.</param>
         /// <param name="archive">An optional archive to use for model population.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
-        public async Task<TModel> Import(TModel item, ArchiveReader archive = null, CancellationToken cancellationToken = default) => await Task.Factory.StartNew(async () =>
+        public virtual async Task<TModel> Import(TModel item, ArchiveReader archive = null, CancellationToken cancellationToken = default) => await Task.Factory.StartNew(async () =>
         {
             cancellationToken.ThrowIfCancellationRequested();
 

osu.Game/Extensions/TaskExtensions.cs

@@ -4,33 +4,65 @@
 #nullable enable
 
 using System;
+using System.Threading;
 using System.Threading.Tasks;
-using osu.Framework.Extensions.ExceptionExtensions;
-using osu.Framework.Logging;
 
 namespace osu.Game.Extensions
 {
     public static class TaskExtensions
     {
         /// <summary>
-        /// Denote a task which is to be run without local error handling logic, where failure is not catastrophic.
-        /// Avoids unobserved exceptions from being fired.
+        /// Add a continuation to be performed only after the attached task has completed.
         /// </summary>
-        /// <param name="task">The task.</param>
-        /// <param name="logAsError">
-        /// Whether errors should be logged as errors visible to users, or as debug messages.
-        /// Logging as debug will essentially silence the errors on non-release builds.
-        /// </param>
-        public static void CatchUnobservedExceptions(this Task task, bool logAsError = false)
+        /// <param name="task">The previous task to be awaited on.</param>
+        /// <param name="action">The action to run.</param>
+        /// <param name="cancellationToken">An optional cancellation token. Will only cancel the provided action, not the sequence.</param>
+        /// <returns>A task representing the provided action.</returns>
+        public static Task ContinueWithSequential(this Task task, Action action, CancellationToken cancellationToken = default) =>
+            task.ContinueWithSequential(() => Task.Run(action, cancellationToken), cancellationToken);
+
+        /// <summary>
+        /// Add a continuation to be performed only after the attached task has completed.
+        /// </summary>
+        /// <param name="task">The previous task to be awaited on.</param>
+        /// <param name="continuationFunction">The continuation to run. Generally should be an async function.</param>
+        /// <param name="cancellationToken">An optional cancellation token. Will only cancel the provided action, not the sequence.</param>
+        /// <returns>A task representing the provided action.</returns>
+        public static Task ContinueWithSequential(this Task task, Func<Task> continuationFunction, CancellationToken cancellationToken = default)
         {
+            var tcs = new TaskCompletionSource<bool>();
+
             task.ContinueWith(t =>
             {
-                Exception? exception = t.Exception?.AsSingular();
-                if (logAsError)
-                    Logger.Error(exception, $"Error running task: {exception?.Message ?? "(unknown)"}", LoggingTarget.Runtime, true);
+                // the previous task has finished execution or been cancelled, so we can run the provided continuation.
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    tcs.SetCanceled();
+                }
                 else
-                    Logger.Log($"Error running task: {exception}", LoggingTarget.Runtime, LogLevel.Debug);
-            }, TaskContinuationOptions.NotOnRanToCompletion);
+                {
+                    continuationFunction().ContinueWith(continuationTask =>
+                    {
+                        if (cancellationToken.IsCancellationRequested || continuationTask.IsCanceled)
+                        {
+                            tcs.TrySetCanceled();
+                        }
+                        else if (continuationTask.IsFaulted)
+                        {
+                            tcs.TrySetException(continuationTask.Exception);
+                        }
+                        else
+                        {
+                            tcs.TrySetResult(true);
+                        }
+                    }, cancellationToken: default);
+                }
+            }, cancellationToken: default);
+
+            // importantly, we are not returning the continuation itself but rather a task which represents its status in sequential execution order.
+            // this will not be cancelled or completed until the previous task has also.
+            return tcs.Task;
         }
     }
 }

osu.Game/Graphics/Containers/ParallaxContainer.cs

@@ -24,6 +24,10 @@ namespace osu.Game.Graphics.Containers
 
         private Bindable<bool> parallaxEnabled;
 
+        private const float parallax_duration = 100;
+
+        private bool firstUpdate = true;
+
         public ParallaxContainer()
         {
             RelativeSizeAxes = Axes.Both;
@@ -60,17 +64,27 @@ namespace osu.Game.Graphics.Containers
             input = GetContainingInputManager();
         }
 
-        private bool firstUpdate = true;
-
         protected override void Update()
         {
             base.Update();
 
             if (parallaxEnabled.Value)
             {
-                Vector2 offset = (input.CurrentState.Mouse == null ? Vector2.Zero : ToLocalSpace(input.CurrentState.Mouse.Position) - DrawSize / 2) * ParallaxAmount;
+                Vector2 offset = Vector2.Zero;
 
-                const float parallax_duration = 100;
+                if (input.CurrentState.Mouse != null)
+                {
+                    var sizeDiv2 = DrawSize / 2;
+
+                    Vector2 relativeAmount = ToLocalSpace(input.CurrentState.Mouse.Position) - sizeDiv2;
+
+                    const float base_factor = 0.999f;
+
+                    relativeAmount.X = (float)(Math.Sign(relativeAmount.X) * Interpolation.Damp(0, 1, base_factor, Math.Abs(relativeAmount.X)));
+                    relativeAmount.Y = (float)(Math.Sign(relativeAmount.Y) * Interpolation.Damp(0, 1, base_factor, Math.Abs(relativeAmount.Y)));
+
+                    offset = relativeAmount * sizeDiv2 * ParallaxAmount;
+                }
 
                 double elapsed = Math.Clamp(Clock.ElapsedFrameTime, 0, parallax_duration);
 

osu.Game/Graphics/Containers/SectionsContainer.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics;
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
@@ -9,6 +10,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Layout;
+using osu.Framework.Utils;
 
 namespace osu.Game.Graphics.Containers
 {
@@ -20,6 +22,7 @@ namespace osu.Game.Graphics.Containers
         where T : Drawable
     {
         public Bindable<T> SelectedSection { get; } = new Bindable<T>();
+        private Drawable lastClickedSection;
 
         public Drawable ExpandableHeader
         {
@@ -36,7 +39,7 @@ namespace osu.Game.Graphics.Containers
                 if (value == null) return;
 
                 AddInternal(expandableHeader);
-                lastKnownScroll = float.NaN;
+                lastKnownScroll = null;
             }
         }
 
@@ -52,7 +55,7 @@ namespace osu.Game.Graphics.Containers
                 if (value == null) return;
 
                 AddInternal(fixedHeader);
-                lastKnownScroll = float.NaN;
+                lastKnownScroll = null;
             }
         }
 
@@ -71,7 +74,7 @@ namespace osu.Game.Graphics.Containers
                 footer.Anchor |= Anchor.y2;
                 footer.Origin |= Anchor.y2;
                 scrollContainer.Add(footer);
-                lastKnownScroll = float.NaN;
+                lastKnownScroll = null;
             }
         }
 
@@ -89,21 +92,26 @@ namespace osu.Game.Graphics.Containers
 
                 headerBackgroundContainer.Add(headerBackground);
 
-                lastKnownScroll = float.NaN;
+                lastKnownScroll = null;
             }
         }
 
         protected override Container<T> Content => scrollContentContainer;
 
-        private readonly OsuScrollContainer scrollContainer;
+        private readonly UserTrackingScrollContainer scrollContainer;
         private readonly Container headerBackgroundContainer;
         private readonly MarginPadding originalSectionsMargin;
         private Drawable expandableHeader, fixedHeader, footer, headerBackground;
         private FlowContainer<T> scrollContentContainer;
 
-        private float headerHeight, footerHeight;
+        private float? headerHeight, footerHeight;
 
-        private float lastKnownScroll;
+        private float? lastKnownScroll;
+
+        /// <summary>
+        /// The percentage of the container to consider the centre-point for deciding the active section (and scrolling to a requested section).
+        /// </summary>
+        private const float scroll_y_centre = 0.1f;
 
         public SectionsContainer()
         {
@@ -128,18 +136,24 @@ namespace osu.Game.Graphics.Containers
         public override void Add(T drawable)
         {
             base.Add(drawable);
-            lastKnownScroll = float.NaN;
-            headerHeight = float.NaN;
-            footerHeight = float.NaN;
+
+            Debug.Assert(drawable != null);
+
+            lastKnownScroll = null;
+            headerHeight = null;
+            footerHeight = null;
         }
 
-        public void ScrollTo(Drawable section) =>
-            scrollContainer.ScrollTo(scrollContainer.GetChildPosInContent(section) - (FixedHeader?.BoundingBox.Height ?? 0));
+        public void ScrollTo(Drawable section)
+        {
+            lastClickedSection = section;
+            scrollContainer.ScrollTo(scrollContainer.GetChildPosInContent(section) - scrollContainer.DisplayableContent * scroll_y_centre - (FixedHeader?.BoundingBox.Height ?? 0));
+        }
 
         public void ScrollToTop() => scrollContainer.ScrollTo(0);
 
         [NotNull]
-        protected virtual OsuScrollContainer CreateScrollContainer() => new OsuScrollContainer();
+        protected virtual UserTrackingScrollContainer CreateScrollContainer() => new UserTrackingScrollContainer();
 
         [NotNull]
         protected virtual FlowContainer<T> CreateScrollContentContainer() =>
@@ -156,7 +170,7 @@ namespace osu.Game.Graphics.Containers
 
             if (source == InvalidationSource.Child && (invalidation & Invalidation.DrawSize) != 0)
             {
-                lastKnownScroll = -1;
+                lastKnownScroll = null;
                 result = true;
             }
 
@@ -167,7 +181,10 @@ namespace osu.Game.Graphics.Containers
         {
             base.UpdateAfterChildren();
 
-            float headerH = (ExpandableHeader?.LayoutSize.Y ?? 0) + (FixedHeader?.LayoutSize.Y ?? 0);
+            float fixedHeaderSize = FixedHeader?.LayoutSize.Y ?? 0;
+            float expandableHeaderSize = ExpandableHeader?.LayoutSize.Y ?? 0;
+
+            float headerH = expandableHeaderSize + fixedHeaderSize;
             float footerH = Footer?.LayoutSize.Y ?? 0;
 
             if (headerH != headerHeight || footerH != footerHeight)
@@ -183,28 +200,39 @@ namespace osu.Game.Graphics.Containers
             {
                 lastKnownScroll = currentScroll;
 
+                // reset last clicked section because user started scrolling themselves
+                if (scrollContainer.UserScrolling)
+                    lastClickedSection = null;
+
                 if (ExpandableHeader != null && FixedHeader != null)
                 {
-                    float offset = Math.Min(ExpandableHeader.LayoutSize.Y, currentScroll);
+                    float offset = Math.Min(expandableHeaderSize, currentScroll);
 
                     ExpandableHeader.Y = -offset;
-                    FixedHeader.Y = -offset + ExpandableHeader.LayoutSize.Y;
+                    FixedHeader.Y = -offset + expandableHeaderSize;
                 }
 
-                headerBackgroundContainer.Height = (ExpandableHeader?.LayoutSize.Y ?? 0) + (FixedHeader?.LayoutSize.Y ?? 0);
+                headerBackgroundContainer.Height = expandableHeaderSize + fixedHeaderSize;
                 headerBackgroundContainer.Y = ExpandableHeader?.Y ?? 0;
 
-                float scrollOffset = FixedHeader?.LayoutSize.Y ?? 0;
-                Func<T, float> diff = section => scrollContainer.GetChildPosInContent(section) - currentScroll - scrollOffset;
+                var smallestSectionHeight = Children.Count > 0 ? Children.Min(d => d.Height) : 0;
 
-                if (scrollContainer.IsScrolledToEnd())
-                {
-                    SelectedSection.Value = Children.LastOrDefault();
-                }
+                // scroll offset is our fixed header height if we have it plus 10% of content height
+                // plus 5% to fix floating point errors and to not have a section instantly unselect when scrolling upwards
+                // but the 5% can't be bigger than our smallest section height, otherwise it won't get selected correctly
+                float selectionLenienceAboveSection = Math.Min(smallestSectionHeight / 2.0f, scrollContainer.DisplayableContent * 0.05f);
+
+                float scrollCentre = fixedHeaderSize + scrollContainer.DisplayableContent * scroll_y_centre + selectionLenienceAboveSection;
+
+                if (Precision.AlmostBigger(0, scrollContainer.Current))
+                    SelectedSection.Value = lastClickedSection as T ?? Children.FirstOrDefault();
+                else if (Precision.AlmostBigger(scrollContainer.Current, scrollContainer.ScrollableExtent))
+                    SelectedSection.Value = lastClickedSection as T ?? Children.LastOrDefault();
                 else
                 {
-                    SelectedSection.Value = Children.TakeWhile(section => diff(section) <= 0).LastOrDefault()
-                                            ?? Children.FirstOrDefault();
+                    SelectedSection.Value = Children
+                                            .TakeWhile(section => scrollContainer.GetChildPosInContent(section) - currentScroll - scrollCentre <= 0)
+                                            .LastOrDefault() ?? Children.FirstOrDefault();
                 }
             }
         }
@@ -214,8 +242,9 @@ namespace osu.Game.Graphics.Containers
             if (!Children.Any()) return;
 
             var newMargin = originalSectionsMargin;
-            newMargin.Top += headerHeight;
-            newMargin.Bottom += footerHeight;
+
+            newMargin.Top += (headerHeight ?? 0);
+            newMargin.Bottom += (footerHeight ?? 0);
 
             scrollContentContainer.Margin = newMargin;
         }

osu.Game/Graphics/Containers/UserTrackingScrollContainer.cs

@@ -0,0 +1,57 @@
+// 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.Graphics.Containers
+{
+    public class UserTrackingScrollContainer : UserTrackingScrollContainer<Drawable>
+    {
+        public UserTrackingScrollContainer()
+        {
+        }
+
+        public UserTrackingScrollContainer(Direction direction)
+            : base(direction)
+        {
+        }
+    }
+
+    public class UserTrackingScrollContainer<T> : OsuScrollContainer<T>
+        where T : Drawable
+    {
+        /// <summary>
+        /// Whether the last scroll event was user triggered, directly on the scroll container.
+        /// </summary>
+        public bool UserScrolling { get; private set; }
+
+        public void CancelUserScroll() => UserScrolling = false;
+
+        public UserTrackingScrollContainer()
+        {
+        }
+
+        public UserTrackingScrollContainer(Direction direction)
+            : base(direction)
+        {
+        }
+
+        protected override void OnUserScroll(float value, bool animated = true, double? distanceDecay = default)
+        {
+            UserScrolling = true;
+            base.OnUserScroll(value, animated, distanceDecay);
+        }
+
+        public new void ScrollTo(float value, bool animated = true, double? distanceDecay = null)
+        {
+            UserScrolling = false;
+            base.ScrollTo(value, animated, distanceDecay);
+        }
+
+        public new void ScrollToEnd(bool animated = true, bool allowDuringDrag = false)
+        {
+            UserScrolling = false;
+            base.ScrollToEnd(animated, allowDuringDrag);
+        }
+    }
+}

osu.Game/Graphics/UserInterface/DownloadButton.cs

@@ -4,54 +4,38 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Online;
 using osuTK;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class DownloadButton : OsuAnimatedButton
+    public class DownloadButton : GrayButton
     {
-        public readonly Bindable<DownloadState> State = new Bindable<DownloadState>();
-
-        private readonly SpriteIcon icon;
-        private readonly SpriteIcon checkmark;
-        private readonly Box background;
-
         [Resolved]
         private OsuColour colours { get; set; }
 
+        public readonly Bindable<DownloadState> State = new Bindable<DownloadState>();
+
+        private SpriteIcon checkmark;
+
         public DownloadButton()
+            : base(FontAwesome.Solid.Download)
         {
-            Children = new Drawable[]
-            {
-                background = new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Depth = float.MaxValue
-                },
-                icon = new SpriteIcon
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Size = new Vector2(13),
-                    Icon = FontAwesome.Solid.Download,
-                },
-                checkmark = new SpriteIcon
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    X = 8,
-                    Size = Vector2.Zero,
-                    Icon = FontAwesome.Solid.Check,
-                }
-            };
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
+            AddInternal(checkmark = new SpriteIcon
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                X = 8,
+                Size = Vector2.Zero,
+                Icon = FontAwesome.Solid.Check,
+            });
+
             State.BindValueChanged(updateState, true);
         }
 
@@ -60,27 +44,27 @@ namespace osu.Game.Graphics.UserInterface
             switch (state.NewValue)
             {
                 case DownloadState.NotDownloaded:
-                    background.FadeColour(colours.Gray4, 500, Easing.InOutExpo);
-                    icon.MoveToX(0, 500, Easing.InOutExpo);
+                    Background.FadeColour(colours.Gray4, 500, Easing.InOutExpo);
+                    Icon.MoveToX(0, 500, Easing.InOutExpo);
                     checkmark.ScaleTo(Vector2.Zero, 500, Easing.InOutExpo);
                     TooltipText = "Download";
                     break;
 
                 case DownloadState.Downloading:
-                    background.FadeColour(colours.Blue, 500, Easing.InOutExpo);
-                    icon.MoveToX(0, 500, Easing.InOutExpo);
+                    Background.FadeColour(colours.Blue, 500, Easing.InOutExpo);
+                    Icon.MoveToX(0, 500, Easing.InOutExpo);
                     checkmark.ScaleTo(Vector2.Zero, 500, Easing.InOutExpo);
                     TooltipText = "Downloading...";
                     break;
 
                 case DownloadState.Importing:
-                    background.FadeColour(colours.Yellow, 500, Easing.InOutExpo);
+                    Background.FadeColour(colours.Yellow, 500, Easing.InOutExpo);
                     TooltipText = "Importing";
                     break;
 
                 case DownloadState.LocallyAvailable:
-                    background.FadeColour(colours.Green, 500, Easing.InOutExpo);
-                    icon.MoveToX(-8, 500, Easing.InOutExpo);
+                    Background.FadeColour(colours.Green, 500, Easing.InOutExpo);
+                    Icon.MoveToX(-8, 500, Easing.InOutExpo);
                     checkmark.ScaleTo(new Vector2(13), 500, Easing.InOutExpo);
                     break;
             }

osu.Game/Graphics/UserInterface/GrayButton.cs

@@ -0,0 +1,48 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    public class GrayButton : OsuAnimatedButton
+    {
+        protected SpriteIcon Icon { get; private set; }
+        protected Box Background { get; private set; }
+
+        private readonly IconUsage icon;
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        public GrayButton(IconUsage icon)
+        {
+            this.icon = icon;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                Background = new Box
+                {
+                    Colour = colours.Gray4,
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = float.MaxValue
+                },
+                Icon = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(13),
+                    Icon = icon,
+                },
+            };
+        }
+    }
+}

osu.Game/Graphics/UserInterface/Nub.cs

@@ -42,13 +42,7 @@ namespace osu.Game.Graphics.UserInterface
                 },
             };
 
-            Current.ValueChanged += filled =>
-            {
-                if (filled.NewValue)
-                    fill.FadeIn(200, Easing.OutQuint);
-                else
-                    fill.FadeTo(0.01f, 200, Easing.OutQuint); //todo: remove once we figure why containers aren't drawing at all times
-            };
+            Current.ValueChanged += filled => fill.FadeTo(filled.NewValue ? 1 : 0, 200, Easing.OutQuint);
         }
 
         [BackgroundDependencyLoader]

osu.Game/Graphics/UserInterface/OsuCheckbox.cs

@@ -5,6 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
@@ -18,6 +19,11 @@ namespace osu.Game.Graphics.UserInterface
         public Color4 UncheckedColor { get; set; } = Color4.White;
         public int FadeDuration { get; set; }
 
+        /// <summary>
+        /// Whether to play sounds when the state changes as a result of user interaction.
+        /// </summary>
+        protected virtual bool PlaySoundsOnUserChange => true;
+
         public string LabelText
         {
             set
@@ -43,7 +49,7 @@ namespace osu.Game.Graphics.UserInterface
         private SampleChannel sampleChecked;
         private SampleChannel sampleUnchecked;
 
-        public OsuCheckbox()
+        public OsuCheckbox(bool nubOnRight = true)
         {
             AutoSizeAxes = Axes.Y;
             RelativeSizeAxes = Axes.X;
@@ -52,26 +58,42 @@ namespace osu.Game.Graphics.UserInterface
 
             Children = new Drawable[]
             {
-                labelText = new OsuTextFlowContainer
+                labelText = new OsuTextFlowContainer(ApplyLabelParameters)
                 {
                     AutoSizeAxes = Axes.Y,
                     RelativeSizeAxes = Axes.X,
-                    Padding = new MarginPadding { Right = Nub.EXPANDED_SIZE + nub_padding }
-                },
-                Nub = new Nub
-                {
-                    Anchor = Anchor.CentreRight,
-                    Origin = Anchor.CentreRight,
-                    Margin = new MarginPadding { Right = nub_padding },
                 },
+                Nub = new Nub(),
                 new HoverClickSounds()
             };
 
+            if (nubOnRight)
+            {
+                Nub.Anchor = Anchor.CentreRight;
+                Nub.Origin = Anchor.CentreRight;
+                Nub.Margin = new MarginPadding { Right = nub_padding };
+                labelText.Padding = new MarginPadding { Right = Nub.EXPANDED_SIZE + nub_padding * 2 };
+            }
+            else
+            {
+                Nub.Anchor = Anchor.CentreLeft;
+                Nub.Origin = Anchor.CentreLeft;
+                Nub.Margin = new MarginPadding { Left = nub_padding };
+                labelText.Padding = new MarginPadding { Left = Nub.EXPANDED_SIZE + nub_padding * 2 };
+            }
+
             Nub.Current.BindTo(Current);
 
             Current.DisabledChanged += disabled => labelText.Alpha = Nub.Alpha = disabled ? 0.3f : 1;
         }
 
+        /// <summary>
+        /// A function which can be overridden to change the parameters of the label's text.
+        /// </summary>
+        protected virtual void ApplyLabelParameters(SpriteText text)
+        {
+        }
+
         [BackgroundDependencyLoader]
         private void load(AudioManager audio)
         {
@@ -96,10 +118,14 @@ namespace osu.Game.Graphics.UserInterface
         protected override void OnUserChange(bool value)
         {
             base.OnUserChange(value);
-            if (value)
-                sampleChecked?.Play();
-            else
-                sampleUnchecked?.Play();
+
+            if (PlaySoundsOnUserChange)
+            {
+                if (value)
+                    sampleChecked?.Play();
+                else
+                    sampleUnchecked?.Play();
+            }
         }
     }
 }

osu.Game/Online/API/APIDownloadRequest.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.IO;
 using osu.Framework.IO.Network;
 
@@ -28,13 +29,19 @@ namespace osu.Game.Online.API
 
         private void request_Progress(long current, long total) => API.Schedule(() => Progressed?.Invoke(current, total));
 
-        protected APIDownloadRequest()
+        protected void TriggerSuccess(string filename)
         {
-            base.Success += onSuccess;
+            if (this.filename != null)
+                throw new InvalidOperationException("Attempted to trigger success more than once");
+
+            this.filename = filename;
+
+            TriggerSuccess();
         }
 
-        private void onSuccess()
+        internal override void TriggerSuccess()
         {
+            base.TriggerSuccess();
             Success?.Invoke(filename);
         }
 

osu.Game/Online/API/APIMod.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using Humanizer;
+using MessagePack;
 using Newtonsoft.Json;
 using osu.Framework.Bindables;
 using osu.Game.Configuration;
@@ -13,16 +14,21 @@ using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Online.API
 {
+    [MessagePackObject]
     public class APIMod : IMod
     {
         [JsonProperty("acronym")]
+        [Key(0)]
         public string Acronym { get; set; }
 
         [JsonProperty("settings")]
+        [Key(1)]
+        [MessagePackFormatter(typeof(ModSettingsDictionaryFormatter))]
         public Dictionary<string, object> Settings { get; set; } = new Dictionary<string, object>();
 
         [JsonConstructor]
-        private APIMod()
+        [SerializationConstructor]
+        public APIMod()
         {
         }
 

osu.Game/Online/API/ArchiveDownloadRequest.cs

@@ -10,7 +10,7 @@ namespace osu.Game.Online.API
     {
         public readonly TModel Model;
 
-        public float Progress;
+        public float Progress { get; private set; }
 
         public event Action<float> DownloadProgressed;
 
@@ -18,7 +18,13 @@ namespace osu.Game.Online.API
         {
             Model = model;
 
-            Progressed += (current, total) => DownloadProgressed?.Invoke(Progress = (float)current / total);
+            Progressed += (current, total) => SetProgress((float)current / total);
+        }
+
+        protected void SetProgress(float progress)
+        {
+            Progress = progress;
+            DownloadProgressed?.Invoke(progress);
         }
     }
 }

osu.Game/Online/API/ModSettingsDictionaryFormatter.cs

@@ -0,0 +1,67 @@
+// 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.Buffers;
+using System.Collections.Generic;
+using System.Text;
+using MessagePack;
+using MessagePack.Formatters;
+using osu.Framework.Bindables;
+
+namespace osu.Game.Online.API
+{
+    public class ModSettingsDictionaryFormatter : IMessagePackFormatter<Dictionary<string, object>>
+    {
+        public void Serialize(ref MessagePackWriter writer, Dictionary<string, object> value, MessagePackSerializerOptions options)
+        {
+            var primitiveFormatter = PrimitiveObjectFormatter.Instance;
+
+            writer.WriteArrayHeader(value.Count);
+
+            foreach (var kvp in value)
+            {
+                var stringBytes = new ReadOnlySequence<byte>(Encoding.UTF8.GetBytes(kvp.Key));
+                writer.WriteString(in stringBytes);
+
+                switch (kvp.Value)
+                {
+                    case Bindable<double> d:
+                        primitiveFormatter.Serialize(ref writer, d.Value, options);
+                        break;
+
+                    case Bindable<int> i:
+                        primitiveFormatter.Serialize(ref writer, i.Value, options);
+                        break;
+
+                    case Bindable<float> f:
+                        primitiveFormatter.Serialize(ref writer, f.Value, options);
+                        break;
+
+                    case Bindable<bool> b:
+                        primitiveFormatter.Serialize(ref writer, b.Value, options);
+                        break;
+
+                    default:
+                        // fall back for non-bindable cases.
+                        primitiveFormatter.Serialize(ref writer, kvp.Value, options);
+                        break;
+                }
+            }
+        }
+
+        public Dictionary<string, object> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
+        {
+            var output = new Dictionary<string, object>();
+
+            int itemCount = reader.ReadArrayHeader();
+
+            for (int i = 0; i < itemCount; i++)
+            {
+                output[reader.ReadString()] =
+                    PrimitiveObjectFormatter.Instance.Deserialize(ref reader, options);
+            }
+
+            return output;
+        }
+    }
+}

osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs

@@ -81,7 +81,7 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"beatmaps")]
         private IEnumerable<APIBeatmap> beatmaps { get; set; }
 
-        public BeatmapSetInfo ToBeatmapSet(RulesetStore rulesets)
+        public virtual BeatmapSetInfo ToBeatmapSet(RulesetStore rulesets)
         {
             var beatmapSet = new BeatmapSetInfo
             {

osu.Game/Online/Chat/ChannelManager.cs

@@ -339,7 +339,7 @@ namespace osu.Game.Online.Chat
         }
 
         /// <summary>
-        /// Joins a channel if it has not already been joined.
+        /// Joins a channel if it has not already been joined. Must be called from the update thread.
         /// </summary>
         /// <param name="channel">The channel to join.</param>
         /// <returns>The joined channel. Note that this may not match the parameter channel as it is a backed object.</returns>
@@ -399,7 +399,11 @@ namespace osu.Game.Online.Chat
             return channel;
         }
 
-        public void LeaveChannel(Channel channel)
+        /// <summary>
+        /// Leave the specified channel. Can be called from any thread.
+        /// </summary>
+        /// <param name="channel">The channel to leave.</param>
+        public void LeaveChannel(Channel channel) => Schedule(() =>
         {
             if (channel == null) return;
 
@@ -413,7 +417,7 @@ namespace osu.Game.Online.Chat
                 api.Queue(new LeaveChannelRequest(channel));
                 channel.Joined.Value = false;
             }
-        }
+        });
 
         private long lastMessageId;
 

osu.Game/Online/DownloadTrackingComposite.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
@@ -20,7 +21,7 @@ namespace osu.Game.Online
         protected readonly Bindable<TModel> Model = new Bindable<TModel>();
 
         [Resolved(CanBeNull = true)]
-        private TModelManager manager { get; set; }
+        protected TModelManager Manager { get; private set; }
 
         /// <summary>
         /// Holds the current download state of the <typeparamref name="TModel"/>, whether is has already been downloaded, is in progress, or is not downloaded.
@@ -46,25 +47,41 @@ namespace osu.Game.Online
             {
                 if (modelInfo.NewValue == null)
                     attachDownload(null);
-                else if (manager?.IsAvailableLocally(modelInfo.NewValue) == true)
+                else if (IsModelAvailableLocally())
                     State.Value = DownloadState.LocallyAvailable;
                 else
-                    attachDownload(manager?.GetExistingDownload(modelInfo.NewValue));
+                    attachDownload(Manager?.GetExistingDownload(modelInfo.NewValue));
             }, true);
 
-            if (manager == null)
+            if (Manager == null)
                 return;
 
-            managerDownloadBegan = manager.DownloadBegan.GetBoundCopy();
+            managerDownloadBegan = Manager.DownloadBegan.GetBoundCopy();
             managerDownloadBegan.BindValueChanged(downloadBegan);
-            managerDownloadFailed = manager.DownloadFailed.GetBoundCopy();
+            managerDownloadFailed = Manager.DownloadFailed.GetBoundCopy();
             managerDownloadFailed.BindValueChanged(downloadFailed);
-            managedUpdated = manager.ItemUpdated.GetBoundCopy();
+            managedUpdated = Manager.ItemUpdated.GetBoundCopy();
             managedUpdated.BindValueChanged(itemUpdated);
-            managerRemoved = manager.ItemRemoved.GetBoundCopy();
+            managerRemoved = Manager.ItemRemoved.GetBoundCopy();
             managerRemoved.BindValueChanged(itemRemoved);
         }
 
+        /// <summary>
+        /// Checks that a database model matches the one expected to be downloaded.
+        /// </summary>
+        /// <example>
+        /// For online play, this could be used to check that the databased model matches the online beatmap.
+        /// </example>
+        /// <param name="databasedModel">The model in database.</param>
+        protected virtual bool VerifyDatabasedModel([NotNull] TModel databasedModel) => true;
+
+        /// <summary>
+        /// Whether the given model is available in the database.
+        /// By default, this calls <see cref="IModelDownloader{TModel}.IsAvailableLocally"/>,
+        /// but can be overriden to add additional checks for verifying the model in database.
+        /// </summary>
+        protected virtual bool IsModelAvailableLocally() => Manager?.IsAvailableLocally(Model.Value) == true;
+
         private void downloadBegan(ValueChangedEvent<WeakReference<ArchiveDownloadRequest<TModel>>> weakRequest)
         {
             if (weakRequest.NewValue.TryGetTarget(out var request))
@@ -134,23 +151,35 @@ namespace osu.Game.Online
         private void itemUpdated(ValueChangedEvent<WeakReference<TModel>> weakItem)
         {
             if (weakItem.NewValue.TryGetTarget(out var item))
-                setDownloadStateFromManager(item, DownloadState.LocallyAvailable);
+            {
+                Schedule(() =>
+                {
+                    if (!item.Equals(Model.Value))
+                        return;
+
+                    if (!VerifyDatabasedModel(item))
+                    {
+                        State.Value = DownloadState.NotDownloaded;
+                        return;
+                    }
+
+                    State.Value = DownloadState.LocallyAvailable;
+                });
+            }
         }
 
         private void itemRemoved(ValueChangedEvent<WeakReference<TModel>> weakItem)
         {
             if (weakItem.NewValue.TryGetTarget(out var item))
-                setDownloadStateFromManager(item, DownloadState.NotDownloaded);
+            {
+                Schedule(() =>
+                {
+                    if (item.Equals(Model.Value))
+                        State.Value = DownloadState.NotDownloaded;
+                });
+            }
         }
 
-        private void setDownloadStateFromManager(TModel s, DownloadState state) => Schedule(() =>
-        {
-            if (!s.Equals(Model.Value))
-                return;
-
-            State.Value = state;
-        });
-
         #region Disposal
 
         protected override void Dispose(bool isDisposing)

osu.Game/Online/Multiplayer/IMultiplayerClient.cs

@@ -1,7 +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.Threading.Tasks;
+using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 
 namespace osu.Game.Online.Multiplayer
@@ -55,6 +57,13 @@ namespace osu.Game.Online.Multiplayer
         /// <param name="beatmapAvailability">The new beatmap availability state of the user.</param>
         Task UserBeatmapAvailabilityChanged(int userId, BeatmapAvailability beatmapAvailability);
 
+        /// <summary>
+        /// Signals that a user in this room changed their local mods.
+        /// </summary>
+        /// <param name="userId">The ID of the user whose mods have changed.</param>
+        /// <param name="mods">The user's new local mods.</param>
+        Task UserModsChanged(int userId, IEnumerable<APIMod> mods);
+
         /// <summary>
         /// Signals that a match is to be started. This will *only* be sent to clients which are to begin loading at this point.
         /// </summary>

osu.Game/Online/Multiplayer/IMultiplayerRoomServer.cs

@@ -1,7 +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.Threading.Tasks;
+using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 
 namespace osu.Game.Online.Multiplayer
@@ -47,6 +49,12 @@ namespace osu.Game.Online.Multiplayer
         /// <param name="newBeatmapAvailability">The proposed new beatmap availability state.</param>
         Task ChangeBeatmapAvailability(BeatmapAvailability newBeatmapAvailability);
 
+        /// <summary>
+        /// Change the local user's mods in the currently joined room.
+        /// </summary>
+        /// <param name="newMods">The proposed new mods, excluding any required by the room itself.</param>
+        Task ChangeUserMods(IEnumerable<APIMod> newMods);
+
         /// <summary>
         /// As the host of a room, start the match.
         /// </summary>

osu.Game/Online/Multiplayer/MultiplayerClient.cs

@@ -4,12 +4,13 @@
 #nullable enable
 
 using System;
-using System.Diagnostics;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.Extensions.DependencyInjection;
 using Newtonsoft.Json;
+using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Logging;
@@ -25,11 +26,15 @@ namespace osu.Game.Online.Multiplayer
         private readonly Bindable<bool> isConnected = new Bindable<bool>();
         private readonly IBindable<APIState> apiState = new Bindable<APIState>();
 
+        private readonly SemaphoreSlim connectionLock = new SemaphoreSlim(1);
+
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
         private HubConnection? connection;
 
+        private CancellationTokenSource connectCancelSource = new CancellationTokenSource();
+
         private readonly string endpoint;
 
         public MultiplayerClient(EndpointConfiguration endpoints)
@@ -50,80 +55,67 @@ namespace osu.Game.Online.Multiplayer
             {
                 case APIState.Failing:
                 case APIState.Offline:
-                    connection?.StopAsync();
-                    connection = null;
+                    Task.Run(() => disconnect(true));
                     break;
 
                 case APIState.Online:
-                    Task.Run(Connect);
+                    Task.Run(connect);
                     break;
             }
         }
 
-        protected virtual async Task Connect()
+        private async Task connect()
         {
-            if (connection != null)
-                return;
+            cancelExistingConnect();
 
-            connection = new HubConnectionBuilder()
-                         .WithUrl(endpoint, options =>
-                         {
-                             options.Headers.Add("Authorization", $"Bearer {api.AccessToken}");
-                         })
-                         .AddNewtonsoftJsonProtocol(options => { options.PayloadSerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; })
-                         .Build();
+            if (!await connectionLock.WaitAsync(10000))
+                throw new TimeoutException("Could not obtain a lock to connect. A previous attempt is likely stuck.");
 
-            // this is kind of SILLY
-            // https://github.com/dotnet/aspnetcore/issues/15198
-            connection.On<MultiplayerRoomState>(nameof(IMultiplayerClient.RoomStateChanged), ((IMultiplayerClient)this).RoomStateChanged);
-            connection.On<MultiplayerRoomUser>(nameof(IMultiplayerClient.UserJoined), ((IMultiplayerClient)this).UserJoined);
-            connection.On<MultiplayerRoomUser>(nameof(IMultiplayerClient.UserLeft), ((IMultiplayerClient)this).UserLeft);
-            connection.On<int>(nameof(IMultiplayerClient.HostChanged), ((IMultiplayerClient)this).HostChanged);
-            connection.On<MultiplayerRoomSettings>(nameof(IMultiplayerClient.SettingsChanged), ((IMultiplayerClient)this).SettingsChanged);
-            connection.On<int, MultiplayerUserState>(nameof(IMultiplayerClient.UserStateChanged), ((IMultiplayerClient)this).UserStateChanged);
-            connection.On(nameof(IMultiplayerClient.LoadRequested), ((IMultiplayerClient)this).LoadRequested);
-            connection.On(nameof(IMultiplayerClient.MatchStarted), ((IMultiplayerClient)this).MatchStarted);
-            connection.On(nameof(IMultiplayerClient.ResultsReady), ((IMultiplayerClient)this).ResultsReady);
-
-            connection.Closed += async ex =>
+            try
             {
-                isConnected.Value = false;
-
-                Logger.Log(ex != null
-                    ? $"Multiplayer client lost connection: {ex}"
-                    : "Multiplayer client disconnected", LoggingTarget.Network);
-
-                if (connection != null)
-                    await tryUntilConnected();
-            };
-
-            await tryUntilConnected();
-
-            async Task tryUntilConnected()
-            {
-                Logger.Log("Multiplayer client connecting...", LoggingTarget.Network);
-
                 while (api.State.Value == APIState.Online)
                 {
+                    // ensure any previous connection was disposed.
+                    // this will also create a new cancellation token source.
+                    await disconnect(false);
+
+                    // this token will be valid for the scope of this connection.
+                    // if cancelled, we can be sure that a disconnect or reconnect is handled elsewhere.
+                    var cancellationToken = connectCancelSource.Token;
+
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    Logger.Log("Multiplayer client connecting...", LoggingTarget.Network);
+
                     try
                     {
-                        Debug.Assert(connection != null);
+                        // importantly, rebuild the connection each attempt to get an updated access token.
+                        connection = createConnection(cancellationToken);
+
+                        await connection.StartAsync(cancellationToken);
 
-                        // reconnect on any failure
-                        await connection.StartAsync();
                         Logger.Log("Multiplayer client connected!", LoggingTarget.Network);
-
-                        // Success.
                         isConnected.Value = true;
-                        break;
+                        return;
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        //connection process was cancelled.
+                        throw;
                     }
                     catch (Exception e)
                     {
                         Logger.Log($"Multiplayer client connection error: {e}", LoggingTarget.Network);
-                        await Task.Delay(5000);
+
+                        // retry on any failure.
+                        await Task.Delay(5000, cancellationToken);
                     }
                 }
             }
+            finally
+            {
+                connectionLock.Release();
+            }
         }
 
         protected override Task<MultiplayerRoom> JoinRoom(long roomId)
@@ -134,20 +126,12 @@ namespace osu.Game.Online.Multiplayer
             return connection.InvokeAsync<MultiplayerRoom>(nameof(IMultiplayerServer.JoinRoom), roomId);
         }
 
-        public override async Task LeaveRoom()
+        protected override Task LeaveRoomInternal()
         {
             if (!isConnected.Value)
-            {
-                // even if not connected, make sure the local room state can be cleaned up.
-                await base.LeaveRoom();
-                return;
-            }
+                return Task.FromCanceled(new CancellationToken(true));
 
-            if (Room == null)
-                return;
-
-            await base.LeaveRoom();
-            await connection.InvokeAsync(nameof(IMultiplayerServer.LeaveRoom));
+            return connection.InvokeAsync(nameof(IMultiplayerServer.LeaveRoom));
         }
 
         public override Task TransferHost(int userId)
@@ -182,6 +166,14 @@ namespace osu.Game.Online.Multiplayer
             return connection.InvokeAsync(nameof(IMultiplayerServer.ChangeBeatmapAvailability), newBeatmapAvailability);
         }
 
+        public override Task ChangeUserMods(IEnumerable<APIMod> newMods)
+        {
+            if (!isConnected.Value)
+                return Task.CompletedTask;
+
+            return connection.InvokeAsync(nameof(IMultiplayerServer.ChangeUserMods), newMods);
+        }
+
         public override Task StartMatch()
         {
             if (!isConnected.Value)
@@ -189,5 +181,85 @@ namespace osu.Game.Online.Multiplayer
 
             return connection.InvokeAsync(nameof(IMultiplayerServer.StartMatch));
         }
+
+        private async Task disconnect(bool takeLock)
+        {
+            cancelExistingConnect();
+
+            if (takeLock)
+            {
+                if (!await connectionLock.WaitAsync(10000))
+                    throw new TimeoutException("Could not obtain a lock to disconnect. A previous attempt is likely stuck.");
+            }
+
+            try
+            {
+                if (connection != null)
+                    await connection.DisposeAsync();
+            }
+            finally
+            {
+                connection = null;
+                if (takeLock)
+                    connectionLock.Release();
+            }
+        }
+
+        private void cancelExistingConnect()
+        {
+            connectCancelSource.Cancel();
+            connectCancelSource = new CancellationTokenSource();
+        }
+
+        private HubConnection createConnection(CancellationToken cancellationToken)
+        {
+            var builder = new HubConnectionBuilder()
+                .WithUrl(endpoint, options => { options.Headers.Add("Authorization", $"Bearer {api.AccessToken}"); });
+
+            if (RuntimeInfo.SupportsJIT)
+                builder.AddMessagePackProtocol();
+            else
+            {
+                // eventually we will precompile resolvers for messagepack, but this isn't working currently
+                // see https://github.com/neuecc/MessagePack-CSharp/issues/780#issuecomment-768794308.
+                builder.AddNewtonsoftJsonProtocol(options => { options.PayloadSerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; });
+            }
+
+            var newConnection = builder.Build();
+
+            // this is kind of SILLY
+            // https://github.com/dotnet/aspnetcore/issues/15198
+            newConnection.On<MultiplayerRoomState>(nameof(IMultiplayerClient.RoomStateChanged), ((IMultiplayerClient)this).RoomStateChanged);
+            newConnection.On<MultiplayerRoomUser>(nameof(IMultiplayerClient.UserJoined), ((IMultiplayerClient)this).UserJoined);
+            newConnection.On<MultiplayerRoomUser>(nameof(IMultiplayerClient.UserLeft), ((IMultiplayerClient)this).UserLeft);
+            newConnection.On<int>(nameof(IMultiplayerClient.HostChanged), ((IMultiplayerClient)this).HostChanged);
+            newConnection.On<MultiplayerRoomSettings>(nameof(IMultiplayerClient.SettingsChanged), ((IMultiplayerClient)this).SettingsChanged);
+            newConnection.On<int, MultiplayerUserState>(nameof(IMultiplayerClient.UserStateChanged), ((IMultiplayerClient)this).UserStateChanged);
+            newConnection.On(nameof(IMultiplayerClient.LoadRequested), ((IMultiplayerClient)this).LoadRequested);
+            newConnection.On(nameof(IMultiplayerClient.MatchStarted), ((IMultiplayerClient)this).MatchStarted);
+            newConnection.On(nameof(IMultiplayerClient.ResultsReady), ((IMultiplayerClient)this).ResultsReady);
+            newConnection.On<int, IEnumerable<APIMod>>(nameof(IMultiplayerClient.UserModsChanged), ((IMultiplayerClient)this).UserModsChanged);
+
+            newConnection.Closed += ex =>
+            {
+                isConnected.Value = false;
+
+                Logger.Log(ex != null ? $"Multiplayer client lost connection: {ex}" : "Multiplayer client disconnected", LoggingTarget.Network);
+
+                // make sure a disconnect wasn't triggered (and this is still the active connection).
+                if (!cancellationToken.IsCancellationRequested)
+                    Task.Run(connect, default);
+
+                return Task.CompletedTask;
+            };
+            return newConnection;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            cancelExistingConnect();
+        }
     }
 }

osu.Game/Online/Multiplayer/MultiplayerRoom.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using MessagePack;
 using Newtonsoft.Json;
 
 namespace osu.Game.Online.Multiplayer
@@ -13,35 +14,42 @@ namespace osu.Game.Online.Multiplayer
     /// A multiplayer room.
     /// </summary>
     [Serializable]
+    [MessagePackObject]
     public class MultiplayerRoom
     {
         /// <summary>
         /// The ID of the room, used for database persistence.
         /// </summary>
+        [Key(0)]
         public readonly long RoomID;
 
         /// <summary>
         /// The current state of the room (ie. whether it is in progress or otherwise).
         /// </summary>
+        [Key(1)]
         public MultiplayerRoomState State { get; set; }
 
         /// <summary>
         /// All currently enforced game settings for this room.
         /// </summary>
+        [Key(2)]
         public MultiplayerRoomSettings Settings { get; set; } = new MultiplayerRoomSettings();
 
         /// <summary>
         /// All users currently in this room.
         /// </summary>
+        [Key(3)]
         public List<MultiplayerRoomUser> Users { get; set; } = new List<MultiplayerRoomUser>();
 
         /// <summary>
         /// The host of this room, in control of changing room settings.
         /// </summary>
+        [Key(4)]
         public MultiplayerRoomUser? Host { get; set; }
 
         [JsonConstructor]
-        public MultiplayerRoom(in long roomId)
+        [SerializationConstructor]
+        public MultiplayerRoom(long roomId)
         {
             RoomID = roomId;
         }

osu.Game/Online/Multiplayer/MultiplayerRoomSettings.cs

@@ -7,31 +7,47 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
+using MessagePack;
 using osu.Game.Online.API;
 
 namespace osu.Game.Online.Multiplayer
 {
     [Serializable]
+    [MessagePackObject]
     public class MultiplayerRoomSettings : IEquatable<MultiplayerRoomSettings>
     {
+        [Key(0)]
         public int BeatmapID { get; set; }
 
+        [Key(1)]
         public int RulesetID { get; set; }
 
+        [Key(2)]
         public string BeatmapChecksum { get; set; } = string.Empty;
 
+        [Key(3)]
         public string Name { get; set; } = "Unnamed room";
 
         [NotNull]
-        public IEnumerable<APIMod> Mods { get; set; } = Enumerable.Empty<APIMod>();
+        [Key(4)]
+        public IEnumerable<APIMod> RequiredMods { get; set; } = Enumerable.Empty<APIMod>();
+
+        [NotNull]
+        [Key(5)]
+        public IEnumerable<APIMod> AllowedMods { get; set; } = Enumerable.Empty<APIMod>();
 
         public bool Equals(MultiplayerRoomSettings other)
             => BeatmapID == other.BeatmapID
                && BeatmapChecksum == other.BeatmapChecksum
-               && Mods.SequenceEqual(other.Mods)
+               && RequiredMods.SequenceEqual(other.RequiredMods)
+               && AllowedMods.SequenceEqual(other.AllowedMods)
                && RulesetID == other.RulesetID
                && Name.Equals(other.Name, StringComparison.Ordinal);
 
-        public override string ToString() => $"Name:{Name} Beatmap:{BeatmapID} ({BeatmapChecksum}) Mods:{string.Join(',', Mods)} Ruleset:{RulesetID}";
+        public override string ToString() => $"Name:{Name}"
+                                             + $" Beatmap:{BeatmapID} ({BeatmapChecksum})"
+                                             + $" RequiredMods:{string.Join(',', RequiredMods)}"
+                                             + $" AllowedMods:{string.Join(',', AllowedMods)}"
+                                             + $" Ruleset:{RulesetID}";
     }
 }

osu.Game/Online/Multiplayer/MultiplayerRoomUser.cs

@@ -4,28 +4,45 @@
 #nullable enable
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using MessagePack;
 using Newtonsoft.Json;
+using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Users;
 
 namespace osu.Game.Online.Multiplayer
 {
     [Serializable]
+    [MessagePackObject]
     public class MultiplayerRoomUser : IEquatable<MultiplayerRoomUser>
     {
+        [Key(0)]
         public readonly int UserID;
 
+        [Key(1)]
         public MultiplayerUserState State { get; set; } = MultiplayerUserState.Idle;
 
         /// <summary>
         /// The availability state of the current beatmap.
         /// </summary>
+        [Key(2)]
         public BeatmapAvailability BeatmapAvailability { get; set; } = BeatmapAvailability.LocallyAvailable();
 
+        /// <summary>
+        /// Any mods applicable only to the local user.
+        /// </summary>
+        [Key(3)]
+        [NotNull]
+        public IEnumerable<APIMod> Mods { get; set; } = Enumerable.Empty<APIMod>();
+
+        [IgnoreMember]
         public User? User { get; set; }
 
         [JsonConstructor]
-        public MultiplayerRoomUser(in int userId)
+        public MultiplayerRoomUser(int userId)
         {
             UserID = userId;
         }

osu.Game/Online/Multiplayer/StatefulMultiplayerClient.cs

@@ -7,6 +7,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -15,13 +16,13 @@ using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
-using osu.Game.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
 using osu.Game.Online.Rooms.RoomStatuses;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Users;
 using osu.Game.Utils;
 
@@ -104,35 +105,48 @@ namespace osu.Game.Online.Multiplayer
                 if (!connected.NewValue && Room != null)
                 {
                     Logger.Log("Connection to multiplayer server was lost.", LoggingTarget.Runtime, LogLevel.Important);
-                    LeaveRoom().CatchUnobservedExceptions();
+                    LeaveRoom();
                 }
             });
         }
 
+        private readonly TaskChain joinOrLeaveTaskChain = new TaskChain();
+        private CancellationTokenSource? joinCancellationSource;
+
         /// <summary>
         /// Joins the <see cref="MultiplayerRoom"/> for a given API <see cref="Room"/>.
         /// </summary>
         /// <param name="room">The API <see cref="Room"/>.</param>
         public async Task JoinRoom(Room room)
         {
-            if (Room != null)
-                throw new InvalidOperationException("Cannot join a multiplayer room while already in one.");
+            var cancellationSource = joinCancellationSource = new CancellationTokenSource();
 
-            Debug.Assert(room.RoomID.Value != null);
+            await joinOrLeaveTaskChain.Add(async () =>
+            {
+                if (Room != null)
+                    throw new InvalidOperationException("Cannot join a multiplayer room while already in one.");
 
-            apiRoom = room;
-            playlistItemId = room.Playlist.SingleOrDefault()?.ID ?? 0;
+                Debug.Assert(room.RoomID.Value != null);
 
-            Room = await JoinRoom(room.RoomID.Value.Value);
+                // Join the server-side room.
+                var joinedRoom = await JoinRoom(room.RoomID.Value.Value);
+                Debug.Assert(joinedRoom != null);
 
-            Debug.Assert(Room != null);
+                // Populate users.
+                Debug.Assert(joinedRoom.Users != null);
+                await Task.WhenAll(joinedRoom.Users.Select(PopulateUser));
 
-            var users = await getRoomUsers();
-            Debug.Assert(users != null);
+                // Update the stored room (must be done on update thread for thread-safety).
+                await scheduleAsync(() =>
+                {
+                    Room = joinedRoom;
+                    apiRoom = room;
+                    playlistItemId = room.Playlist.SingleOrDefault()?.ID ?? 0;
+                }, cancellationSource.Token);
 
-            await Task.WhenAll(users.Select(PopulateUser));
-
-            updateLocalRoomSettings(Room.Settings);
+                // Update room settings.
+                await updateLocalRoomSettings(joinedRoom.Settings, cancellationSource.Token);
+            }, cancellationSource.Token);
         }
 
         /// <summary>
@@ -142,23 +156,33 @@ namespace osu.Game.Online.Multiplayer
         /// <returns>The joined <see cref="MultiplayerRoom"/>.</returns>
         protected abstract Task<MultiplayerRoom> JoinRoom(long roomId);
 
-        public virtual Task LeaveRoom()
+        public Task LeaveRoom()
         {
-            Scheduler.Add(() =>
-            {
-                if (Room == null)
-                    return;
+            // The join may have not completed yet, so certain tasks that either update the room or reference the room should be cancelled.
+            // This includes the setting of Room itself along with the initial update of the room settings on join.
+            joinCancellationSource?.Cancel();
 
+            // Leaving rooms is expected to occur instantaneously whilst the operation is finalised in the background.
+            // However a few members need to be reset immediately to prevent other components from entering invalid states whilst the operation hasn't yet completed.
+            // For example, if a room was left and the user immediately pressed the "create room" button, then the user could be taken into the lobby if the value of Room is not reset in time.
+            var scheduledReset = scheduleAsync(() =>
+            {
                 apiRoom = null;
                 Room = null;
                 CurrentMatchPlayingUserIds.Clear();
 
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
-            return Task.CompletedTask;
+            return joinOrLeaveTaskChain.Add(async () =>
+            {
+                await scheduledReset;
+                await LeaveRoomInternal();
+            });
         }
 
+        protected abstract Task LeaveRoomInternal();
+
         /// <summary>
         /// Change the current <see cref="MultiplayerRoom"/> settings.
         /// </summary>
@@ -192,7 +216,8 @@ namespace osu.Game.Online.Multiplayer
                 BeatmapID = item.GetOr(existingPlaylistItem).BeatmapID,
                 BeatmapChecksum = item.GetOr(existingPlaylistItem).Beatmap.Value.MD5Hash,
                 RulesetID = item.GetOr(existingPlaylistItem).RulesetID,
-                Mods = item.HasValue ? item.Value.AsNonNull().RequiredMods.Select(m => new APIMod(m)).ToList() : Room.Settings.Mods
+                RequiredMods = item.HasValue ? item.Value.AsNonNull().RequiredMods.Select(m => new APIMod(m)).ToList() : Room.Settings.RequiredMods,
+                AllowedMods = item.HasValue ? item.Value.AsNonNull().AllowedMods.Select(m => new APIMod(m)).ToList() : Room.Settings.AllowedMods
             });
         }
 
@@ -230,6 +255,14 @@ namespace osu.Game.Online.Multiplayer
 
         public abstract Task ChangeBeatmapAvailability(BeatmapAvailability newBeatmapAvailability);
 
+        /// <summary>
+        /// Change the local user's mods in the currently joined room.
+        /// </summary>
+        /// <param name="newMods">The proposed new mods, excluding any required by the room itself.</param>
+        public Task ChangeUserMods(IEnumerable<Mod> newMods) => ChangeUserMods(newMods.Select(m => new APIMod(m)).ToList());
+
+        public abstract Task ChangeUserMods(IEnumerable<APIMod> newMods);
+
         public abstract Task StartMatch();
 
         Task IMultiplayerClient.RoomStateChanged(MultiplayerRoomState state)
@@ -378,6 +411,27 @@ namespace osu.Game.Online.Multiplayer
             return Task.CompletedTask;
         }
 
+        public Task UserModsChanged(int userId, IEnumerable<APIMod> mods)
+        {
+            if (Room == null)
+                return Task.CompletedTask;
+
+            Scheduler.Add(() =>
+            {
+                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+
+                // errors here are not critical - user mods are mostly for display.
+                if (user == null)
+                    return;
+
+                user.Mods = mods;
+
+                RoomUpdated?.Invoke();
+            }, false);
+
+            return Task.CompletedTask;
+        }
+
         Task IMultiplayerClient.LoadRequested()
         {
             if (Room == null)
@@ -432,27 +486,6 @@ namespace osu.Game.Online.Multiplayer
         /// <param name="multiplayerUser">The <see cref="MultiplayerRoomUser"/> to populate.</param>
         protected async Task PopulateUser(MultiplayerRoomUser multiplayerUser) => multiplayerUser.User ??= await userLookupCache.GetUserAsync(multiplayerUser.UserID);
 
-        /// <summary>
-        /// Retrieve a copy of users currently in the joined <see cref="Room"/> in a thread-safe manner.
-        /// This should be used whenever accessing users from outside of an Update thread context (ie. when not calling <see cref="Drawable.Schedule"/>).
-        /// </summary>
-        /// <returns>A copy of users in the current room, or null if unavailable.</returns>
-        private Task<List<MultiplayerRoomUser>?> getRoomUsers()
-        {
-            var tcs = new TaskCompletionSource<List<MultiplayerRoomUser>?>();
-
-            // at some point we probably want to replace all these schedule calls with Room.LockForUpdate.
-            // for now, as this would require quite some consideration due to the number of accesses to the room instance,
-            // let's just add a manual schedule for the non-scheduled usages instead.
-            Scheduler.Add(() =>
-            {
-                var users = Room?.Users.ToList();
-                tcs.SetResult(users);
-            }, false);
-
-            return tcs.Task;
-        }
-
         /// <summary>
         /// Updates the local room settings with the given <see cref="MultiplayerRoomSettings"/>.
         /// </summary>
@@ -460,34 +493,36 @@ namespace osu.Game.Online.Multiplayer
         /// This updates both the joined <see cref="MultiplayerRoom"/> and the respective API <see cref="Room"/>.
         /// </remarks>
         /// <param name="settings">The new <see cref="MultiplayerRoomSettings"/> to update from.</param>
-        private void updateLocalRoomSettings(MultiplayerRoomSettings settings)
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to cancel the update.</param>
+        private Task updateLocalRoomSettings(MultiplayerRoomSettings settings, CancellationToken cancellationToken = default) => scheduleAsync(() =>
         {
             if (Room == null)
                 return;
 
-            Scheduler.Add(() =>
+            Debug.Assert(apiRoom != null);
+
+            // Update a few properties of the room instantaneously.
+            Room.Settings = settings;
+            apiRoom.Name.Value = Room.Settings.Name;
+
+            // The playlist update is delayed until an online beatmap lookup (below) succeeds.
+            // In-order for the client to not display an outdated beatmap, the playlist is forcefully cleared here.
+            apiRoom.Playlist.Clear();
+
+            RoomUpdated?.Invoke();
+
+            var req = new GetBeatmapSetRequest(settings.BeatmapID, BeatmapSetLookupType.BeatmapId);
+
+            req.Success += res =>
             {
-                if (Room == null)
+                if (cancellationToken.IsCancellationRequested)
                     return;
 
-                Debug.Assert(apiRoom != null);
+                updatePlaylist(settings, res);
+            };
 
-                // Update a few properties of the room instantaneously.
-                Room.Settings = settings;
-                apiRoom.Name.Value = Room.Settings.Name;
-
-                // The playlist update is delayed until an online beatmap lookup (below) succeeds.
-                // In-order for the client to not display an outdated beatmap, the playlist is forcefully cleared here.
-                apiRoom.Playlist.Clear();
-
-                RoomUpdated?.Invoke();
-
-                var req = new GetBeatmapSetRequest(settings.BeatmapID, BeatmapSetLookupType.BeatmapId);
-                req.Success += res => updatePlaylist(settings, res);
-
-                api.Queue(req);
-            }, false);
-        }
+            api.Queue(req);
+        }, cancellationToken);
 
         private void updatePlaylist(MultiplayerRoomSettings settings, APIBeatmapSet onlineSet)
         {
@@ -501,7 +536,8 @@ namespace osu.Game.Online.Multiplayer
             beatmap.MD5Hash = settings.BeatmapChecksum;
 
             var ruleset = rulesets.GetRuleset(settings.RulesetID).CreateInstance();
-            var mods = settings.Mods.Select(m => m.ToMod(ruleset));
+            var mods = settings.RequiredMods.Select(m => m.ToMod(ruleset));
+            var allowedMods = settings.AllowedMods.Select(m => m.ToMod(ruleset));
 
             PlaylistItem playlistItem = new PlaylistItem
             {
@@ -511,6 +547,7 @@ namespace osu.Game.Online.Multiplayer
             };
 
             playlistItem.RequiredMods.AddRange(mods);
+            playlistItem.AllowedMods.AddRange(allowedMods);
 
             apiRoom.Playlist.Clear(); // Clearing should be unnecessary, but here for sanity.
             apiRoom.Playlist.Add(playlistItem);
@@ -534,5 +571,31 @@ namespace osu.Game.Online.Multiplayer
             else
                 CurrentMatchPlayingUserIds.Remove(userId);
         }
+
+        private Task scheduleAsync(Action action, CancellationToken cancellationToken = default)
+        {
+            var tcs = new TaskCompletionSource<bool>();
+
+            Scheduler.Add(() =>
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    tcs.SetCanceled();
+                    return;
+                }
+
+                try
+                {
+                    action();
+                    tcs.SetResult(true);
+                }
+                catch (Exception ex)
+                {
+                    tcs.SetException(ex);
+                }
+            });
+
+            return tcs.Task;
+        }
     }
 }

osu.Game/Online/Rooms/BeatmapAvailability.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using MessagePack;
 using Newtonsoft.Json;
 
 namespace osu.Game.Online.Rooms
@@ -9,27 +10,30 @@ namespace osu.Game.Online.Rooms
     /// <summary>
     /// The local availability information about a certain beatmap for the client.
     /// </summary>
+    [MessagePackObject]
     public class BeatmapAvailability : IEquatable<BeatmapAvailability>
     {
         /// <summary>
         /// The beatmap's availability state.
         /// </summary>
+        [Key(0)]
         public readonly DownloadState State;
 
         /// <summary>
         /// The beatmap's downloading progress, null when not in <see cref="DownloadState.Downloading"/> state.
         /// </summary>
-        public readonly double? DownloadProgress;
+        [Key(1)]
+        public readonly float? DownloadProgress;
 
         [JsonConstructor]
-        private BeatmapAvailability(DownloadState state, double? downloadProgress = null)
+        public BeatmapAvailability(DownloadState state, float? downloadProgress = null)
         {
             State = state;
             DownloadProgress = downloadProgress;
         }
 
         public static BeatmapAvailability NotDownloaded() => new BeatmapAvailability(DownloadState.NotDownloaded);
-        public static BeatmapAvailability Downloading(double progress) => new BeatmapAvailability(DownloadState.Downloading, progress);
+        public static BeatmapAvailability Downloading(float progress) => new BeatmapAvailability(DownloadState.Downloading, progress);
         public static BeatmapAvailability Importing() => new BeatmapAvailability(DownloadState.Importing);
         public static BeatmapAvailability LocallyAvailable() => new BeatmapAvailability(DownloadState.LocallyAvailable);
 

osu.Game/Online/Rooms/OnlinePlayBeatmapAvailablilityTracker.cs

@@ -0,0 +1,92 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Logging;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Online.Rooms
+{
+    /// <summary>
+    /// Represent a checksum-verifying beatmap availability tracker usable for online play screens.
+    ///
+    /// This differs from a regular download tracking composite as this accounts for the
+    /// databased beatmap set's checksum, to disallow from playing with an altered version of the beatmap.
+    /// </summary>
+    public class OnlinePlayBeatmapAvailablilityTracker : DownloadTrackingComposite<BeatmapSetInfo, BeatmapManager>
+    {
+        public readonly IBindable<PlaylistItem> SelectedItem = new Bindable<PlaylistItem>();
+
+        /// <summary>
+        /// The availability state of the currently selected playlist item.
+        /// </summary>
+        public IBindable<BeatmapAvailability> Availability => availability;
+
+        private readonly Bindable<BeatmapAvailability> availability = new Bindable<BeatmapAvailability>();
+
+        public OnlinePlayBeatmapAvailablilityTracker()
+        {
+            State.BindValueChanged(_ => updateAvailability());
+            Progress.BindValueChanged(_ => updateAvailability(), true);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            SelectedItem.BindValueChanged(item => Model.Value = item.NewValue?.Beatmap.Value.BeatmapSet, true);
+        }
+
+        protected override bool VerifyDatabasedModel(BeatmapSetInfo databasedSet)
+        {
+            int? beatmapId = SelectedItem.Value.Beatmap.Value.OnlineBeatmapID;
+            string checksum = SelectedItem.Value.Beatmap.Value.MD5Hash;
+
+            var matchingBeatmap = databasedSet.Beatmaps.FirstOrDefault(b => b.OnlineBeatmapID == beatmapId && b.MD5Hash == checksum);
+
+            if (matchingBeatmap == null)
+            {
+                Logger.Log("The imported beatmap set does not match the online version.", LoggingTarget.Runtime, LogLevel.Important);
+                return false;
+            }
+
+            return true;
+        }
+
+        protected override bool IsModelAvailableLocally()
+        {
+            int? beatmapId = SelectedItem.Value.Beatmap.Value.OnlineBeatmapID;
+            string checksum = SelectedItem.Value.Beatmap.Value.MD5Hash;
+
+            var beatmap = Manager.QueryBeatmap(b => b.OnlineBeatmapID == beatmapId && b.MD5Hash == checksum);
+            return beatmap?.BeatmapSet.DeletePending == false;
+        }
+
+        private void updateAvailability()
+        {
+            switch (State.Value)
+            {
+                case DownloadState.NotDownloaded:
+                    availability.Value = BeatmapAvailability.NotDownloaded();
+                    break;
+
+                case DownloadState.Downloading:
+                    availability.Value = BeatmapAvailability.Downloading((float)Progress.Value);
+                    break;
+
+                case DownloadState.Importing:
+                    availability.Value = BeatmapAvailability.Importing();
+                    break;
+
+                case DownloadState.LocallyAvailable:
+                    availability.Value = BeatmapAvailability.LocallyAvailable();
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(State));
+            }
+        }
+    }
+}

osu.Game/Online/Spectator/FrameDataBundle.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using MessagePack;
 using Newtonsoft.Json;
 using osu.Game.Replays.Legacy;
 using osu.Game.Scoring;
@@ -12,10 +13,13 @@ using osu.Game.Scoring;
 namespace osu.Game.Online.Spectator
 {
     [Serializable]
+    [MessagePackObject]
     public class FrameDataBundle
     {
+        [Key(0)]
         public FrameHeader Header { get; set; }
 
+        [Key(1)]
         public IEnumerable<LegacyReplayFrame> Frames { get; set; }
 
         public FrameDataBundle(ScoreInfo score, IEnumerable<LegacyReplayFrame> frames)

osu.Game/Online/Spectator/FrameHeader.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using MessagePack;
 using Newtonsoft.Json;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
@@ -12,31 +13,37 @@ using osu.Game.Scoring;
 namespace osu.Game.Online.Spectator
 {
     [Serializable]
+    [MessagePackObject]
     public class FrameHeader
     {
         /// <summary>
         /// The current accuracy of the score.
         /// </summary>
+        [Key(0)]
         public double Accuracy { get; set; }
 
         /// <summary>
         /// The current combo of the score.
         /// </summary>
+        [Key(1)]
         public int Combo { get; set; }
 
         /// <summary>
         /// The maximum combo achieved up to the current point in time.
         /// </summary>
+        [Key(2)]
         public int MaxCombo { get; set; }
 
         /// <summary>
         /// Cumulative hit statistics.
         /// </summary>
+        [Key(3)]
         public Dictionary<HitResult, int> Statistics { get; set; }
 
         /// <summary>
         /// The time at which this frame was received by the server.
         /// </summary>
+        [Key(4)]
         public DateTimeOffset ReceivedTime { get; set; }
 
         /// <summary>
@@ -54,7 +61,8 @@ namespace osu.Game.Online.Spectator
         }
 
         [JsonConstructor]
-        public FrameHeader(int combo, int maxCombo, double accuracy, Dictionary<HitResult, int> statistics, DateTimeOffset receivedTime)
+        [SerializationConstructor]
+        public FrameHeader(double accuracy, int combo, int maxCombo, Dictionary<HitResult, int> statistics, DateTimeOffset receivedTime)
         {
             Combo = combo;
             MaxCombo = maxCombo;

osu.Game/Online/Spectator/SpectatorState.cs

@@ -5,18 +5,23 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using MessagePack;
 using osu.Game.Online.API;
 
 namespace osu.Game.Online.Spectator
 {
     [Serializable]
+    [MessagePackObject]
     public class SpectatorState : IEquatable<SpectatorState>
     {
+        [Key(0)]
         public int? BeatmapID { get; set; }
 
+        [Key(1)]
         public int? RulesetID { get; set; }
 
         [NotNull]
+        [Key(2)]
         public IEnumerable<APIMod> Mods { get; set; } = Enumerable.Empty<APIMod>();
 
         public bool Equals(SpectatorState other) => BeatmapID == other?.BeatmapID && Mods.SequenceEqual(other?.Mods) && RulesetID == other?.RulesetID;

osu.Game/Online/Spectator/SpectatorStreamingClient.cs

@@ -10,6 +10,7 @@ using JetBrains.Annotations;
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.Extensions.DependencyInjection;
 using Newtonsoft.Json;
+using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -116,14 +117,19 @@ namespace osu.Game.Online.Spectator
             if (connection != null)
                 return;
 
-            connection = new HubConnectionBuilder()
-                         .WithUrl(endpoint, options =>
-                         {
-                             options.Headers.Add("Authorization", $"Bearer {api.AccessToken}");
-                         })
-                         .AddNewtonsoftJsonProtocol(options => { options.PayloadSerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; })
-                         .Build();
+            var builder = new HubConnectionBuilder()
+                .WithUrl(endpoint, options => { options.Headers.Add("Authorization", $"Bearer {api.AccessToken}"); });
 
+            if (RuntimeInfo.SupportsJIT)
+                builder.AddMessagePackProtocol();
+            else
+            {
+                // eventually we will precompile resolvers for messagepack, but this isn't working currently
+                // see https://github.com/neuecc/MessagePack-CSharp/issues/780#issuecomment-768794308.
+                builder.AddNewtonsoftJsonProtocol(options => { options.PayloadSerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; });
+            }
+
+            connection = builder.Build();
             // until strong typed client support is added, each method must be manually bound (see https://github.com/dotnet/aspnetcore/issues/15198)
             connection.On<int, SpectatorState>(nameof(ISpectatorClient.UserBeganPlaying), ((ISpectatorClient)this).UserBeganPlaying);
             connection.On<int, FrameDataBundle>(nameof(ISpectatorClient.UserSentFrames), ((ISpectatorClient)this).UserSentFrames);

osu.Game/OsuGame.cs

@@ -468,6 +468,16 @@ namespace osu.Game
         private void modsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
         {
             updateModDefaults();
+
+            // a lease may be taken on the mods bindable, at which point we can't really ensure valid mods.
+            if (SelectedMods.Disabled)
+                return;
+
+            if (!ModUtils.CheckValidForGameplay(mods.NewValue, out var invalid))
+            {
+                // ensure we always have a valid set of mods.
+                SelectedMods.Value = mods.NewValue.Except(invalid).ToArray();
+            }
         }
 
         private void updateModDefaults()

osu.Game/Overlays/BeatmapListing/BeatmapSearchFilterRow.cs

@@ -12,7 +12,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osuTK;
 using Humanizer;
-using osu.Game.Utils;
+using osu.Framework.Extensions.EnumExtensions;
 
 namespace osu.Game.Overlays.BeatmapListing
 {
@@ -80,7 +80,7 @@ namespace osu.Game.Overlays.BeatmapListing
 
                 if (typeof(T).IsEnum)
                 {
-                    foreach (var val in OrderAttributeUtils.GetValuesInOrder<T>())
+                    foreach (var val in EnumExtensions.GetValuesInOrder<T>())
                         AddItem(val);
                 }
             }

osu.Game/Overlays/BeatmapListing/SearchLanguage.cs

@@ -1,7 +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 osu.Game.Utils;
+using osu.Framework.Utils;
 
 namespace osu.Game.Overlays.BeatmapListing
 {

osu.Game/Overlays/BeatmapListingOverlay.cs

@@ -160,23 +160,34 @@ namespace osu.Game.Overlays
             Loading.Hide();
             lastFetchDisplayedTime = Time.Current;
 
+            if (content == currentContent)
+                return;
+
             var lastContent = currentContent;
 
             if (lastContent != null)
             {
-                lastContent.FadeOut(100, Easing.OutQuint).Expire();
+                var transform = lastContent.FadeOut(100, Easing.OutQuint);
 
-                // Consider the case when the new content is smaller than the last content.
-                // If the auto-size computation is delayed until fade out completes, the background remain high for too long making the resulting transition to the smaller height look weird.
-                // At the same time, if the last content's height is bypassed immediately, there is a period where the new content is at Alpha = 0 when the auto-sized height will be 0.
-                // To resolve both of these issues, the bypass is delayed until a point when the content transitions (fade-in and fade-out) overlap and it looks good to do so.
-                lastContent.Delay(25).Schedule(() => lastContent.BypassAutoSizeAxes = Axes.Y).Then().Schedule(() => panelTarget.Remove(lastContent));
+                if (lastContent == notFoundContent)
+                {
+                    // not found display may be used multiple times, so don't expire/dispose it.
+                    transform.Schedule(() => panelTarget.Remove(lastContent));
+                }
+                else
+                {
+                    // Consider the case when the new content is smaller than the last content.
+                    // If the auto-size computation is delayed until fade out completes, the background remain high for too long making the resulting transition to the smaller height look weird.
+                    // At the same time, if the last content's height is bypassed immediately, there is a period where the new content is at Alpha = 0 when the auto-sized height will be 0.
+                    // To resolve both of these issues, the bypass is delayed until a point when the content transitions (fade-in and fade-out) overlap and it looks good to do so.
+                    lastContent.Delay(25).Schedule(() => lastContent.BypassAutoSizeAxes = Axes.Y).Then().Schedule(() => lastContent.Expire());
+                }
             }
 
             if (!content.IsAlive)
                 panelTarget.Add(content);
-            content.FadeIn(200, Easing.OutQuint);
 
+            content.FadeInFromZero(200, Easing.OutQuint);
             currentContent = content;
         }
 
@@ -186,7 +197,7 @@ namespace osu.Game.Overlays
             base.Dispose(isDisposing);
         }
 
-        private class NotFoundDrawable : CompositeDrawable
+        public class NotFoundDrawable : CompositeDrawable
         {
             public NotFoundDrawable()
             {

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

@@ -7,6 +7,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -15,7 +16,6 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Users.Drawables;
-using osu.Game.Utils;
 using osuTK;
 using osuTK.Graphics;
 
@@ -105,7 +105,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
 
             var ruleset = scores.First().Ruleset.CreateInstance();
 
-            foreach (var result in OrderAttributeUtils.GetValuesInOrder<HitResult>())
+            foreach (var result in EnumExtensions.GetValuesInOrder<HitResult>())
             {
                 if (!allScoreStatistics.Contains(result))
                     continue;

osu.Game/Overlays/Chat/ChatLine.cs

@@ -190,13 +190,13 @@ namespace osu.Game.Overlays.Chat
                     }
                 }
             };
-
-            updateMessageContent();
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
+
+            updateMessageContent();
             FinishTransforms(true);
         }
 

osu.Game/Overlays/Chat/DrawableChannel.cs

@@ -16,6 +16,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
 using osu.Game.Graphics.Sprites;
 
 namespace osu.Game.Overlays.Chat
@@ -24,7 +25,7 @@ namespace osu.Game.Overlays.Chat
     {
         public readonly Channel Channel;
         protected FillFlowContainer ChatLineFlow;
-        private OsuScrollContainer scroll;
+        private ChannelScrollContainer scroll;
 
         private bool scrollbarVisible = true;
 
@@ -56,7 +57,7 @@ namespace osu.Game.Overlays.Chat
             {
                 RelativeSizeAxes = Axes.Both,
                 Masking = true,
-                Child = scroll = new OsuScrollContainer
+                Child = scroll = new ChannelScrollContainer
                 {
                     ScrollbarVisible = scrollbarVisible,
                     RelativeSizeAxes = Axes.Both,
@@ -80,12 +81,6 @@ namespace osu.Game.Overlays.Chat
             Channel.PendingMessageResolved += pendingMessageResolved;
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            scrollToEnd();
-        }
-
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
@@ -113,8 +108,6 @@ namespace osu.Game.Overlays.Chat
                 ChatLineFlow.Clear();
             }
 
-            bool shouldScrollToEnd = scroll.IsScrolledToEnd(10) || !chatLines.Any() || newMessages.Any(m => m is LocalMessage);
-
             // Add up to last Channel.MAX_HISTORY messages
             var displayMessages = newMessages.Skip(Math.Max(0, newMessages.Count() - Channel.MAX_HISTORY));
 
@@ -153,8 +146,10 @@ namespace osu.Game.Overlays.Chat
                 }
             }
 
-            if (shouldScrollToEnd)
-                scrollToEnd();
+            // due to the scroll adjusts from old messages removal above, a scroll-to-end must be enforced,
+            // to avoid making the container think the user has scrolled back up and unwantedly disable auto-scrolling.
+            if (newMessages.Any(m => m is LocalMessage))
+                scroll.ScrollToEnd();
         });
 
         private void pendingMessageResolved(Message existing, Message updated) => Schedule(() =>
@@ -178,8 +173,6 @@ namespace osu.Game.Overlays.Chat
 
         private IEnumerable<ChatLine> chatLines => ChatLineFlow.Children.OfType<ChatLine>();
 
-        private void scrollToEnd() => ScheduleAfterChildren(() => scroll.ScrollToEnd());
-
         public class DaySeparator : Container
         {
             public float TextSize
@@ -243,5 +236,51 @@ namespace osu.Game.Overlays.Chat
                 };
             }
         }
+
+        /// <summary>
+        /// An <see cref="OsuScrollContainer"/> with functionality to automatically scroll whenever the maximum scrollable distance increases.
+        /// </summary>
+        private class ChannelScrollContainer : UserTrackingScrollContainer
+        {
+            /// <summary>
+            /// The chat will be automatically scrolled to end if and only if
+            /// the distance between the current scroll position and the end of the scroll
+            /// is less than this value.
+            /// </summary>
+            private const float auto_scroll_leniency = 10f;
+
+            private float? lastExtent;
+
+            protected override void OnUserScroll(float value, bool animated = true, double? distanceDecay = default)
+            {
+                base.OnUserScroll(value, animated, distanceDecay);
+                lastExtent = null;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                // If the user has scrolled to the bottom of the container, we should resume tracking new content.
+                if (UserScrolling && IsScrolledToEnd(auto_scroll_leniency))
+                    CancelUserScroll();
+
+                // If the user hasn't overridden our behaviour and there has been new content added to the container, we should update our scroll position to track it.
+                bool requiresScrollUpdate = !UserScrolling && (lastExtent == null || Precision.AlmostBigger(ScrollableExtent, lastExtent.Value));
+
+                if (requiresScrollUpdate)
+                {
+                    // Schedule required to allow FillFlow to be the correct size.
+                    Schedule(() =>
+                    {
+                        if (!UserScrolling)
+                        {
+                            ScrollToEnd();
+                            lastExtent = ScrollableExtent;
+                        }
+                    });
+                }
+            }
+        }
     }
 }

osu.Game/Overlays/Comments/VotePill.cs

@@ -33,11 +33,16 @@ namespace osu.Game.Overlays.Comments
         [Resolved]
         private IAPIProvider api { get; set; }
 
+        [Resolved(canBeNull: true)]
+        private LoginOverlay login { get; set; }
+
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; }
 
+        protected Box Background { get; private set; }
+
         private readonly Comment comment;
-        private Box background;
+
         private Box hoverLayer;
         private CircularContainer borderContainer;
         private SpriteText sideNumber;
@@ -62,8 +67,12 @@ namespace osu.Game.Overlays.Comments
             AccentColour = borderContainer.BorderColour = sideNumber.Colour = colours.GreenLight;
             hoverLayer.Colour = Color4.Black.Opacity(0.5f);
 
-            if (api.IsLoggedIn && api.LocalUser.Value.Id != comment.UserId)
+            var ownComment = api.LocalUser.Value.Id == comment.UserId;
+
+            if (!ownComment)
                 Action = onAction;
+
+            Background.Alpha = ownComment ? 0 : 1;
         }
 
         protected override void LoadComplete()
@@ -71,12 +80,18 @@ namespace osu.Game.Overlays.Comments
             base.LoadComplete();
             isVoted.Value = comment.IsVoted;
             votesCount.Value = comment.VotesCount;
-            isVoted.BindValueChanged(voted => background.Colour = voted.NewValue ? AccentColour : colourProvider.Background6, true);
+            isVoted.BindValueChanged(voted => Background.Colour = voted.NewValue ? AccentColour : colourProvider.Background6, true);
             votesCount.BindValueChanged(count => votesCounter.Text = $"+{count.NewValue}", true);
         }
 
         private void onAction()
         {
+            if (!api.IsLoggedIn)
+            {
+                login?.Show();
+                return;
+            }
+
             request = new CommentVoteRequest(comment.Id, isVoted.Value ? CommentVoteAction.UnVote : CommentVoteAction.Vote);
             request.Success += onSuccess;
             api.Queue(request);
@@ -102,7 +117,7 @@ namespace osu.Game.Overlays.Comments
                     Masking = true,
                     Children = new Drawable[]
                     {
-                        background = new Box
+                        Background = new Box
                         {
                             RelativeSizeAxes = Axes.Both
                         },

osu.Game/Overlays/Mods/LocalPlayerModSelectOverlay.cs

@@ -0,0 +1,18 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Overlays.Mods
+{
+    public class LocalPlayerModSelectOverlay : ModSelectOverlay
+    {
+        protected override void OnModSelected(Mod mod)
+        {
+            base.OnModSelected(mod);
+
+            foreach (var section in ModSectionsContainer.Children)
+                section.DeselectTypes(mod.IncompatibleMods, true);
+        }
+    }
+}

osu.Game/Overlays/Mods/ModButton.cs

@@ -236,13 +236,13 @@ namespace osu.Game.Overlays.Mods
             {
                 iconsContainer.AddRange(new[]
                 {
-                    backgroundIcon = new PassThroughTooltipModIcon(Mods[1])
+                    backgroundIcon = new ModIcon(Mods[1], false)
                     {
                         Origin = Anchor.BottomRight,
                         Anchor = Anchor.BottomRight,
                         Position = new Vector2(1.5f),
                     },
-                    foregroundIcon = new PassThroughTooltipModIcon(Mods[0])
+                    foregroundIcon = new ModIcon(Mods[0], false)
                     {
                         Origin = Anchor.BottomRight,
                         Anchor = Anchor.BottomRight,
@@ -252,7 +252,7 @@ namespace osu.Game.Overlays.Mods
             }
             else
             {
-                iconsContainer.Add(foregroundIcon = new PassThroughTooltipModIcon(Mod)
+                iconsContainer.Add(foregroundIcon = new ModIcon(Mod, false)
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
@@ -297,15 +297,5 @@ namespace osu.Game.Overlays.Mods
 
             Mod = mod;
         }
-
-        private class PassThroughTooltipModIcon : ModIcon
-        {
-            public override string TooltipText => null;
-
-            public PassThroughTooltipModIcon(Mod mod)
-                : base(mod)
-            {
-            }
-        }
     }
 }