Merge branch 'master' into timing-equivalence

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

@@ -0,0 +1,51 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Replays;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class ManiaLegacyReplayTest
+    {
+        [TestCase(ManiaAction.Key1)]
+        [TestCase(ManiaAction.Key1, ManiaAction.Key2)]
+        [TestCase(ManiaAction.Special1)]
+        [TestCase(ManiaAction.Key8)]
+        public void TestEncodeDecodeSingleStage(params ManiaAction[] actions)
+        {
+            var beatmap = new ManiaBeatmap(new StageDefinition { Columns = 9 });
+
+            var frame = new ManiaReplayFrame(0, actions);
+            var legacyFrame = frame.ToLegacy(beatmap);
+
+            var decodedFrame = new ManiaReplayFrame();
+            decodedFrame.FromLegacy(legacyFrame, beatmap);
+
+            Assert.That(decodedFrame.Actions, Is.EquivalentTo(frame.Actions));
+        }
+
+        [TestCase(ManiaAction.Key1)]
+        [TestCase(ManiaAction.Key1, ManiaAction.Key2)]
+        [TestCase(ManiaAction.Special1)]
+        [TestCase(ManiaAction.Special2)]
+        [TestCase(ManiaAction.Special1, ManiaAction.Special2)]
+        [TestCase(ManiaAction.Special1, ManiaAction.Key5)]
+        [TestCase(ManiaAction.Key8)]
+        public void TestEncodeDecodeDualStage(params ManiaAction[] actions)
+        {
+            var beatmap = new ManiaBeatmap(new StageDefinition { Columns = 5 });
+            beatmap.Stages.Add(new StageDefinition { Columns = 5 });
+
+            var frame = new ManiaReplayFrame(0, actions);
+            var legacyFrame = frame.ToLegacy(beatmap);
+
+            var decodedFrame = new ManiaReplayFrame();
+            decodedFrame.FromLegacy(legacyFrame, beatmap);
+
+            Assert.That(decodedFrame.Actions, Is.EquivalentTo(frame.Actions));
+        }
+    }
+}

osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs

@@ -1,8 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Replays
 
             while (activeColumns > 0)
             {
-                var isSpecial = maniaBeatmap.Stages.First().IsSpecialColumn(counter);
+                bool isSpecial = isColumnAtIndexSpecial(maniaBeatmap, counter);
 
                 if ((activeColumns & 1) > 0)
                     Actions.Add(isSpecial ? specialAction : normalAction);
@@ -58,33 +58,87 @@ namespace osu.Game.Rulesets.Mania.Replays
 
             int keys = 0;
 
-            var specialColumns = new List<int>();
-
-            for (int i = 0; i < maniaBeatmap.TotalColumns; i++)
-            {
-                if (maniaBeatmap.Stages.First().IsSpecialColumn(i))
-                    specialColumns.Add(i);
-            }
-
             foreach (var action in Actions)
             {
                 switch (action)
                 {
                     case ManiaAction.Special1:
-                        keys |= 1 << specialColumns[0];
+                        keys |= 1 << getSpecialColumnIndex(maniaBeatmap, 0);
                         break;
 
                     case ManiaAction.Special2:
-                        keys |= 1 << specialColumns[1];
+                        keys |= 1 << getSpecialColumnIndex(maniaBeatmap, 1);
                         break;
 
                     default:
-                        keys |= 1 << (action - ManiaAction.Key1);
+                        // the index in lazer, which doesn't include special keys.
+                        int nonSpecialKeyIndex = action - ManiaAction.Key1;
+
+                        // the index inclusive of special keys.
+                        int overallIndex = 0;
+
+                        // iterate to find the index including special keys.
+                        for (; overallIndex < maniaBeatmap.TotalColumns; overallIndex++)
+                        {
+                            // skip over special columns.
+                            if (isColumnAtIndexSpecial(maniaBeatmap, overallIndex))
+                                continue;
+                            // found a non-special column to use.
+                            if (nonSpecialKeyIndex == 0)
+                                break;
+                            // found a non-special column but not ours.
+                            nonSpecialKeyIndex--;
+                        }
+
+                        keys |= 1 << overallIndex;
                         break;
                 }
             }
 
             return new LegacyReplayFrame(Time, keys, null, ReplayButtonState.None);
         }
+
+        /// <summary>
+        /// Find the overall index (across all stages) for a specified special key.
+        /// </summary>
+        /// <param name="maniaBeatmap">The beatmap.</param>
+        /// <param name="specialOffset">The special key offset (0 is S1).</param>
+        /// <returns>The overall index for the special column.</returns>
+        private int getSpecialColumnIndex(ManiaBeatmap maniaBeatmap, int specialOffset)
+        {
+            for (int i = 0; i < maniaBeatmap.TotalColumns; i++)
+            {
+                if (isColumnAtIndexSpecial(maniaBeatmap, i))
+                {
+                    if (specialOffset == 0)
+                        return i;
+
+                    specialOffset--;
+                }
+            }
+
+            throw new ArgumentException("Special key index is too high.", nameof(specialOffset));
+        }
+
+        /// <summary>
+        /// Check whether the column at an overall index (across all stages) is a special column.
+        /// </summary>
+        /// <param name="beatmap">The beatmap.</param>
+        /// <param name="index">The overall index to check.</param>
+        private bool isColumnAtIndexSpecial(ManiaBeatmap beatmap, int index)
+        {
+            foreach (var stage in beatmap.Stages)
+            {
+                if (index >= stage.Columns)
+                {
+                    index -= stage.Columns;
+                    continue;
+                }
+
+                return stage.IsSpecialColumn(index);
+            }
+
+            throw new ArgumentException("Column index is too high.", nameof(index));
+        }
     }
 }

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

@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         /// <summary>
         /// Moves <see cref="Content"/> to a layer proxied above the playfield.
-        /// Does nothing is content is already proxied.
+        /// Does nothing if content is already proxied.
         /// </summary>
         protected void ProxyContent()
         {

osu.Game.Tests/Editor/EditorChangeHandlerTest.cs

@@ -15,15 +15,18 @@ namespace osu.Game.Tests.Editor
         {
             var handler = new EditorChangeHandler(new EditorBeatmap(new Beatmap()));
 
-            Assert.That(handler.HasUndoState, Is.False);
+            Assert.That(handler.CanUndo.Value, Is.False);
+            Assert.That(handler.CanRedo.Value, Is.False);
 
             handler.SaveState();
 
-            Assert.That(handler.HasUndoState, Is.True);
+            Assert.That(handler.CanUndo.Value, Is.True);
+            Assert.That(handler.CanRedo.Value, Is.False);
 
             handler.RestoreState(-1);
 
-            Assert.That(handler.HasUndoState, Is.False);
+            Assert.That(handler.CanUndo.Value, Is.False);
+            Assert.That(handler.CanRedo.Value, Is.True);
         }
 
         [Test]
@@ -31,20 +34,20 @@ namespace osu.Game.Tests.Editor
         {
             var handler = new EditorChangeHandler(new EditorBeatmap(new Beatmap()));
 
-            Assert.That(handler.HasUndoState, Is.False);
+            Assert.That(handler.CanUndo.Value, Is.False);
 
             for (int i = 0; i < EditorChangeHandler.MAX_SAVED_STATES; i++)
                 handler.SaveState();
 
-            Assert.That(handler.HasUndoState, Is.True);
+            Assert.That(handler.CanUndo.Value, Is.True);
 
             for (int i = 0; i < EditorChangeHandler.MAX_SAVED_STATES; i++)
             {
-                Assert.That(handler.HasUndoState, Is.True);
+                Assert.That(handler.CanUndo.Value, Is.True);
                 handler.RestoreState(-1);
             }
 
-            Assert.That(handler.HasUndoState, Is.False);
+            Assert.That(handler.CanUndo.Value, Is.False);
         }
 
         [Test]
@@ -52,20 +55,20 @@ namespace osu.Game.Tests.Editor
         {
             var handler = new EditorChangeHandler(new EditorBeatmap(new Beatmap()));
 
-            Assert.That(handler.HasUndoState, Is.False);
+            Assert.That(handler.CanUndo.Value, Is.False);
 
             for (int i = 0; i < EditorChangeHandler.MAX_SAVED_STATES * 2; i++)
                 handler.SaveState();
 
-            Assert.That(handler.HasUndoState, Is.True);
+            Assert.That(handler.CanUndo.Value, Is.True);
 
             for (int i = 0; i < EditorChangeHandler.MAX_SAVED_STATES; i++)
             {
-                Assert.That(handler.HasUndoState, Is.True);
+                Assert.That(handler.CanUndo.Value, Is.True);
                 handler.RestoreState(-1);
             }
 
-            Assert.That(handler.HasUndoState, Is.False);
+            Assert.That(handler.CanUndo.Value, Is.False);
         }
     }
 }

osu.Game.Tests/Gameplay/TestSceneHitObjectSamples.cs

@@ -0,0 +1,346 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.IO.Stores;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.IO;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Skinning;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Resources;
+using osu.Game.Tests.Visual;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Gameplay
+{
+    [HeadlessTest]
+    public class TestSceneHitObjectSamples : PlayerTestScene
+    {
+        private readonly SkinInfo userSkinInfo = new SkinInfo();
+
+        private readonly BeatmapInfo beatmapInfo = new BeatmapInfo
+        {
+            BeatmapSet = new BeatmapSetInfo(),
+            Metadata = new BeatmapMetadata
+            {
+                Author = User.SYSTEM_USER
+            }
+        };
+
+        private readonly TestResourceStore userSkinResourceStore = new TestResourceStore();
+        private readonly TestResourceStore beatmapSkinResourceStore = new TestResourceStore();
+
+        protected override bool HasCustomSteps => true;
+
+        public TestSceneHitObjectSamples()
+            : base(new OsuRuleset())
+        {
+        }
+
+        private SkinSourceDependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            => new DependencyContainer(dependencies = new SkinSourceDependencyContainer(base.CreateChildDependencies(parent)));
+
+        /// <summary>
+        /// Tests that a hitobject which provides no custom sample set retrieves samples from the user skin.
+        /// </summary>
+        [Test]
+        public void TestDefaultSampleFromUserSkin()
+        {
+            const string expected_sample = "normal-hitnormal";
+
+            setupSkins(expected_sample, expected_sample);
+
+            createTestWithBeatmap("hitobject-skin-sample.osu");
+
+            assertUserLookup(expected_sample);
+        }
+
+        /// <summary>
+        /// Tests that a hitobject which provides a sample set of 1 retrieves samples from the beatmap skin.
+        /// </summary>
+        [Test]
+        public void TestDefaultSampleFromBeatmap()
+        {
+            const string expected_sample = "normal-hitnormal";
+
+            setupSkins(expected_sample, expected_sample);
+
+            createTestWithBeatmap("hitobject-beatmap-sample.osu");
+
+            assertBeatmapLookup(expected_sample);
+        }
+
+        /// <summary>
+        /// Tests that a hitobject which provides a sample set of 1 retrieves samples from the user skin when the beatmap does not contain the sample.
+        /// </summary>
+        [Test]
+        public void TestDefaultSampleFromUserSkinFallback()
+        {
+            const string expected_sample = "normal-hitnormal";
+
+            setupSkins(null, expected_sample);
+
+            createTestWithBeatmap("hitobject-beatmap-sample.osu");
+
+            assertUserLookup(expected_sample);
+        }
+
+        /// <summary>
+        /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the beatmap skin:
+        /// normal-hitnormal2
+        /// normal-hitnormal
+        /// </summary>
+        [TestCase("normal-hitnormal2")]
+        [TestCase("normal-hitnormal")]
+        public void TestDefaultCustomSampleFromBeatmap(string expectedSample)
+        {
+            setupSkins(expectedSample, expectedSample);
+
+            createTestWithBeatmap("hitobject-beatmap-custom-sample.osu");
+
+            assertBeatmapLookup(expectedSample);
+        }
+
+        /// <summary>
+        /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the user skin when the beatmap does not contain the sample:
+        /// normal-hitnormal2
+        /// normal-hitnormal
+        /// </summary>
+        [TestCase("normal-hitnormal2")]
+        [TestCase("normal-hitnormal")]
+        public void TestDefaultCustomSampleFromUserSkinFallback(string expectedSample)
+        {
+            setupSkins(string.Empty, expectedSample);
+
+            createTestWithBeatmap("hitobject-beatmap-custom-sample.osu");
+
+            assertUserLookup(expectedSample);
+        }
+
+        /// <summary>
+        /// Tests that a hitobject which provides a sample file retrieves the sample file from the beatmap skin.
+        /// </summary>
+        [Test]
+        public void TestFileSampleFromBeatmap()
+        {
+            const string expected_sample = "hit_1.wav";
+
+            setupSkins(expected_sample, expected_sample);
+
+            createTestWithBeatmap("file-beatmap-sample.osu");
+
+            assertBeatmapLookup(expected_sample);
+        }
+
+        /// <summary>
+        /// Tests that a default hitobject and control point causes <see cref="TestDefaultSampleFromUserSkin"/>.
+        /// </summary>
+        [Test]
+        public void TestControlPointSampleFromSkin()
+        {
+            const string expected_sample = "normal-hitnormal";
+
+            setupSkins(expected_sample, expected_sample);
+
+            createTestWithBeatmap("controlpoint-skin-sample.osu");
+
+            assertUserLookup(expected_sample);
+        }
+
+        /// <summary>
+        /// Tests that a control point that provides a custom sample set of 1 causes <see cref="TestDefaultSampleFromBeatmap"/>.
+        /// </summary>
+        [Test]
+        public void TestControlPointSampleFromBeatmap()
+        {
+            const string expected_sample = "normal-hitnormal";
+
+            setupSkins(expected_sample, expected_sample);
+
+            createTestWithBeatmap("controlpoint-beatmap-sample.osu");
+
+            assertBeatmapLookup(expected_sample);
+        }
+
+        /// <summary>
+        /// Tests that a control point that provides a custom sample of 2 causes <see cref="TestDefaultCustomSampleFromBeatmap"/>.
+        /// </summary>
+        [TestCase("normal-hitnormal2")]
+        [TestCase("normal-hitnormal")]
+        public void TestControlPointCustomSampleFromBeatmap(string sampleName)
+        {
+            setupSkins(sampleName, sampleName);
+
+            createTestWithBeatmap("controlpoint-beatmap-custom-sample.osu");
+
+            assertBeatmapLookup(sampleName);
+        }
+
+        /// <summary>
+        /// Tests that a hitobject's custom sample overrides the control point's.
+        /// </summary>
+        [Test]
+        public void TestHitObjectCustomSampleOverride()
+        {
+            const string expected_sample = "normal-hitnormal3";
+
+            setupSkins(expected_sample, expected_sample);
+
+            createTestWithBeatmap("hitobject-beatmap-custom-sample-override.osu");
+
+            assertBeatmapLookup(expected_sample);
+        }
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => currentTestBeatmap;
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
+            => new TestWorkingBeatmap(beatmapInfo, beatmapSkinResourceStore, beatmap, storyboard, Clock, Audio);
+
+        private IBeatmap currentTestBeatmap;
+
+        private void createTestWithBeatmap(string filename)
+        {
+            CreateTest(() =>
+            {
+                AddStep("clear performed lookups", () =>
+                {
+                    userSkinResourceStore.PerformedLookups.Clear();
+                    beatmapSkinResourceStore.PerformedLookups.Clear();
+                });
+
+                AddStep($"load {filename}", () =>
+                {
+                    using (var reader = new LineBufferedReader(TestResources.OpenResource($"SampleLookups/{filename}")))
+                        currentTestBeatmap = Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
+                });
+            });
+        }
+
+        private void setupSkins(string beatmapFile, string userFile)
+        {
+            AddStep("setup skins", () =>
+            {
+                userSkinInfo.Files = new List<SkinFileInfo>
+                {
+                    new SkinFileInfo
+                    {
+                        Filename = userFile,
+                        FileInfo = new IO.FileInfo { Hash = userFile }
+                    }
+                };
+
+                beatmapInfo.BeatmapSet.Files = new List<BeatmapSetFileInfo>
+                {
+                    new BeatmapSetFileInfo
+                    {
+                        Filename = beatmapFile,
+                        FileInfo = new IO.FileInfo { Hash = beatmapFile }
+                    }
+                };
+
+                // Need to refresh the cached skin source to refresh the skin resource store.
+                dependencies.SkinSource = new SkinProvidingContainer(new LegacySkin(userSkinInfo, userSkinResourceStore, Audio));
+            });
+        }
+
+        private void assertBeatmapLookup(string name) => AddAssert($"\"{name}\" looked up from beatmap skin",
+            () => !userSkinResourceStore.PerformedLookups.Contains(name) && beatmapSkinResourceStore.PerformedLookups.Contains(name));
+
+        private void assertUserLookup(string name) => AddAssert($"\"{name}\" looked up from user skin",
+            () => !beatmapSkinResourceStore.PerformedLookups.Contains(name) && userSkinResourceStore.PerformedLookups.Contains(name));
+
+        private class SkinSourceDependencyContainer : IReadOnlyDependencyContainer
+        {
+            public ISkinSource SkinSource;
+
+            private readonly IReadOnlyDependencyContainer fallback;
+
+            public SkinSourceDependencyContainer(IReadOnlyDependencyContainer fallback)
+            {
+                this.fallback = fallback;
+            }
+
+            public object Get(Type type)
+            {
+                if (type == typeof(ISkinSource))
+                    return SkinSource;
+
+                return fallback.Get(type);
+            }
+
+            public object Get(Type type, CacheInfo info)
+            {
+                if (type == typeof(ISkinSource))
+                    return SkinSource;
+
+                return fallback.Get(type, info);
+            }
+
+            public void Inject<T>(T instance) where T : class
+            {
+                // Never used directly
+            }
+        }
+
+        private class TestResourceStore : IResourceStore<byte[]>
+        {
+            public readonly List<string> PerformedLookups = new List<string>();
+
+            public byte[] Get(string name)
+            {
+                markLookup(name);
+                return Array.Empty<byte>();
+            }
+
+            public Task<byte[]> GetAsync(string name)
+            {
+                markLookup(name);
+                return Task.FromResult(Array.Empty<byte>());
+            }
+
+            public Stream GetStream(string name)
+            {
+                markLookup(name);
+                return new MemoryStream();
+            }
+
+            private void markLookup(string name) => PerformedLookups.Add(name.Substring(name.LastIndexOf(Path.DirectorySeparatorChar) + 1));
+
+            public IEnumerable<string> GetAvailableResources() => Enumerable.Empty<string>();
+
+            public void Dispose()
+            {
+            }
+        }
+
+        private class TestWorkingBeatmap : ClockBackedTestWorkingBeatmap
+        {
+            private readonly BeatmapInfo skinBeatmapInfo;
+            private readonly IResourceStore<byte[]> resourceStore;
+
+            public TestWorkingBeatmap(BeatmapInfo skinBeatmapInfo, IResourceStore<byte[]> resourceStore, IBeatmap beatmap, Storyboard storyboard, IFrameBasedClock referenceClock, AudioManager audio,
+                                      double length = 60000)
+                : base(beatmap, storyboard, referenceClock, audio, length)
+            {
+                this.skinBeatmapInfo = skinBeatmapInfo;
+                this.resourceStore = resourceStore;
+            }
+
+            protected override ISkin GetSkin() => new LegacyBeatmapSkin(skinBeatmapInfo, resourceStore, AudioManager);
+        }
+    }
+}

osu.Game.Tests/Online/TestDummyAPIRequestHandling.cs

@@ -0,0 +1,117 @@
+// 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.Testing;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Chat;
+using osu.Game.Tests.Visual;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Online
+{
+    [HeadlessTest]
+    public class TestDummyAPIRequestHandling : OsuTestScene
+    {
+        [Test]
+        public void TestGenericRequestHandling()
+        {
+            AddStep("register request handling", () => ((DummyAPIAccess)API).HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case CommentVoteRequest cRequest:
+                        cRequest.TriggerSuccess(new CommentBundle());
+                        break;
+                }
+            });
+
+            CommentVoteRequest request = null;
+            CommentBundle response = null;
+
+            AddStep("fire request", () =>
+            {
+                response = null;
+                request = new CommentVoteRequest(1, CommentVoteAction.Vote);
+                request.Success += res => response = res;
+                API.Queue(request);
+            });
+
+            AddAssert("response event fired", () => response != null);
+
+            AddAssert("request has response", () => request.Result == response);
+        }
+
+        [Test]
+        public void TestQueueRequestHandling()
+        {
+            registerHandler();
+
+            LeaveChannelRequest request;
+            bool gotResponse = false;
+
+            AddStep("fire request", () =>
+            {
+                gotResponse = false;
+                request = new LeaveChannelRequest(new Channel(), new User());
+                request.Success += () => gotResponse = true;
+                API.Queue(request);
+            });
+
+            AddAssert("response event fired", () => gotResponse);
+        }
+
+        [Test]
+        public void TestPerformRequestHandling()
+        {
+            registerHandler();
+
+            LeaveChannelRequest request;
+            bool gotResponse = false;
+
+            AddStep("fire request", () =>
+            {
+                gotResponse = false;
+                request = new LeaveChannelRequest(new Channel(), new User());
+                request.Success += () => gotResponse = true;
+                API.Perform(request);
+            });
+
+            AddAssert("response event fired", () => gotResponse);
+        }
+
+        [Test]
+        public void TestPerformAsyncRequestHandling()
+        {
+            registerHandler();
+
+            LeaveChannelRequest request;
+            bool gotResponse = false;
+
+            AddStep("fire request", () =>
+            {
+                gotResponse = false;
+                request = new LeaveChannelRequest(new Channel(), new User());
+                request.Success += () => gotResponse = true;
+                API.PerformAsync(request);
+            });
+
+            AddAssert("response event fired", () => gotResponse);
+        }
+
+        private void registerHandler()
+        {
+            AddStep("register request handling", () => ((DummyAPIAccess)API).HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case LeaveChannelRequest cRequest:
+                        cRequest.TriggerSuccess();
+                        break;
+                }
+            });
+        }
+    }
+}

osu.Game.Tests/Resources/SampleLookups/controlpoint-beatmap-custom-sample.osu

@@ -0,0 +1,7 @@
+osu file format v14
+
+[TimingPoints]
+0,300,4,0,2,100,1,0
+
+[HitObjects]
+444,320,1000,5,0,0:0:0:0:

osu.Game.Tests/Resources/SampleLookups/controlpoint-beatmap-sample.osu

@@ -0,0 +1,7 @@
+osu file format v14
+
+[TimingPoints]
+0,300,4,0,1,100,1,0
+
+[HitObjects]
+444,320,1000,5,0,0:0:0:0:

osu.Game.Tests/Resources/SampleLookups/controlpoint-skin-sample.osu

@@ -0,0 +1,7 @@
+osu file format v14
+
+[TimingPoints]
+0,300,4,0,0,100,1,0
+
+[HitObjects]
+444,320,1000,5,0,0:0:0:0:

osu.Game.Tests/Resources/SampleLookups/file-beatmap-sample.osu

@@ -0,0 +1,4 @@
+osu file format v14
+
+[HitObjects]
+255,193,2170,1,0,0:0:0:0:hit_1.wav

osu.Game.Tests/Resources/SampleLookups/hitobject-beatmap-custom-sample-override.osu

@@ -0,0 +1,7 @@
+osu file format v14
+
+[TimingPoints]
+0,300,4,0,2,100,1,0
+
+[HitObjects]
+444,320,1000,5,0,0:0:3:0:

osu.Game.Tests/Resources/SampleLookups/hitobject-beatmap-custom-sample.osu

@@ -0,0 +1,4 @@
+osu file format v14
+
+[HitObjects]
+444,320,1000,5,0,0:0:2:0:

osu.Game.Tests/Resources/SampleLookups/hitobject-beatmap-sample.osu

@@ -0,0 +1,4 @@
+osu file format v14
+
+[HitObjects]
+444,320,1000,5,0,0:0:1:0:

osu.Game.Tests/Resources/SampleLookups/hitobject-skin-sample.osu

@@ -0,0 +1,4 @@
+osu file format v14
+
+[HitObjects]
+444,320,1000,5,0,0:0:0:0:

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

@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Testing;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneFailingLayer : OsuTestScene
+    {
+        private FailingLayer layer;
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create layer", () =>
+            {
+                Child = layer = new FailingLayer();
+                layer.BindHealthProcessor(new DrainingHealthProcessor(1));
+            });
+
+            AddStep("enable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
+            AddUntilStep("layer is visible", () => layer.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerFading()
+        {
+            AddSliderStep("current health", 0.0, 1.0, 1.0, val =>
+            {
+                if (layer != null)
+                    layer.Current.Value = val;
+            });
+
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+            AddUntilStep("layer fade is visible", () => layer.Child.Alpha > 0.1f);
+            AddStep("set health to 1", () => layer.Current.Value = 1f);
+            AddUntilStep("layer fade is invisible", () => !layer.Child.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerDisabledViaConfig()
+        {
+            AddStep("disable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, false));
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+            AddUntilStep("layer is not visible", () => !layer.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerVisibilityWithAccumulatingProcessor()
+        {
+            AddStep("bind accumulating processor", () => layer.BindHealthProcessor(new AccumulatingHealthProcessor(1)));
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+            AddUntilStep("layer is not visible", () => !layer.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerVisibilityWithDrainingProcessor()
+        {
+            AddStep("bind accumulating processor", () => layer.BindHealthProcessor(new DrainingHealthProcessor(1)));
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+            AddWaitStep("wait for potential fade", 10);
+            AddAssert("layer is still visible", () => layer.IsPresent);
+        }
+    }
+}

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

@@ -54,6 +54,35 @@ namespace osu.Game.Tests.Visual.SongSelect
             this.rulesets = rulesets;
         }
 
+        [Test]
+        public void TestRecommendedSelection()
+        {
+            loadBeatmaps();
+
+            AddStep("set recommendation function", () => carousel.GetRecommendedBeatmap = beatmaps => beatmaps.LastOrDefault());
+
+            // check recommended was selected
+            advanceSelection(direction: 1, diff: false);
+            waitForSelection(1, 3);
+
+            // change away from recommended
+            advanceSelection(direction: -1, diff: true);
+            waitForSelection(1, 2);
+
+            // next set, check recommended
+            advanceSelection(direction: 1, diff: false);
+            waitForSelection(2, 3);
+
+            // next set, check recommended
+            advanceSelection(direction: 1, diff: false);
+            waitForSelection(3, 3);
+
+            // go back to first set and ensure user selection was retained
+            advanceSelection(direction: -1, diff: false);
+            advanceSelection(direction: -1, diff: false);
+            waitForSelection(1, 2);
+        }
+
         /// <summary>
         /// Test keyboard traversal
         /// </summary>

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

@@ -0,0 +1,91 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterface;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneOsuMenu : OsuManualInputManagerTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(OsuMenu),
+            typeof(DrawableOsuMenuItem)
+        };
+
+        private OsuMenu menu;
+        private bool actionPerformed;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            actionPerformed = false;
+
+            Child = menu = new OsuMenu(Direction.Vertical, true)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Items = new[]
+                {
+                    new OsuMenuItem("standard", MenuItemType.Standard, performAction),
+                    new OsuMenuItem("highlighted", MenuItemType.Highlighted, performAction),
+                    new OsuMenuItem("destructive", MenuItemType.Destructive, performAction),
+                }
+            };
+        });
+
+        [Test]
+        public void TestClickEnabledMenuItem()
+        {
+            AddStep("move to first menu item", () => InputManager.MoveMouseTo(menu.ChildrenOfType<DrawableOsuMenuItem>().First()));
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("action performed", () => actionPerformed);
+        }
+
+        [Test]
+        public void TestDisableMenuItemsAndClick()
+        {
+            AddStep("disable menu items", () =>
+            {
+                foreach (var item in menu.Items)
+                    ((OsuMenuItem)item).Action.Disabled = true;
+            });
+
+            AddStep("move to first menu item", () => InputManager.MoveMouseTo(menu.ChildrenOfType<DrawableOsuMenuItem>().First()));
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("action not performed", () => !actionPerformed);
+        }
+
+        [Test]
+        public void TestEnableMenuItemsAndClick()
+        {
+            AddStep("disable menu items", () =>
+            {
+                foreach (var item in menu.Items)
+                    ((OsuMenuItem)item).Action.Disabled = true;
+            });
+
+            AddStep("enable menu items", () =>
+            {
+                foreach (var item in menu.Items)
+                    ((OsuMenuItem)item).Action.Disabled = false;
+            });
+
+            AddStep("move to first menu item", () => InputManager.MoveMouseTo(menu.ChildrenOfType<DrawableOsuMenuItem>().First()));
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("action performed", () => actionPerformed);
+        }
+
+        private void performAction() => actionPerformed = true;
+    }
+}

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -8,6 +8,7 @@ using osu.Framework.Logging;
 using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.IO;
+using osu.Game.Rulesets.Objects.Legacy;
 using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.Formats
@@ -168,8 +169,11 @@ namespace osu.Game.Beatmaps.Formats
             {
                 var baseInfo = base.ApplyTo(hitSampleInfo);
 
-                if (string.IsNullOrEmpty(baseInfo.Suffix) && CustomSampleBank > 1)
+                if (baseInfo is ConvertHitObjectParser.LegacyHitSampleInfo legacy
-                    baseInfo.Suffix = CustomSampleBank.ToString();
+                    && legacy.CustomSampleBank == 0)
+                {
+                    legacy.CustomSampleBank = CustomSampleBank;
+                }
 
                 return baseInfo;
             }

osu.Game/Configuration/OsuConfigManager.cs

@@ -88,6 +88,7 @@ namespace osu.Game.Configuration
             Set(OsuSetting.ShowInterface, true);
             Set(OsuSetting.ShowProgressGraph, true);
             Set(OsuSetting.ShowHealthDisplayWhenCantFail, true);
+            Set(OsuSetting.FadePlayfieldWhenHealthLow, true);
             Set(OsuSetting.KeyOverlay, false);
             Set(OsuSetting.PositionalHitSounds, true);
             Set(OsuSetting.ScoreMeter, ScoreMeterType.HitErrorBoth);
@@ -184,6 +185,7 @@ namespace osu.Game.Configuration
         ShowInterface,
         ShowProgressGraph,
         ShowHealthDisplayWhenCantFail,
+        FadePlayfieldWhenHealthLow,
         MouseDisableButtons,
         MouseDisableWheel,
         AudioOffset,

osu.Game/Graphics/UserInterface/DrawableOsuMenuItem.cs

@@ -42,6 +42,8 @@ namespace osu.Game.Graphics.UserInterface
             BackgroundColourHover = Color4Extensions.FromHex(@"172023");
 
             updateTextColour();
+
+            Item.Action.BindDisabledChanged(_ => updateState(), true);
         }
 
         private void updateTextColour()
@@ -65,17 +67,31 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override bool OnHover(HoverEvent e)
         {
-            sampleHover.Play();
+            updateState();
-            text.BoldText.FadeIn(transition_length, Easing.OutQuint);
-            text.NormalText.FadeOut(transition_length, Easing.OutQuint);
             return base.OnHover(e);
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
+        {
+            updateState();
+            base.OnHoverLost(e);
+        }
+
+        private void updateState()
+        {
+            Alpha = Item.Action.Disabled ? 0.2f : 1;
+
+            if (IsHovered && !Item.Action.Disabled)
+            {
+                sampleHover.Play();
+                text.BoldText.FadeIn(transition_length, Easing.OutQuint);
+                text.NormalText.FadeOut(transition_length, Easing.OutQuint);
+            }
+            else
             {
                 text.BoldText.FadeOut(transition_length, Easing.OutQuint);
                 text.NormalText.FadeIn(transition_length, Easing.OutQuint);
-            base.OnHoverLost(e);
+            }
         }
 
         protected override bool OnClick(ClickEvent e)

osu.Game/Online/API/APIRequest.cs

@@ -16,20 +16,27 @@ namespace osu.Game.Online.API
     {
         protected override WebRequest CreateWebRequest() => new OsuJsonWebRequest<T>(Uri);
 
-        public T Result => ((OsuJsonWebRequest<T>)WebRequest)?.ResponseObject;
+        public T Result { get; private set; }
 
         protected APIRequest()
         {
-            base.Success += onSuccess;
+            base.Success += () => TriggerSuccess(((OsuJsonWebRequest<T>)WebRequest)?.ResponseObject);
         }
 
-        private void onSuccess() => Success?.Invoke(Result);
-
         /// <summary>
         /// Invoked on successful completion of an API request.
         /// This will be scheduled to the API's internal scheduler (run on update thread automatically).
         /// </summary>
         public new event APISuccessHandler<T> Success;
+
+        internal void TriggerSuccess(T result)
+        {
+            if (Result != null)
+                throw new InvalidOperationException("Attempted to trigger success more than once");
+
+            Result = result;
+            Success?.Invoke(result);
+        }
     }
 
     /// <summary>
@@ -96,10 +103,15 @@ namespace osu.Game.Online.API
             {
                 if (cancelled) return;
 
-                Success?.Invoke();
+                TriggerSuccess();
             });
         }
 
+        internal void TriggerSuccess()
+        {
+            Success?.Invoke();
+        }
+
         public void Cancel() => Fail(new OperationCanceledException(@"Request cancelled"));
 
         public void Fail(Exception e)

osu.Game/Online/API/DummyAPIAccess.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -30,6 +31,11 @@ namespace osu.Game.Online.API
 
         private readonly List<IOnlineComponent> components = new List<IOnlineComponent>();
 
+        /// <summary>
+        /// Provide handling logic for an arbitrary API request.
+        /// </summary>
+        public Action<APIRequest> HandleRequest;
+
         public APIState State
         {
             get => state;
@@ -55,11 +61,16 @@ namespace osu.Game.Online.API
 
         public virtual void Queue(APIRequest request)
         {
+            HandleRequest?.Invoke(request);
         }
 
-        public void Perform(APIRequest request) { }
+        public void Perform(APIRequest request) => HandleRequest?.Invoke(request);
 
-        public Task PerformAsync(APIRequest request) => Task.CompletedTask;
+        public Task PerformAsync(APIRequest request)
+        {
+            HandleRequest?.Invoke(request);
+            return Task.CompletedTask;
+        }
 
         public void Register(IOnlineComponent component)
         {

osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs

@@ -53,6 +53,11 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                     Keywords = new[] { "hp", "bar" }
                 },
                 new SettingsCheckbox
+                {
+                    LabelText = "Fade playfield to red when health is low",
+                    Bindable = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenHealthLow),
+                },
+                new SettingsCheckbox
                 {
                     LabelText = "Always show key overlay",
                     Bindable = config.GetBindable<bool>(OsuSetting.KeyOverlay)

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs

@@ -409,22 +409,34 @@ namespace osu.Game.Rulesets.Objects.Legacy
             public SampleBankInfo Clone() => (SampleBankInfo)MemberwiseClone();
         }
 
-        private class LegacyHitSampleInfo : HitSampleInfo
+        internal class LegacyHitSampleInfo : HitSampleInfo
         {
+            private int customSampleBank;
+
             public int CustomSampleBank
             {
+                get => customSampleBank;
                 set
                 {
-                    if (value > 1)
+                    customSampleBank = value;
+
+                    if (value >= 2)
                         Suffix = value.ToString();
                 }
             }
         }
 
-        private class FileHitSampleInfo : HitSampleInfo
+        private class FileHitSampleInfo : LegacyHitSampleInfo
         {
             public string Filename;
 
+            public FileHitSampleInfo()
+            {
+                // Make sure that the LegacyBeatmapSkin does not fall back to the user skin.
+                // Note that this does not change the lookup names, as they are overridden locally.
+                CustomSampleBank = 1;
+            }
+
             public override IEnumerable<string> LookupNames => new[]
             {
                 Filename,

osu.Game/Screens/Edit/Editor.cs

@@ -107,6 +107,8 @@ namespace osu.Game.Screens.Edit
             dependencies.CacheAs<IEditorChangeHandler>(changeHandler);
 
             EditorMenuBar menuBar;
+            OsuMenuItem undoMenuItem;
+            OsuMenuItem redoMenuItem;
 
             var fileMenuItems = new List<MenuItem>
             {
@@ -155,8 +157,8 @@ namespace osu.Game.Screens.Edit
                                 {
                                     Items = new[]
                                     {
-                                        new EditorMenuItem("Undo", MenuItemType.Standard, undo),
+                                        undoMenuItem = new EditorMenuItem("Undo", MenuItemType.Standard, undo),
-                                        new EditorMenuItem("Redo", MenuItemType.Standard, redo)
+                                        redoMenuItem = new EditorMenuItem("Redo", MenuItemType.Standard, redo)
                                     }
                                 }
                             }
@@ -214,6 +216,9 @@ namespace osu.Game.Screens.Edit
                 }
             });
 
+            changeHandler.CanUndo.BindValueChanged(v => undoMenuItem.Action.Disabled = !v.NewValue, true);
+            changeHandler.CanRedo.BindValueChanged(v => redoMenuItem.Action.Disabled = !v.NewValue, true);
+
             menuBar.Mode.ValueChanged += onModeChanged;
 
             bottomBackground.Colour = colours.Gray2;

osu.Game/Screens/Edit/EditorChangeHandler.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using osu.Framework.Bindables;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Objects;
 
@@ -15,8 +16,10 @@ namespace osu.Game.Screens.Edit
     /// </summary>
     public class EditorChangeHandler : IEditorChangeHandler
     {
-        private readonly LegacyEditorBeatmapPatcher patcher;
+        public readonly Bindable<bool> CanUndo = new Bindable<bool>();
+        public readonly Bindable<bool> CanRedo = new Bindable<bool>();
 
+        private readonly LegacyEditorBeatmapPatcher patcher;
         private readonly List<byte[]> savedStates = new List<byte[]>();
 
         private int currentState = -1;
@@ -45,8 +48,6 @@ namespace osu.Game.Screens.Edit
             SaveState();
         }
 
-        public bool HasUndoState => currentState > 0;
-
         private void hitObjectAdded(HitObject obj) => SaveState();
 
         private void hitObjectRemoved(HitObject obj) => SaveState();
@@ -90,6 +91,8 @@ namespace osu.Game.Screens.Edit
             }
 
             currentState = savedStates.Count - 1;
+
+            updateBindables();
         }
 
         /// <summary>
@@ -114,6 +117,14 @@ namespace osu.Game.Screens.Edit
             currentState = newState;
 
             isRestoring = false;
+
+            updateBindables();
+        }
+
+        private void updateBindables()
+        {
+            CanUndo.Value = savedStates.Count > 0 && currentState > 0;
+            CanRedo.Value = currentState < savedStates.Count - 1;
         }
     }
 }

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

@@ -0,0 +1,117 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Scoring;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Play.HUD
+{
+    /// <summary>
+    /// An overlay layer on top of the playfield which fades to red when the current player health falls below a certain threshold defined by <see cref="LowHealthThreshold"/>.
+    /// </summary>
+    public class FailingLayer : HealthDisplay
+    {
+        private const float max_alpha = 0.4f;
+        private const int fade_time = 400;
+        private const float gradient_size = 0.3f;
+
+        /// <summary>
+        /// The threshold under which the current player life should be considered low and the layer should start fading in.
+        /// </summary>
+        public double LowHealthThreshold = 0.20f;
+
+        private readonly Bindable<bool> enabled = new Bindable<bool>();
+        private readonly Container boxes;
+
+        private Bindable<bool> configEnabled;
+        private HealthProcessor healthProcessor;
+
+        public FailingLayer()
+        {
+            RelativeSizeAxes = Axes.Both;
+            Children = new Drawable[]
+            {
+                boxes = new Container
+                {
+                    Alpha = 0,
+                    Blending = BlendingParameters.Additive,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = ColourInfo.GradientVertical(Color4.White, Color4.White.Opacity(0)),
+                            Height = gradient_size,
+                        },
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Height = gradient_size,
+                            Colour = ColourInfo.GradientVertical(Color4.White.Opacity(0), Color4.White),
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                        },
+                    }
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour color, OsuConfigManager config)
+        {
+            boxes.Colour = color.Red;
+
+            configEnabled = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenHealthLow);
+            enabled.BindValueChanged(e => this.FadeTo(e.NewValue ? 1 : 0, fade_time, Easing.OutQuint), true);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateBindings();
+        }
+
+        public override void BindHealthProcessor(HealthProcessor processor)
+        {
+            base.BindHealthProcessor(processor);
+
+            healthProcessor = processor;
+            updateBindings();
+        }
+
+        private void updateBindings()
+        {
+            if (LoadState < LoadState.Ready)
+                return;
+
+            enabled.UnbindBindings();
+
+            // Don't display ever if the ruleset is not using a draining health display.
+            if (healthProcessor is DrainingHealthProcessor)
+                enabled.BindTo(configEnabled);
+            else
+                enabled.Value = false;
+        }
+
+        protected override void Update()
+        {
+            double target = Math.Clamp(max_alpha * (1 - Current.Value / LowHealthThreshold), 0, max_alpha);
+
+            boxes.Alpha = (float)Interpolation.Lerp(boxes.Alpha, target, Clock.ElapsedFrameTime * 0.01f);
+
+            base.Update();
+        }
+    }
+}

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

@@ -3,15 +3,29 @@
 
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Screens.Play.HUD
 {
+    /// <summary>
+    /// A container for components displaying the current player health.
+    /// Gets bound automatically to the <see cref="HealthProcessor"/> when inserted to <see cref="DrawableRuleset.Overlays"/> hierarchy.
+    /// </summary>
     public abstract class HealthDisplay : Container
     {
-        public readonly BindableDouble Current = new BindableDouble
+        public readonly BindableDouble Current = new BindableDouble(1)
         {
             MinValue = 0,
             MaxValue = 1
         };
+
+        /// <summary>
+        /// Bind the tracked fields of <see cref="HealthProcessor"/> to this health display.
+        /// </summary>
+        public virtual void BindHealthProcessor(HealthProcessor processor)
+        {
+            Current.BindTo(processor.Health);
+        }
     }
 }

osu.Game/Screens/Play/HUDOverlay.cs

@@ -37,6 +37,7 @@ namespace osu.Game.Screens.Play
         public readonly HitErrorDisplay HitErrorDisplay;
         public readonly HoldForMenuButton HoldToQuit;
         public readonly PlayerSettingsOverlay PlayerSettingsOverlay;
+        public readonly FailingLayer FailingLayer;
 
         public Bindable<bool> ShowHealthbar = new Bindable<bool>(true);
 
@@ -75,6 +76,7 @@ namespace osu.Game.Screens.Play
 
             Children = new Drawable[]
             {
+                FailingLayer = CreateFailingLayer(),
                 visibilityContainer = new Container
                 {
                     RelativeSizeAxes = Axes.Both,
@@ -260,6 +262,8 @@ namespace osu.Game.Screens.Play
             Margin = new MarginPadding { Top = 20 }
         };
 
+        protected virtual FailingLayer CreateFailingLayer() => new FailingLayer();
+
         protected virtual KeyCounterDisplay CreateKeyCounter() => new KeyCounterDisplay
         {
             Anchor = Anchor.BottomRight,
@@ -304,7 +308,8 @@ namespace osu.Game.Screens.Play
 
         protected virtual void BindHealthProcessor(HealthProcessor processor)
         {
-            HealthDisplay?.Current.BindTo(processor.Health);
+            HealthDisplay?.BindHealthProcessor(processor);
+            FailingLayer?.BindHealthProcessor(processor);
         }
     }
 }

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -48,6 +48,11 @@ namespace osu.Game.Screens.Select
         /// </summary>
         public BeatmapSetInfo SelectedBeatmapSet => selectedBeatmapSet?.BeatmapSet;
 
+        /// <summary>
+        /// A function to optionally decide on a recommended difficulty from a beatmap set.
+        /// </summary>
+        public Func<IEnumerable<BeatmapInfo>, BeatmapInfo> GetRecommendedBeatmap;
+
         private CarouselBeatmapSet selectedBeatmapSet;
 
         /// <summary>
@@ -116,6 +121,7 @@ namespace osu.Game.Screens.Select
         private readonly Stack<CarouselBeatmap> randomSelectedBeatmaps = new Stack<CarouselBeatmap>();
 
         protected List<DrawableCarouselItem> Items = new List<DrawableCarouselItem>();
+
         private CarouselRoot root;
 
         public BeatmapCarousel()
@@ -579,7 +585,10 @@ namespace osu.Game.Screens.Select
                     b.Metadata = beatmapSet.Metadata;
             }
 
-            var set = new CarouselBeatmapSet(beatmapSet);
+            var set = new CarouselBeatmapSet(beatmapSet)
+            {
+                GetRecommendedBeatmap = beatmaps => GetRecommendedBeatmap?.Invoke(beatmaps)
+            };
 
             foreach (var c in set.Beatmaps)
             {

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

@@ -16,6 +16,8 @@ namespace osu.Game.Screens.Select.Carousel
 
         public BeatmapSetInfo BeatmapSet;
 
+        public Func<IEnumerable<BeatmapInfo>, BeatmapInfo> GetRecommendedBeatmap;
+
         public CarouselBeatmapSet(BeatmapSetInfo beatmapSet)
         {
             BeatmapSet = beatmapSet ?? throw new ArgumentNullException(nameof(beatmapSet));
@@ -28,6 +30,17 @@ namespace osu.Game.Screens.Select.Carousel
 
         protected override DrawableCarouselItem CreateDrawableRepresentation() => new DrawableCarouselBeatmapSet(this);
 
+        protected override CarouselItem GetNextToSelect()
+        {
+            if (LastSelected == null)
+            {
+                if (GetRecommendedBeatmap?.Invoke(Children.OfType<CarouselBeatmap>().Where(b => !b.Filtered.Value).Select(b => b.Beatmap)) is BeatmapInfo recommended)
+                    return Children.OfType<CarouselBeatmap>().First(b => b.Beatmap == recommended);
+            }
+
+            return base.GetNextToSelect();
+        }
+
         public override int CompareTo(FilterCriteria criteria, CarouselItem other)
         {
             if (!(other is CarouselBeatmapSet otherSet))

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

@@ -90,11 +90,15 @@ namespace osu.Game.Screens.Select.Carousel
             PerformSelection();
         }
 
+        protected virtual CarouselItem GetNextToSelect()
+        {
+            return Children.Skip(lastSelectedIndex).FirstOrDefault(i => !i.Filtered.Value) ??
+                   Children.Reverse().Skip(InternalChildren.Count - lastSelectedIndex).FirstOrDefault(i => !i.Filtered.Value);
+        }
+
         protected virtual void PerformSelection()
         {
-            CarouselItem nextToSelect =
+            CarouselItem nextToSelect = GetNextToSelect();
-                Children.Skip(lastSelectedIndex).FirstOrDefault(i => !i.Filtered.Value) ??
-                Children.Reverse().Skip(InternalChildren.Count - lastSelectedIndex).FirstOrDefault(i => !i.Filtered.Value);
 
             if (nextToSelect != null)
                 nextToSelect.State.Value = CarouselItemState.Selected;

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

@@ -49,11 +49,12 @@ namespace osu.Game.Screens.Select.Carousel
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(SongSelect songSelect, BeatmapManager manager)
+        private void load(BeatmapManager manager, SongSelect songSelect)
         {
             if (songSelect != null)
             {
                 startRequested = b => songSelect.FinaliseSelection(b);
+                if (songSelect.AllowEditing)
                     editRequested = songSelect.Edit;
             }
 
@@ -187,15 +188,19 @@ namespace osu.Game.Screens.Select.Carousel
         {
             get
             {
-                List<MenuItem> items = new List<MenuItem>
+                List<MenuItem> items = new List<MenuItem>();
-                {
-                    new OsuMenuItem("Play", MenuItemType.Highlighted, () => startRequested?.Invoke(beatmap)),
-                    new OsuMenuItem("Edit", MenuItemType.Standard, () => editRequested?.Invoke(beatmap)),
-                    new OsuMenuItem("Hide", MenuItemType.Destructive, () => hideRequested?.Invoke(beatmap)),
-                };
 
-                if (beatmap.OnlineBeatmapID.HasValue)
+                if (startRequested != null)
-                    items.Add(new OsuMenuItem("Details", MenuItemType.Standard, () => beatmapOverlay?.FetchAndShowBeatmap(beatmap.OnlineBeatmapID.Value)));
+                    items.Add(new OsuMenuItem("Play", MenuItemType.Highlighted, () => startRequested(beatmap)));
+
+                if (editRequested != null)
+                    items.Add(new OsuMenuItem("Edit", MenuItemType.Standard, () => editRequested(beatmap)));
+
+                if (hideRequested != null)
+                    items.Add(new OsuMenuItem("Hide", MenuItemType.Destructive, () => hideRequested(beatmap)));
+
+                if (beatmap.OnlineBeatmapID.HasValue && beatmapOverlay != null)
+                    items.Add(new OsuMenuItem("Details", MenuItemType.Standard, () => beatmapOverlay.FetchAndShowBeatmap(beatmap.OnlineBeatmapID.Value)));
 
                 return items.ToArray();
             }

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

@@ -46,6 +46,7 @@ namespace osu.Game.Screens.Select.Carousel
         private void load(BeatmapManager manager, BeatmapSetOverlay beatmapOverlay)
         {
             restoreHiddenRequested = s => s.Beatmaps.ForEach(manager.Restore);
+
             if (beatmapOverlay != null)
                 viewDetails = beatmapOverlay.FetchAndShowBeatmapSet;
 
@@ -131,13 +132,14 @@ namespace osu.Game.Screens.Select.Carousel
                 if (Item.State.Value == CarouselItemState.NotSelected)
                     items.Add(new OsuMenuItem("Expand", MenuItemType.Highlighted, () => Item.State.Value = CarouselItemState.Selected));
 
-                if (beatmapSet.OnlineBeatmapSetID != null)
+                if (beatmapSet.OnlineBeatmapSetID != null && viewDetails != null)
-                    items.Add(new OsuMenuItem("Details...", MenuItemType.Standard, () => viewDetails?.Invoke(beatmapSet.OnlineBeatmapSetID.Value)));
+                    items.Add(new OsuMenuItem("Details...", MenuItemType.Standard, () => viewDetails(beatmapSet.OnlineBeatmapSetID.Value)));
 
                 if (beatmapSet.Beatmaps.Any(b => b.Hidden))
-                    items.Add(new OsuMenuItem("Restore all hidden", MenuItemType.Standard, () => restoreHiddenRequested?.Invoke(beatmapSet)));
+                    items.Add(new OsuMenuItem("Restore all hidden", MenuItemType.Standard, () => restoreHiddenRequested(beatmapSet)));
 
-                items.Add(new OsuMenuItem("Delete", MenuItemType.Destructive, () => dialogOverlay?.Push(new BeatmapDeleteDialog(beatmapSet))));
+                if (dialogOverlay != null)
+                    items.Add(new OsuMenuItem("Delete", MenuItemType.Destructive, () => dialogOverlay.Push(new BeatmapDeleteDialog(beatmapSet))));
 
                 return items.ToArray();
             }

osu.Game/Screens/Select/DifficultyRecommender.cs

@@ -0,0 +1,92 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Screens.Select
+{
+    public class DifficultyRecommender : Component, IOnlineComponent
+    {
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
+        [Resolved]
+        private Bindable<RulesetInfo> ruleset { get; set; }
+
+        private readonly Dictionary<RulesetInfo, double> recommendedStarDifficulty = new Dictionary<RulesetInfo, double>();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            api.Register(this);
+        }
+
+        /// <summary>
+        /// Find the recommended difficulty from a selection of available difficulties for the current local user.
+        /// </summary>
+        /// <remarks>
+        /// This requires the user to be online for now.
+        /// </remarks>
+        /// <param name="beatmaps">A collection of beatmaps to select a difficulty from.</param>
+        /// <returns>The recommended difficulty, or null if a recommendation could not be provided.</returns>
+        public BeatmapInfo GetRecommendedBeatmap(IEnumerable<BeatmapInfo> beatmaps)
+        {
+            if (recommendedStarDifficulty.TryGetValue(ruleset.Value, out var stars))
+            {
+                return beatmaps.OrderBy(b =>
+                {
+                    var difference = b.StarDifficulty - stars;
+                    return difference >= 0 ? difference * 2 : difference * -1; // prefer easier over harder
+                }).FirstOrDefault();
+            }
+
+            return null;
+        }
+
+        private void calculateRecommendedDifficulties()
+        {
+            rulesets.AvailableRulesets.ForEach(rulesetInfo =>
+            {
+                var req = new GetUserRequest(api.LocalUser.Value.Id, rulesetInfo);
+
+                req.Success += result =>
+                {
+                    // algorithm taken from https://github.com/ppy/osu-web/blob/e6e2825516449e3d0f3f5e1852c6bdd3428c3437/app/Models/User.php#L1505
+                    recommendedStarDifficulty[rulesetInfo] = Math.Pow((double)(result.Statistics.PP ?? 0), 0.4) * 0.195;
+                };
+
+                api.Queue(req);
+            });
+        }
+
+        public void APIStateChanged(IAPIProvider api, APIState state)
+        {
+            switch (state)
+            {
+                case APIState.Online:
+                    calculateRecommendedDifficulties();
+                    break;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            api.Unregister(this);
+        }
+    }
+}

osu.Game/Screens/Select/SongSelect.cs

@@ -34,7 +34,6 @@ using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
-using osu.Game.Overlays.Notifications;
 using osu.Game.Scoring;
 
 namespace osu.Game.Screens.Select
@@ -71,9 +70,6 @@ namespace osu.Game.Screens.Select
         /// </summary>
         public virtual bool AllowEditing => true;
 
-        [Resolved(canBeNull: true)]
-        private NotificationOverlay notificationOverlay { get; set; }
-
         [Resolved]
         private Bindable<IReadOnlyList<Mod>> selectedMods { get; set; }
 
@@ -81,6 +77,8 @@ namespace osu.Game.Screens.Select
 
         protected BeatmapCarousel Carousel { get; private set; }
 
+        private DifficultyRecommender recommender;
+
         private BeatmapInfoWedge beatmapInfoWedge;
         private DialogOverlay dialogOverlay;
 
@@ -109,6 +107,7 @@ namespace osu.Game.Screens.Select
 
             AddRangeInternal(new Drawable[]
             {
+                recommender = new DifficultyRecommender(),
                 new ResetScrollContainer(() => Carousel.ScrollToSelected())
                 {
                     RelativeSizeAxes = Axes.Y,
@@ -156,6 +155,7 @@ namespace osu.Game.Screens.Select
                                             RelativeSizeAxes = Axes.Both,
                                             SelectionChanged = updateSelectedBeatmap,
                                             BeatmapSetsChanged = carouselBeatmapsLoaded,
+                                            GetRecommendedBeatmap = recommender.GetRecommendedBeatmap,
                                         },
                                     }
                                 },
@@ -325,10 +325,7 @@ namespace osu.Game.Screens.Select
         public void Edit(BeatmapInfo beatmap = null)
         {
             if (!AllowEditing)
-            {
+                throw new InvalidOperationException($"Attempted to edit when {nameof(AllowEditing)} is disabled");
-                notificationOverlay?.Post(new SimpleNotification { Text = "Editing is not available from the current mode." });
-                return;
-            }
 
             Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap ?? beatmapNoDebounce);
             this.Push(new Editor());

osu.Game/Skinning/LegacyBeatmapSkin.cs

@@ -2,9 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.IO.Stores;
+using osu.Game.Audio;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects.Legacy;
 
 namespace osu.Game.Skinning
 {
@@ -33,6 +36,17 @@ namespace osu.Game.Skinning
             return base.GetConfig<TLookup, TValue>(lookup);
         }
 
+        public override SampleChannel GetSample(ISampleInfo sampleInfo)
+        {
+            if (sampleInfo is ConvertHitObjectParser.LegacyHitSampleInfo legacy && legacy.CustomSampleBank == 0)
+            {
+                // When no custom sample bank is provided, always fall-back to the default samples.
+                return null;
+            }
+
+            return base.GetSample(sampleInfo);
+        }
+
         private static SkinInfo createSkinInfo(BeatmapInfo beatmap) =>
             new SkinInfo { Name = beatmap.ToString(), Creator = beatmap.Metadata.Author.ToString() };
     }

osu.Game/Tests/Beatmaps/TestWorkingBeatmap.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.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps;
@@ -18,8 +19,9 @@ namespace osu.Game.Tests.Beatmaps
         /// </summary>
         /// <param name="beatmap">The beatmap.</param>
         /// <param name="storyboard">An optional storyboard.</param>
-        public TestWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
+        /// <param name="audioManager">The <see cref="AudioManager"/>.</param>
-            : base(beatmap.BeatmapInfo, null)
+        public TestWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null, AudioManager audioManager = null)
+            : base(beatmap.BeatmapInfo, audioManager)
         {
             this.beatmap = beatmap;
             this.storyboard = storyboard;

osu.Game/Tests/Visual/OsuTestScene.cs

@@ -179,7 +179,7 @@ namespace osu.Game.Tests.Visual
             /// <param name="audio">Audio manager. Required if a reference clock isn't provided.</param>
             /// <param name="length">The length of the returned virtual track.</param>
             public ClockBackedTestWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard, IFrameBasedClock referenceClock, AudioManager audio, double length = 60000)
-                : base(beatmap, storyboard)
+                : base(beatmap, storyboard, audio)
             {
                 if (referenceClock != null)
                 {