Merge remote-tracking branch 'Game4all/master' into truncate-metadata-on-wedge

Gemfile.lock

@@ -1,11 +1,11 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    CFPropertyList (3.0.0)
-    addressable (2.6.0)
-      public_suffix (>= 2.0.2, < 4.0)
+    CFPropertyList (3.0.1)
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
     atomos (0.1.3)
-    babosa (1.0.2)
+    babosa (1.0.3)
     claide (1.0.3)
     colored (1.2)
     colored2 (3.1.2)
@@ -26,8 +26,8 @@ GEM
       http-cookie (~> 1.0.0)
     faraday_middleware (0.13.1)
       faraday (>= 0.7.4, < 1.0)
-    fastimage (2.1.5)
-    fastlane (2.129.0)
+    fastimage (2.1.7)
+    fastlane (2.131.0)
       CFPropertyList (>= 2.3, < 4.0.0)
       addressable (>= 2.3, < 3.0.0)
       babosa (>= 1.0.2, < 2.0.0)
@@ -77,9 +77,9 @@ GEM
       representable (~> 3.0)
       retriable (>= 2.0, < 4.0)
       signet (~> 0.9)
-    google-cloud-core (1.3.0)
+    google-cloud-core (1.3.1)
       google-cloud-env (~> 1.0)
-    google-cloud-env (1.2.0)
+    google-cloud-env (1.2.1)
       faraday (~> 0.11)
     google-cloud-storage (1.16.0)
       digest-crc (~> 0.4)
@@ -100,9 +100,9 @@ GEM
     json (2.2.0)
     jwt (2.1.0)
     memoist (0.16.0)
-    mime-types (3.2.2)
+    mime-types (3.3)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2019.0331)
+    mime-types-data (3.2019.0904)
     mini_magick (4.9.5)
     mini_portile2 (2.4.0)
     multi_json (1.13.1)
@@ -121,14 +121,14 @@ GEM
       uber (< 0.2.0)
     retriable (3.1.2)
     rouge (2.0.7)
-    rubyzip (1.2.3)
+    rubyzip (1.2.4)
     security (0.1.3)
     signet (0.11.0)
       addressable (~> 2.3)
       faraday (~> 0.9)
       jwt (>= 1.5, < 3.0)
       multi_json (~> 1.10)
-    simctl (1.6.5)
+    simctl (1.6.6)
       CFPropertyList
       naturally
     slack-notifier (2.3.2)

README.md

@@ -31,12 +31,10 @@ If you are not interested in developing the game, you can still consume our [bin
 
 **Latest build:**
 
-| [Windows (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe)  | [macOS 10.12+](https://github.com/ppy/osu/releases/latest/download/osu.app.zip) |
-| ------------- | ------------- |
+| [Windows (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe)  | [macOS 10.12+](https://github.com/ppy/osu/releases/latest/download/osu.app.zip) | [iOS(iOS 10+)](https://testflight.apple.com/join/2tLcjWlF) | [Android (5+)](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
+| ------------- | ------------- | ------------- | ------------- |
 
 - **Linux** users are recommended to self-compile until we have official deployment in place.
-- **iOS** users can join the [TestFlight beta program](https://testflight.apple.com/join/2tLcjWlF) (note that due to high demand this is regularly full).
-- **Android** users can self-compile, and expect a public beta soon.
 
 If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.
 

fastlane/Fastfile

@@ -1,5 +1,83 @@
 update_fastlane
 
+platform :android do
+desc 'Deploy to play store'
+  lane :beta do |options|
+
+    update_version(
+      version: options[:version],
+      build: options[:build],
+    )
+
+    build(options)
+
+    supply(
+      apk: './osu.Android/bin/Release/sh.ppy.osulazer-Signed.apk',
+      package_name: 'sh.ppy.osulazer',
+      track: 'alpha', # upload to alpha, we can promote it later
+      json_key: options[:json_key],
+    )
+  end
+
+  desc 'Deploy to github release'
+  lane :build_github do |options|
+
+    update_version(
+      version: options[:version],
+      build: options[:build],
+    )
+
+    build(options)
+
+    client = HTTPClient.new
+    changelog = client.get_content 'https://gist.githubusercontent.com/peppy/aaa2ec1a323554b619671cac6dbbb776/raw'
+    changelog.gsub!('$BUILD_ID', options[:build])
+
+    set_github_release(
+      repository_name: "ppy/osu",
+      api_token: ENV["GITHUB_TOKEN"],
+      name: options[:build],
+      tag_name: options[:build],
+      is_draft: true,
+      description: changelog,
+      commitish: "master",
+      upload_assets: ["osu.Android/bin/Release/sh.ppy.osulazer.apk"]
+    )
+
+  end
+
+  desc 'Compile the project'
+  lane :build do |options|
+    nuget_restore(
+      project_path: 'osu.Android.sln'
+    )
+
+    souyuz(
+      build_configuration: 'Release',
+      solution_path: 'osu.Android.sln',
+      platform: "android",
+      output_path: "osu.Android/bin/Release/",
+      keystore_path: options[:keystore_path],
+      keystore_alias: options[:keystore_alias],
+      keystore_password: ENV["KEYSTORE_PASSWORD"]
+    )
+  end
+
+  lane :update_version do |options|
+
+    split = options[:build].split('.')
+    split[1] = split[1].to_s.rjust(4, '0')
+    android_build = split.join('')
+
+    app_version(
+      solution_path: 'osu.Android.sln',
+      version: options[:version],
+      build: android_build,
+    )
+  end
+
+end
+
 platform :ios do
   desc 'Deploy to testflight'
   lane :beta do |options|

fastlane/README.md

@@ -15,6 +15,30 @@ Install _fastlane_ using
 or alternatively using `brew cask install fastlane`
 
 # Available Actions
+## Android
+### android beta
+```
+fastlane android beta
+```
+Deploy to play store
+### android build_github
+```
+fastlane android build_github
+```
+Deploy to github release
+### android build
+```
+fastlane android build
+```
+Compile the project
+### android update_version
+```
+fastlane android update_version
+```
+
+
+----
+
 ## iOS
 ### ios beta
 ```

osu.Android.props

@@ -62,6 +62,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.913.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.924.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.930.0" />
   </ItemGroup>
 </Project>

osu.Android/OsuGameAndroid.cs

@@ -4,11 +4,37 @@
 using System;
 using Android.App;
 using osu.Game;
+using osu.Game.Updater;
 
 namespace osu.Android
 {
     public class OsuGameAndroid : OsuGame
     {
-        public override Version AssemblyVersion => new Version(Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0).VersionName);
+        public override Version AssemblyVersion
+        {
+            get
+            {
+                var packageInfo = Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0);
+
+                try
+                {
+                    string versionName = packageInfo.VersionCode.ToString();
+                    // undo play store version garbling
+                    return new Version(int.Parse(versionName.Substring(0, 4)), int.Parse(versionName.Substring(4, 4)), int.Parse(versionName.Substring(8, 1)));
+                }
+                catch
+                {
+                }
+
+                return new Version(packageInfo.VersionName);
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Add(new SimpleUpdateManager());
+        }
     }
 }

osu.Desktop/OsuGameDesktop.cs

@@ -17,6 +17,7 @@ using osu.Framework.Logging;
 using osu.Framework.Platform.Windows;
 using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
+using osu.Game.Updater;
 
 namespace osu.Desktop
 {

osu.Desktop/Overlays/VersionManager.cs

@@ -8,11 +8,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game;
-using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Notifications;
 using osuTK;
 using osuTK.Graphics;
 
@@ -20,17 +17,9 @@ namespace osu.Desktop.Overlays
 {
     public class VersionManager : OverlayContainer
     {
-        private OsuConfigManager config;
-        private OsuGameBase game;
-        private NotificationOverlay notificationOverlay;
-
         [BackgroundDependencyLoader]
-        private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game, OsuConfigManager config)
+        private void load(OsuColour colours, TextureStore textures, OsuGameBase game)
         {
-            notificationOverlay = notification;
-            this.config = config;
-            this.game = game;
-
             AutoSizeAxes = Axes.Both;
             Anchor = Anchor.BottomCentre;
             Origin = Anchor.BottomCentre;
@@ -85,48 +74,6 @@ namespace osu.Desktop.Overlays
             };
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            var version = game.Version;
-            var lastVersion = config.Get<string>(OsuSetting.Version);
-
-            if (game.IsDeployedBuild && version != lastVersion)
-            {
-                config.Set(OsuSetting.Version, version);
-
-                // only show a notification if we've previously saved a version to the config file (ie. not the first run).
-                if (!string.IsNullOrEmpty(lastVersion))
-                    notificationOverlay.Post(new UpdateCompleteNotification(version));
-            }
-        }
-
-        private class UpdateCompleteNotification : SimpleNotification
-        {
-            private readonly string version;
-
-            public UpdateCompleteNotification(string version)
-            {
-                this.version = version;
-                Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours, ChangelogOverlay changelog, NotificationOverlay notificationOverlay)
-            {
-                Icon = FontAwesome.Solid.CheckSquare;
-                IconBackgound.Colour = colours.BlueDark;
-
-                Activated = delegate
-                {
-                    notificationOverlay.Hide();
-                    changelog.ShowBuild(OsuGameBase.CLIENT_STREAM_NAME, version);
-                    return true;
-                };
-            }
-        }
-
         protected override void PopIn()
         {
             this.FadeIn(1400, Easing.OutQuint);

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -20,7 +20,7 @@ using LogLevel = Splat.LogLevel;
 
 namespace osu.Desktop.Updater
 {
-    public class SquirrelUpdateManager : Component
+    public class SquirrelUpdateManager : osu.Game.Updater.UpdateManager
     {
         private UpdateManager updateManager;
         private NotificationOverlay notificationOverlay;

osu.Game.Rulesets.Catch/Objects/CatchHitObject.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.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Beatmaps;
@@ -37,9 +38,21 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int ComboOffset { get; set; }
 
-        public int IndexInCurrentCombo { get; set; }
+        public Bindable<int> IndexInCurrentComboBindable { get; } = new Bindable<int>();
 
-        public int ComboIndex { get; set; }
+        public int IndexInCurrentCombo
+        {
+            get => IndexInCurrentComboBindable.Value;
+            set => IndexInCurrentComboBindable.Value = value;
+        }
+
+        public Bindable<int> ComboIndexBindable { get; } = new Bindable<int>();
+
+        public int ComboIndex
+        {
+            get => ComboIndexBindable.Value;
+            set => ComboIndexBindable.Value = value;
+        }
 
         /// <summary>
         /// Difference between the distance to the next object
@@ -48,10 +61,16 @@ namespace osu.Game.Rulesets.Catch.Objects
         /// </summary>
         public float DistanceToHyperDash { get; set; }
 
+        public Bindable<bool> LastInComboBindable { get; } = new Bindable<bool>();
+
         /// <summary>
         /// The next fruit starts a new combo. Used for explodey.
         /// </summary>
-        public virtual bool LastInCombo { get; set; }
+        public virtual bool LastInCombo
+        {
+            get => LastInComboBindable.Value;
+            set => LastInComboBindable.Value = value;
+        }
 
         public float Scale { get; set; } = 1;
 

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

@@ -15,7 +15,6 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -67,6 +66,8 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             AddAssert("check note anchors", () => notesInStageAreAnchored(stages[0], Anchor.TopCentre));
             AddAssert("check note anchors", () => notesInStageAreAnchored(stages[1], Anchor.BottomCentre));
+            AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[0], Anchor.TopCentre));
+            AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[1], Anchor.BottomCentre));
 
             AddStep("flip direction", () =>
             {
@@ -76,10 +77,14 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             AddAssert("check note anchors", () => notesInStageAreAnchored(stages[0], Anchor.BottomCentre));
             AddAssert("check note anchors", () => notesInStageAreAnchored(stages[1], Anchor.TopCentre));
+            AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[0], Anchor.BottomCentre));
+            AddAssert("check bar anchors", () => barsInStageAreAnchored(stages[1], Anchor.TopCentre));
         }
 
         private bool notesInStageAreAnchored(ManiaStage stage, Anchor anchor) => stage.Columns.SelectMany(c => c.AllHitObjects).All(o => o.Anchor == anchor);
 
+        private bool barsInStageAreAnchored(ManiaStage stage, Anchor anchor) => stage.AllHitObjects.Where(obj => obj is DrawableBarLine).All(o => o.Anchor == anchor);
+
         private void createNote()
         {
             foreach (var stage in stages)

osu.Game.Rulesets.Mania/Objects/BarLine.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.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Mania.Objects
+{
+    public class BarLine : ManiaHitObject, IBarLine
+    {
+        public bool Major { get; set; }
+    }
+}

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableBarLine.cs

@@ -4,7 +4,6 @@
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osuTK.Graphics;
 
@@ -14,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// Visualises a <see cref="BarLine"/>. Although this derives DrawableManiaHitObject,
     /// this does not handle input/sound like a normal hit object.
     /// </summary>
-    public class DrawableBarLine : DrawableHitObject<BarLine>
+    public class DrawableBarLine : DrawableManiaHitObject<BarLine>
     {
         /// <summary>
         /// Height of major bar line triangles.

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

@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Mania.UI
         public DrawableManiaRuleset(Ruleset ruleset, IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
             : base(ruleset, beatmap, mods)
         {
-            BarLines = new BarLineGenerator(Beatmap).BarLines;
+            BarLines = new BarLineGenerator<BarLine>(Beatmap).BarLines;
         }
 
         [BackgroundDependencyLoader]

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

@@ -8,7 +8,6 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;

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

@@ -12,7 +12,6 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;

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

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneHitCircleComboChange : TestSceneHitCircle
+    {
+        private readonly Bindable<int> comboIndex = new Bindable<int>();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Scheduler.AddDelayed(() => comboIndex.Value++, 250, true);
+        }
+
+        protected override TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto)
+        {
+            circle.ComboIndexBindable.BindTo(comboIndex);
+            circle.IndexInCurrentComboBindable.BindTo(comboIndex);
+            return base.CreateDrawableHitCircle(circle, auto);
+        }
+    }
+}

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

@@ -297,11 +297,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             slider.ApplyDefaults(cpi, new BeatmapDifficulty { CircleSize = circleSize, SliderTickRate = 3 });
 
-            var drawable = new DrawableSlider(slider)
-            {
-                Anchor = Anchor.Centre,
-                Depth = depthIndex++
-            };
+            var drawable = CreateDrawableSlider(slider);
 
             foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
@@ -311,6 +307,12 @@ namespace osu.Game.Rulesets.Osu.Tests
             return drawable;
         }
 
+        protected virtual DrawableSlider CreateDrawableSlider(Slider slider) => new DrawableSlider(slider)
+        {
+            Anchor = Anchor.Centre,
+            Depth = depthIndex++
+        };
+
         private float judgementOffsetDirection = 1;
 
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)

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

@@ -0,0 +1,28 @@
+// 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.Bindables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneSliderComboChange : TestSceneSlider
+    {
+        private readonly Bindable<int> comboIndex = new Bindable<int>();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Scheduler.AddDelayed(() => comboIndex.Value++, 250, true);
+        }
+
+        protected override DrawableSlider CreateDrawableSlider(Slider slider)
+        {
+            slider.ComboIndexBindable.BindTo(comboIndex);
+            slider.IndexInCurrentComboBindable.BindTo(comboIndex);
+
+            return base.CreateDrawableSlider(slider);
+        }
+    }
+}

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

@@ -0,0 +1,96 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.MathUtils;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+using osuTK;
+using System.Collections.Generic;
+using System.Linq;
+using static osu.Game.Tests.Visual.OsuTestScene.ClockBackedTestWorkingBeatmap;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneSpinnerRotation : TestSceneOsuPlayer
+    {
+        [Resolved]
+        private AudioManager audioManager { get; set; }
+
+        private TrackVirtualManual track;
+
+        protected override bool Autoplay => true;
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap)
+        {
+            var working = new ClockBackedTestWorkingBeatmap(beatmap, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
+            track = (TrackVirtualManual)working.Track;
+            return working;
+        }
+
+        private DrawableSpinner drawableSpinner;
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddUntilStep("wait for track to start running", () => track.IsRunning);
+            AddStep("retrieve spinner", () => drawableSpinner = (DrawableSpinner)((TestPlayer)Player).DrawableRuleset.Playfield.AllHitObjects.First());
+        }
+
+        [Test]
+        public void TestSpinnerRewindingRotation()
+        {
+            addSeekStep(5000);
+            AddAssert("is rotation absolute not almost 0", () => !Precision.AlmostEquals(drawableSpinner.Disc.RotationAbsolute, 0, 100));
+
+            addSeekStep(0);
+            AddAssert("is rotation absolute almost 0", () => Precision.AlmostEquals(drawableSpinner.Disc.RotationAbsolute, 0, 100));
+        }
+
+        [Test]
+        public void TestSpinnerMiddleRewindingRotation()
+        {
+            double estimatedRotation = 0;
+
+            addSeekStep(5000);
+            AddStep("retrieve rotation", () => estimatedRotation = drawableSpinner.Disc.RotationAbsolute);
+
+            addSeekStep(2500);
+            addSeekStep(5000);
+            AddAssert("is rotation absolute almost same", () => Precision.AlmostEquals(drawableSpinner.Disc.RotationAbsolute, estimatedRotation, 100));
+        }
+
+        private void addSeekStep(double time)
+        {
+            AddStep($"seek to {time}", () => track.Seek(time));
+
+            AddUntilStep("wait for seek to finish", () => Precision.AlmostEquals(time, ((TestPlayer)Player).DrawableRuleset.FrameStableClock.CurrentTime, 100));
+        }
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
+        {
+            HitObjects = new List<HitObject>
+            {
+                new Spinner
+                {
+                    Position = new Vector2(256, 192),
+                    EndTime = 5000,
+                },
+                // placeholder object to avoid hitting the results screen
+                new HitObject
+                {
+                    StartTime = 99999,
+                }
+            }
+        };
+    }
+}

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

@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                                 return true;
                             },
                         },
-                        CirclePiece = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.HitCircle), _ => new MainCirclePiece(HitObject.IndexInCurrentCombo)),
+                        CirclePiece = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.HitCircle), _ => new MainCirclePiece()),
                         ApproachCircle = new ApproachCircle
                         {
                             Alpha = 0,

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/MainCirclePiece.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         private readonly NumberPiece number;
         private readonly GlowPiece glow;
 
-        public MainCirclePiece(int index)
+        public MainCirclePiece()
         {
             Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
@@ -31,10 +31,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             {
                 glow = new GlowPiece(),
                 circle = new CirclePiece(),
-                number = new NumberPiece
-                {
-                    Text = (index + 1).ToString(),
-                },
+                number = new NumberPiece(),
                 ring = new RingPiece(),
                 flash = new FlashPiece(),
                 explode = new ExplodePiece(),
@@ -42,12 +39,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         }
 
         private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
-
-        private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly IBindable<int> indexInCurrentCombo = new Bindable<int>();
 
         [BackgroundDependencyLoader]
         private void load(DrawableHitObject drawableObject)
         {
+            OsuHitObject osuObject = (OsuHitObject)drawableObject.HitObject;
+
             state.BindTo(drawableObject.State);
             state.BindValueChanged(updateState, true);
 
@@ -58,6 +57,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 glow.Colour = colour.NewValue;
                 circle.Colour = colour.NewValue;
             }, true);
+
+            indexInCurrentCombo.BindTo(osuObject.IndexInCurrentComboBindable);
+            indexInCurrentCombo.BindValueChanged(index => number.Text = (index.NewValue + 1).ToString(), true);
         }
 
         private void updateState(ValueChangedEvent<ArmedState> state)

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerDisc.cs

@@ -111,7 +111,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     lastAngle -= 360;
 
                 currentRotation += thisAngle - lastAngle;
-                RotationAbsolute += Math.Abs(thisAngle - lastAngle);
+                RotationAbsolute += Math.Abs(thisAngle - lastAngle) * Math.Sign(Clock.ElapsedFrameTime);
             }
 
             lastAngle = thisAngle;

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

@@ -58,13 +58,37 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public virtual bool NewCombo { get; set; }
 
-        public int ComboOffset { get; set; }
+        public readonly Bindable<int> ComboOffsetBindable = new Bindable<int>();
 
-        public virtual int IndexInCurrentCombo { get; set; }
+        public int ComboOffset
+        {
+            get => ComboOffsetBindable.Value;
+            set => ComboOffsetBindable.Value = value;
+        }
 
-        public virtual int ComboIndex { get; set; }
+        public Bindable<int> IndexInCurrentComboBindable { get; } = new Bindable<int>();
 
-        public bool LastInCombo { get; set; }
+        public virtual int IndexInCurrentCombo
+        {
+            get => IndexInCurrentComboBindable.Value;
+            set => IndexInCurrentComboBindable.Value = value;
+        }
+
+        public Bindable<int> ComboIndexBindable { get; } = new Bindable<int>();
+
+        public virtual int ComboIndex
+        {
+            get => ComboIndexBindable.Value;
+            set => ComboIndexBindable.Value = value;
+        }
+
+        public Bindable<bool> LastInComboBindable { get; } = new Bindable<bool>();
+
+        public bool LastInCombo
+        {
+            get => LastInComboBindable.Value;
+            set => LastInComboBindable.Value = value;
+        }
 
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {

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

@@ -33,28 +33,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public Vector2 StackedPositionAt(double t) => StackedPosition + this.CurvePositionAt(t);
 
-        public override int ComboIndex
-        {
-            get => base.ComboIndex;
-            set
-            {
-                base.ComboIndex = value;
-                foreach (var n in NestedHitObjects.OfType<IHasComboInformation>())
-                    n.ComboIndex = value;
-            }
-        }
-
-        public override int IndexInCurrentCombo
-        {
-            get => base.IndexInCurrentCombo;
-            set
-            {
-                base.IndexInCurrentCombo = value;
-                foreach (var n in NestedHitObjects.OfType<IHasComboInformation>())
-                    n.IndexInCurrentCombo = value;
-            }
-        }
-
         public readonly Bindable<SliderPath> PathBindable = new Bindable<SliderPath>();
 
         public SliderPath Path
@@ -192,8 +170,6 @@ namespace osu.Game.Rulesets.Osu.Objects
                             Position = Position,
                             Samples = getNodeSamples(0),
                             SampleControlPoint = SampleControlPoint,
-                            IndexInCurrentCombo = IndexInCurrentCombo,
-                            ComboIndex = ComboIndex,
                         });
                         break;
 
@@ -205,8 +181,6 @@ namespace osu.Game.Rulesets.Osu.Objects
                         {
                             StartTime = e.Time,
                             Position = EndPosition,
-                            IndexInCurrentCombo = IndexInCurrentCombo,
-                            ComboIndex = ComboIndex,
                         });
                         break;
 

osu.Game.Rulesets.Osu/Skinning/LegacyMainCirclePiece.cs

@@ -9,7 +9,6 @@ using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Skinning;
 using osuTK;
@@ -25,13 +24,16 @@ namespace osu.Game.Rulesets.Osu.Skinning
         }
 
         private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
-
         private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly IBindable<int> indexInCurrentCombo = new Bindable<int>();
 
         [BackgroundDependencyLoader]
         private void load(DrawableHitObject drawableObject, ISkinSource skin)
         {
+            OsuHitObject osuObject = (OsuHitObject)drawableObject.HitObject;
+
             Sprite hitCircleSprite;
+            SkinnableSpriteText hitCircleText;
 
             InternalChildren = new Drawable[]
             {
@@ -42,14 +44,11 @@ namespace osu.Game.Rulesets.Osu.Skinning
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                 },
-                new SkinnableSpriteText(new OsuSkinComponent(OsuSkinComponents.HitCircleText), _ => new OsuSpriteText
+                hitCircleText = new SkinnableSpriteText(new OsuSkinComponent(OsuSkinComponents.HitCircleText), _ => new OsuSpriteText
                 {
                     Font = OsuFont.Numeric.With(size: 40),
                     UseFullGlyphHeight = false,
-                }, confineMode: ConfineMode.NoScaling)
-                {
-                    Text = (((IHasComboInformation)drawableObject.HitObject).IndexInCurrentCombo + 1).ToString()
-                },
+                }, confineMode: ConfineMode.NoScaling),
                 new Sprite
                 {
                     Texture = skin.GetTexture("hitcircleoverlay"),
@@ -63,6 +62,9 @@ namespace osu.Game.Rulesets.Osu.Skinning
 
             accentColour.BindTo(drawableObject.AccentColour);
             accentColour.BindValueChanged(colour => hitCircleSprite.Colour = colour.NewValue, true);
+
+            indexInCurrentCombo.BindTo(osuObject.IndexInCurrentComboBindable);
+            indexInCurrentCombo.BindValueChanged(index => hitCircleText.Text = (index.NewValue + 1).ToString(), true);
         }
 
         private void updateState(ValueChangedEvent<ArmedState> state)

osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs

@@ -40,9 +40,8 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
             for (int i = 0; i < max_sprites; i++)
             {
-                // InvalidationID 1 forces an update of each part of the cursor trail the first time ApplyState is run on the draw node
-                // This is to prevent garbage data from being sent to the vertex shader, resulting in visual issues on some platforms
-                parts[i].InvalidationID = 1;
+                // -1 signals that the part is unusable, and should not be drawn
+                parts[i].InvalidationID = -1;
             }
         }
 
@@ -112,6 +111,8 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             for (int i = 0; i < parts.Length; ++i)
             {
                 parts[i].Time -= time;
+
+                if (parts[i].InvalidationID != -1)
                     ++parts[i].InvalidationID;
             }
 
@@ -205,8 +206,6 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             public TrailDrawNode(CursorTrail source)
                 : base(source)
             {
-                for (int i = 0; i < max_sprites; i++)
-                    parts[i].InvalidationID = 0;
             }
 
             public override void ApplyState()
@@ -218,11 +217,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 size = Source.partSize;
                 time = Source.time;
 
-                for (int i = 0; i < Source.parts.Length; ++i)
-                {
-                    if (Source.parts[i].InvalidationID > parts[i].InvalidationID)
-                        parts[i] = Source.parts[i];
-                }
+                Source.parts.CopyTo(parts, 0);
             }
 
             public override void Draw(Action<TexturedVertex2D> vertexAction)
@@ -234,6 +229,9 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
                 for (int i = 0; i < parts.Length; ++i)
                 {
+                    if (parts[i].InvalidationID == -1)
+                        continue;
+
                     vertexBatch.DrawTime = parts[i].Time;
 
                     Vector2 pos = parts[i].Position;

osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoPlayfield.cs

@@ -53,6 +53,11 @@ namespace osu.Game.Rulesets.Taiko.Tests
             AddStep("Strong Rim", () => addRimHit(true));
             AddStep("Add bar line", () => addBarLine(false));
             AddStep("Add major bar line", () => addBarLine(true));
+            AddStep("Add centre w/ bar line", () =>
+            {
+                addCentreHit(false);
+                addBarLine(true);
+            });
             AddStep("Height test 1", () => changePlayfieldSize(1));
             AddStep("Height test 2", () => changePlayfieldSize(2));
             AddStep("Height test 3", () => changePlayfieldSize(3));

osu.Game.Rulesets.Taiko/Objects/BarLine.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.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Objects
+{
+    public class BarLine : TaikoHitObject, IBarLine
+    {
+        public bool Major { get; set; }
+    }
+}

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableBarLineMajor.cs

@@ -5,7 +5,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osuTK;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {

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

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Taiko.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            new BarLineGenerator(Beatmap).BarLines.ForEach(bar => Playfield.Add(bar.Major ? new DrawableBarLineMajor(bar) : new DrawableBarLine(bar)));
+            new BarLineGenerator<BarLine>(Beatmap).BarLines.ForEach(bar => Playfield.Add(bar.Major ? new DrawableBarLineMajor(bar) : new DrawableBarLine(bar)));
         }
 
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor(this);

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

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -115,6 +116,32 @@ namespace osu.Game.Tests.Visual.Gameplay
             assertPosition(4, 1f);
         }
 
+        [Test]
+        public void TestSliderMultiplierDoesNotAffectRelativeBeatLength()
+        {
+            var beatmap = createBeatmap(new TimingControlPoint { BeatLength = time_range });
+            beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2;
+
+            createTest(beatmap, d => d.RelativeScaleBeatLengthsOverride = true);
+            AddStep("adjust time range", () => drawableRuleset.TimeRange.Value = 5000);
+
+            for (int i = 0; i < 5; i++)
+                assertPosition(i, i / 5f);
+        }
+
+        [Test]
+        public void TestSliderMultiplierAffectsNonRelativeBeatLength()
+        {
+            var beatmap = createBeatmap(new TimingControlPoint { BeatLength = time_range });
+            beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2;
+
+            createTest(beatmap);
+            AddStep("adjust time range", () => drawableRuleset.TimeRange.Value = 2000);
+
+            assertPosition(0, 0);
+            assertPosition(1, 1);
+        }
+
         private void assertPosition(int index, float relativeY) => AddAssert($"hitobject {index} at {relativeY}",
             () => Precision.AlmostEquals(drawableRuleset.Playfield.AllHitObjects.ElementAt(index).DrawPosition.Y, drawableRuleset.Playfield.HitObjectContainer.DrawHeight * relativeY));
 
@@ -193,6 +220,8 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Overlapping;
 
+            public new Bindable<double> TimeRange => base.TimeRange;
+
             public TestDrawableScrollingRuleset(Ruleset ruleset, IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
                 : base(ruleset, beatmap, mods)
             {

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

@@ -7,10 +7,16 @@ using System.Linq;
 using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
 using osu.Framework.Screens;
+using osu.Game.Configuration;
+using osu.Game.Graphics.Containers;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
@@ -18,25 +24,49 @@ using osu.Game.Scoring;
 using osu.Game.Screens;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.PlayerSettings;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestScenePlayerLoader : ManualInputManagerTestScene
     {
         private TestPlayerLoader loader;
-        private OsuScreenStack stack;
+        private TestPlayerLoaderContainer container;
+        private TestPlayer player;
 
-        [SetUp]
-        public void Setup() => Schedule(() =>
+        [Resolved]
+        private AudioManager audioManager { get; set; }
+
+        [Resolved]
+        private SessionStatics sessionStatics { get; set; }
+
+        /// <summary>
+        /// Sets the input manager child to a new test player loader container instance.
+        /// </summary>
+        /// <param name="interactive">If the test player should behave like the production one.</param>
+        /// <param name="beforeLoadAction">An action to run before player load but after bindable leases are returned.</param>
+        /// <param name="afterLoadAction">An action to run after container load.</param>
+        public void ResetPlayer(bool interactive, Action beforeLoadAction = null, Action afterLoadAction = null)
         {
-            InputManager.Child = stack = new OsuScreenStack { RelativeSizeAxes = Axes.Both };
+            audioManager.Volume.SetDefault();
+
+            InputManager.Clear();
+
+            beforeLoadAction?.Invoke();
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
-        });
+
+            InputManager.Child = container = new TestPlayerLoaderContainer(
+                loader = new TestPlayerLoader(() =>
+                {
+                    afterLoadAction?.Invoke();
+                    return player = new TestPlayer(interactive, interactive);
+                }));
+        }
 
         [Test]
         public void TestBlockLoadViaMouseMovement()
         {
-            AddStep("load dummy beatmap", () => stack.Push(loader = new TestPlayerLoader(() => new TestPlayer(false, false))));
+            AddStep("load dummy beatmap", () => ResetPlayer(false));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
             AddRepeatStep("move mouse", () => InputManager.MoveMouseTo(loader.VisualSettings.ScreenSpaceDrawQuad.TopLeft + (loader.VisualSettings.ScreenSpaceDrawQuad.BottomRight - loader.VisualSettings.ScreenSpaceDrawQuad.TopLeft) * RNG.NextSingle()), 20);
             AddAssert("loader still active", () => loader.IsCurrentScreen());
@@ -46,16 +76,17 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestLoadContinuation()
         {
-            Player player = null;
             SlowLoadPlayer slowPlayer = null;
 
-            AddStep("load dummy beatmap", () => stack.Push(loader = new TestPlayerLoader(() => player = new TestPlayer(false, false))));
+            AddStep("load dummy beatmap", () => ResetPlayer(false));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
             AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
             AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
             AddStep("load slow dummy beatmap", () =>
             {
-                stack.Push(loader = new TestPlayerLoader(() => slowPlayer = new SlowLoadPlayer(false, false)));
+                InputManager.Child = container = new TestPlayerLoaderContainer(
+                    loader = new TestPlayerLoader(() => slowPlayer = new SlowLoadPlayer(false, false)));
+
                 Scheduler.AddDelayed(() => slowPlayer.AllowLoad.Set(), 5000);
             });
 
@@ -65,16 +96,11 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestModReinstantiation()
         {
-            TestPlayer player = null;
             TestMod gameMod = null;
             TestMod playerMod1 = null;
             TestMod playerMod2 = null;
 
-            AddStep("load player", () =>
-            {
-                Mods.Value = new[] { gameMod = new TestMod() };
-                stack.Push(loader = new TestPlayerLoader(() => player = new TestPlayer()));
-            });
+            AddStep("load player", () => { ResetPlayer(true, () => Mods.Value = new[] { gameMod = new TestMod() }); });
 
             AddUntilStep("wait for loader to become current", () => loader.IsCurrentScreen());
             AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
@@ -97,6 +123,75 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("player mods applied", () => playerMod2.Applied);
         }
 
+        [Test]
+        public void TestMutedNotificationMasterVolume() => addVolumeSteps("master volume", () => audioManager.Volume.Value = 0, null, () => audioManager.Volume.IsDefault);
+
+        [Test]
+        public void TestMutedNotificationTrackVolume() => addVolumeSteps("music volume", () => audioManager.VolumeTrack.Value = 0, null, () => audioManager.VolumeTrack.IsDefault);
+
+        [Test]
+        public void TestMutedNotificationMuteButton() => addVolumeSteps("mute button", null, () => container.VolumeOverlay.IsMuted.Value = true, () => !container.VolumeOverlay.IsMuted.Value);
+
+        /// <remarks>
+        /// Created for avoiding copy pasting code for the same steps.
+        /// </remarks>
+        /// <param name="volumeName">What part of the volume system is checked</param>
+        /// <param name="beforeLoad">The action to be invoked to set the volume before loading</param>
+        /// <param name="afterLoad">The action to be invoked to set the volume after loading</param>
+        /// <param name="assert">The function to be invoked and checked</param>
+        private void addVolumeSteps(string volumeName, Action beforeLoad, Action afterLoad, Func<bool> assert)
+        {
+            AddStep("reset notification lock", () => sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).Value = false);
+
+            AddStep("load player", () => ResetPlayer(false, beforeLoad, afterLoad));
+            AddUntilStep("wait for player", () => player.IsLoaded);
+
+            AddAssert("check for notification", () => container.NotificationOverlay.UnreadCount.Value == 1);
+            AddStep("click notification", () =>
+            {
+                var scrollContainer = (OsuScrollContainer)container.NotificationOverlay.Children.Last();
+                var flowContainer = scrollContainer.Children.OfType<FillFlowContainer<NotificationSection>>().First();
+                var notification = flowContainer.First();
+
+                InputManager.MoveMouseTo(notification);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("check " + volumeName, assert);
+        }
+
+        private class TestPlayerLoaderContainer : Container
+        {
+            [Cached]
+            public readonly NotificationOverlay NotificationOverlay;
+
+            [Cached]
+            public readonly VolumeOverlay VolumeOverlay;
+
+            public TestPlayerLoaderContainer(IScreen screen)
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                InternalChildren = new Drawable[]
+                {
+                    new OsuScreenStack(screen)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    NotificationOverlay = new NotificationOverlay
+                    {
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                    },
+                    VolumeOverlay = new VolumeOverlay
+                    {
+                        Anchor = Anchor.TopLeft,
+                        Origin = Anchor.TopLeft,
+                    }
+                };
+            }
+        }
+
         private class TestPlayerLoader : PlayerLoader
         {
             public new VisualSettings VisualSettings => base.VisualSettings;

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

@@ -0,0 +1,202 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Platform;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
+using osu.Game.Screens;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.Select;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+using IntroSequence = osu.Game.Configuration.IntroSequence;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    public class TestSceneScreenNavigation : ManualInputManagerTestScene
+    {
+        private const float click_padding = 25;
+
+        private GameHost host;
+        private TestOsuGame osuGame;
+
+        private Vector2 backButtonPosition => osuGame.ToScreenSpace(new Vector2(click_padding, osuGame.LayoutRectangle.Bottom - click_padding));
+
+        private Vector2 optionsButtonPosition => osuGame.ToScreenSpace(new Vector2(click_padding, click_padding));
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
+        {
+            this.host = host;
+
+            Child = new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = Color4.Black,
+            };
+        }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create new game instance", () =>
+            {
+                if (osuGame != null)
+                {
+                    Remove(osuGame);
+                    osuGame.Dispose();
+                }
+
+                osuGame = new TestOsuGame(LocalStorage, API);
+                osuGame.SetHost(host);
+
+                // todo: this can be removed once we can run audio trakcs without a device present
+                // see https://github.com/ppy/osu/issues/1302
+                osuGame.LocalConfig.Set(OsuSetting.IntroSequence, IntroSequence.Circles);
+
+                Add(osuGame);
+            });
+            AddUntilStep("Wait for load", () => osuGame.IsLoaded);
+            AddUntilStep("Wait for intro", () => osuGame.ScreenStack.CurrentScreen is IntroScreen);
+            confirmAtMainMenu();
+        }
+
+        [Test]
+        public void TestExitSongSelectWithEscape()
+        {
+            TestSongSelect songSelect = null;
+
+            pushAndConfirm(() => songSelect = new TestSongSelect());
+            AddStep("Show mods overlay", () => songSelect.ModSelectOverlay.Show());
+            AddAssert("Overlay was shown", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+            AddStep("Press escape", () => pressAndRelease(Key.Escape));
+            AddAssert("Overlay was hidden", () => songSelect.ModSelectOverlay.State.Value == Visibility.Hidden);
+            exitViaEscapeAndConfirm();
+        }
+
+        [Test]
+        public void TestExitSongSelectWithClick()
+        {
+            TestSongSelect songSelect = null;
+
+            pushAndConfirm(() => songSelect = new TestSongSelect());
+            AddStep("Show mods overlay", () => songSelect.ModSelectOverlay.Show());
+            AddAssert("Overlay was shown", () => songSelect.ModSelectOverlay.State.Value == Visibility.Visible);
+            AddStep("Move mouse to backButton", () => InputManager.MoveMouseTo(backButtonPosition));
+
+            // BackButton handles hover using its child button, so this checks whether or not any of BackButton's children are hovered.
+            AddUntilStep("Back button is hovered", () => InputManager.HoveredDrawables.Any(d => d.Parent == osuGame.BackButton));
+
+            AddStep("Click back button", () => InputManager.Click(MouseButton.Left));
+            AddUntilStep("Overlay was hidden", () => songSelect.ModSelectOverlay.State.Value == Visibility.Hidden);
+            exitViaBackButtonAndConfirm();
+        }
+
+        [Test]
+        public void TestExitMultiWithEscape()
+        {
+            pushAndConfirm(() => new Screens.Multi.Multiplayer());
+            exitViaEscapeAndConfirm();
+        }
+
+        [Test]
+        public void TestExitMultiWithBackButton()
+        {
+            pushAndConfirm(() => new Screens.Multi.Multiplayer());
+            exitViaBackButtonAndConfirm();
+        }
+
+        [Test]
+        public void TestOpenOptionsAndExitWithEscape()
+        {
+            AddUntilStep("Wait for options to load", () => osuGame.Settings.IsLoaded);
+            AddStep("Enter menu", () => pressAndRelease(Key.Enter));
+            AddStep("Move mouse to options overlay", () => InputManager.MoveMouseTo(optionsButtonPosition));
+            AddStep("Click options overlay", () => InputManager.Click(MouseButton.Left));
+            AddAssert("Options overlay was opened", () => osuGame.Settings.State.Value == Visibility.Visible);
+            AddStep("Hide options overlay using escape", () => pressAndRelease(Key.Escape));
+            AddAssert("Options overlay was closed", () => osuGame.Settings.State.Value == Visibility.Hidden);
+        }
+
+        private void pushAndConfirm(Func<Screen> newScreen)
+        {
+            Screen screen = null;
+            AddStep("Push new screen", () => osuGame.ScreenStack.Push(screen = newScreen()));
+            AddUntilStep("Wait for new screen", () => osuGame.ScreenStack.CurrentScreen == screen && screen.IsLoaded);
+        }
+
+        private void exitViaEscapeAndConfirm()
+        {
+            AddStep("Press escape", () => pressAndRelease(Key.Escape));
+            confirmAtMainMenu();
+        }
+
+        private void exitViaBackButtonAndConfirm()
+        {
+            AddStep("Move mouse to backButton", () => InputManager.MoveMouseTo(backButtonPosition));
+            AddStep("Click back button", () => InputManager.Click(MouseButton.Left));
+            confirmAtMainMenu();
+        }
+
+        private void confirmAtMainMenu() => AddUntilStep("Wait for main menu", () => osuGame.ScreenStack.CurrentScreen is MainMenu menu && menu.IsLoaded);
+
+        private void pressAndRelease(Key key)
+        {
+            InputManager.PressKey(key);
+            InputManager.ReleaseKey(key);
+        }
+
+        private class TestOsuGame : OsuGame
+        {
+            public new ScreenStack ScreenStack => base.ScreenStack;
+
+            public new BackButton BackButton => base.BackButton;
+
+            public new SettingsPanel Settings => base.Settings;
+
+            public new OsuConfigManager LocalConfig => base.LocalConfig;
+
+            protected override Loader CreateLoader() => new TestLoader();
+
+            public TestOsuGame(Storage storage, IAPIProvider api)
+            {
+                Storage = storage;
+                API = api;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                API.Login("Rhythm Champion", "osu!");
+            }
+        }
+
+        private class TestSongSelect : PlaySongSelect
+        {
+            public ModSelectOverlay ModSelectOverlay => ModSelect;
+        }
+
+        private class TestLoader : Loader
+        {
+            protected override ShaderPrecompiler CreateShaderPrecompiler() => new TestShaderPrecompiler();
+
+            private class TestShaderPrecompiler : ShaderPrecompiler
+            {
+                protected override bool AllLoaded => true;
+            }
+        }
+    }
+}

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

@@ -32,6 +32,12 @@ namespace osu.Game.Tests.Visual.Online
             Id = 4,
         };
 
+        private readonly User longUsernameUser = new User
+        {
+            Username = "Very Long Long Username",
+            Id = 5,
+        };
+
         [Cached]
         private ChannelManager channelManager = new ChannelManager();
 
@@ -99,6 +105,12 @@ namespace osu.Game.Tests.Visual.Online
                 Sender = admin,
                 Content = "Okay okay, calm down guys. Let's do this!"
             }));
+
+            AddStep("message from long username", () => testChannel.AddNewMessages(new Message(sequence++)
+            {
+                Sender = longUsernameUser,
+                Content = "Hi guys, my new username is lit!"
+            }));
         }
     }
 }

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

@@ -107,6 +107,15 @@ namespace osu.Game.Tests.Visual.Online
                 CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c6.jpg"
             }, api.IsLoggedIn));
 
+            AddStep("Show bancho", () => profile.ShowUser(new User
+            {
+                Username = @"BanchoBot",
+                Id = 3,
+                IsBot = true,
+                Country = new Country { FullName = @"Saint Helena", FlagName = @"SH" },
+                CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c4.jpg"
+            }, api.IsLoggedIn));
+
             AddStep("Hide", profile.Hide);
             AddStep("Show without reload", profile.Show);
         }

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

@@ -43,7 +43,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private readonly Stack<BeatmapSetInfo> selectedSets = new Stack<BeatmapSetInfo>();
         private readonly HashSet<int> eagerSelectedIDs = new HashSet<int>();
 
-        private BeatmapInfo currentSelection;
+        private BeatmapInfo currentSelection => carousel.SelectedBeatmap;
 
         private const int set_count = 5;
 
@@ -56,45 +56,34 @@ namespace osu.Game.Tests.Visual.SongSelect
             {
                 RelativeSizeAxes = Axes.Both,
             });
+        }
 
-            List<BeatmapSetInfo> beatmapSets = new List<BeatmapSetInfo>();
+        private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets = null)
+        {
+            if (beatmapSets == null)
+            {
+                beatmapSets = new List<BeatmapSetInfo>();
 
                 for (int i = 1; i <= set_count; i++)
                     beatmapSets.Add(createTestBeatmapSet(i));
-
-            carousel.SelectionChanged = s => currentSelection = s;
-
-            loadBeatmaps(beatmapSets);
-
-            testTraversal();
-            testFiltering();
-            testRandom();
-            testAddRemove();
-            testSorting();
-
-            testRemoveAll();
-            testEmptyTraversal();
-            testHiding();
-            testSelectingFilteredRuleset();
-            testCarouselRootIsRandom();
             }
 
-        private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets)
-        {
             bool changed = false;
             AddStep($"Load {beatmapSets.Count} Beatmaps", () =>
             {
+                carousel.Filter(new FilterCriteria());
                 carousel.BeatmapSetsChanged = () => changed = true;
                 carousel.BeatmapSets = beatmapSets;
             });
+
             AddUntilStep("Wait for load", () => changed);
         }
 
         private void ensureRandomFetchSuccess() =>
             AddAssert("ensure prev random fetch worked", () => selectedSets.Peek() == carousel.SelectedBeatmapSet);
 
-        private void checkSelected(int set, int? diff = null) =>
-            AddAssert($"selected is set{set}{(diff.HasValue ? $" diff{diff.Value}" : "")}", () =>
+        private void waitForSelection(int set, int? diff = null) =>
+            AddUntilStep($"selected is set{set}{(diff.HasValue ? $" diff{diff.Value}" : "")}", () =>
             {
                 if (diff != null)
                     return carousel.SelectedBeatmap == carousel.BeatmapSets.Skip(set - 1).First().Beatmaps.Skip(diff.Value - 1).First();
@@ -173,34 +162,40 @@ namespace osu.Game.Tests.Visual.SongSelect
         /// <summary>
         /// Test keyboard traversal
         /// </summary>
-        private void testTraversal()
+        [Test]
+        public void TestTraversal()
         {
+            loadBeatmaps();
+
             advanceSelection(direction: 1, diff: false);
-            checkSelected(1, 1);
+            waitForSelection(1, 1);
 
             advanceSelection(direction: 1, diff: true);
-            checkSelected(1, 2);
+            waitForSelection(1, 2);
 
             advanceSelection(direction: -1, diff: false);
-            checkSelected(set_count, 1);
+            waitForSelection(set_count, 1);
 
             advanceSelection(direction: -1, diff: true);
-            checkSelected(set_count - 1, 3);
+            waitForSelection(set_count - 1, 3);
 
             advanceSelection(diff: false);
             advanceSelection(diff: false);
-            checkSelected(1, 2);
+            waitForSelection(1, 2);
 
             advanceSelection(direction: -1, diff: true);
             advanceSelection(direction: -1, diff: true);
-            checkSelected(set_count, 3);
+            waitForSelection(set_count, 3);
         }
 
         /// <summary>
         /// Test filtering
         /// </summary>
-        private void testFiltering()
+        [Test]
+        public void TestFiltering()
         {
+            loadBeatmaps();
+
             // basic filtering
 
             setSelected(1, 1);
@@ -208,10 +203,10 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("Filter", () => carousel.Filter(new FilterCriteria { SearchText = "set #3!" }, false));
             checkVisibleItemCount(diff: false, count: 1);
             checkVisibleItemCount(diff: true, count: 3);
-            checkSelected(3, 1);
+            waitForSelection(3, 1);
 
             advanceSelection(diff: true, count: 4);
-            checkSelected(3, 2);
+            waitForSelection(3, 2);
 
             AddStep("Un-filter (debounce)", () => carousel.Filter(new FilterCriteria()));
             AddUntilStep("Wait for debounce", () => !carousel.PendingFilterTask);
@@ -222,10 +217,10 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             setSelected(1, 2);
             AddStep("Filter some difficulties", () => carousel.Filter(new FilterCriteria { SearchText = "Normal" }, false));
-            checkSelected(1, 1);
+            waitForSelection(1, 1);
 
             AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
-            checkSelected(1, 1);
+            waitForSelection(1, 1);
 
             AddStep("Filter all", () => carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false));
 
@@ -244,6 +239,18 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("Selection is non-null", () => currentSelection != null);
 
             setSelected(1, 3);
+        }
+
+        [Test]
+        public void TestFilterRange()
+        {
+            loadBeatmaps();
+
+            // buffer the selection
+            setSelected(3, 2);
+
+            setSelected(1, 3);
+
             AddStep("Apply a range filter", () => carousel.Filter(new FilterCriteria
             {
                 SearchText = "#3",
@@ -254,16 +261,19 @@ namespace osu.Game.Tests.Visual.SongSelect
                     IsLowerInclusive = true
                 }
             }, false));
-            checkSelected(3, 2);
 
-            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+            // should reselect the buffered selection.
+            waitForSelection(3, 2);
         }
 
         /// <summary>
         /// Test random non-repeating algorithm
         /// </summary>
-        private void testRandom()
+        [Test]
+        public void TestRandom()
         {
+            loadBeatmaps();
+
             setSelected(1, 1);
 
             nextRandom();
@@ -299,8 +309,11 @@ namespace osu.Game.Tests.Visual.SongSelect
         /// <summary>
         /// Test adding and removing beatmap sets
         /// </summary>
-        private void testAddRemove()
+        [Test]
+        public void TestAddRemove()
         {
+            loadBeatmaps();
+
             AddStep("Add new set", () => carousel.UpdateBeatmapSet(createTestBeatmapSet(set_count + 1)));
             AddStep("Add new set", () => carousel.UpdateBeatmapSet(createTestBeatmapSet(set_count + 2)));
 
@@ -316,31 +329,37 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             checkVisibleItemCount(false, set_count);
 
-            checkSelected(set_count);
+            waitForSelection(set_count);
         }
 
         /// <summary>
         /// Test sorting
         /// </summary>
-        private void testSorting()
+        [Test]
+        public void TestSorting()
         {
+            loadBeatmaps();
+
             AddStep("Sort by author", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Author }, false));
             AddAssert("Check zzzzz is at bottom", () => carousel.BeatmapSets.Last().Metadata.AuthorString == "zzzzz");
             AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
             AddAssert($"Check #{set_count} is at bottom", () => carousel.BeatmapSets.Last().Metadata.Title.EndsWith($"#{set_count}!"));
         }
 
-        private void testRemoveAll()
+        [Test]
+        public void TestRemoveAll()
         {
+            loadBeatmaps();
+
             setSelected(2, 1);
             AddAssert("Selection is non-null", () => currentSelection != null);
 
             AddStep("Remove selected", () => carousel.RemoveBeatmapSet(carousel.SelectedBeatmapSet));
-            checkSelected(2);
+            waitForSelection(2);
 
             AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
             AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
-            checkSelected(1);
+            waitForSelection(1);
 
             AddUntilStep("Remove all", () =>
             {
@@ -353,8 +372,11 @@ namespace osu.Game.Tests.Visual.SongSelect
             checkNoSelection();
         }
 
-        private void testEmptyTraversal()
+        [Test]
+        public void TestEmptyTraversal()
         {
+            loadBeatmaps(new List<BeatmapSetInfo>());
+
             advanceSelection(direction: 1, diff: false);
             checkNoSelection();
 
@@ -368,26 +390,29 @@ namespace osu.Game.Tests.Visual.SongSelect
             checkNoSelection();
         }
 
-        private void testHiding()
+        [Test]
+        public void TestHiding()
         {
-            var hidingSet = createTestBeatmapSet(1);
+            BeatmapSetInfo hidingSet = createTestBeatmapSet(1);
             hidingSet.Beatmaps[1].Hidden = true;
-            AddStep("Add set with diff 2 hidden", () => carousel.UpdateBeatmapSet(hidingSet));
+
+            loadBeatmaps(new List<BeatmapSetInfo> { hidingSet });
+
             setSelected(1, 1);
 
             checkVisibleItemCount(true, 2);
             advanceSelection(true);
-            checkSelected(1, 3);
+            waitForSelection(1, 3);
 
             setHidden(3);
-            checkSelected(1, 1);
+            waitForSelection(1, 1);
 
             setHidden(2, false);
             advanceSelection(true);
-            checkSelected(1, 2);
+            waitForSelection(1, 2);
 
             setHidden(1);
-            checkSelected(1, 2);
+            waitForSelection(1, 2);
 
             setHidden(2);
             checkNoSelection();
@@ -402,7 +427,8 @@ namespace osu.Game.Tests.Visual.SongSelect
             }
         }
 
-        private void testSelectingFilteredRuleset()
+        [Test]
+        public void TestSelectingFilteredRuleset()
         {
             var testMixed = createTestBeatmapSet(set_count + 1);
             AddStep("add mixed ruleset beatmapset", () =>
@@ -437,14 +463,16 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("remove single ruleset set", () => carousel.RemoveBeatmapSet(testSingle));
         }
 
-        private void testCarouselRootIsRandom()
+        [Test]
+        public void TestCarouselRootIsRandom()
         {
-            List<BeatmapSetInfo> beatmapSets = new List<BeatmapSetInfo>();
+            List<BeatmapSetInfo> manySets = new List<BeatmapSetInfo>();
 
             for (int i = 1; i <= 50; i++)
-                beatmapSets.Add(createTestBeatmapSet(i));
+                manySets.Add(createTestBeatmapSet(i));
+
+            loadBeatmaps(manySets);
 
-            loadBeatmaps(beatmapSets);
             advanceSelection(direction: 1, diff: false);
             checkNonmatchingFilter();
             checkNonmatchingFilter();

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

@@ -22,6 +22,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         public TestSceneBackButton()
         {
             BackButton button;
+            BackButton.Receptor receptor = new BackButton.Receptor();
 
             Child = new Container
             {
@@ -31,12 +32,13 @@ namespace osu.Game.Tests.Visual.UserInterface
                 Masking = true,
                 Children = new Drawable[]
                 {
+                    receptor,
                     new Box
                     {
                         RelativeSizeAxes = Axes.Both,
                         Colour = Color4.SlateGray
                     },
-                    button = new BackButton
+                    button = new BackButton(receptor)
                     {
                         Anchor = Anchor.BottomLeft,
                         Origin = Anchor.BottomLeft,

osu.Game/Beatmaps/BeatmapProcessor.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Beatmaps
@@ -45,25 +44,6 @@ namespace osu.Game.Beatmaps
 
         public virtual void PostProcess()
         {
-            void updateNestedCombo(HitObject obj, int comboIndex, int indexInCurrentCombo)
-            {
-                if (obj is IHasComboInformation objectComboInfo)
-                {
-                    objectComboInfo.ComboIndex = comboIndex;
-                    objectComboInfo.IndexInCurrentCombo = indexInCurrentCombo;
-                    foreach (var nestedObject in obj.NestedHitObjects)
-                        updateNestedCombo(nestedObject, comboIndex, indexInCurrentCombo);
-                }
-            }
-
-            foreach (var hitObject in Beatmap.HitObjects)
-            {
-                if (hitObject is IHasComboInformation objectComboInfo)
-                {
-                    foreach (var nested in hitObject.NestedHitObjects)
-                        updateNestedCombo(nested, objectComboInfo.ComboIndex, objectComboInfo.IndexInCurrentCombo);
-                }
-            }
         }
     }
 }

osu.Game/Beatmaps/BindableBeatmap.cs

@@ -1,42 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Diagnostics;
-using osu.Framework.Bindables;
-
-namespace osu.Game.Beatmaps
-{
-    /// <summary>
-    /// A <see cref="Bindable{T}"/> for the <see cref="OsuGame"/> beatmap.
-    /// This should be used sparingly in-favour of <see cref="IBindable{WorkingBeatmap}"/>.
-    /// </summary>
-    public abstract class BindableBeatmap : NonNullableBindable<WorkingBeatmap>
-    {
-        private WorkingBeatmap lastBeatmap;
-
-        protected BindableBeatmap(WorkingBeatmap defaultValue)
-            : base(defaultValue)
-        {
-            BindValueChanged(b => updateAudioTrack(b.NewValue), true);
-        }
-
-        private void updateAudioTrack(WorkingBeatmap beatmap)
-        {
-            var trackLoaded = lastBeatmap?.TrackLoaded ?? false;
-
-            // compare to last beatmap as sometimes the two may share a track representation (optimisation, see WorkingBeatmap.TransferTo)
-            if (!trackLoaded || lastBeatmap?.Track != beatmap.Track)
-            {
-                if (trackLoaded)
-                {
-                    Debug.Assert(lastBeatmap != null);
-                    Debug.Assert(lastBeatmap.Track != null);
-
-                    lastBeatmap.RecycleTrack();
-                }
-            }
-
-            lastBeatmap = beatmap;
-        }
-    }
-}

osu.Game/Configuration/InMemoryConfigManager.cs

@@ -0,0 +1,22 @@
+// 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.Configuration;
+
+namespace osu.Game.Configuration
+{
+    public class InMemoryConfigManager<T> : ConfigManager<T>
+        where T : struct
+    {
+        public InMemoryConfigManager()
+        {
+            InitialiseDefaults();
+        }
+
+        protected override void PerformLoad()
+        {
+        }
+
+        protected override bool PerformSave() => true;
+    }
+}

osu.Game/Configuration/IntroSequence.cs

@@ -6,6 +6,7 @@ namespace osu.Game.Configuration
     public enum IntroSequence
     {
         Circles,
-        Triangles
+        Triangles,
+        Random
     }
 }

osu.Game/Configuration/OsuConfigManager.cs

@@ -114,7 +114,7 @@ namespace osu.Game.Configuration
 
             Set(OsuSetting.UIScale, 1f, 0.8f, 1.6f, 0.01f);
 
-            Set(OsuSetting.UIHoldActivationDelay, 200, 0, 500);
+            Set(OsuSetting.UIHoldActivationDelay, 200f, 0f, 500f, 50f);
 
             Set(OsuSetting.IntroSequence, IntroSequence.Triangles);
         }

osu.Game/Configuration/SessionStatics.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
+{
+    /// <summary>
+    /// Stores global per-session statics. These will not be stored after exiting the game.
+    /// </summary>
+    public class SessionStatics : InMemoryConfigManager<Static>
+    {
+        protected override void InitialiseDefaults()
+        {
+            Set(Static.LoginOverlayDisplayed, false);
+            Set(Static.MutedAudioNotificationShownOnce, false);
+        }
+    }
+
+    public enum Static
+    {
+        LoginOverlayDisplayed,
+        MutedAudioNotificationShownOnce
+    }
+}

osu.Game/Database/ArchiveModelManager.cs

@@ -400,8 +400,6 @@ namespace osu.Game.Database
 
             int i = 0;
 
-            using (ContextFactory.GetForWrite())
-            {
             foreach (var b in items)
             {
                 if (notification.State == ProgressNotificationState.Cancelled)
@@ -414,7 +412,6 @@ namespace osu.Game.Database
 
                 notification.Progress = (float)i / items.Count;
             }
-            }
 
             notification.State = ProgressNotificationState.Completed;
         }
@@ -439,8 +436,6 @@ namespace osu.Game.Database
 
             int i = 0;
 
-            using (ContextFactory.GetForWrite())
-            {
             foreach (var item in items)
             {
                 if (notification.State == ProgressNotificationState.Cancelled)
@@ -453,7 +448,6 @@ namespace osu.Game.Database
 
                 notification.Progress = (float)i / items.Count;
             }
-            }
 
             notification.State = ProgressNotificationState.Completed;
         }

osu.Game/Graphics/Containers/HoldToConfirmContainer.cs

@@ -30,12 +30,12 @@ namespace osu.Game.Graphics.Containers
 
         public Bindable<double> Progress = new BindableDouble();
 
-        private Bindable<int> holdActivationDelay;
+        private Bindable<float> holdActivationDelay;
 
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
-            holdActivationDelay = config.GetBindable<int>(OsuSetting.UIHoldActivationDelay);
+            holdActivationDelay = config.GetBindable<float>(OsuSetting.UIHoldActivationDelay);
         }
 
         protected void BeginConfirm()

osu.Game/Graphics/UserInterface/BackButton.cs

@@ -10,14 +10,16 @@ using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class BackButton : VisibilityContainer, IKeyBindingHandler<GlobalAction>
+    public class BackButton : VisibilityContainer
     {
         public Action Action;
 
         private readonly TwoLayerButton button;
 
-        public BackButton()
+        public BackButton(Receptor receptor)
         {
+            receptor.OnBackPressed = () => button.Click();
+
             Size = TwoLayerButton.SIZE_EXTENDED;
 
             Child = button = new TwoLayerButton
@@ -37,19 +39,6 @@ namespace osu.Game.Graphics.UserInterface
             button.HoverColour = colours.PinkDark;
         }
 
-        public bool OnPressed(GlobalAction action)
-        {
-            if (action == GlobalAction.Back)
-            {
-                Action?.Invoke();
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(GlobalAction action) => action == GlobalAction.Back;
-
         protected override void PopIn()
         {
             button.MoveToX(0, 400, Easing.OutQuint);
@@ -61,5 +50,24 @@ namespace osu.Game.Graphics.UserInterface
             button.MoveToX(-TwoLayerButton.SIZE_EXTENDED.X / 2, 400, Easing.OutQuint);
             button.FadeOut(400, Easing.OutQuint);
         }
+
+        public class Receptor : Drawable, IKeyBindingHandler<GlobalAction>
+        {
+            public Action OnBackPressed;
+
+            public bool OnPressed(GlobalAction action)
+            {
+                switch (action)
+                {
+                    case GlobalAction.Back:
+                        OnBackPressed?.Invoke();
+                        return true;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(GlobalAction action) => action == GlobalAction.Back;
+        }
     }
 }

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -2,22 +2,20 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osuTK.Graphics;
-using System;
 using osu.Framework.Allocation;
 using osu.Framework.Input.Events;
 using osu.Framework.Platform;
 using osu.Game.Input.Bindings;
 using osuTK.Input;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface
 {
     /// <summary>
     /// A textbox which holds focus eagerly.
     /// </summary>
-    public class FocusedTextBox : OsuTextBox
+    public class FocusedTextBox : OsuTextBox, IKeyBindingHandler<GlobalAction>
     {
-        public Action Exit;
-
         private bool focus;
 
         private bool allowImmediateFocus => host?.OnScreenKeyboardOverlapsGameWindow != true;
@@ -63,12 +61,12 @@ namespace osu.Game.Graphics.UserInterface
             if (!HasFocus) return false;
 
             if (e.Key == Key.Escape)
-                return false; // disable the framework-level handling of escape key for confority (we use GlobalAction.Back).
+                return false; // disable the framework-level handling of escape key for conformity (we use GlobalAction.Back).
 
             return base.OnKeyDown(e);
         }
 
-        public override bool OnPressed(GlobalAction action)
+        public bool OnPressed(GlobalAction action)
         {
             if (action == GlobalAction.Back)
             {
@@ -79,14 +77,10 @@ namespace osu.Game.Graphics.UserInterface
                 }
             }
 
-            return base.OnPressed(action);
+            return false;
         }
 
-        protected override void KillFocus()
-        {
-            base.KillFocus();
-            Exit?.Invoke();
-        }
+        public bool OnReleased(GlobalAction action) => false;
 
         public override bool RequestsFocus => HoldFocus;
     }

osu.Game/Graphics/UserInterface/OsuTextBox.cs

@@ -8,13 +8,11 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.Sprites;
 using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
-using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class OsuTextBox : TextBox, IKeyBindingHandler<GlobalAction>
+    public class OsuTextBox : TextBox
     {
         protected override float LeftRightPadding => 10;
 
@@ -57,18 +55,5 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         protected override Drawable GetDrawableCharacter(char c) => new OsuSpriteText { Text = c.ToString(), Font = OsuFont.GetFont(size: CalculatedTextSize) };
-
-        public virtual bool OnPressed(GlobalAction action)
-        {
-            if (action == GlobalAction.Back)
-            {
-                KillFocus();
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(GlobalAction action) => false;
     }
 }

osu.Game/Online/API/APIRequest.cs

@@ -64,7 +64,10 @@ namespace osu.Game.Online.API
         public void Perform(IAPIProvider api)
         {
             if (!(api is APIAccess apiAccess))
-                throw new NotSupportedException($"A {nameof(APIAccess)} is required to perform requests.");
+            {
+                Fail(new NotSupportedException($"A {nameof(APIAccess)} is required to perform requests."));
+                return;
+            }
 
             API = apiAccess;
 

osu.Game/Online/Chat/StandAloneChatDisplay.cs

@@ -21,8 +21,6 @@ namespace osu.Game.Online.Chat
     {
         public readonly Bindable<Channel> Channel = new Bindable<Channel>();
 
-        public Action Exit;
-
         private readonly FocusedTextBox textbox;
 
         protected ChannelManager ChannelManager;
@@ -66,8 +64,6 @@ namespace osu.Game.Online.Chat
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.BottomLeft,
                 });
-
-                textbox.Exit += () => Exit?.Invoke();
             }
 
             Channel.BindValueChanged(channelChanged);
@@ -146,6 +142,7 @@ namespace osu.Game.Online.Chat
 
             protected override float HorizontalPadding => 10;
             protected override float MessagePadding => 120;
+            protected override float TimestampPadding => 50;
 
             public StandAloneMessage(Message message)
                 : base(message)

osu.Game/OsuGame.cs

@@ -81,10 +81,14 @@ namespace osu.Game
 
         public readonly Bindable<OverlayActivation> OverlayActivationMode = new Bindable<OverlayActivation>();
 
-        private OsuScreenStack screenStack;
+        protected OsuScreenStack ScreenStack;
+
+        protected BackButton BackButton;
+
+        protected SettingsPanel Settings;
+
         private VolumeOverlay volume;
         private OsuLogo osuLogo;
-        private BackButton backButton;
 
         private MainMenu menuScreen;
 
@@ -96,8 +100,6 @@ namespace osu.Game
 
         private readonly string[] args;
 
-        private SettingsPanel settings;
-
         private readonly List<OverlayContainer> overlays = new List<OverlayContainer>();
 
         private readonly List<OverlayContainer> toolbarElements = new List<OverlayContainer>();
@@ -318,6 +320,8 @@ namespace osu.Game
             }, $"watch {databasedScoreInfo}", bypassScreenAllowChecks: true);
         }
 
+        protected virtual Loader CreateLoader() => new Loader();
+
         #region Beatmap progression
 
         private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> beatmap)
@@ -356,7 +360,7 @@ namespace osu.Game
             performFromMainMenuTask?.Cancel();
 
             // if the current screen does not allow screen changing, give the user an option to try again later.
-            if (!bypassScreenAllowChecks && (screenStack.CurrentScreen as IOsuScreen)?.AllowExternalScreenChange == false)
+            if (!bypassScreenAllowChecks && (ScreenStack.CurrentScreen as IOsuScreen)?.AllowExternalScreenChange == false)
             {
                 notifications.Post(new SimpleNotification
                 {
@@ -374,7 +378,7 @@ namespace osu.Game
             CloseAllOverlays(false);
 
             // we may already be at the target screen type.
-            if (targetScreen != null && screenStack.CurrentScreen?.GetType() == targetScreen)
+            if (targetScreen != null && ScreenStack.CurrentScreen?.GetType() == targetScreen)
             {
                 action();
                 return;
@@ -421,6 +425,7 @@ namespace osu.Game
             ScoreManager.PresentImport = items => PresentScore(items.First());
 
             Container logoContainer;
+            BackButton.Receptor receptor;
 
             dependencies.CacheAs(idleTracker = new GameIdleTracker(6000));
 
@@ -437,15 +442,16 @@ namespace osu.Game
                     RelativeSizeAxes = Axes.Both,
                     Children = new Drawable[]
                     {
-                        screenStack = new OsuScreenStack { RelativeSizeAxes = Axes.Both },
-                        backButton = new BackButton
+                        receptor = new BackButton.Receptor(),
+                        ScreenStack = new OsuScreenStack { RelativeSizeAxes = Axes.Both },
+                        BackButton = new BackButton(receptor)
                         {
                             Anchor = Anchor.BottomLeft,
                             Origin = Anchor.BottomLeft,
                             Action = () =>
                             {
-                                if ((screenStack.CurrentScreen as IOsuScreen)?.AllowBackButton == true)
-                                    screenStack.Exit();
+                                if ((ScreenStack.CurrentScreen as IOsuScreen)?.AllowBackButton == true)
+                                    ScreenStack.Exit();
                             }
                         },
                         logoContainer = new Container { RelativeSizeAxes = Axes.Both },
@@ -458,18 +464,15 @@ namespace osu.Game
                 idleTracker
             });
 
-            screenStack.ScreenPushed += screenPushed;
-            screenStack.ScreenExited += screenExited;
+            ScreenStack.ScreenPushed += screenPushed;
+            ScreenStack.ScreenExited += screenExited;
 
             loadComponentSingleFile(osuLogo, logo =>
             {
                 logoContainer.Add(logo);
 
                 // Loader has to be created after the logo has finished loading as Loader performs logo transformations on entering.
-                screenStack.Push(new Loader
-                {
-                    RelativeSizeAxes = Axes.Both
-                });
+                ScreenStack.Push(CreateLoader().With(l => l.RelativeSizeAxes = Axes.Both));
             });
 
             loadComponentSingleFile(Toolbar = new Toolbar
@@ -485,7 +488,8 @@ namespace osu.Game
                 toolbarElements.Add(d);
             });
 
-            loadComponentSingleFile(volume = new VolumeOverlay(), leftFloatingOverlayContent.Add);
+            loadComponentSingleFile(volume = new VolumeOverlay(), leftFloatingOverlayContent.Add, true);
+
             loadComponentSingleFile(new OnScreenDisplay(), Add, true);
 
             loadComponentSingleFile(musicController = new MusicController(), Add, true);
@@ -504,7 +508,7 @@ namespace osu.Game
             loadComponentSingleFile(social = new SocialOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(channelManager = new ChannelManager(), AddInternal, true);
             loadComponentSingleFile(chatOverlay = new ChatOverlay(), overlayContent.Add, true);
-            loadComponentSingleFile(settings = new SettingsOverlay { GetToolbarHeight = () => ToolbarOffset }, leftFloatingOverlayContent.Add, true);
+            loadComponentSingleFile(Settings = new SettingsOverlay { GetToolbarHeight = () => ToolbarOffset }, leftFloatingOverlayContent.Add, true);
             var changelogOverlay = loadComponentSingleFile(new ChangelogOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(userProfile = new UserProfileOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(beatmapSetOverlay = new BeatmapSetOverlay(), overlayContent.Add, true);
@@ -535,7 +539,7 @@ namespace osu.Game
 
             Add(externalLinkOpener = new ExternalLinkOpener());
 
-            var singleDisplaySideOverlays = new OverlayContainer[] { settings, notifications };
+            var singleDisplaySideOverlays = new OverlayContainer[] { Settings, notifications };
             overlays.AddRange(singleDisplaySideOverlays);
 
             foreach (var overlay in singleDisplaySideOverlays)
@@ -588,7 +592,7 @@ namespace osu.Game
             {
                 float offset = 0;
 
-                if (settings.State.Value == Visibility.Visible)
+                if (Settings.State.Value == Visibility.Visible)
                     offset += ToolbarButton.WIDTH / 2;
                 if (notifications.State.Value == Visibility.Visible)
                     offset -= ToolbarButton.WIDTH / 2;
@@ -596,7 +600,7 @@ namespace osu.Game
                 screenContainer.MoveToX(offset, SettingsPanel.TRANSITION_LENGTH, Easing.OutQuint);
             }
 
-            settings.State.ValueChanged += _ => updateScreenOffset();
+            Settings.State.ValueChanged += _ => updateScreenOffset();
             notifications.State.ValueChanged += _ => updateScreenOffset();
         }
 
@@ -741,7 +745,7 @@ namespace osu.Game
                     return true;
 
                 case GlobalAction.ToggleSettings:
-                    settings.ToggleVisibility();
+                    Settings.ToggleVisibility();
                     return true;
 
                 case GlobalAction.ToggleDirect:
@@ -788,13 +792,13 @@ namespace osu.Game
 
         protected override bool OnExiting()
         {
-            if (screenStack.CurrentScreen is Loader)
+            if (ScreenStack.CurrentScreen is Loader)
                 return false;
 
             if (introScreen == null)
                 return true;
 
-            if (!introScreen.DidLoadMenu || !(screenStack.CurrentScreen is IntroScreen))
+            if (!introScreen.DidLoadMenu || !(ScreenStack.CurrentScreen is IntroScreen))
             {
                 Scheduler.Add(introScreen.MakeCurrent);
                 return true;
@@ -822,7 +826,7 @@ namespace osu.Game
             screenContainer.Padding = new MarginPadding { Top = ToolbarOffset };
             overlayContent.Padding = new MarginPadding { Top = ToolbarOffset };
 
-            MenuCursorContainer.CanShowCursor = (screenStack.CurrentScreen as IOsuScreen)?.CursorVisible ?? false;
+            MenuCursorContainer.CanShowCursor = (ScreenStack.CurrentScreen as IOsuScreen)?.CursorVisible ?? false;
         }
 
         protected virtual void ScreenChanged(IScreen current, IScreen newScreen)
@@ -848,9 +852,9 @@ namespace osu.Game
                     Toolbar.Show();
 
                 if (newOsuScreen.AllowBackButton)
-                    backButton.Show();
+                    BackButton.Show();
                 else
-                    backButton.Hide();
+                    BackButton.Hide();
             }
         }
 

osu.Game/OsuGameBase.cs

@@ -65,7 +65,7 @@ namespace osu.Game
 
         protected RulesetConfigCache RulesetConfigCache;
 
-        protected APIAccess API;
+        protected IAPIProvider API;
 
         protected MenuCursorContainer MenuCursorContainer;
 
@@ -73,6 +73,8 @@ namespace osu.Game
 
         protected override Container<Drawable> Content => content;
 
+        protected Storage Storage { get; set; }
+
         private Bindable<WorkingBeatmap> beatmap; // cached via load() method
 
         [Cached]
@@ -123,7 +125,7 @@ namespace osu.Game
         {
             Resources.AddStore(new DllResourceStore(@"osu.Game.Resources.dll"));
 
-            dependencies.Cache(contextFactory = new DatabaseContextFactory(Host.Storage));
+            dependencies.Cache(contextFactory = new DatabaseContextFactory(Storage));
 
             var largeStore = new LargeTextureStore(Host.CreateTextureLoaderStore(new NamespacedResourceStore<byte[]>(Resources, @"Textures")));
             largeStore.AddStore(Host.CreateTextureLoaderStore(new OnlineStore()));
@@ -158,21 +160,21 @@ namespace osu.Game
 
             runMigrations();
 
-            dependencies.Cache(SkinManager = new SkinManager(Host.Storage, contextFactory, Host, Audio, new NamespacedResourceStore<byte[]>(Resources, "Skins/Legacy")));
+            dependencies.Cache(SkinManager = new SkinManager(Storage, contextFactory, Host, Audio, new NamespacedResourceStore<byte[]>(Resources, "Skins/Legacy")));
             dependencies.CacheAs<ISkinSource>(SkinManager);
 
-            API = new APIAccess(LocalConfig);
+            if (API == null) API = new APIAccess(LocalConfig);
 
-            dependencies.CacheAs<IAPIProvider>(API);
+            dependencies.CacheAs(API);
 
             var defaultBeatmap = new DummyWorkingBeatmap(Audio, Textures);
 
             dependencies.Cache(RulesetStore = new RulesetStore(contextFactory));
-            dependencies.Cache(FileStore = new FileStore(contextFactory, Host.Storage));
+            dependencies.Cache(FileStore = new FileStore(contextFactory, Storage));
 
             // ordering is important here to ensure foreign keys rules are not broken in ModelStore.Cleanup()
-            dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Host.Storage, API, contextFactory, Host));
-            dependencies.Cache(BeatmapManager = new BeatmapManager(Host.Storage, contextFactory, RulesetStore, API, Audio, Host, defaultBeatmap));
+            dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, contextFactory, Host));
+            dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, contextFactory, RulesetStore, API, Audio, Host, defaultBeatmap));
 
             // this should likely be moved to ArchiveModelManager when another case appers where it is necessary
             // to have inter-dependent model managers. this could be obtained with an IHasForeign<T> interface to
@@ -189,6 +191,7 @@ namespace osu.Game
             dependencies.Cache(KeyBindingStore = new KeyBindingStore(contextFactory, RulesetStore));
             dependencies.Cache(SettingsStore = new SettingsStore(contextFactory));
             dependencies.Cache(RulesetConfigCache = new RulesetConfigCache(SettingsStore));
+            dependencies.Cache(new SessionStatics());
             dependencies.Cache(new OsuColour());
 
             fileImporters.Add(BeatmapManager);
@@ -199,14 +202,21 @@ namespace osu.Game
             // this adds a global reduction of track volume for the time being.
             Audio.Tracks.AddAdjustment(AdjustableProperty.Volume, new BindableDouble(0.8));
 
-            beatmap = new OsuBindableBeatmap(defaultBeatmap);
+            beatmap = new NonNullableBindable<WorkingBeatmap>(defaultBeatmap);
+            beatmap.BindValueChanged(b => ScheduleAfterChildren(() =>
+            {
+                // compare to last beatmap as sometimes the two may share a track representation (optimisation, see WorkingBeatmap.TransferTo)
+                if (b.OldValue?.TrackLoaded == true && b.OldValue?.Track != b.NewValue?.Track)
+                    b.OldValue.RecycleTrack();
+            }));
 
             dependencies.CacheAs<IBindable<WorkingBeatmap>>(beatmap);
             dependencies.CacheAs(beatmap);
 
             FileStore.Cleanup();
 
-            AddInternal(API);
+            if (API is APIAccess apiAcces)
+                AddInternal(apiAcces);
             AddInternal(RulesetConfigCache);
 
             GlobalActionContainer globalBinding;
@@ -266,9 +276,13 @@ namespace osu.Game
 
         public override void SetHost(GameHost host)
         {
-            if (LocalConfig == null)
-                LocalConfig = new OsuConfigManager(host.Storage);
             base.SetHost(host);
+
+            if (Storage == null)
+                Storage = host.Storage;
+
+            if (LocalConfig == null)
+                LocalConfig = new OsuConfigManager(Storage);
         }
 
         private readonly List<ICanAcceptFiles> fileImporters = new List<ICanAcceptFiles>();
@@ -284,14 +298,6 @@ namespace osu.Game
 
         public string[] HandledExtensions => fileImporters.SelectMany(i => i.HandledExtensions).ToArray();
 
-        private class OsuBindableBeatmap : BindableBeatmap
-        {
-            public OsuBindableBeatmap(WorkingBeatmap defaultValue)
-                : base(defaultValue)
-            {
-            }
-        }
-
         private class OsuUserInputManager : UserInputManager
         {
             protected override MouseButtonEventManager CreateButtonManagerFor(MouseButton button)

osu.Game/Overlays/Chat/ChatLine.cs

@@ -31,7 +31,9 @@ namespace osu.Game.Overlays.Chat
 
         protected virtual float MessagePadding => default_message_padding;
 
-        private const float timestamp_padding = 65;
+        private const float default_timestamp_padding = 65;
+
+        protected virtual float TimestampPadding => default_timestamp_padding;
 
         private const float default_horizontal_padding = 15;
 
@@ -94,7 +96,7 @@ namespace osu.Game.Overlays.Chat
                 Font = OsuFont.GetFont(size: TextSize, weight: FontWeight.Bold, italics: true),
                 Anchor = Anchor.TopRight,
                 Origin = Anchor.TopRight,
-                MaxWidth = default_message_padding - timestamp_padding
+                MaxWidth = MessagePadding - TimestampPadding
             };
 
             if (hasBackground)
@@ -149,7 +151,6 @@ namespace osu.Game.Overlays.Chat
                         new MessageSender(message.Sender)
                         {
                             AutoSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Left = timestamp_padding },
                             Origin = Anchor.TopRight,
                             Anchor = Anchor.TopRight,
                             Child = effectedUsername,

osu.Game/Overlays/Chat/Selection/ChannelSelectionOverlay.cs

@@ -119,7 +119,6 @@ namespace osu.Game.Overlays.Chat.Selection
                                 {
                                     RelativeSizeAxes = Axes.X,
                                     PlaceholderText = @"Search",
-                                    Exit = Hide,
                                 },
                             },
                         },

osu.Game/Overlays/ChatOverlay.cs

@@ -138,7 +138,6 @@ namespace osu.Game.Overlays
                                             RelativeSizeAxes = Axes.Both,
                                             Height = 1,
                                             PlaceholderText = "type your message",
-                                            Exit = Hide,
                                             OnCommit = postMessage,
                                             ReleaseFocusOnCommit = false,
                                             HoldFocus = true,

osu.Game/Overlays/Music/FilterControl.cs

@@ -31,7 +31,6 @@ namespace osu.Game.Overlays.Music
                         {
                             RelativeSizeAxes = Axes.X,
                             Height = 40,
-                            Exit = () => ExitRequested?.Invoke(),
                         },
                         new CollectionsDropdown<PlaylistCollection>
                         {
@@ -47,8 +46,6 @@ namespace osu.Game.Overlays.Music
 
         private void current_ValueChanged(ValueChangedEvent<string> e) => FilterChanged?.Invoke(e.NewValue);
 
-        public Action ExitRequested;
-
         public Action<string> FilterChanged;
 
         public class FilterTextBox : SearchTextBox

osu.Game/Overlays/Music/PlaylistOverlay.cs

@@ -63,7 +63,6 @@ namespace osu.Game.Overlays.Music
                         {
                             RelativeSizeAxes = Axes.X,
                             AutoSizeAxes = Axes.Y,
-                            ExitRequested = Hide,
                             FilterChanged = search => list.Filter(search),
                             Padding = new MarginPadding(10),
                         },

osu.Game/Overlays/MusicController.cs

@@ -57,7 +57,7 @@ namespace osu.Game.Overlays
         protected override void LoadComplete()
         {
             beatmap.BindValueChanged(beatmapChanged, true);
-            mods.BindValueChanged(_ => updateAudioAdjustments(), true);
+            mods.BindValueChanged(_ => ResetTrackAdjustments(), true);
             base.LoadComplete();
         }
 
@@ -75,7 +75,7 @@ namespace osu.Game.Overlays
         /// <summary>
         /// Returns whether the current beatmap track is playing.
         /// </summary>
-        public bool IsPlaying => beatmap.Value.Track.IsRunning;
+        public bool IsPlaying => current?.Track.IsRunning ?? false;
 
         private void handleBeatmapAdded(BeatmapSetInfo set) =>
             Schedule(() => beatmapSets.Add(set));
@@ -213,12 +213,12 @@ namespace osu.Game.Overlays
             current = beatmap.NewValue;
             TrackChanged?.Invoke(current, direction);
 
-            updateAudioAdjustments();
+            ResetTrackAdjustments();
 
             queuedDirection = null;
         }
 
-        private void updateAudioAdjustments()
+        public void ResetTrackAdjustments()
         {
             var track = current?.Track;
             if (track == null)

osu.Game/Overlays/SearchableList/SearchableListOverlay.cs

@@ -88,8 +88,6 @@ namespace osu.Game.Overlays.SearchableList
                     },
                 },
             };
-
-            Filter.Search.Exit = Hide;
         }
 
         protected override void Update()

osu.Game/Overlays/Settings/Sections/Graphics/UserInterfaceSettings.cs

@@ -27,16 +27,16 @@ namespace osu.Game.Overlays.Settings.Sections.Graphics
                     LabelText = "Parallax",
                     Bindable = config.GetBindable<bool>(OsuSetting.MenuParallax)
                 },
-                new SettingsSlider<int, TimeSlider>
+                new SettingsSlider<float, TimeSlider>
                 {
                     LabelText = "Hold-to-confirm activation time",
-                    Bindable = config.GetBindable<int>(OsuSetting.UIHoldActivationDelay),
+                    Bindable = config.GetBindable<float>(OsuSetting.UIHoldActivationDelay),
                     KeyboardStep = 50
                 },
             };
         }
 
-        private class TimeSlider : OsuSliderBar<int>
+        private class TimeSlider : OsuSliderBar<float>
         {
             public override string TooltipText => Current.Value.ToString("N0") + "ms";
         }

osu.Game/Overlays/SettingsPanel.cs

@@ -91,7 +91,6 @@ namespace osu.Game.Overlays
                                 Top = 20,
                                 Bottom = 20
                             },
-                            Exit = Hide,
                         },
                         Footer = CreateFooter()
                     },

osu.Game/Overlays/UserProfileOverlay.cs

@@ -44,7 +44,8 @@ namespace osu.Game.Overlays
             Clear();
             lastSection = null;
 
-            sections = new ProfileSection[]
+            sections = !user.IsBot
+                ? new ProfileSection[]
                 {
                     //new AboutSection(),
                     new RecentSection(),
@@ -53,6 +54,10 @@ namespace osu.Game.Overlays
                     new HistoricalSection(),
                     new BeatmapsSection(),
                     new KudosuSection()
+                }
+                : new ProfileSection[]
+                {
+                    //new AboutSection(),
                 };
 
             tabs = new ProfileTabControl

osu.Game/Overlays/VolumeOverlay.cs

@@ -32,6 +32,9 @@ namespace osu.Game.Overlays
 
         private readonly BindableDouble muteAdjustment = new BindableDouble();
 
+        private readonly Bindable<bool> isMuted = new Bindable<bool>();
+        public Bindable<bool> IsMuted => isMuted;
+
         [BackgroundDependencyLoader]
         private void load(AudioManager audio, OsuColour colours)
         {
@@ -64,7 +67,8 @@ namespace osu.Game.Overlays
                         volumeMeterMusic = new VolumeMeter("MUSIC", 125, colours.BlueDarker),
                         muteButton = new MuteButton
                         {
-                            Margin = new MarginPadding { Top = 100 }
+                            Margin = new MarginPadding { Top = 100 },
+                            Current = { BindTarget = isMuted }
                         }
                     }
                 },
@@ -74,13 +78,13 @@ namespace osu.Game.Overlays
             volumeMeterEffect.Bindable.BindTo(audio.VolumeSample);
             volumeMeterMusic.Bindable.BindTo(audio.VolumeTrack);
 
-            muteButton.Current.ValueChanged += muted =>
+            isMuted.BindValueChanged(muted =>
             {
                 if (muted.NewValue)
                     audio.AddAdjustment(AdjustableProperty.Volume, muteAdjustment);
                 else
                     audio.RemoveAdjustment(AdjustableProperty.Volume, muteAdjustment);
-            };
+            });
         }
 
         protected override void LoadComplete()

osu.Game/Rulesets/Objects/BarLine.cs

@@ -1,16 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-namespace osu.Game.Rulesets.Objects
-{
-    /// <summary>
-    /// A hit object representing the end of a bar.
-    /// </summary>
-    public class BarLine : HitObject
-    {
-        /// <summary>
-        /// Whether this barline is a prominent beat (based on time signature of beatmap).
-        /// </summary>
-        public bool Major;
-    }
-}

osu.Game/Rulesets/Objects/BarLineGenerator.cs

@@ -10,12 +10,13 @@ using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Objects
 {
-    public class BarLineGenerator
+    public class BarLineGenerator<TBarLine>
+        where TBarLine : class, IBarLine, new()
     {
         /// <summary>
         /// The generated bar lines.
         /// </summary>
-        public readonly List<BarLine> BarLines = new List<BarLine>();
+        public readonly List<TBarLine> BarLines = new List<TBarLine>();
 
         /// <summary>
         /// Constructs and generates bar lines for provided beatmap.
@@ -46,7 +47,7 @@ namespace osu.Game.Rulesets.Objects
 
                 for (double t = currentTimingPoint.Time; Precision.DefinitelyBigger(endTime, t); t += barLength, currentBeat++)
                 {
-                    BarLines.Add(new BarLine
+                    BarLines.Add(new TBarLine
                     {
                         StartTime = t,
                         Major = currentBeat % (int)currentTimingPoint.TimeSignature == 0

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -76,6 +76,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </summary>
         public JudgementResult Result { get; private set; }
 
+        private Bindable<int> comboIndexBindable;
+
         public override bool RemoveWhenNotAlive => false;
         public override bool RemoveCompletedTransforms => false;
         protected override bool RequiresChildrenUpdate => true;
@@ -122,6 +124,13 @@ namespace osu.Game.Rulesets.Objects.Drawables
         protected override void LoadComplete()
         {
             base.LoadComplete();
+
+            if (HitObject is IHasComboInformation combo)
+            {
+                comboIndexBindable = combo.ComboIndexBindable.GetBoundCopy();
+                comboIndexBindable.BindValueChanged(_ => updateAccentColour());
+            }
+
             updateState(ArmedState.Idle, true);
         }
 
@@ -244,12 +253,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         {
             base.SkinChanged(skin, allowFallback);
 
-            if (HitObject is IHasComboInformation combo)
-            {
-                var comboColours = skin.GetConfig<GlobalSkinConfiguration, List<Color4>>(GlobalSkinConfiguration.ComboColours)?.Value;
-
-                AccentColour.Value = comboColours?.Count > 0 ? comboColours[combo.ComboIndex % comboColours.Count] : Color4.White;
-            }
+            updateAccentColour();
 
             ApplySkin(skin, allowFallback);
 
@@ -257,6 +261,15 @@ namespace osu.Game.Rulesets.Objects.Drawables
                 updateState(State.Value, true);
         }
 
+        private void updateAccentColour()
+        {
+            if (HitObject is IHasComboInformation combo)
+            {
+                var comboColours = CurrentSkin.GetConfig<GlobalSkinConfiguration, List<Color4>>(GlobalSkinConfiguration.ComboColours)?.Value;
+                AccentColour.Value = comboColours?.Count > 0 ? comboColours[combo.ComboIndex % comboColours.Count] : Color4.White;
+            }
+        }
+
         /// <summary>
         /// Called when a change is made to the skin.
         /// </summary>
@@ -316,8 +329,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
             get => lifetimeStart ?? (HitObject.StartTime - InitialLifetimeOffset);
             set
             {
-                base.LifetimeStart = value;
                 lifetimeStart = value;
+                base.LifetimeStart = value;
             }
         }
 

osu.Game/Rulesets/Objects/HitObject.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Game.Audio;
@@ -82,6 +83,15 @@ namespace osu.Game.Rulesets.Objects
 
             CreateNestedHitObjects();
 
+            if (this is IHasComboInformation hasCombo)
+            {
+                foreach (var n in NestedHitObjects.OfType<IHasComboInformation>())
+                {
+                    n.ComboIndexBindable.BindTo(hasCombo.ComboIndexBindable);
+                    n.IndexInCurrentComboBindable.BindTo(hasCombo.IndexInCurrentComboBindable);
+                }
+            }
+
             nestedHitObjects.Sort((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));
 
             foreach (var h in nestedHitObjects)

osu.Game/Rulesets/Objects/IBarLine.cs

@@ -0,0 +1,22 @@
+// 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.Rulesets.Objects
+{
+    /// <summary>
+    /// Interface for bar line hitobjects.
+    /// Used to decouple bar line generation from ruleset-specific rendering/drawing hierarchies.
+    /// </summary>
+    public interface IBarLine
+    {
+        /// <summary>
+        /// The time position of the bar.
+        /// </summary>
+        double StartTime { set; }
+
+        /// <summary>
+        /// Whether this bar line is a prominent beat (based on time signature of beatmap).
+        /// </summary>
+        bool Major { set; }
+    }
+}

osu.Game/Rulesets/Objects/Types/IHasComboInformation.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Bindables;
+
 namespace osu.Game.Rulesets.Objects.Types
 {
     /// <summary>
@@ -8,16 +10,22 @@ namespace osu.Game.Rulesets.Objects.Types
     /// </summary>
     public interface IHasComboInformation : IHasCombo
     {
+        Bindable<int> IndexInCurrentComboBindable { get; }
+
         /// <summary>
         /// The offset of this hitobject in the current combo.
         /// </summary>
         int IndexInCurrentCombo { get; set; }
 
+        Bindable<int> ComboIndexBindable { get; }
+
         /// <summary>
         /// The offset of this combo in relation to the beatmap.
         /// </summary>
         int ComboIndex { get; set; }
 
+        Bindable<bool> LastInComboBindable { get; }
+
         /// <summary>
         /// Whether this is the last object in the current combo.
         /// </summary>

osu.Game/Rulesets/RulesetStore.cs

@@ -135,9 +135,9 @@ namespace osu.Game.Rulesets
                 foreach (string file in files.Where(f => !Path.GetFileName(f).Contains("Tests")))
                     loadRulesetFromFile(file);
             }
-            catch
+            catch (Exception e)
             {
-                Logger.Log($"Could not load rulesets from directory {Environment.CurrentDirectory}");
+                Logger.Error(e, $"Could not load rulesets from directory {Environment.CurrentDirectory}");
             }
         }
 

osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs

@@ -131,7 +131,9 @@ namespace osu.Game.Rulesets.UI.Scrolling
                     if (duration > maxDuration)
                     {
                         maxDuration = duration;
-                        baseBeatLength = timingPoints[i].BeatLength;
+                        // The slider multiplier is post-multiplied to determine the final velocity, but for relative scale beat lengths
+                        // the multiplier should not affect the effective timing point (the longest in the beatmap), so it is factored out here
+                        baseBeatLength = timingPoints[i].BeatLength / Beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier;
                     }
                 }
             }

osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs

@@ -77,6 +77,9 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
             if (!initialStateCache.IsValid)
             {
+                foreach (var cached in hitObjectInitialStateCache.Values)
+                    cached.Invalidate();
+
                 switch (direction.Value)
                 {
                     case ScrollingDirection.Up:

osu.Game/Screens/Loader.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shaders;
+using osu.Framework.MathUtils;
 using osu.Game.Screens.Menu;
 using osuTK;
 using osu.Framework.Screens;
@@ -59,6 +60,9 @@ namespace osu.Game.Screens
 
         private IntroScreen getIntroSequence()
         {
+            if (introSequence == IntroSequence.Random)
+                introSequence = (IntroSequence)RNG.Next(0, (int)IntroSequence.Random);
+
             switch (introSequence)
             {
                 case IntroSequence.Circles:

osu.Game/Screens/Menu/MainMenu.cs

@@ -62,14 +62,16 @@ namespace osu.Game.Screens.Menu
 
         protected override BackgroundScreen CreateBackground() => background;
 
-        private Bindable<int> holdDelay;
+        private Bindable<float> holdDelay;
+        private Bindable<bool> loginDisplayed;
 
         private ExitConfirmOverlay exitConfirmOverlay;
 
         [BackgroundDependencyLoader(true)]
-        private void load(DirectOverlay direct, SettingsOverlay settings, OsuConfigManager config)
+        private void load(DirectOverlay direct, SettingsOverlay settings, OsuConfigManager config, SessionStatics statics)
         {
-            holdDelay = config.GetBindable<int>(OsuSetting.UIHoldActivationDelay);
+            holdDelay = config.GetBindable<float>(OsuSetting.UIHoldActivationDelay);
+            loginDisplayed = statics.GetBindable<bool>(Static.LoginOverlayDisplayed);
 
             if (host.CanExit)
             {
@@ -170,7 +172,6 @@ namespace osu.Game.Screens.Menu
             Beatmap.ValueChanged += beatmap_ValueChanged;
         }
 
-        private bool loginDisplayed;
         private bool exitConfirmed;
 
         protected override void LogoArriving(OsuLogo logo, bool resuming)
@@ -198,10 +199,10 @@ namespace osu.Game.Screens.Menu
 
             bool displayLogin()
             {
-                if (!loginDisplayed)
+                if (!loginDisplayed.Value)
                 {
                     Scheduler.AddDelayed(() => login?.Show(), 500);
-                    loginDisplayed = true;
+                    loginDisplayed.Value = true;
                 }
 
                 return true;

osu.Game/Screens/Multi/Lounge/LoungeSubScreen.cs

@@ -69,8 +69,6 @@ namespace osu.Game.Screens.Multi.Lounge
                     },
                 },
             };
-
-            Filter.Search.Exit += this.Exit;
         }
 
         protected override void UpdateAfterChildren()

osu.Game/Screens/Multi/Match/MatchSubScreen.cs

@@ -62,7 +62,6 @@ namespace osu.Game.Screens.Multi.Match
         [BackgroundDependencyLoader]
         private void load()
         {
-            MatchChatDisplay chat;
             Components.Header header;
             Info info;
             GridContainer bottomRow;
@@ -122,7 +121,7 @@ namespace osu.Game.Screens.Multi.Match
                                                 Vertical = 10,
                                             },
                                             RelativeSizeAxes = Axes.Both,
-                                            Child = chat = new MatchChatDisplay
+                                            Child = new MatchChatDisplay
                                             {
                                                 RelativeSizeAxes = Axes.Both
                                             }
@@ -159,12 +158,6 @@ namespace osu.Game.Screens.Multi.Match
                 bottomRow.FadeTo(settingsDisplayed ? 0 : 1, fade_duration, Easing.OutQuint);
             }, true);
 
-            chat.Exit += () =>
-            {
-                if (this.IsCurrentScreen())
-                    this.Exit();
-            };
-
             beatmapManager.ItemAdded += beatmapAdded;
         }
 

osu.Game/Screens/Play/HUD/HoldForMenuButton.cs

@@ -13,6 +13,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -45,7 +46,6 @@ namespace osu.Game.Screens.Play.HUD
             {
                 text = new OsuSpriteText
                 {
-                    Text = "hold for menu",
                     Font = OsuFont.GetFont(weight: FontWeight.Bold),
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.CentreLeft
@@ -60,9 +60,23 @@ namespace osu.Game.Screens.Play.HUD
             AutoSizeAxes = Axes.Both;
         }
 
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        private Bindable<float> activationDelay;
+
         protected override void LoadComplete()
         {
+            activationDelay = config.GetBindable<float>(OsuSetting.UIHoldActivationDelay);
+            activationDelay.BindValueChanged(v =>
+            {
+                text.Text = v.NewValue > 0
+                    ? "hold for menu"
+                    : "press for menu";
+            }, true);
+
             text.FadeInFromZero(500, Easing.OutQuint).Delay(1500).FadeOut(500, Easing.OutQuint);
+
             base.LoadComplete();
         }
 

osu.Game/Screens/Play/PlayerLoader.cs

@@ -6,6 +6,8 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -14,11 +16,14 @@ using osu.Framework.Localisation;
 using osu.Framework.Screens;
 using osu.Framework.Threading;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Input;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play.HUD;
@@ -53,9 +58,19 @@ namespace osu.Game.Screens.Play
         private Task loadTask;
 
         private InputManager inputManager;
-
         private IdleTracker idleTracker;
 
+        [Resolved(CanBeNull = true)]
+        private NotificationOverlay notificationOverlay { get; set; }
+
+        [Resolved(CanBeNull = true)]
+        private VolumeOverlay volumeOverlay { get; set; }
+
+        [Resolved]
+        private AudioManager audioManager { get; set; }
+
+        private Bindable<bool> muteWarningShownOnce;
+
         public PlayerLoader(Func<Player> createPlayer)
         {
             this.createPlayer = createPlayer;
@@ -68,8 +83,10 @@ namespace osu.Game.Screens.Play
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(SessionStatics sessionStatics)
         {
+            muteWarningShownOnce = sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce);
+
             InternalChild = (content = new LogoTrackingContainer
             {
                 Anchor = Anchor.Centre,
@@ -103,7 +120,22 @@ namespace osu.Game.Screens.Play
             loadNewPlayer();
         }
 
-        private void playerLoaded(Player player) => info.Loading = false;
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            inputManager = GetContainingInputManager();
+
+            if (!muteWarningShownOnce.Value)
+            {
+                //Checks if the notification has not been shown yet and also if master volume is muted, track/music volume is muted or if the whole game is muted.
+                if (volumeOverlay?.IsMuted.Value == true || audioManager.Volume.Value <= audioManager.Volume.MinValue || audioManager.VolumeTrack.Value <= audioManager.VolumeTrack.MinValue)
+                {
+                    notificationOverlay?.Post(new MutedNotification());
+                    muteWarningShownOnce.Value = true;
+                }
+            }
+        }
 
         public override void OnResuming(IScreen last)
         {
@@ -127,7 +159,7 @@ namespace osu.Game.Screens.Play
             player.RestartCount = restartCount;
             player.RestartRequested = restartRequested;
 
-            loadTask = LoadComponentAsync(player, playerLoaded);
+            loadTask = LoadComponentAsync(player, _ => info.Loading = false);
         }
 
         private void contentIn()
@@ -185,12 +217,6 @@ namespace osu.Game.Screens.Play
             content.StopTracking();
         }
 
-        protected override void LoadComplete()
-        {
-            inputManager = GetContainingInputManager();
-            base.LoadComplete();
-        }
-
         private ScheduledDelegate pushDebounce;
         protected VisualSettings VisualSettings;
 
@@ -473,5 +499,33 @@ namespace osu.Game.Screens.Play
                 Loading = true;
             }
         }
+
+        private class MutedNotification : SimpleNotification
+        {
+            public MutedNotification()
+            {
+                Text = "Your music volume is set to 0%! Click here to restore it.";
+            }
+
+            public override bool IsImportant => true;
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours, AudioManager audioManager, NotificationOverlay notificationOverlay, VolumeOverlay volumeOverlay)
+            {
+                Icon = FontAwesome.Solid.VolumeMute;
+                IconBackgound.Colour = colours.RedDark;
+
+                Activated = delegate
+                {
+                    notificationOverlay.Hide();
+
+                    volumeOverlay.IsMuted.Value = false;
+                    audioManager.Volume.SetDefault();
+                    audioManager.VolumeTrack.SetDefault();
+
+                    return true;
+                };
+            }
+        }
     }
 }

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -82,6 +82,9 @@ namespace osu.Game.Screens.Select
             var _ = newRoot.Drawables;
 
             root = newRoot;
+            if (selectedBeatmapSet != null && !beatmapSets.Contains(selectedBeatmapSet.BeatmapSet))
+                selectedBeatmapSet = null;
+
             scrollableContent.Clear(false);
             itemsCache.Invalidate();
             scrollPositionCache.Invalidate();

osu.Game/Screens/Select/FilterControl.cs

@@ -49,8 +49,6 @@ namespace osu.Game.Screens.Select
             return criteria;
         }
 
-        public Action Exit;
-
         private readonly SearchTextBox searchTextBox;
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) =>
@@ -75,11 +73,7 @@ namespace osu.Game.Screens.Select
                     Origin = Anchor.TopRight,
                     Children = new Drawable[]
                     {
-                        searchTextBox = new SearchTextBox
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            Exit = () => Exit?.Invoke(),
-                        },
+                        searchTextBox = new SearchTextBox { RelativeSizeAxes = Axes.X },
                         new Box
                         {
                             RelativeSizeAxes = Axes.X,

osu.Game/Screens/Select/SongSelect.cs

@@ -171,11 +171,6 @@ namespace osu.Game.Screens.Select
                                 Height = FilterControl.HEIGHT,
                                 FilterChanged = c => Carousel.Filter(c),
                                 Background = { Width = 2 },
-                                Exit = () =>
-                                {
-                                    if (this.IsCurrentScreen())
-                                        this.Exit();
-                                },
                             },
                         }
                     },
@@ -490,6 +485,7 @@ namespace osu.Game.Screens.Select
             BeatmapDetails.Leaderboard.RefreshScores();
 
             Beatmap.Value.Track.Looping = true;
+            music?.ResetTrackAdjustments();
 
             if (Beatmap != null && !Beatmap.Value.BeatmapSetInfo.DeletePending)
             {

osu.Game/Skinning/SkinReloadableDrawable.cs

@@ -12,13 +12,17 @@ namespace osu.Game.Skinning
     /// </summary>
     public abstract class SkinReloadableDrawable : CompositeDrawable
     {
+        /// <summary>
+        /// The current skin source.
+        /// </summary>
+        protected ISkinSource CurrentSkin { get; private set; }
+
         private readonly Func<ISkinSource, bool> allowFallback;
-        private ISkinSource skin;
 
         /// <summary>
         /// Whether fallback to default skin should be allowed if the custom skin is missing this resource.
         /// </summary>
-        private bool allowDefaultFallback => allowFallback == null || allowFallback.Invoke(skin);
+        private bool allowDefaultFallback => allowFallback == null || allowFallback.Invoke(CurrentSkin);
 
         /// <summary>
         /// Create a new <see cref="SkinReloadableDrawable"/>
@@ -32,19 +36,19 @@ namespace osu.Game.Skinning
         [BackgroundDependencyLoader]
         private void load(ISkinSource source)
         {
-            skin = source;
-            skin.SourceChanged += onChange;
+            CurrentSkin = source;
+            CurrentSkin.SourceChanged += onChange;
         }
 
         private void onChange() =>
             // schedule required to avoid calls after disposed.
             // note that this has the side-effect of components only performing a skin change when they are alive.
-            Scheduler.AddOnce(() => SkinChanged(skin, allowDefaultFallback));
+            Scheduler.AddOnce(() => SkinChanged(CurrentSkin, allowDefaultFallback));
 
         protected override void LoadAsyncComplete()
         {
             base.LoadAsyncComplete();
-            SkinChanged(skin, allowDefaultFallback);
+            SkinChanged(CurrentSkin, allowDefaultFallback);
         }
 
         /// <summary>
@@ -60,8 +64,8 @@ namespace osu.Game.Skinning
         {
             base.Dispose(isDisposing);
 
-            if (skin != null)
-                skin.SourceChanged -= onChange;
+            if (CurrentSkin != null)
+                CurrentSkin.SourceChanged -= onChange;
         }
     }
 }

osu.Game/Tests/Visual/OsuTestScene.cs

@@ -28,9 +28,9 @@ namespace osu.Game.Tests.Visual
     {
         [Cached(typeof(Bindable<WorkingBeatmap>))]
         [Cached(typeof(IBindable<WorkingBeatmap>))]
-        private OsuTestBeatmap beatmap;
+        private NonNullableBindable<WorkingBeatmap> beatmap;
 
-        protected BindableBeatmap Beatmap => beatmap;
+        protected Bindable<WorkingBeatmap> Beatmap => beatmap;
 
         [Cached]
         [Cached(typeof(IBindable<RulesetInfo>))]
@@ -73,10 +73,13 @@ namespace osu.Game.Tests.Visual
             // This is the earliest we can get OsuGameBase, which is used by the dummy working beatmap to find textures
             var working = new DummyWorkingBeatmap(parent.Get<AudioManager>(), parent.Get<TextureStore>());
 
-            beatmap = new OsuTestBeatmap(working)
+            beatmap = new NonNullableBindable<WorkingBeatmap>(working) { Default = working };
+            beatmap.BindValueChanged(b => ScheduleAfterChildren(() =>
             {
-                Default = working
-            };
+                // compare to last beatmap as sometimes the two may share a track representation (optimisation, see WorkingBeatmap.TransferTo)
+                if (b.OldValue?.TrackLoaded == true && b.OldValue?.Track != b.NewValue?.Track)
+                    b.OldValue.RecycleTrack();
+            }));
 
             Dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
@@ -317,13 +320,5 @@ namespace osu.Game.Tests.Visual
 
             public void RunTestBlocking(TestScene test) => runner.RunTestBlocking(test);
         }
-
-        private class OsuTestBeatmap : BindableBeatmap
-        {
-            public OsuTestBeatmap(WorkingBeatmap defaultValue)
-                : base(defaultValue)
-            {
-            }
-        }
     }
 }

osu.Game/Updater/SimpleUpdateManager.cs

@@ -6,31 +6,25 @@ using System.Threading.Tasks;
 using Newtonsoft.Json;
 using osu.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.IO.Network;
 using osu.Framework.Platform;
-using osu.Game;
-using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 
-namespace osu.Desktop.Updater
+namespace osu.Game.Updater
 {
     /// <summary>
     /// An update manager that shows notifications if a newer release is detected.
     /// Installation is left up to the user.
     /// </summary>
-    internal class SimpleUpdateManager : CompositeDrawable
+    public class SimpleUpdateManager : UpdateManager
     {
-        private NotificationOverlay notificationOverlay;
         private string version;
         private GameHost host;
 
         [BackgroundDependencyLoader]
-        private void load(NotificationOverlay notification, OsuGameBase game, GameHost host)
+        private void load(OsuGameBase game, GameHost host)
         {
-            notificationOverlay = notification;
-
             this.host = host;
             version = game.Version;
 
@@ -50,7 +44,7 @@ namespace osu.Desktop.Updater
 
                 if (latest.TagName != version)
                 {
-                    notificationOverlay.Post(new SimpleNotification
+                    Notifications.Post(new SimpleNotification
                     {
                         Text = $"A newer release of osu! has been found ({version} → {latest.TagName}).\n\n"
                                + "Click here to download the new version, which can be installed over the top of your existing installation",
@@ -82,6 +76,11 @@ namespace osu.Desktop.Updater
                 case RuntimeInfo.Platform.MacOsx:
                     bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".app.zip"));
                     break;
+
+                case RuntimeInfo.Platform.Android:
+                    // on our testing device this causes the download to magically disappear.
+                    //bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".apk"));
+                    break;
             }
 
             return bestAsset?.BrowserDownloadUrl ?? release.HtmlUrl;

osu.Game/Updater/UpdateManager.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 osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
+
+namespace osu.Game.Updater
+{
+    public abstract class UpdateManager : CompositeDrawable
+    {
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [Resolved]
+        private OsuGameBase game { get; set; }
+
+        [Resolved]
+        protected NotificationOverlay Notifications { get; private set; }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            var version = game.Version;
+            var lastVersion = config.Get<string>(OsuSetting.Version);
+
+            if (game.IsDeployedBuild && version != lastVersion)
+            {
+                config.Set(OsuSetting.Version, version);
+
+                // only show a notification if we've previously saved a version to the config file (ie. not the first run).
+                if (!string.IsNullOrEmpty(lastVersion))
+                    Notifications.Post(new UpdateCompleteNotification(version));
+            }
+        }
+
+        private class UpdateCompleteNotification : SimpleNotification
+        {
+            private readonly string version;
+
+            public UpdateCompleteNotification(string version)
+            {
+                this.version = version;
+                Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours, ChangelogOverlay changelog, NotificationOverlay notificationOverlay)
+            {
+                Icon = FontAwesome.Solid.CheckSquare;
+                IconBackgound.Colour = colours.BlueDark;
+
+                Activated = delegate
+                {
+                    notificationOverlay.Hide();
+                    changelog.ShowBuild(OsuGameBase.CLIENT_STREAM_NAME, version);
+                    return true;
+                };
+            }
+        }
+    }
+}

osu.Game/Users/User.cs

@@ -78,6 +78,9 @@ namespace osu.Game.Users
         [JsonProperty(@"is_bng")]
         public bool IsBNG;
 
+        [JsonProperty(@"is_bot")]
+        public bool IsBot;
+
         [JsonProperty(@"is_active")]
         public bool Active;
 

osu.Game/osu.Game.csproj

@@ -21,12 +21,12 @@
     <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Humanizer" Version="2.7.2" />
+    <PackageReference Include="Humanizer" Version="2.7.9" />
     <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.2" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.913.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2019.924.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2019.930.0" />
     <PackageReference Include="SharpCompress" Version="0.24.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />

osu.iOS.props

@@ -113,13 +113,13 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Humanizer" Version="2.7.2" />
+    <PackageReference Include="Humanizer" Version="2.7.9" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.1" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.913.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2019.924.0" />
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.924.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2019.930.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.930.0" />
     <PackageReference Include="SharpCompress" Version="0.24.0" />
     <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />