Merge branch 'master' into sample-lookup-improvements

Directory.Build.props

@@ -16,9 +16,9 @@
     <EmbeddedResource Include="Resources\**\*.*" />
   </ItemGroup>
   <ItemGroup Label="Code Analysis">
-    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.3.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.3.1" PrivateAssets="All" />
     <AdditionalFiles Include="$(MSBuildThisFileDirectory)CodeAnalysis\BannedSymbols.txt" />
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.0.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.3.1" PrivateAssets="All" />
   </ItemGroup>
   <PropertyGroup Label="Code Analysis">
     <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)CodeAnalysis\osu.ruleset</CodeAnalysisRuleSet>

global.json

@@ -5,6 +5,6 @@
     "version": "3.1.100"
   },
   "msbuild-sdks": {
-    "Microsoft.Build.Traversal": "2.1.1"
+    "Microsoft.Build.Traversal": "2.2.3"
   }
 }

osu.Android.props

@@ -52,6 +52,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1016.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1019.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1029.1" />
   </ItemGroup>
 </Project>

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

@@ -35,6 +35,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
                 objects.Add(new Note { StartTime = time });
 
+                // don't hit the first note
                 if (i > 0)
                 {
                     frames.Add(new ManiaReplayFrame(time + 10, ManiaAction.Key1));

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

@@ -64,8 +64,8 @@ namespace osu.Game.Rulesets.Osu.Mods
             /// </summary>
             private const float target_clamp = 1;
 
-            private readonly float targetBreakMultiplier = 0;
+            private readonly float targetBreakMultiplier;
-            private readonly float easing = 1;
+            private readonly float easing;
 
             private readonly CompositeDrawable restrictTo;
 
@@ -86,6 +86,9 @@ namespace osu.Game.Rulesets.Osu.Mods
             {
                 this.restrictTo = restrictTo;
                 this.beatmap = beatmap;
+
+                targetBreakMultiplier = 0;
+                easing = 1;
             }
 
             [BackgroundDependencyLoader]

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Performance;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;

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

@@ -821,15 +821,13 @@ namespace osu.Game.Tests.Beatmaps.IO
 
             var manager = osu.Dependencies.Get<BeatmapManager>();
 
-            await manager.Import(temp);
+            var importedSet = await manager.Import(temp);
-
-            var imported = manager.GetAllUsableBeatmapSets();
 
             ensureLoaded(osu);
 
             waitForOrAssert(() => !File.Exists(temp), "Temporary file still exists after standard import", 5000);
 
-            return imported.LastOrDefault();
+            return manager.GetAllUsableBeatmapSets().Find(beatmapSet => beatmapSet.ID == importedSet.ID);
         }
 
         private void deleteBeatmapSet(BeatmapSetInfo imported, OsuGameBase osu)

osu.Game.Tests/Gameplay/TestSceneHitObjectAccentColour.cs

@@ -81,8 +81,8 @@ namespace osu.Game.Tests.Gameplay
 
         private class TestHitObjectWithCombo : ConvertHitObject, IHasComboInformation
         {
-            public bool NewCombo { get; set; } = false;
+            public bool NewCombo { get; set; }
-            public int ComboOffset { get; } = 0;
+            public int ComboOffset => 0;
 
             public Bindable<int> IndexInCurrentComboBindable { get; } = new Bindable<int>();
 

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

@@ -0,0 +1,196 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Configuration;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Tests.Visual.Background
+{
+    public class TestSceneSeasonalBackgroundLoader : ScreenTestScene
+    {
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [Resolved]
+        private SessionStatics statics { get; set; }
+
+        [Cached(typeof(LargeTextureStore))]
+        private LookupLoggingTextureStore textureStore = new LookupLoggingTextureStore();
+
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
+
+        private SeasonalBackgroundLoader backgroundLoader;
+        private Container backgroundContainer;
+
+        // in real usages these would be online URLs, but correct execution of this test
+        // shouldn't be coupled to existence of online assets.
+        private static readonly List<string> seasonal_background_urls = new List<string>
+        {
+            "Backgrounds/bg2",
+            "Backgrounds/bg4",
+            "Backgrounds/bg3"
+        };
+
+        [BackgroundDependencyLoader]
+        private void load(LargeTextureStore wrappedStore)
+        {
+            textureStore.AddStore(wrappedStore);
+
+            Add(backgroundContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both
+            });
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            // reset API response in statics to avoid test crosstalk.
+            statics.Set<APISeasonalBackgrounds>(Static.SeasonalBackgrounds, null);
+            textureStore.PerformedLookups.Clear();
+            dummyAPI.SetState(APIState.Online);
+
+            backgroundContainer.Clear();
+        });
+
+        [TestCase(-5)]
+        [TestCase(5)]
+        public void TestAlwaysSeasonal(int daysOffset)
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(daysOffset));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Always);
+
+            createLoader();
+
+            for (int i = 0; i < 4; ++i)
+                loadNextBackground();
+
+            AddAssert("all backgrounds cycled", () => new HashSet<string>(textureStore.PerformedLookups).SetEquals(seasonal_background_urls));
+        }
+
+        [TestCase(-5)]
+        [TestCase(5)]
+        public void TestNeverSeasonal(int daysOffset)
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(daysOffset));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Never);
+
+            createLoader();
+
+            assertNoBackgrounds();
+        }
+
+        [Test]
+        public void TestSometimesInSeason()
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(5));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Sometimes);
+
+            createLoader();
+
+            assertAnyBackground();
+        }
+
+        [Test]
+        public void TestSometimesOutOfSeason()
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(-10));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Sometimes);
+
+            createLoader();
+
+            assertNoBackgrounds();
+        }
+
+        [Test]
+        public void TestDelayedConnectivity()
+        {
+            registerBackgroundsResponse(DateTimeOffset.Now.AddDays(30));
+            setSeasonalBackgroundMode(SeasonalBackgroundMode.Always);
+            AddStep("go offline", () => dummyAPI.SetState(APIState.Offline));
+
+            createLoader();
+            assertNoBackgrounds();
+
+            AddStep("go online", () => dummyAPI.SetState(APIState.Online));
+
+            assertAnyBackground();
+        }
+
+        private void registerBackgroundsResponse(DateTimeOffset endDate)
+            => AddStep("setup request handler", () =>
+            {
+                dummyAPI.HandleRequest = request =>
+                {
+                    if (dummyAPI.State.Value != APIState.Online || !(request is GetSeasonalBackgroundsRequest backgroundsRequest))
+                        return;
+
+                    backgroundsRequest.TriggerSuccess(new APISeasonalBackgrounds
+                    {
+                        Backgrounds = seasonal_background_urls.Select(url => new APISeasonalBackground { Url = url }).ToList(),
+                        EndDate = endDate
+                    });
+                };
+            });
+
+        private void setSeasonalBackgroundMode(SeasonalBackgroundMode mode)
+            => AddStep($"set seasonal mode to {mode}", () => config.Set(OsuSetting.SeasonalBackgroundMode, mode));
+
+        private void createLoader()
+            => AddStep("create loader", () =>
+            {
+                if (backgroundLoader != null)
+                    Remove(backgroundLoader);
+
+                Add(backgroundLoader = new SeasonalBackgroundLoader());
+            });
+
+        private void loadNextBackground()
+        {
+            SeasonalBackground background = null;
+
+            AddStep("create next background", () =>
+            {
+                background = backgroundLoader.LoadNextBackground();
+                LoadComponentAsync(background, bg => backgroundContainer.Child = bg);
+            });
+
+            AddUntilStep("background loaded", () => background.IsLoaded);
+        }
+
+        private void assertAnyBackground()
+        {
+            loadNextBackground();
+            AddAssert("background looked up", () => textureStore.PerformedLookups.Any());
+        }
+
+        private void assertNoBackgrounds()
+        {
+            AddAssert("no background available", () => backgroundLoader.LoadNextBackground() == null);
+            AddAssert("no lookups performed", () => !textureStore.PerformedLookups.Any());
+        }
+
+        private class LookupLoggingTextureStore : LargeTextureStore
+        {
+            public List<string> PerformedLookups { get; } = new List<string>();
+
+            public override Texture Get(string name, WrapMode wrapModeS, WrapMode wrapModeT)
+            {
+                PerformedLookups.Add(name);
+                return base.Get(name, wrapModeS, wrapModeT);
+            }
+        }
+    }
+}

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

@@ -2,29 +2,23 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Configuration;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Play;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneHUDOverlay : SkinnableTestScene
+    public class TestSceneHUDOverlay : OsuManualInputManagerTestScene
     {
         private HUDOverlay hudOverlay;
 
-        private IEnumerable<HUDOverlay> hudOverlays => CreatedDrawables.OfType<HUDOverlay>();
-
         // best way to check without exposing.
         private Drawable hideTarget => hudOverlay.KeyCounter;
         private FillFlowContainer<KeyCounter> keyCounterFlow => hudOverlay.KeyCounter.ChildrenOfType<FillFlowContainer<KeyCounter>>().First();
@@ -37,17 +31,9 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             createNew();
 
-            AddRepeatStep("increase combo", () =>
+            AddRepeatStep("increase combo", () => { hudOverlay.ComboCounter.Current.Value++; }, 10);
-            {
-                foreach (var hud in hudOverlays)
-                    hud.ComboCounter.Current.Value++;
-            }, 10);
 
-            AddStep("reset combo", () =>
+            AddStep("reset combo", () => { hudOverlay.ComboCounter.Current.Value = 0; });
-            {
-                foreach (var hud in hudOverlays)
-                    hud.ComboCounter.Current.Value = 0;
-            });
         }
 
         [Test]
@@ -77,7 +63,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             createNew();
 
-            AddStep("set showhud false", () => hudOverlays.ForEach(h => h.ShowHud.Value = false));
+            AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
 
             AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
             AddAssert("pause button is still visible", () => hudOverlay.HoldToQuit.IsPresent);
@@ -86,10 +72,32 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("key counter flow not affected", () => keyCounterFlow.IsPresent);
         }
 
+        [Test]
+        public void TestMomentaryShowHUD()
+        {
+            createNew();
+
+            HUDVisibilityMode originalConfigValue = HUDVisibilityMode.HideDuringGameplay;
+
+            AddStep("get original config value", () => originalConfigValue = config.Get<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode));
+
+            AddStep("set hud to never show", () => config.Set(OsuSetting.HUDVisibilityMode, HUDVisibilityMode.Never));
+
+            AddUntilStep("wait for fade", () => !hideTarget.IsPresent);
+
+            AddStep("trigger momentary show", () => InputManager.PressKey(Key.ControlLeft));
+            AddUntilStep("wait for visible", () => hideTarget.IsPresent);
+
+            AddStep("stop trigering", () => InputManager.ReleaseKey(Key.ControlLeft));
+            AddUntilStep("wait for fade", () => !hideTarget.IsPresent);
+
+            AddStep("set original config value", () => config.Set(OsuSetting.HUDVisibilityMode, originalConfigValue));
+        }
+
         [Test]
         public void TestExternalHideDoesntAffectConfig()
         {
-            HUDVisibilityMode originalConfigValue = HUDVisibilityMode.HideDuringBreaks;
+            HUDVisibilityMode originalConfigValue = HUDVisibilityMode.HideDuringGameplay;
 
             createNew();
 
@@ -113,14 +121,14 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("set keycounter visible false", () =>
             {
                 config.Set<bool>(OsuSetting.KeyOverlay, false);
-                hudOverlays.ForEach(h => h.KeyCounter.AlwaysVisible.Value = false);
+                hudOverlay.KeyCounter.AlwaysVisible.Value = false;
             });
 
-            AddStep("set showhud false", () => hudOverlays.ForEach(h => h.ShowHud.Value = false));
+            AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
             AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
             AddAssert("key counters hidden", () => !keyCounterFlow.IsPresent);
 
-            AddStep("set showhud true", () => hudOverlays.ForEach(h => h.ShowHud.Value = true));
+            AddStep("set showhud true", () => hudOverlay.ShowHud.Value = true);
             AddUntilStep("hidetarget is visible", () => hideTarget.IsPresent);
             AddAssert("key counters still hidden", () => !keyCounterFlow.IsPresent);
 
@@ -131,22 +139,17 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create overlay", () =>
             {
-                SetContents(() =>
+                hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
-                {
-                    hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
 
-                    // Add any key just to display the key counter visually.
+                // Add any key just to display the key counter visually.
-                    hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
+                hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
 
-                    hudOverlay.ComboCounter.Current.Value = 1;
+                hudOverlay.ComboCounter.Current.Value = 1;
 
-                    action?.Invoke(hudOverlay);
+                action?.Invoke(hudOverlay);
 
-                    return hudOverlay;
+                Child = hudOverlay;
-                });
             });
         }
-
-        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
     }
 }

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

@@ -0,0 +1,99 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Configuration;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableHUDOverlay : SkinnableTestScene
+    {
+        private HUDOverlay hudOverlay;
+
+        private IEnumerable<HUDOverlay> hudOverlays => CreatedDrawables.OfType<HUDOverlay>();
+
+        // best way to check without exposing.
+        private Drawable hideTarget => hudOverlay.KeyCounter;
+        private FillFlowContainer<KeyCounter> keyCounterFlow => hudOverlay.KeyCounter.ChildrenOfType<FillFlowContainer<KeyCounter>>().First();
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [Test]
+        public void TestComboCounterIncrementing()
+        {
+            createNew();
+
+            AddRepeatStep("increase combo", () =>
+            {
+                foreach (var hud in hudOverlays)
+                    hud.ComboCounter.Current.Value++;
+            }, 10);
+
+            AddStep("reset combo", () =>
+            {
+                foreach (var hud in hudOverlays)
+                    hud.ComboCounter.Current.Value = 0;
+            });
+        }
+
+        [Test]
+        public void TestFadesInOnLoadComplete()
+        {
+            float? initialAlpha = null;
+
+            createNew(h => h.OnLoadComplete += _ => initialAlpha = hideTarget.Alpha);
+            AddUntilStep("wait for load", () => hudOverlay.IsAlive);
+            AddAssert("initial alpha was less than 1", () => initialAlpha < 1);
+        }
+
+        [Test]
+        public void TestHideExternally()
+        {
+            createNew();
+
+            AddStep("set showhud false", () => hudOverlays.ForEach(h => h.ShowHud.Value = false));
+
+            AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
+            AddAssert("pause button is still visible", () => hudOverlay.HoldToQuit.IsPresent);
+
+            // Key counter flow container should not be affected by this, only the key counter display will be hidden as checked above.
+            AddAssert("key counter flow not affected", () => keyCounterFlow.IsPresent);
+        }
+
+        private void createNew(Action<HUDOverlay> action = null)
+        {
+            AddStep("create overlay", () =>
+            {
+                SetContents(() =>
+                {
+                    hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
+
+                    // Add any key just to display the key counter visually.
+                    hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
+
+                    hudOverlay.ComboCounter.Current.Value = 1;
+
+                    action?.Invoke(hudOverlay);
+
+                    return hudOverlay;
+                });
+            });
+        }
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+    }
+}

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

@@ -135,7 +135,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             public Bindable<bool> InitialRoomsReceived { get; } = new Bindable<bool>(true);
 
-            public IBindableList<Room> Rooms { get; } = null;
+            public IBindableList<Room> Rooms => null;
 
             public void CreateRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null)
             {

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

@@ -103,7 +103,7 @@ namespace osu.Game.Tests.Visual.Ranking
 
         private void addPanelStep(ScoreInfo score, PanelState state = PanelState.Expanded) => AddStep("add panel", () =>
         {
-            Child = panel = new ScorePanel(score)
+            Child = panel = new ScorePanel(score, true)
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,

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

@@ -197,8 +197,8 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private class TestHitObject : ConvertHitObject, IHasPosition
         {
-            public float X { get; } = 0;
+            public float X => 0;
-            public float Y { get; } = 0;
+            public float Y => 0;
             public Vector2 Position { get; } = Vector2.Zero;
         }
     }

osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs

@@ -417,7 +417,7 @@ namespace osu.Game.Beatmaps.Formats
                 string sampleFilename = samples.FirstOrDefault(s => string.IsNullOrEmpty(s.Name))?.LookupNames.First() ?? string.Empty;
                 int volume = samples.FirstOrDefault()?.Volume ?? 100;
 
-                sb.Append(":");
+                sb.Append(':');
                 sb.Append(FormattableString.Invariant($"{customSampleBank}:"));
                 sb.Append(FormattableString.Invariant($"{volume}:"));
                 sb.Append(FormattableString.Invariant($"{sampleFilename}"));

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -347,7 +347,7 @@ namespace osu.Game.Beatmaps.Formats
         /// <param name="line">The line which may contains variables.</param>
         private void decodeVariables(ref string line)
         {
-            while (line.IndexOf('$') >= 0)
+            while (line.Contains('$'))
             {
                 string origLine = line;
 

osu.Game/Configuration/HUDVisibilityMode.cs

@@ -12,9 +12,6 @@ namespace osu.Game.Configuration
         [Description("Hide during gameplay")]
         HideDuringGameplay,
 
-        [Description("Hide during breaks")]
-        HideDuringBreaks,
-
         Always
     }
 }

osu.Game/Configuration/OsuConfigManager.cs

@@ -131,6 +131,7 @@ namespace osu.Game.Configuration
             Set(OsuSetting.IntroSequence, IntroSequence.Triangles);
 
             Set(OsuSetting.MenuBackgroundSource, BackgroundSource.Skin);
+            Set(OsuSetting.SeasonalBackgroundMode, SeasonalBackgroundMode.Sometimes);
         }
 
         public OsuConfigManager(Storage storage)
@@ -170,6 +171,7 @@ namespace osu.Game.Configuration
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
         {
             new TrackedSetting<bool>(OsuSetting.MouseDisableButtons, v => new SettingDescription(!v, "gameplay mouse buttons", v ? "disabled" : "enabled")),
+            new TrackedSetting<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode, m => new SettingDescription(m, "HUD Visibility", m.GetDescription())),
             new TrackedSetting<ScalingMode>(OsuSetting.Scaling, m => new SettingDescription(m, "scaling", m.GetDescription())),
         };
     }
@@ -239,5 +241,6 @@ namespace osu.Game.Configuration
         HitLighting,
         MenuBackgroundSource,
         GameplayDisableWinKey,
+        SeasonalBackgroundMode
     }
 }

osu.Game/Configuration/SeasonalBackgroundMode.cs

@@ -0,0 +1,23 @@
+// 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.
+
+namespace osu.Game.Configuration
+{
+    public enum SeasonalBackgroundMode
+    {
+        /// <summary>
+        /// Seasonal backgrounds are shown regardless of season, if at all available.
+        /// </summary>
+        Always,
+
+        /// <summary>
+        /// Seasonal backgrounds are shown only during their corresponding season.
+        /// </summary>
+        Sometimes,
+
+        /// <summary>
+        /// Seasonal backgrounds are never shown.
+        /// </summary>
+        Never
+    }
+}

osu.Game/Configuration/SessionStatics.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Online.API.Requests.Responses;
+
 namespace osu.Game.Configuration
 {
     /// <summary>
@@ -12,12 +14,19 @@ namespace osu.Game.Configuration
         {
             Set(Static.LoginOverlayDisplayed, false);
             Set(Static.MutedAudioNotificationShownOnce, false);
+            Set<APISeasonalBackgrounds>(Static.SeasonalBackgrounds, null);
         }
     }
 
     public enum Static
     {
         LoginOverlayDisplayed,
-        MutedAudioNotificationShownOnce
+        MutedAudioNotificationShownOnce,
+
+        /// <summary>
+        /// Info about seasonal backgrounds available fetched from API - see <see cref="APISeasonalBackgrounds"/>.
+        /// Value under this lookup can be <c>null</c> if there are no backgrounds available (or API is not reachable).
+        /// </summary>
+        SeasonalBackgrounds,
     }
 }

osu.Game/Database/DatabaseWriteUsage.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Database
         /// Whether this write usage will commit a transaction on completion.
         /// If false, there is a parent usage responsible for transaction commit.
         /// </summary>
-        public bool IsTransactionLeader = false;
+        public bool IsTransactionLeader;
 
         protected void Dispose(bool disposing)
         {

osu.Game/Graphics/Backgrounds/SeasonalBackgroundLoader.cs

@@ -0,0 +1,103 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Graphics.Backgrounds
+{
+    public class SeasonalBackgroundLoader : Component
+    {
+        /// <summary>
+        /// Fired when background should be changed due to receiving backgrounds from API
+        /// or when the user setting is changed (as it might require unloading the seasonal background).
+        /// </summary>
+        public event Action SeasonalBackgroundChanged;
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        private readonly IBindable<APIState> apiState = new Bindable<APIState>();
+        private Bindable<SeasonalBackgroundMode> seasonalBackgroundMode;
+        private Bindable<APISeasonalBackgrounds> seasonalBackgrounds;
+
+        private int current;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config, SessionStatics sessionStatics)
+        {
+            seasonalBackgroundMode = config.GetBindable<SeasonalBackgroundMode>(OsuSetting.SeasonalBackgroundMode);
+            seasonalBackgroundMode.BindValueChanged(_ => SeasonalBackgroundChanged?.Invoke());
+
+            seasonalBackgrounds = sessionStatics.GetBindable<APISeasonalBackgrounds>(Static.SeasonalBackgrounds);
+            seasonalBackgrounds.BindValueChanged(_ => SeasonalBackgroundChanged?.Invoke());
+
+            apiState.BindTo(api.State);
+            apiState.BindValueChanged(fetchSeasonalBackgrounds, true);
+        }
+
+        private void fetchSeasonalBackgrounds(ValueChangedEvent<APIState> stateChanged)
+        {
+            if (seasonalBackgrounds.Value != null || stateChanged.NewValue != APIState.Online)
+                return;
+
+            var request = new GetSeasonalBackgroundsRequest();
+            request.Success += response =>
+            {
+                seasonalBackgrounds.Value = response;
+                current = RNG.Next(0, response.Backgrounds?.Count ?? 0);
+            };
+
+            api.PerformAsync(request);
+        }
+
+        public SeasonalBackground LoadNextBackground()
+        {
+            if (seasonalBackgroundMode.Value == SeasonalBackgroundMode.Never
+                || (seasonalBackgroundMode.Value == SeasonalBackgroundMode.Sometimes && !isInSeason))
+            {
+                return null;
+            }
+
+            var backgrounds = seasonalBackgrounds.Value?.Backgrounds;
+            if (backgrounds == null || !backgrounds.Any())
+                return null;
+
+            current = (current + 1) % backgrounds.Count;
+            string url = backgrounds[current].Url;
+
+            return new SeasonalBackground(url);
+        }
+
+        private bool isInSeason => seasonalBackgrounds.Value != null && DateTimeOffset.Now < seasonalBackgrounds.Value.EndDate;
+    }
+
+    [LongRunningLoad]
+    public class SeasonalBackground : Background
+    {
+        private readonly string url;
+        private const string fallback_texture_name = @"Backgrounds/bg1";
+
+        public SeasonalBackground(string url)
+        {
+            this.url = url;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(LargeTextureStore textures)
+        {
+            Sprite.Texture = textures.Get(url) ?? textures.Get(fallback_texture_name);
+            // ensure we're not loading in without a transition.
+            this.FadeInFromZero(200, Easing.InOutSine);
+        }
+    }
+}

osu.Game/Graphics/Containers/OsuScrollContainer.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Graphics.Containers
         /// Allows controlling the scroll bar from any position in the container using the right mouse button.
         /// Uses the value of <see cref="DistanceDecayOnRightMouseScrollbar"/> to smoothly scroll to the dragged location.
         /// </summary>
-        public bool RightMouseScrollbar = false;
+        public bool RightMouseScrollbar;
 
         /// <summary>
         /// Controls the rate with which the target position is approached when performing a relative drag. Default is 0.02.

osu.Game/IO/Archives/ArchiveReader.cs

@@ -41,7 +41,7 @@ namespace osu.Game.IO.Archives
                     return null;
 
                 byte[] buffer = new byte[input.Length];
-                await input.ReadAsync(buffer, 0, buffer.Length);
+                await input.ReadAsync(buffer);
                 return buffer;
             }
         }

osu.Game/Input/Bindings/GlobalActionContainer.cs

@@ -67,6 +67,7 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(new[] { InputKey.Control, InputKey.Plus }, GlobalAction.IncreaseScrollSpeed),
             new KeyBinding(new[] { InputKey.Control, InputKey.Minus }, GlobalAction.DecreaseScrollSpeed),
             new KeyBinding(InputKey.MouseMiddle, GlobalAction.PauseGameplay),
+            new KeyBinding(InputKey.Control, GlobalAction.HoldForHUD),
         };
 
         public IEnumerable<KeyBinding> AudioControlKeyBindings => new[]
@@ -187,5 +188,8 @@ namespace osu.Game.Input.Bindings
 
         [Description("Timing Mode")]
         EditorTimingMode,
+
+        [Description("Hold for HUD")]
+        HoldForHUD,
     }
 }

osu.Game/Online/API/Requests/GetSeasonalBackgroundsRequest.cs

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetSeasonalBackgroundsRequest : APIRequest<APISeasonalBackgrounds>
+    {
+        protected override string Target => @"seasonal-backgrounds";
+    }
+}

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

@@ -0,0 +1,24 @@
+// 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 Newtonsoft.Json;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APISeasonalBackgrounds
+    {
+        [JsonProperty("ends_at")]
+        public DateTimeOffset EndDate;
+
+        [JsonProperty("backgrounds")]
+        public List<APISeasonalBackground> Backgrounds { get; set; }
+    }
+
+    public class APISeasonalBackground
+    {
+        [JsonProperty("url")]
+        public string Url { get; set; }
+    }
+}

osu.Game/Overlays/Settings/Sections/Audio/MainMenuSettings.cs

@@ -39,6 +39,12 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
                     LabelText = "Background source",
                     Current = config.GetBindable<BackgroundSource>(OsuSetting.MenuBackgroundSource),
                     Items = Enum.GetValues(typeof(BackgroundSource)).Cast<BackgroundSource>()
+                },
+                new SettingsDropdown<SeasonalBackgroundMode>
+                {
+                    LabelText = "Seasonal backgrounds",
+                    Current = config.GetBindable<SeasonalBackgroundMode>(OsuSetting.SeasonalBackgroundMode),
+                    Items = Enum.GetValues(typeof(SeasonalBackgroundMode)).Cast<SeasonalBackgroundMode>()
                 }
             };
         }

osu.Game/Rulesets/Replays/FramedReplayInputHandler.cs

@@ -80,7 +80,7 @@ namespace osu.Game.Rulesets.Replays
         /// When set, we will ensure frames executed by nested drawables are frame-accurate to replay data.
         /// Disabling this can make replay playback smoother (useful for autoplay, currently).
         /// </summary>
-        public bool FrameAccuratePlayback = false;
+        public bool FrameAccuratePlayback;
 
         protected bool HasFrames => Frames.Count > 0;
 

osu.Game/Rulesets/UI/HitObjectContainer.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Performance;
 using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.UI

osu.Game/Screens/Backgrounds/BackgroundScreenDefault.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.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -25,6 +26,7 @@ namespace osu.Game.Screens.Backgrounds
         private Bindable<Skin> skin;
         private Bindable<BackgroundSource> mode;
         private Bindable<IntroSequence> introSequence;
+        private readonly SeasonalBackgroundLoader seasonalBackgroundLoader = new SeasonalBackgroundLoader();
 
         [Resolved]
         private IBindable<WorkingBeatmap> beatmap { get; set; }
@@ -42,15 +44,18 @@ namespace osu.Game.Screens.Backgrounds
             mode = config.GetBindable<BackgroundSource>(OsuSetting.MenuBackgroundSource);
             introSequence = config.GetBindable<IntroSequence>(OsuSetting.IntroSequence);
 
+            AddInternal(seasonalBackgroundLoader);
+
             user.ValueChanged += _ => Next();
             skin.ValueChanged += _ => Next();
             mode.ValueChanged += _ => Next();
             beatmap.ValueChanged += _ => Next();
             introSequence.ValueChanged += _ => Next();
+            seasonalBackgroundLoader.SeasonalBackgroundChanged += Next;
 
             currentDisplay = RNG.Next(0, background_count);
 
-            display(createBackground());
+            Next();
         }
 
         private void display(Background newBackground)
@@ -63,11 +68,14 @@ namespace osu.Game.Screens.Backgrounds
         }
 
         private ScheduledDelegate nextTask;
+        private CancellationTokenSource cancellationTokenSource;
 
         public void Next()
         {
             nextTask?.Cancel();
-            nextTask = Scheduler.AddDelayed(() => { LoadComponentAsync(createBackground(), display); }, 100);
+            cancellationTokenSource?.Cancel();
+            cancellationTokenSource = new CancellationTokenSource();
+            nextTask = Scheduler.AddDelayed(() => LoadComponentAsync(createBackground(), display, cancellationTokenSource.Token), 100);
         }
 
         private Background createBackground()
@@ -75,6 +83,14 @@ namespace osu.Game.Screens.Backgrounds
             Background newBackground;
             string backgroundName;
 
+            var seasonalBackground = seasonalBackgroundLoader.LoadNextBackground();
+
+            if (seasonalBackground != null)
+            {
+                seasonalBackground.Depth = currentDisplay;
+                return seasonalBackground;
+            }
+
             switch (introSequence.Value)
             {
                 case IntroSequence.Welcome:

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

@@ -210,10 +210,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
 
             if (DragBox.State == Visibility.Visible)
-            {
                 DragBox.Hide();
-                SelectionHandler.UpdateVisibility();
-            }
         }
 
         protected override bool OnKeyDown(KeyDownEvent e)
@@ -352,11 +349,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <summary>
         /// Selects all <see cref="SelectionBlueprint"/>s.
         /// </summary>
-        private void selectAll()
+        private void selectAll() => SelectionBlueprints.ToList().ForEach(m => m.Select());
-        {
-            SelectionBlueprints.ToList().ForEach(m => m.Select());
-            SelectionHandler.UpdateVisibility();
-        }
 
         /// <summary>
         /// Deselects all selected <see cref="SelectionBlueprint"/>s.

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

@@ -201,8 +201,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
             // there are potentially multiple SelectionHandlers active, but we only want to add hitobjects to the selected list once.
             if (!EditorBeatmap.SelectedHitObjects.Contains(blueprint.HitObject))
                 EditorBeatmap.SelectedHitObjects.Add(blueprint.HitObject);
-
-            UpdateVisibility();
         }
 
         /// <summary>
@@ -214,8 +212,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
             selectedBlueprints.Remove(blueprint);
 
             EditorBeatmap.SelectedHitObjects.Remove(blueprint.HitObject);
-
-            UpdateVisibility();
         }
 
         /// <summary>
@@ -226,13 +222,21 @@ namespace osu.Game.Screens.Edit.Compose.Components
         internal void HandleSelectionRequested(SelectionBlueprint blueprint, InputState state)
         {
             if (state.Keyboard.ShiftPressed && state.Mouse.IsPressed(MouseButton.Right))
-                EditorBeatmap.Remove(blueprint.HitObject);
+                handleQuickDeletion(blueprint);
             else if (state.Keyboard.ControlPressed && state.Mouse.IsPressed(MouseButton.Left))
                 blueprint.ToggleSelection();
             else
                 ensureSelected(blueprint);
         }
 
+        private void handleQuickDeletion(SelectionBlueprint blueprint)
+        {
+            if (!blueprint.IsSelected)
+                EditorBeatmap.Remove(blueprint.HitObject);
+            else
+                deleteSelected();
+        }
+
         private void ensureSelected(SelectionBlueprint blueprint)
         {
             if (blueprint.IsSelected)
@@ -254,23 +258,18 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <summary>
         /// Updates whether this <see cref="SelectionHandler"/> is visible.
         /// </summary>
-        internal void UpdateVisibility()
+        private void updateVisibility()
         {
             int count = selectedBlueprints.Count;
 
             selectionDetailsText.Text = count > 0 ? count.ToString() : string.Empty;
 
-            if (count > 0)
+            this.FadeTo(count > 0 ? 1 : 0);
-            {
+            OnSelectionChanged();
-                Show();
-                OnSelectionChanged();
-            }
-            else
-                Hide();
         }
 
         /// <summary>
-        /// Triggered whenever more than one object is selected, on each change.
+        /// Triggered whenever the set of selected objects changes.
         /// Should update the selection box's state to match supported operations.
         /// </summary>
         protected virtual void OnSelectionChanged()
@@ -421,7 +420,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             // bring in updates from selection changes
             EditorBeatmap.HitObjectUpdated += _ => UpdateTernaryStates();
-            EditorBeatmap.SelectedHitObjects.CollectionChanged += (sender, args) => UpdateTernaryStates();
+            EditorBeatmap.SelectedHitObjects.CollectionChanged += (sender, args) =>
+            {
+                Scheduler.AddOnce(updateVisibility);
+                UpdateTernaryStates();
+            };
         }
 
         /// <summary>

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs

@@ -9,10 +9,10 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
-using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Screens.Edit.Compose.Components.Timeline
@@ -137,8 +137,14 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private class TimelineDragBox : DragBox
         {
-            private Vector2 lastMouseDown;
+            // the following values hold the start and end X positions of the drag box in the timeline's local space,
-            private float localMouseDown;
+            // but with zoom unapplied in order to be able to compensate for positional changes
+            // while the timeline is being zoomed in/out.
+            private float? selectionStart;
+            private float selectionEnd;
+
+            [Resolved]
+            private Timeline timeline { get; set; }
 
             public TimelineDragBox(Action<RectangleF> performSelect)
                 : base(performSelect)
@@ -153,21 +159,34 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
             public override bool HandleDrag(MouseButtonEvent e)
             {
-                // store the original position of the mouse down, as we may be scrolled during selection.
+                selectionStart ??= e.MouseDownPosition.X / timeline.CurrentZoom;
-                if (lastMouseDown != e.ScreenSpaceMouseDownPosition)
-                {
-                    lastMouseDown = e.ScreenSpaceMouseDownPosition;
-                    localMouseDown = e.MouseDownPosition.X;
-                }
 
-                float selection1 = localMouseDown;
+                // only calculate end when a transition is not in progress to avoid bouncing.
-                float selection2 = e.MousePosition.X;
+                if (Precision.AlmostEquals(timeline.CurrentZoom, timeline.Zoom))
+                    selectionEnd = e.MousePosition.X / timeline.CurrentZoom;
 
-                Box.X = Math.Min(selection1, selection2);
+                updateDragBoxPosition();
-                Box.Width = Math.Abs(selection1 - selection2);
+                return true;
+            }
+
+            private void updateDragBoxPosition()
+            {
+                if (selectionStart == null)
+                    return;
+
+                float rescaledStart = selectionStart.Value * timeline.CurrentZoom;
+                float rescaledEnd = selectionEnd * timeline.CurrentZoom;
+
+                Box.X = Math.Min(rescaledStart, rescaledEnd);
+                Box.Width = Math.Abs(rescaledStart - rescaledEnd);
 
                 PerformSelection?.Invoke(Box.ScreenSpaceDrawQuad.AABBFloat);
-                return true;
+            }
+
+            public override void Hide()
+            {
+                base.Hide();
+                selectionStart = null;
             }
         }
 

osu.Game/Screens/Edit/Compose/Components/Timeline/ZoomableScrollContainer.cs

@@ -29,9 +29,14 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private readonly Container zoomedContent;
         protected override Container<Drawable> Content => zoomedContent;
-
         private float currentZoom = 1;
 
+        /// <summary>
+        /// The current zoom level of <see cref="ZoomableScrollContainer" />.
+        /// It may differ from <see cref="Zoom" /> during transitions.
+        /// </summary>
+        public float CurrentZoom => currentZoom;
+
         [Resolved(canBeNull: true)]
         private IFrameBasedClock editorClock { get; set; }
 

osu.Game/Screens/Multi/Lounge/Components/RoomsContainer.cs

@@ -84,7 +84,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
                     matchingFilter &= r.Room.Playlist.Count == 0 || r.Room.Playlist.Any(i => i.Ruleset.Value.Equals(criteria.Ruleset));
 
                     if (!string.IsNullOrEmpty(criteria.SearchString))
-                        matchingFilter &= r.FilterTerms.Any(term => term.IndexOf(criteria.SearchString, StringComparison.InvariantCultureIgnoreCase) >= 0);
+                        matchingFilter &= r.FilterTerms.Any(term => term.Contains(criteria.SearchString, StringComparison.InvariantCultureIgnoreCase));
 
                     r.MatchingFilter = matchingFilter;
                 }

osu.Game/Screens/Play/HUDOverlay.cs

@@ -8,8 +8,10 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Configuration;
+using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets.Mods;
@@ -22,7 +24,7 @@ using osuTK.Input;
 namespace osu.Game.Screens.Play
 {
     [Cached]
-    public class HUDOverlay : Container
+    public class HUDOverlay : Container, IKeyBindingHandler<GlobalAction>
     {
         public const float FADE_DURATION = 400;
 
@@ -67,6 +69,8 @@ namespace osu.Game.Screens.Play
 
         internal readonly IBindable<bool> IsBreakTime = new Bindable<bool>();
 
+        private bool holdingForHUD;
+
         private IEnumerable<Drawable> hideTargets => new Drawable[] { visibilityContainer, KeyCounter };
 
         public HUDOverlay(ScoreProcessor scoreProcessor, HealthProcessor healthProcessor, DrawableRuleset drawableRuleset, IReadOnlyList<Mod> mods)
@@ -217,17 +221,18 @@ namespace osu.Game.Screens.Play
             if (ShowHud.Disabled)
                 return;
 
+            if (holdingForHUD)
+            {
+                ShowHud.Value = true;
+                return;
+            }
+
             switch (configVisibilityMode.Value)
             {
                 case HUDVisibilityMode.Never:
                     ShowHud.Value = false;
                     break;
 
-                case HUDVisibilityMode.HideDuringBreaks:
-                    // always show during replay as we want the seek bar to be visible.
-                    ShowHud.Value = replayLoaded.Value || !IsBreakTime.Value;
-                    break;
-
                 case HUDVisibilityMode.HideDuringGameplay:
                     // always show during replay as we want the seek bar to be visible.
                     ShowHud.Value = replayLoaded.Value || IsBreakTime.Value;
@@ -277,9 +282,21 @@ namespace osu.Game.Screens.Play
                 switch (e.Key)
                 {
                     case Key.Tab:
-                        configVisibilityMode.Value = configVisibilityMode.Value != HUDVisibilityMode.Never
+                        switch (configVisibilityMode.Value)
-                            ? HUDVisibilityMode.Never
+                        {
-                            : HUDVisibilityMode.HideDuringGameplay;
+                            case HUDVisibilityMode.Never:
+                                configVisibilityMode.Value = HUDVisibilityMode.HideDuringGameplay;
+                                break;
+
+                            case HUDVisibilityMode.HideDuringGameplay:
+                                configVisibilityMode.Value = HUDVisibilityMode.Always;
+                                break;
+
+                            case HUDVisibilityMode.Always:
+                                configVisibilityMode.Value = HUDVisibilityMode.Never;
+                                break;
+                        }
+
                         return true;
                 }
             }
@@ -351,5 +368,29 @@ namespace osu.Game.Screens.Play
             HealthDisplay?.BindHealthProcessor(processor);
             FailingLayer?.BindHealthProcessor(processor);
         }
+
+        public bool OnPressed(GlobalAction action)
+        {
+            switch (action)
+            {
+                case GlobalAction.HoldForHUD:
+                    holdingForHUD = true;
+                    updateVisibility();
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(GlobalAction action)
+        {
+            switch (action)
+            {
+                case GlobalAction.HoldForHUD:
+                    holdingForHUD = false;
+                    updateVisibility();
+                    break;
+            }
+        }
     }
 }

osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs

@@ -29,6 +29,8 @@ namespace osu.Game.Screens.Ranking.Expanded
         private const float padding = 10;
 
         private readonly ScoreInfo score;
+        private readonly bool withFlair;
+
         private readonly List<StatisticDisplay> statisticDisplays = new List<StatisticDisplay>();
 
         private FillFlowContainer starAndModDisplay;
@@ -41,9 +43,11 @@ namespace osu.Game.Screens.Ranking.Expanded
         /// Creates a new <see cref="ExpandedPanelMiddleContent"/>.
         /// </summary>
         /// <param name="score">The score to display.</param>
-        public ExpandedPanelMiddleContent(ScoreInfo score)
+        /// <param name="withFlair">Whether to add flair for a new score being set.</param>
+        public ExpandedPanelMiddleContent(ScoreInfo score, bool withFlair = false)
         {
             this.score = score;
+            this.withFlair = withFlair;
 
             RelativeSizeAxes = Axes.Both;
             Masking = true;
@@ -266,6 +270,9 @@ namespace osu.Game.Screens.Ranking.Expanded
                         delay += 200;
                     }
                 }
+
+                if (!withFlair)
+                    FinishTransforms(true);
             });
         }
     }

osu.Game/Screens/Ranking/ResultsScreen.cs

@@ -149,7 +149,7 @@ namespace osu.Game.Screens.Ranking
             };
 
             if (Score != null)
-                ScorePanelList.AddScore(Score);
+                ScorePanelList.AddScore(Score, true);
 
             if (player != null && allowRetry)
             {

osu.Game/Screens/Ranking/ScorePanel.cs

@@ -85,6 +85,8 @@ namespace osu.Game.Screens.Ranking
 
         public readonly ScoreInfo Score;
 
+        private bool displayWithFlair;
+
         private Container content;
 
         private Container topLayerContainer;
@@ -97,9 +99,10 @@ namespace osu.Game.Screens.Ranking
         private Container middleLayerContentContainer;
         private Drawable middleLayerContent;
 
-        public ScorePanel(ScoreInfo score)
+        public ScorePanel(ScoreInfo score, bool isNewLocalScore = false)
         {
             Score = score;
+            displayWithFlair = isNewLocalScore;
         }
 
         [BackgroundDependencyLoader]
@@ -188,7 +191,7 @@ namespace osu.Game.Screens.Ranking
 
                 state = value;
 
-                if (LoadState >= LoadState.Ready)
+                if (IsLoaded)
                     updateState();
 
                 StateChanged?.Invoke(value);
@@ -209,7 +212,10 @@ namespace osu.Game.Screens.Ranking
                     middleLayerBackground.FadeColour(expanded_middle_layer_colour, resize_duration, Easing.OutQuint);
 
                     topLayerContentContainer.Add(topLayerContent = new ExpandedPanelTopContent(Score.User).With(d => d.Alpha = 0));
-                    middleLayerContentContainer.Add(middleLayerContent = new ExpandedPanelMiddleContent(Score).With(d => d.Alpha = 0));
+                    middleLayerContentContainer.Add(middleLayerContent = new ExpandedPanelMiddleContent(Score, displayWithFlair).With(d => d.Alpha = 0));
+
+                    // only the first expanded display should happen with flair.
+                    displayWithFlair = false;
                     break;
 
                 case PanelState.Contracted:

osu.Game/Screens/Ranking/ScorePanelList.cs

@@ -95,9 +95,10 @@ namespace osu.Game.Screens.Ranking
         /// Adds a <see cref="ScoreInfo"/> to this list.
         /// </summary>
         /// <param name="score">The <see cref="ScoreInfo"/> to add.</param>
-        public ScorePanel AddScore(ScoreInfo score)
+        /// <param name="isNewLocalScore">Whether this is a score that has just been achieved locally. Controls whether flair is added to the display or not.</param>
+        public ScorePanel AddScore(ScoreInfo score, bool isNewLocalScore = false)
         {
-            var panel = new ScorePanel(score)
+            var panel = new ScorePanel(score, isNewLocalScore)
             {
                 Anchor = Anchor.CentreLeft,
                 Origin = Anchor.CentreLeft,
@@ -117,19 +118,24 @@ namespace osu.Game.Screens.Ranking
                 d.Origin = Anchor.Centre;
             }));
 
-            if (SelectedScore.Value == score)
+            if (IsLoaded)
-                selectedScoreChanged(new ValueChangedEvent<ScoreInfo>(SelectedScore.Value, SelectedScore.Value));
-            else
             {
-                // We want the scroll position to remain relative to the expanded panel. When a new panel is added after the expanded panel, nothing needs to be done.
+                if (SelectedScore.Value == score)
-                // But when a panel is added before the expanded panel, we need to offset the scroll position by the width of the new panel.
-                if (expandedPanel != null && flow.GetPanelIndex(score) < flow.GetPanelIndex(expandedPanel.Score))
                 {
-                    // A somewhat hacky property is used here because we need to:
+                    SelectedScore.TriggerChange();
-                    // 1) Scroll after the scroll container's visible range is updated.
+                }
-                    // 2) Scroll before the scroll container's scroll position is updated.
+                else
-                    // Without this, we would have a 1-frame positioning error which looks very jarring.
+                {
-                    scroll.InstantScrollTarget = (scroll.InstantScrollTarget ?? scroll.Target) + ScorePanel.CONTRACTED_WIDTH + panel_spacing;
+                    // We want the scroll position to remain relative to the expanded panel. When a new panel is added after the expanded panel, nothing needs to be done.
+                    // But when a panel is added before the expanded panel, we need to offset the scroll position by the width of the new panel.
+                    if (expandedPanel != null && flow.GetPanelIndex(score) < flow.GetPanelIndex(expandedPanel.Score))
+                    {
+                        // A somewhat hacky property is used here because we need to:
+                        // 1) Scroll after the scroll container's visible range is updated.
+                        // 2) Scroll before the scroll container's scroll position is updated.
+                        // Without this, we would have a 1-frame positioning error which looks very jarring.
+                        scroll.InstantScrollTarget = (scroll.InstantScrollTarget ?? scroll.Target) + ScorePanel.CONTRACTED_WIDTH + panel_spacing;
+                    }
                 }
             }
 
@@ -142,11 +148,15 @@ namespace osu.Game.Screens.Ranking
         /// <param name="score">The <see cref="ScoreInfo"/> to present.</param>
         private void selectedScoreChanged(ValueChangedEvent<ScoreInfo> score)
         {
-            // Contract the old panel.
+            // avoid contracting panels unnecessarily when TriggerChange is fired manually.
-            foreach (var t in flow.Where(t => t.Panel.Score == score.OldValue))
+            if (score.OldValue != score.NewValue)
             {
-                t.Panel.State = PanelState.Contracted;
+                // Contract the old panel.
-                t.Margin = new MarginPadding();
+                foreach (var t in flow.Where(t => t.Panel.Score == score.OldValue))
+                {
+                    t.Panel.State = PanelState.Contracted;
+                    t.Margin = new MarginPadding();
+                }
             }
 
             // Find the panel corresponding to the new score.
@@ -162,12 +172,16 @@ namespace osu.Game.Screens.Ranking
             expandedTrackingComponent.Margin = new MarginPadding { Horizontal = expanded_panel_spacing };
             expandedPanel.State = PanelState.Expanded;
 
-            // Scroll to the new panel. This is done manually since we need:
+            // requires schedule after children to ensure the flow (and thus ScrollContainer's ScrollableExtent) has been updated.
-            // 1) To scroll after the scroll container's visible range is updated.
+            ScheduleAfterChildren(() =>
-            // 2) To account for the centre anchor/origins of panels.
+            {
-            // In the end, it's easier to compute the scroll position manually.
+                // Scroll to the new panel. This is done manually since we need:
-            float scrollOffset = flow.GetPanelIndex(expandedPanel.Score) * (ScorePanel.CONTRACTED_WIDTH + panel_spacing);
+                // 1) To scroll after the scroll container's visible range is updated.
-            scroll.ScrollTo(scrollOffset);
+                // 2) To account for the centre anchor/origins of panels.
+                // In the end, it's easier to compute the scroll position manually.
+                float scrollOffset = flow.GetPanelIndex(expandedPanel.Score) * (ScorePanel.CONTRACTED_WIDTH + panel_spacing);
+                scroll.ScrollTo(scrollOffset);
+            });
         }
 
         protected override void Update()

osu.Game/Screens/Select/BeatmapDetails.cs

@@ -300,6 +300,7 @@ namespace osu.Game.Screens.Select
 
             public MetadataSection(string title)
             {
+                Alpha = 0;
                 RelativeSizeAxes = Axes.X;
                 AutoSizeAxes = Axes.Y;
 

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

@@ -59,7 +59,7 @@ namespace osu.Game.Screens.Select.Carousel
                 var terms = Beatmap.SearchableTerms;
 
                 foreach (var criteriaTerm in criteria.SearchTerms)
-                    match &= terms.Any(term => term.IndexOf(criteriaTerm, StringComparison.InvariantCultureIgnoreCase) >= 0);
+                    match &= terms.Any(term => term.Contains(criteriaTerm, StringComparison.InvariantCultureIgnoreCase));
 
                 // if a match wasn't found via text matching of terms, do a second catch-all check matching against online IDs.
                 // this should be done after text matching so we can prioritise matching numbers in metadata.

osu.Game/Screens/Select/FilterCriteria.cs

@@ -126,7 +126,7 @@ namespace osu.Game.Screens.Select
                 if (string.IsNullOrEmpty(value))
                     return false;
 
-                return value.IndexOf(SearchTerm, StringComparison.InvariantCultureIgnoreCase) >= 0;
+                return value.Contains(SearchTerm, StringComparison.InvariantCultureIgnoreCase);
             }
 
             public string SearchTerm;

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -32,11 +32,7 @@ namespace osu.Game.Screens.Select
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            BeatmapOptions.AddButton(@"Edit", @"beatmap", FontAwesome.Solid.PencilAlt, colours.Yellow, () =>
+            BeatmapOptions.AddButton(@"Edit", @"beatmap", FontAwesome.Solid.PencilAlt, colours.Yellow, () => Edit());
-            {
-                ValidForResume = false;
-                Edit();
-            });
 
             ((PlayBeatmapDetailArea)BeatmapDetails).Leaderboard.ScoreSelected += PresentScore;
         }

osu.Game/Tests/Beatmaps/HitObjectSampleTest.cs

@@ -180,9 +180,8 @@ namespace osu.Game.Tests.Beatmaps
             private readonly BeatmapInfo skinBeatmapInfo;
             private readonly IResourceStore<byte[]> resourceStore;
 
-            public TestWorkingBeatmap(BeatmapInfo skinBeatmapInfo, IResourceStore<byte[]> resourceStore, IBeatmap beatmap, Storyboard storyboard, IFrameBasedClock referenceClock, AudioManager audio,
+            public TestWorkingBeatmap(BeatmapInfo skinBeatmapInfo, IResourceStore<byte[]> resourceStore, IBeatmap beatmap, Storyboard storyboard, IFrameBasedClock referenceClock, AudioManager audio)
-                                      double length = 60000)
+                : base(beatmap, storyboard, referenceClock, audio)
-                : base(beatmap, storyboard, referenceClock, audio, length)
             {
                 this.skinBeatmapInfo = skinBeatmapInfo;
                 this.resourceStore = resourceStore;

osu.Game/Tests/Visual/OsuTestScene.cs

@@ -23,6 +23,7 @@ using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens;
 using osu.Game.Storyboards;
@@ -222,18 +223,23 @@ namespace osu.Game.Tests.Visual
             /// <param name="storyboard">The storyboard.</param>
             /// <param name="referenceClock">An optional clock which should be used instead of a stopwatch for virtual time progression.</param>
             /// <param name="audio">Audio manager. Required if a reference clock isn't provided.</param>
-            /// <param name="length">The length of the returned virtual track.</param>
+            public ClockBackedTestWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard, IFrameBasedClock referenceClock, AudioManager audio)
-            public ClockBackedTestWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard, IFrameBasedClock referenceClock, AudioManager audio, double length = 60000)
                 : base(beatmap, storyboard, audio)
             {
+                double trackLength = 60000;
+
+                if (beatmap.HitObjects.Count > 0)
+                    // add buffer after last hitobject to allow for final replay frames etc.
+                    trackLength = Math.Max(trackLength, beatmap.HitObjects.Max(h => h.GetEndTime()) + 2000);
+
                 if (referenceClock != null)
                 {
                     store = new TrackVirtualStore(referenceClock);
                     audio.AddItem(store);
-                    track = store.GetVirtual(length);
+                    track = store.GetVirtual(trackLength);
                 }
                 else
-                    track = audio?.Tracks.GetVirtual(length);
+                    track = audio?.Tracks.GetVirtual(trackLength);
             }
 
             ~ClockBackedTestWorkingBeatmap()

osu.Game/Tests/Visual/PlayerTestScene.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Tests.Visual
         /// <summary>
         /// Whether custom test steps are provided. Custom tests should invoke <see cref="CreateTest"/> to create the test steps.
         /// </summary>
-        protected virtual bool HasCustomSteps { get; } = false;
+        protected virtual bool HasCustomSteps => false;
 
         protected TestPlayer Player;
 

osu.Game/osu.Game.csproj

@@ -26,7 +26,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="ppy.osu.Framework" Version="2020.1019.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2020.1029.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1016.0" />
     <PackageReference Include="Sentry" Version="2.1.6" />
     <PackageReference Include="SharpCompress" Version="0.26.0" />

osu.iOS.props

@@ -70,7 +70,7 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.1019.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.1029.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1016.0" />
   </ItemGroup>
   <!-- Xamarin.iOS does not automatically handle transitive dependencies from NuGet packages. -->
@@ -80,7 +80,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="ppy.osu.Framework" Version="2020.1019.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2020.1029.1" />
     <PackageReference Include="SharpCompress" Version="0.26.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />