From 1aacd1aaa2568eecb1f00ecc1b77cb0ae406082f Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Mon, 16 Mar 2020 20:43:02 +0100
Subject: [PATCH 01/26] Initial implementation of LowHealthLayer

---
 osu.Game/Configuration/OsuConfigManager.cs    |  2 +
 .../Sections/Gameplay/GeneralSettings.cs      |  6 +++
 osu.Game/Screens/Play/HUD/LowHealthLayer.cs   | 47 +++++++++++++++++++
 3 files changed, 55 insertions(+)
 create mode 100644 osu.Game/Screens/Play/HUD/LowHealthLayer.cs

diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index 21de654670..895bacafc4 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/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.FadePlayfieldWhenLowHealth, true);
             Set(OsuSetting.KeyOverlay, false);
             Set(OsuSetting.ScoreMeter, ScoreMeterType.HitErrorBoth);
 
@@ -183,6 +184,7 @@ namespace osu.Game.Configuration
         ShowInterface,
         ShowProgressGraph,
         ShowHealthDisplayWhenCantFail,
+        FadePlayfieldWhenLowHealth,
         MouseDisableButtons,
         MouseDisableWheel,
         AudioOffset,
diff --git a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
index 2d2cd42213..6b6b3e8fa4 100644
--- a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
@@ -53,6 +53,12 @@ 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.FadePlayfieldWhenLowHealth),
+                    Keywords = new[] { "hp", "playfield", "health" }
+                },
+                new SettingsCheckbox
                 {
                     LabelText = "Always show key overlay",
                     Bindable = config.GetBindable<bool>(OsuSetting.KeyOverlay)
diff --git a/osu.Game/Screens/Play/HUD/LowHealthLayer.cs b/osu.Game/Screens/Play/HUD/LowHealthLayer.cs
new file mode 100644
index 0000000000..8f03a95877
--- /dev/null
+++ b/osu.Game/Screens/Play/HUD/LowHealthLayer.cs
@@ -0,0 +1,47 @@
+// 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.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+
+namespace osu.Game.Screens.Play.HUD
+{
+    public class LowHealthLayer : HealthDisplay
+    {
+        private const float max_alpha = 0.4f;
+
+        private const double fade_time = 300;
+
+        private readonly Box box;
+
+        private Bindable<bool> configFadeRedWhenLowHealth;
+
+        public LowHealthLayer()
+        {
+            Child = box = new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Alpha = 0
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config, OsuColour color)
+        {
+            configFadeRedWhenLowHealth = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenLowHealth);
+            box.Colour = color.Red;
+
+            configFadeRedWhenLowHealth.BindValueChanged(value =>
+            {
+                if (value.NewValue)
+                    this.FadeIn(fade_time, Easing.OutQuint);
+                else
+                    this.FadeOut(fade_time, Easing.OutQuint);
+            }, true);
+        }
+    }
+}

From 8c611a981f0fc35ab89fb8012157dc7c62cecb00 Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Mon, 16 Mar 2020 21:48:28 +0100
Subject: [PATCH 02/26] Update visual tests

---
 .../Visual/Gameplay/TestSceneHUDOverlay.cs    | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
index fc03dc6ed3..579f6ff9b6 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
@@ -103,6 +103,38 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("return value", () => config.Set<bool>(OsuSetting.KeyOverlay, keyCounterVisibleValue));
         }
 
+        [Test]
+        public void TestChangeHealthValue()
+        {
+            void applyToHealthDisplays(double value)
+            {
+                if (hudOverlay == null) return;
+
+                hudOverlay.LowHealthDisplay.Current.Value = value;
+                hudOverlay.HealthDisplay.Current.Value = value;
+            }
+
+            createNew();
+            AddSliderStep("health value", 0, 1, 0.5, applyToHealthDisplays);
+
+            AddStep("enable low health display", () =>
+            {
+                config.Set(OsuSetting.FadePlayfieldWhenLowHealth, true);
+                hudOverlay.LowHealthDisplay.FinishTransforms(true);
+            });
+            AddAssert("low health display is visible", () => hudOverlay.LowHealthDisplay.IsPresent);
+            AddStep("set health to 30%", () => applyToHealthDisplays(0.3));
+            AddAssert("hud is not faded to red", () => !hudOverlay.LowHealthDisplay.Child.IsPresent);
+            AddStep("set health to < 10%", () => applyToHealthDisplays(0.1f));
+            AddAssert("hud is faded to red", () => hudOverlay.LowHealthDisplay.Child.IsPresent);
+            AddStep("disable low health display", () =>
+            {
+                config.Set(OsuSetting.FadePlayfieldWhenLowHealth, false);
+                hudOverlay.LowHealthDisplay.FinishTransforms(true);
+            });
+            AddAssert("low health display is not visible", () => !hudOverlay.LowHealthDisplay.IsPresent);
+        }
+
         private void createNew(Action<HUDOverlay> action = null)
         {
             AddStep("create overlay", () =>

From 6b0c5bc65d1f6aa80fd98abd2261613ca971fbbc Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Tue, 17 Mar 2020 22:32:07 +0100
Subject: [PATCH 03/26] Rename to LowHealthLayer to FaillingLayer.

---
 .../Visual/Gameplay/TestSceneHUDOverlay.cs    | 32 -------------
 osu.Game/Screens/Play/HUD/FaillingLayer.cs    | 47 +++++++++++++++++++
 osu.Game/Screens/Play/HUD/LowHealthLayer.cs   | 47 -------------------
 3 files changed, 47 insertions(+), 79 deletions(-)
 create mode 100644 osu.Game/Screens/Play/HUD/FaillingLayer.cs
 delete mode 100644 osu.Game/Screens/Play/HUD/LowHealthLayer.cs

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
index 579f6ff9b6..fc03dc6ed3 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
@@ -103,38 +103,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("return value", () => config.Set<bool>(OsuSetting.KeyOverlay, keyCounterVisibleValue));
         }
 
-        [Test]
-        public void TestChangeHealthValue()
-        {
-            void applyToHealthDisplays(double value)
-            {
-                if (hudOverlay == null) return;
-
-                hudOverlay.LowHealthDisplay.Current.Value = value;
-                hudOverlay.HealthDisplay.Current.Value = value;
-            }
-
-            createNew();
-            AddSliderStep("health value", 0, 1, 0.5, applyToHealthDisplays);
-
-            AddStep("enable low health display", () =>
-            {
-                config.Set(OsuSetting.FadePlayfieldWhenLowHealth, true);
-                hudOverlay.LowHealthDisplay.FinishTransforms(true);
-            });
-            AddAssert("low health display is visible", () => hudOverlay.LowHealthDisplay.IsPresent);
-            AddStep("set health to 30%", () => applyToHealthDisplays(0.3));
-            AddAssert("hud is not faded to red", () => !hudOverlay.LowHealthDisplay.Child.IsPresent);
-            AddStep("set health to < 10%", () => applyToHealthDisplays(0.1f));
-            AddAssert("hud is faded to red", () => hudOverlay.LowHealthDisplay.Child.IsPresent);
-            AddStep("disable low health display", () =>
-            {
-                config.Set(OsuSetting.FadePlayfieldWhenLowHealth, false);
-                hudOverlay.LowHealthDisplay.FinishTransforms(true);
-            });
-            AddAssert("low health display is not visible", () => !hudOverlay.LowHealthDisplay.IsPresent);
-        }
-
         private void createNew(Action<HUDOverlay> action = null)
         {
             AddStep("create overlay", () =>
diff --git a/osu.Game/Screens/Play/HUD/FaillingLayer.cs b/osu.Game/Screens/Play/HUD/FaillingLayer.cs
new file mode 100644
index 0000000000..3dc18cefec
--- /dev/null
+++ b/osu.Game/Screens/Play/HUD/FaillingLayer.cs
@@ -0,0 +1,47 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+
+namespace osu.Game.Screens.Play.HUD
+{
+    /// <summary>
+    /// An overlay layer on top of the player HUD which fades to red when the current player health falls a certain threshold defined by <see cref="LowHealthThreshold"/>.
+    /// </summary>
+    public class FaillingLayer : HealthDisplay
+    {
+        private const float max_alpha = 0.4f;
+
+        private readonly Box box;
+
+        /// <summary>
+        /// The threshold under which the current player life should be considered low and the layer should start fading in.
+        /// </summary>
+        protected virtual double LowHealthThreshold => 0.20f;
+
+        public FaillingLayer()
+        {
+            Child = box = new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Alpha = 0
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour color)
+        {
+            box.Colour = color.Red;
+        }
+
+        protected override void Update()
+        {
+            box.Alpha = (float)Math.Clamp(max_alpha * (1 - Current.Value / LowHealthThreshold), 0, max_alpha);
+            base.Update();
+        }
+    }
+}
diff --git a/osu.Game/Screens/Play/HUD/LowHealthLayer.cs b/osu.Game/Screens/Play/HUD/LowHealthLayer.cs
deleted file mode 100644
index 8f03a95877..0000000000
--- a/osu.Game/Screens/Play/HUD/LowHealthLayer.cs
+++ /dev/null
@@ -1,47 +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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Configuration;
-using osu.Game.Graphics;
-
-namespace osu.Game.Screens.Play.HUD
-{
-    public class LowHealthLayer : HealthDisplay
-    {
-        private const float max_alpha = 0.4f;
-
-        private const double fade_time = 300;
-
-        private readonly Box box;
-
-        private Bindable<bool> configFadeRedWhenLowHealth;
-
-        public LowHealthLayer()
-        {
-            Child = box = new Box
-            {
-                RelativeSizeAxes = Axes.Both,
-                Alpha = 0
-            };
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config, OsuColour color)
-        {
-            configFadeRedWhenLowHealth = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenLowHealth);
-            box.Colour = color.Red;
-
-            configFadeRedWhenLowHealth.BindValueChanged(value =>
-            {
-                if (value.NewValue)
-                    this.FadeIn(fade_time, Easing.OutQuint);
-                else
-                    this.FadeOut(fade_time, Easing.OutQuint);
-            }, true);
-        }
-    }
-}

From ed4f9f8ba9959c142dc1282ef37e735a4a162b7e Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Tue, 17 Mar 2020 22:57:47 +0100
Subject: [PATCH 04/26] Bind every HealthDisplay on Player load

---
 osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs | 8 ++++++++
 osu.Game/Screens/Play/HUD/FaillingLayer.cs     | 1 +
 osu.Game/Screens/Play/HUD/HealthDisplay.cs     | 6 ++++++
 osu.Game/Screens/Play/Player.cs                | 4 ++++
 4 files changed, 19 insertions(+)

diff --git a/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs b/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
index a37ef8d9a0..50bff4fe3a 100644
--- a/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Input.Handlers;
@@ -16,6 +17,7 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.UI
@@ -29,6 +31,12 @@ namespace osu.Game.Rulesets.Osu.UI
         {
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Overlays.Add(new FaillingLayer());
+        }
+
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true; // always show the gameplay cursor
 
         protected override Playfield CreatePlayfield() => new OsuPlayfield();
diff --git a/osu.Game/Screens/Play/HUD/FaillingLayer.cs b/osu.Game/Screens/Play/HUD/FaillingLayer.cs
index 3dc18cefec..6651ad6c88 100644
--- a/osu.Game/Screens/Play/HUD/FaillingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FaillingLayer.cs
@@ -25,6 +25,7 @@ namespace osu.Game.Screens.Play.HUD
 
         public FaillingLayer()
         {
+            RelativeSizeAxes = Axes.Both;
             Child = box = new Box
             {
                 RelativeSizeAxes = Axes.Both,
diff --git a/osu.Game/Screens/Play/HUD/HealthDisplay.cs b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
index 37038ad58c..6a5b77a64b 100644
--- a/osu.Game/Screens/Play/HUD/HealthDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
@@ -3,6 +3,7 @@
 
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Screens.Play.HUD
 {
@@ -13,5 +14,10 @@ namespace osu.Game.Screens.Play.HUD
             MinValue = 0,
             MaxValue = 1
         };
+        
+        public virtual void BindHealthProcessor(HealthProcessor processor)
+        {
+            Current.BindTo(processor.Health);
+        }
     }
 }
diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index bcadba14af..0df4aacb7a 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -24,6 +24,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Ranking;
 using osu.Game.Skinning;
 using osu.Game.Users;
@@ -184,6 +185,9 @@ namespace osu.Game.Screens.Play
             foreach (var mod in Mods.Value.OfType<IApplicableToHealthProcessor>())
                 mod.ApplyToHealthProcessor(HealthProcessor);
 
+            foreach (var overlay in DrawableRuleset.Overlays.OfType<HealthDisplay>())
+                overlay.BindHealthProcessor(HealthProcessor);
+
             BreakOverlay.IsBreakTime.BindValueChanged(onBreakTimeChanged, true);
         }
 

From 44c13b081c4167685ace193a5a6fadae95072fcf Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Tue, 17 Mar 2020 22:58:20 +0100
Subject: [PATCH 05/26] Remove old configuration variants.

---
 osu.Game/Configuration/OsuConfigManager.cs                  | 2 --
 .../Overlays/Settings/Sections/Gameplay/GeneralSettings.cs  | 6 ------
 2 files changed, 8 deletions(-)

diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index 895bacafc4..21de654670 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/osu.Game/Configuration/OsuConfigManager.cs
@@ -88,7 +88,6 @@ namespace osu.Game.Configuration
             Set(OsuSetting.ShowInterface, true);
             Set(OsuSetting.ShowProgressGraph, true);
             Set(OsuSetting.ShowHealthDisplayWhenCantFail, true);
-            Set(OsuSetting.FadePlayfieldWhenLowHealth, true);
             Set(OsuSetting.KeyOverlay, false);
             Set(OsuSetting.ScoreMeter, ScoreMeterType.HitErrorBoth);
 
@@ -184,7 +183,6 @@ namespace osu.Game.Configuration
         ShowInterface,
         ShowProgressGraph,
         ShowHealthDisplayWhenCantFail,
-        FadePlayfieldWhenLowHealth,
         MouseDisableButtons,
         MouseDisableWheel,
         AudioOffset,
diff --git a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
index 6b6b3e8fa4..2d2cd42213 100644
--- a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
@@ -53,12 +53,6 @@ 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.FadePlayfieldWhenLowHealth),
-                    Keywords = new[] { "hp", "playfield", "health" }
-                },
-                new SettingsCheckbox
                 {
                     LabelText = "Always show key overlay",
                     Bindable = config.GetBindable<bool>(OsuSetting.KeyOverlay)

From 17bae532bd91e782ac9be727843b4e8f57456df9 Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Tue, 17 Mar 2020 23:09:50 +0100
Subject: [PATCH 06/26] Add failling layer to others rulesets.

---
 osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs | 8 ++++++++
 osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs | 3 +++
 2 files changed, 11 insertions(+)

diff --git a/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs b/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
index fd8a1d175d..705c2d756c 100644
--- a/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using osu.Framework.Allocation;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -14,6 +15,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Play.HUD;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -30,6 +32,12 @@ namespace osu.Game.Rulesets.Catch.UI
             TimeRange.Value = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450);
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Overlays.Add(new FaillingLayer());
+        }
+
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
 
         protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, CreateDrawableRepresentation);
diff --git a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
index 2c497541a8..b8b6ff3c3c 100644
--- a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
@@ -19,6 +19,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Play.HUD;
 using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
@@ -52,6 +53,8 @@ namespace osu.Game.Rulesets.Mania.UI
             configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);
 
             Config.BindWith(ManiaRulesetSetting.ScrollTime, TimeRange);
+
+            Overlays.Add(new FaillingLayer());
         }
 
         /// <summary>

From a1274a9eb0ca927c4d07cb94aaba0fa101745a4a Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Wed, 18 Mar 2020 08:17:41 +0100
Subject: [PATCH 07/26] Fix and add missing XMLDoc

---
 osu.Game/Screens/Play/HUD/FaillingLayer.cs |  2 +-
 osu.Game/Screens/Play/HUD/HealthDisplay.cs | 11 ++++++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/osu.Game/Screens/Play/HUD/FaillingLayer.cs b/osu.Game/Screens/Play/HUD/FaillingLayer.cs
index 6651ad6c88..55cc4476b0 100644
--- a/osu.Game/Screens/Play/HUD/FaillingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FaillingLayer.cs
@@ -10,7 +10,7 @@ using osu.Game.Graphics;
 namespace osu.Game.Screens.Play.HUD
 {
     /// <summary>
-    /// An overlay layer on top of the player HUD which fades to red when the current player health falls a certain threshold defined by <see cref="LowHealthThreshold"/>.
+    /// An overlay layer on top of the playfield which fades to red when the current player health falls a certain threshold defined by <see cref="LowHealthThreshold"/>.
     /// </summary>
     public class FaillingLayer : HealthDisplay
     {
diff --git a/osu.Game/Screens/Play/HUD/HealthDisplay.cs b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
index 6a5b77a64b..4094b3de69 100644
--- a/osu.Game/Screens/Play/HUD/HealthDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
@@ -4,9 +4,14 @@
 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
@@ -14,7 +19,11 @@ namespace osu.Game.Screens.Play.HUD
             MinValue = 0,
             MaxValue = 1
         };
-        
+
+        /// <summary>
+        /// Bind the tracked fields of <see cref="HealthProcessor"/> to this health display.
+        /// </summary>
+        /// <param name="processor"></param>
         public virtual void BindHealthProcessor(HealthProcessor processor)
         {
             Current.BindTo(processor.Health);

From e9f224b5e8c3ae93098848ee3ee2146d47e7146e Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Wed, 18 Mar 2020 21:16:54 +0100
Subject: [PATCH 08/26] Apply review suggestions

---
 osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs        | 2 +-
 osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs        | 2 +-
 osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs            | 2 +-
 .../Play/HUD/{FaillingLayer.cs => FailingLayer.cs}        | 8 ++++----
 osu.Game/Screens/Play/HUD/HealthDisplay.cs                | 2 +-
 5 files changed, 8 insertions(+), 8 deletions(-)
 rename osu.Game/Screens/Play/HUD/{FaillingLayer.cs => FailingLayer.cs} (82%)

diff --git a/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs b/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
index 705c2d756c..50c4154c61 100644
--- a/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Catch.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            Overlays.Add(new FaillingLayer());
+            Overlays.Add(new FailingLayer());
         }
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
diff --git a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
index b8b6ff3c3c..8e56144752 100644
--- a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
@@ -54,7 +54,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             Config.BindWith(ManiaRulesetSetting.ScrollTime, TimeRange);
 
-            Overlays.Add(new FaillingLayer());
+            Overlays.Add(new FailingLayer());
         }
 
         /// <summary>
diff --git a/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs b/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
index 50bff4fe3a..ed75d47bbe 100644
--- a/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            Overlays.Add(new FaillingLayer());
+            Overlays.Add(new FailingLayer());
         }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true; // always show the gameplay cursor
diff --git a/osu.Game/Screens/Play/HUD/FaillingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
similarity index 82%
rename from osu.Game/Screens/Play/HUD/FaillingLayer.cs
rename to osu.Game/Screens/Play/HUD/FailingLayer.cs
index 55cc4476b0..5f7dc77928 100644
--- a/osu.Game/Screens/Play/HUD/FaillingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -10,9 +10,9 @@ using osu.Game.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 a certain threshold defined by <see cref="LowHealthThreshold"/>.
+    /// 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 FaillingLayer : HealthDisplay
+    public class FailingLayer : HealthDisplay
     {
         private const float max_alpha = 0.4f;
 
@@ -21,9 +21,9 @@ namespace osu.Game.Screens.Play.HUD
         /// <summary>
         /// The threshold under which the current player life should be considered low and the layer should start fading in.
         /// </summary>
-        protected virtual double LowHealthThreshold => 0.20f;
+        protected double LowHealthThreshold { get; set; } = 0.20f;
 
-        public FaillingLayer()
+        public FailingLayer()
         {
             RelativeSizeAxes = Axes.Both;
             Child = box = new Box
diff --git a/osu.Game/Screens/Play/HUD/HealthDisplay.cs b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
index 4094b3de69..4ea08626ad 100644
--- a/osu.Game/Screens/Play/HUD/HealthDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Screens.Play.HUD
         /// Bind the tracked fields of <see cref="HealthProcessor"/> to this health display.
         /// </summary>
         /// <param name="processor"></param>
-        public virtual void BindHealthProcessor(HealthProcessor processor)
+        public void BindHealthProcessor(HealthProcessor processor)
         {
             Current.BindTo(processor.Health);
         }

From a4171253a38f2d09eedea9f38eb7d3eca0afebff Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Wed, 18 Mar 2020 21:41:43 +0100
Subject: [PATCH 09/26] Make LowHealthThreshold a field.

---
 osu.Game/Screens/Play/HUD/FailingLayer.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index 5f7dc77928..5f4037c14d 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Screens.Play.HUD
         /// <summary>
         /// The threshold under which the current player life should be considered low and the layer should start fading in.
         /// </summary>
-        protected double LowHealthThreshold { get; set; } = 0.20f;
+        public double LowHealthThreshold = 0.20f;
 
         public FailingLayer()
         {

From c1ac57e70fc05e11e6d085f2829eef31d524328e Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Thu, 26 Mar 2020 12:14:44 +0100
Subject: [PATCH 10/26] Add back visual tests and add easing to alpha fade.

---
 .../Visual/Gameplay/TestSceneFailingLayer.cs  | 31 +++++++++++++++++++
 osu.Game/Screens/Play/HUD/FailingLayer.cs     |  7 ++++-
 2 files changed, 37 insertions(+), 1 deletion(-)
 create mode 100644 osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
new file mode 100644
index 0000000000..3016890ade
--- /dev/null
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneFailingLayer : OsuTestScene
+    {
+        private readonly FailingLayer layer;
+
+        public TestSceneFailingLayer()
+        {
+            Child = layer = new FailingLayer();
+        }
+
+        [Test]
+        public void TestLayerFading()
+        {
+            AddSliderStep("current health", 0.0, 1.0, 1.0, val =>
+            {
+                layer.Current.Value = val;
+            });
+
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.10);
+            AddWaitStep("wait for fade to finish", 5);
+            AddStep("set health to 1", () => layer.Current.Value = 1f);
+        }
+    }
+}
diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index 5f4037c14d..97d2458674 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
 using osu.Game.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
@@ -16,6 +17,8 @@ namespace osu.Game.Screens.Play.HUD
     {
         private const float max_alpha = 0.4f;
 
+        private const int fade_time = 400;
+
         private readonly Box box;
 
         /// <summary>
@@ -41,7 +44,9 @@ namespace osu.Game.Screens.Play.HUD
 
         protected override void Update()
         {
-            box.Alpha = (float)Math.Clamp(max_alpha * (1 - Current.Value / LowHealthThreshold), 0, max_alpha);
+            box.Alpha = (float)Interpolation.ValueAt(Math.Clamp(Clock.ElapsedFrameTime, 0, fade_time), box.Alpha,
+                Math.Clamp(max_alpha * (1 - Current.Value / LowHealthThreshold), 0, max_alpha), 0, fade_time, Easing.Out);
+
             base.Update();
         }
     }

From 3cae0cedeea80e1dc6206f26e5526a5b7e22662a Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Mon, 30 Mar 2020 12:59:39 +0200
Subject: [PATCH 11/26] Add a game setting to disable the layer

---
 osu.Game/Configuration/OsuConfigManager.cs                | 2 ++
 .../Settings/Sections/Gameplay/GeneralSettings.cs         | 6 ++++++
 osu.Game/Screens/Play/HUD/FailingLayer.cs                 | 8 +++++++-
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index 41f6747b74..6fed5ea5a2 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/osu.Game/Configuration/OsuConfigManager.cs
@@ -87,6 +87,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.ScoreMeter, ScoreMeterType.HitErrorBoth);
 
@@ -181,6 +182,7 @@ namespace osu.Game.Configuration
         ShowInterface,
         ShowProgressGraph,
         ShowHealthDisplayWhenCantFail,
+        FadePlayfieldWhenHealthLow,
         MouseDisableButtons,
         MouseDisableWheel,
         AudioOffset,
diff --git a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
index 2d2cd42213..4b75910454 100644
--- a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
@@ -53,6 +53,12 @@ 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),
+                    Keywords = new[] { "hp", "low", "playfield", "red" }
+                },
+                new SettingsCheckbox
                 {
                     LabelText = "Always show key overlay",
                     Bindable = config.GetBindable<bool>(OsuSetting.KeyOverlay)
diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index 97d2458674..761178b93d 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -3,9 +3,11 @@
 
 using System;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Utils;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
@@ -21,6 +23,8 @@ namespace osu.Game.Screens.Play.HUD
 
         private readonly Box box;
 
+        private Bindable<bool> enabled;
+
         /// <summary>
         /// The threshold under which the current player life should be considered low and the layer should start fading in.
         /// </summary>
@@ -37,9 +41,11 @@ namespace osu.Game.Screens.Play.HUD
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour color)
+        private void load(OsuColour color, OsuConfigManager config)
         {
             box.Colour = color.Red;
+            enabled = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenHealthLow);
+            enabled.BindValueChanged(e => this.FadeTo(e.NewValue ? 1 : 0, fade_time, Easing.OutQuint), true);
         }
 
         protected override void Update()

From 1562612f41681da4ead59c0d220068f933ef5faf Mon Sep 17 00:00:00 2001
From: Lucas A <game4allyt@gmail.com>
Date: Wed, 1 Apr 2020 15:12:31 +0200
Subject: [PATCH 12/26] Update visual tests and remove unessecary XMLDoc tag

---
 .../Visual/Gameplay/TestSceneFailingLayer.cs  | 30 ++++++++++++++++---
 osu.Game/Screens/Play/HUD/HealthDisplay.cs    |  1 -
 2 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
index 3016890ade..97fe0ac769 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
@@ -1,7 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
+using osu.Game.Configuration;
 using osu.Game.Screens.Play.HUD;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -10,22 +15,39 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         private readonly FailingLayer layer;
 
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
         public TestSceneFailingLayer()
         {
             Child = layer = new FailingLayer();
         }
 
+        [Test]
+        public void TestLayerConfig()
+        {
+            AddStep("enable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
+            AddWaitStep("wait for transition to finish", 5);
+            AddAssert("layer is enabled", () => layer.IsPresent);
+
+            AddStep("disable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, false));
+            AddWaitStep("wait for transition to finish", 5);
+            AddAssert("layer is disabled", () => !layer.IsPresent);
+            AddStep("restore layer enabling", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
+        }
+
         [Test]
         public void TestLayerFading()
         {
-            AddSliderStep("current health", 0.0, 1.0, 1.0, val =>
-            {
-                layer.Current.Value = val;
-            });
+            AddSliderStep("current health", 0.0, 1.0, 1.0, val => layer.Current.Value = val);
+            var box = layer.ChildrenOfType<Box>().First();
 
             AddStep("set health to 0.10", () => layer.Current.Value = 0.10);
             AddWaitStep("wait for fade to finish", 5);
+            AddAssert("layer fade is visible", () => box.IsPresent);
             AddStep("set health to 1", () => layer.Current.Value = 1f);
+            AddWaitStep("wait for fade to finish", 10);
+            AddAssert("layer fade is invisible", () => !box.IsPresent);
         }
     }
 }
diff --git a/osu.Game/Screens/Play/HUD/HealthDisplay.cs b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
index 4ea08626ad..01cb64a88c 100644
--- a/osu.Game/Screens/Play/HUD/HealthDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
@@ -23,7 +23,6 @@ namespace osu.Game.Screens.Play.HUD
         /// <summary>
         /// Bind the tracked fields of <see cref="HealthProcessor"/> to this health display.
         /// </summary>
-        /// <param name="processor"></param>
         public void BindHealthProcessor(HealthProcessor processor)
         {
             Current.BindTo(processor.Health);

From 4976f80b7107ae0e7554b02423ef0515c1b023f6 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 9 Apr 2020 14:31:25 +0900
Subject: [PATCH 13/26] Move implementation to HUD

---
 osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs |  8 --------
 osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs |  3 ---
 osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs     |  8 --------
 osu.Game/Screens/Play/HUD/FailingLayer.cs          | 12 ++++++++++++
 osu.Game/Screens/Play/HUD/HealthDisplay.cs         |  2 +-
 osu.Game/Screens/Play/HUDOverlay.cs                |  7 ++++++-
 6 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs b/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
index 4df2bc0f52..ebe45aa3ab 100644
--- a/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using osu.Framework.Allocation;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -15,7 +14,6 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using osu.Game.Screens.Play.HUD;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -32,12 +30,6 @@ namespace osu.Game.Rulesets.Catch.UI
             TimeRange.Value = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450);
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Overlays.Add(new FailingLayer());
-        }
-
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
 
         protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new CatchReplayRecorder(replay, (CatchPlayfield)Playfield);
diff --git a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
index 18bdfa5b5d..14cad39b04 100644
--- a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
@@ -21,7 +21,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using osu.Game.Screens.Play.HUD;
 using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
@@ -78,8 +77,6 @@ namespace osu.Game.Rulesets.Mania.UI
             configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);
 
             Config.BindWith(ManiaRulesetSetting.ScrollTime, TimeRange);
-
-            Overlays.Add(new FailingLayer());
         }
 
         protected override void AdjustScrollSpeed(int amount)
diff --git a/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs b/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
index b04e3cef3b..b4d51d11c9 100644
--- a/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Allocation;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Input.Handlers;
@@ -17,7 +16,6 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Play;
-using osu.Game.Screens.Play.HUD;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.UI
@@ -31,12 +29,6 @@ namespace osu.Game.Rulesets.Osu.UI
         {
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Overlays.Add(new FailingLayer());
-        }
-
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true; // always show the gameplay cursor
 
         protected override Playfield CreatePlayfield() => new OsuPlayfield();
diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index 761178b93d..f026d09c39 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Screens.Play.HUD
 {
@@ -48,6 +49,17 @@ namespace osu.Game.Screens.Play.HUD
             enabled.BindValueChanged(e => this.FadeTo(e.NewValue ? 1 : 0, fade_time, Easing.OutQuint), true);
         }
 
+        public override void BindHealthProcessor(HealthProcessor processor)
+        {
+            base.BindHealthProcessor(processor);
+
+            if (!(processor is DrainingHealthProcessor))
+            {
+                enabled.UnbindBindings();
+                enabled.Value = false;
+            }
+        }
+
         protected override void Update()
         {
             box.Alpha = (float)Interpolation.ValueAt(Math.Clamp(Clock.ElapsedFrameTime, 0, fade_time), box.Alpha,
diff --git a/osu.Game/Screens/Play/HUD/HealthDisplay.cs b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
index 01cb64a88c..08cb07d7ee 100644
--- a/osu.Game/Screens/Play/HUD/HealthDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
@@ -23,7 +23,7 @@ namespace osu.Game.Screens.Play.HUD
         /// <summary>
         /// Bind the tracked fields of <see cref="HealthProcessor"/> to this health display.
         /// </summary>
-        public void BindHealthProcessor(HealthProcessor processor)
+        public virtual void BindHealthProcessor(HealthProcessor processor)
         {
             Current.BindTo(processor.Health);
         }
diff --git a/osu.Game/Screens/Play/HUDOverlay.cs b/osu.Game/Screens/Play/HUDOverlay.cs
index e06f6d19c2..5114efd9a9 100644
--- a/osu.Game/Screens/Play/HUDOverlay.cs
+++ b/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);
         }
     }
 }

From 947745d87eff2d73b2f6f3c7da091897245217e7 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 9 Apr 2020 14:33:11 +0900
Subject: [PATCH 14/26] Change fail effect to be less distracting

---
 .../Visual/Gameplay/TestSceneFailingLayer.cs  |  5 +--
 osu.Game/Screens/Play/HUD/FailingLayer.cs     | 40 +++++++++++++++----
 2 files changed, 34 insertions(+), 11 deletions(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
index 97fe0ac769..42a211cb3d 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
@@ -1,11 +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.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 using osu.Game.Configuration;
 using osu.Game.Screens.Play.HUD;
 
@@ -40,7 +37,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         public void TestLayerFading()
         {
             AddSliderStep("current health", 0.0, 1.0, 1.0, val => layer.Current.Value = val);
-            var box = layer.ChildrenOfType<Box>().First();
+            var box = layer.Child;
 
             AddStep("set health to 0.10", () => layer.Current.Value = 0.10);
             AddWaitStep("wait for fade to finish", 5);
diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index f026d09c39..79f6855804 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -4,12 +4,16 @@
 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
 {
@@ -22,8 +26,6 @@ namespace osu.Game.Screens.Play.HUD
 
         private const int fade_time = 400;
 
-        private readonly Box box;
-
         private Bindable<bool> enabled;
 
         /// <summary>
@@ -31,20 +33,43 @@ namespace osu.Game.Screens.Play.HUD
         /// </summary>
         public double LowHealthThreshold = 0.20f;
 
+        private readonly Container boxes;
+
         public FailingLayer()
         {
             RelativeSizeAxes = Axes.Both;
-            Child = box = new Box
+            Children = new Drawable[]
             {
-                RelativeSizeAxes = Axes.Both,
-                Alpha = 0
+                boxes = new Container
+                {
+                    Blending = BlendingParameters.Additive,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = ColourInfo.GradientVertical(Color4.White, Color4.White.Opacity(0)),
+                            Height = 0.2f,
+                        },
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Height = 0.2f,
+                            Colour = ColourInfo.GradientVertical(Color4.White.Opacity(0), Color4.White),
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                        },
+                    }
+                },
             };
         }
 
         [BackgroundDependencyLoader]
         private void load(OsuColour color, OsuConfigManager config)
         {
-            box.Colour = color.Red;
+            boxes.Colour = color.Red;
+
             enabled = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenHealthLow);
             enabled.BindValueChanged(e => this.FadeTo(e.NewValue ? 1 : 0, fade_time, Easing.OutQuint), true);
         }
@@ -53,6 +78,7 @@ namespace osu.Game.Screens.Play.HUD
         {
             base.BindHealthProcessor(processor);
 
+            // don't display ever if the ruleset is not using a draining health display.
             if (!(processor is DrainingHealthProcessor))
             {
                 enabled.UnbindBindings();
@@ -62,7 +88,7 @@ namespace osu.Game.Screens.Play.HUD
 
         protected override void Update()
         {
-            box.Alpha = (float)Interpolation.ValueAt(Math.Clamp(Clock.ElapsedFrameTime, 0, fade_time), box.Alpha,
+            boxes.Alpha = (float)Interpolation.ValueAt(Math.Clamp(Clock.ElapsedFrameTime, 0, fade_time), boxes.Alpha,
                 Math.Clamp(max_alpha * (1 - Current.Value / LowHealthThreshold), 0, max_alpha), 0, fade_time, Easing.Out);
 
             base.Update();

From 52c976265146e754738a5c8f94222687537cd769 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 9 Apr 2020 14:36:04 +0900
Subject: [PATCH 15/26] Remove pointless keywords

---
 osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
index 4b75910454..0e854e8e9f 100644
--- a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
@@ -56,7 +56,6 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                 {
                     LabelText = "Fade playfield to red when health is low",
                     Bindable = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenHealthLow),
-                    Keywords = new[] { "hp", "low", "playfield", "red" }
                 },
                 new SettingsCheckbox
                 {

From 6db22366e2bcd50bb60aaa5b327d42e6fa639ad0 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 9 Apr 2020 14:47:48 +0900
Subject: [PATCH 16/26] Add new tests and tidy up existing tests

---
 .../Visual/Gameplay/TestSceneFailingLayer.cs  | 51 ++++++++++++-------
 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
index 42a211cb3d..0b5f023007 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
@@ -3,48 +3,63 @@
 
 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 readonly FailingLayer layer;
+        private FailingLayer layer;
 
         [Resolved]
         private OsuConfigManager config { get; set; }
 
-        public TestSceneFailingLayer()
+        [SetUpSteps]
+        public void SetUpSteps()
         {
-            Child = layer = new FailingLayer();
+            AddStep("create layer", () => Child = layer = new FailingLayer());
+            AddStep("enable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
+            AddUntilStep("layer is visible", () => layer.IsPresent);
         }
 
         [Test]
-        public void TestLayerConfig()
+        public void TestLayerDisabledViaConfig()
         {
-            AddStep("enable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
-            AddWaitStep("wait for transition to finish", 5);
-            AddAssert("layer is enabled", () => layer.IsPresent);
-
             AddStep("disable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, false));
-            AddWaitStep("wait for transition to finish", 5);
-            AddAssert("layer is disabled", () => !layer.IsPresent);
-            AddStep("restore layer enabling", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
+            AddUntilStep("layer is not visible", () => !layer.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerVisibilityWithAccumulatingProcessor()
+        {
+            AddStep("bind accumulating processor", () => layer.BindHealthProcessor(new AccumulatingHealthProcessor(1)));
+            AddUntilStep("layer is not visible", () => !layer.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerVisibilityWithDrainingProcessor()
+        {
+            AddStep("bind accumulating processor", () => layer.BindHealthProcessor(new DrainingHealthProcessor(1)));
+            AddWaitStep("wait for potential fade", 10);
+            AddAssert("layer is still visible", () => layer.IsPresent);
         }
 
         [Test]
         public void TestLayerFading()
         {
-            AddSliderStep("current health", 0.0, 1.0, 1.0, val => layer.Current.Value = val);
-            var box = layer.Child;
+            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.10);
-            AddWaitStep("wait for fade to finish", 5);
-            AddAssert("layer fade is visible", () => box.IsPresent);
+            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);
-            AddWaitStep("wait for fade to finish", 10);
-            AddAssert("layer fade is invisible", () => !box.IsPresent);
+            AddUntilStep("layer fade is invisible", () => !layer.Child.IsPresent);
         }
     }
 }

From c44957db3f8261da13f277c1b225e0bedbdebf3b Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 9 Apr 2020 14:49:09 +0900
Subject: [PATCH 17/26] Change initial health to 1 to avoid false fail display

---
 osu.Game/Screens/Play/HUD/FailingLayer.cs  | 1 +
 osu.Game/Screens/Play/HUD/HealthDisplay.cs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index 79f6855804..335516a767 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -42,6 +42,7 @@ namespace osu.Game.Screens.Play.HUD
             {
                 boxes = new Container
                 {
+                    Alpha = 0,
                     Blending = BlendingParameters.Additive,
                     RelativeSizeAxes = Axes.Both,
                     Children = new Drawable[]
diff --git a/osu.Game/Screens/Play/HUD/HealthDisplay.cs b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
index 08cb07d7ee..edc9dedf24 100644
--- a/osu.Game/Screens/Play/HUD/HealthDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/HealthDisplay.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Screens.Play.HUD
     /// </summary>
     public abstract class HealthDisplay : Container
     {
-        public readonly BindableDouble Current = new BindableDouble
+        public readonly BindableDouble Current = new BindableDouble(1)
         {
             MinValue = 0,
             MaxValue = 1

From 5a78e74470740ab31141c71b623d3d0c4bfa2987 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 9 Apr 2020 14:51:50 +0900
Subject: [PATCH 18/26] Use Lerp instead of ValueAt

---
 osu.Game/Screens/Play/HUD/FailingLayer.cs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index 335516a767..2a98e277b3 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -89,8 +89,9 @@ namespace osu.Game.Screens.Play.HUD
 
         protected override void Update()
         {
-            boxes.Alpha = (float)Interpolation.ValueAt(Math.Clamp(Clock.ElapsedFrameTime, 0, fade_time), boxes.Alpha,
-                Math.Clamp(max_alpha * (1 - Current.Value / LowHealthThreshold), 0, max_alpha), 0, fade_time, Easing.Out);
+            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();
         }

From 1c72afe8c49bfbe8df6f7670bb21c8f45cbcd271 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 9 Apr 2020 14:52:40 +0900
Subject: [PATCH 19/26] Move fading test to top for convenience

---
 .../Visual/Gameplay/TestSceneFailingLayer.cs  | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
index 0b5f023007..d831ea1835 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
@@ -25,6 +25,21 @@ namespace osu.Game.Tests.Visual.Gameplay
             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()
         {
@@ -46,20 +61,5 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddWaitStep("wait for potential fade", 10);
             AddAssert("layer is still 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);
-        }
     }
 }

From c5005eb378c657fff32971aebcb336ea4ff20ad1 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 9 Apr 2020 14:55:02 +0900
Subject: [PATCH 20/26] Adjust gradient size slightly and make const

---
 osu.Game/Screens/Play/HUD/FailingLayer.cs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index 2a98e277b3..a1188343ac 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -33,6 +33,8 @@ namespace osu.Game.Screens.Play.HUD
         /// </summary>
         public double LowHealthThreshold = 0.20f;
 
+        private const float gradient_size = 0.3f;
+
         private readonly Container boxes;
 
         public FailingLayer()
@@ -51,12 +53,12 @@ namespace osu.Game.Screens.Play.HUD
                         {
                             RelativeSizeAxes = Axes.Both,
                             Colour = ColourInfo.GradientVertical(Color4.White, Color4.White.Opacity(0)),
-                            Height = 0.2f,
+                            Height = gradient_size,
                         },
                         new Box
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Height = 0.2f,
+                            Height = gradient_size,
                             Colour = ColourInfo.GradientVertical(Color4.White.Opacity(0), Color4.White),
                             Anchor = Anchor.BottomLeft,
                             Origin = Anchor.BottomLeft,

From 9619fb9f6a5fa140b3bbf0226cf12c879619c66e Mon Sep 17 00:00:00 2001
From: smoogipoo <smoogipoo@smgi.me>
Date: Tue, 14 Apr 2020 15:00:36 +0900
Subject: [PATCH 21/26] Remove bind in Player

---
 osu.Game/Screens/Play/Player.cs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index f1df69c5db..4597ae760c 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -27,7 +27,6 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
-using osu.Game.Screens.Play.HUD;
 using osu.Game.Scoring.Legacy;
 using osu.Game.Screens.Ranking;
 using osu.Game.Skinning;
@@ -207,9 +206,6 @@ namespace osu.Game.Screens.Play
             foreach (var mod in Mods.Value.OfType<IApplicableToHealthProcessor>())
                 mod.ApplyToHealthProcessor(HealthProcessor);
 
-            foreach (var overlay in DrawableRuleset.Overlays.OfType<HealthDisplay>())
-                overlay.BindHealthProcessor(HealthProcessor);
-
             breakTracker.IsBreakTime.BindValueChanged(onBreakTimeChanged, true);
         }
 

From 7d2d0785fd0cda708e8cfe0ecf867c7eb6214bb6 Mon Sep 17 00:00:00 2001
From: smoogipoo <smoogipoo@smgi.me>
Date: Tue, 14 Apr 2020 15:07:32 +0900
Subject: [PATCH 22/26] Fix potential unsafe ordering of binds

---
 osu.Game/Screens/Play/HUD/FailingLayer.cs | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index a1188343ac..aa15c1fd45 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -26,7 +26,8 @@ namespace osu.Game.Screens.Play.HUD
 
         private const int fade_time = 400;
 
-        private Bindable<bool> enabled;
+        private readonly Bindable<bool> enabled = new Bindable<bool>();
+        private Bindable<bool> configEnabled;
 
         /// <summary>
         /// The threshold under which the current player life should be considered low and the layer should start fading in.
@@ -36,6 +37,7 @@ namespace osu.Game.Screens.Play.HUD
         private const float gradient_size = 0.3f;
 
         private readonly Container boxes;
+        private HealthProcessor healthProcessor;
 
         public FailingLayer()
         {
@@ -73,16 +75,29 @@ namespace osu.Game.Screens.Play.HUD
         {
             boxes.Colour = color.Red;
 
-            enabled = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenHealthLow);
+            configEnabled = config.GetBindable<bool>(OsuSetting.FadePlayfieldWhenHealthLow);
             enabled.BindValueChanged(e => this.FadeTo(e.NewValue ? 1 : 0, fade_time, Easing.OutQuint), true);
+
+            updateBindings();
         }
 
         public override void BindHealthProcessor(HealthProcessor processor)
         {
             base.BindHealthProcessor(processor);
 
-            // don't display ever if the ruleset is not using a draining health display.
-            if (!(processor is DrainingHealthProcessor))
+            healthProcessor = processor;
+            updateBindings();
+        }
+
+        private void updateBindings()
+        {
+            if (configEnabled == null || healthProcessor == null)
+                return;
+
+            // Don't display ever if the ruleset is not using a draining health display.
+            if (healthProcessor is DrainingHealthProcessor)
+                enabled.BindTo(configEnabled);
+            else
             {
                 enabled.UnbindBindings();
                 enabled.Value = false;

From 3183827329e477c8edb138f0f3930fcc450bf8a8 Mon Sep 17 00:00:00 2001
From: smoogipoo <smoogipoo@smgi.me>
Date: Tue, 14 Apr 2020 15:09:31 +0900
Subject: [PATCH 23/26] Reorder fields

---
 osu.Game/Screens/Play/HUD/FailingLayer.cs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index aa15c1fd45..cea85af112 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -23,20 +23,18 @@ namespace osu.Game.Screens.Play.HUD
     public class FailingLayer : HealthDisplay
     {
         private const float max_alpha = 0.4f;
-
         private const int fade_time = 400;
-
-        private readonly Bindable<bool> enabled = new Bindable<bool>();
-        private Bindable<bool> configEnabled;
+        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 const float gradient_size = 0.3f;
-
+        private readonly Bindable<bool> enabled = new Bindable<bool>();
         private readonly Container boxes;
+
+        private Bindable<bool> configEnabled;
         private HealthProcessor healthProcessor;
 
         public FailingLayer()

From b8b334ca27d853b81bf86eeb93d29a91d3ca4f34 Mon Sep 17 00:00:00 2001
From: smoogipoo <smoogipoo@smgi.me>
Date: Tue, 14 Apr 2020 15:21:56 +0900
Subject: [PATCH 24/26] Always unbind bindings

---
 osu.Game/Screens/Play/HUD/FailingLayer.cs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index cea85af112..cb8b5c1a9d 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -92,14 +92,13 @@ namespace osu.Game.Screens.Play.HUD
             if (configEnabled == null || healthProcessor == null)
                 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.UnbindBindings();
                 enabled.Value = false;
-            }
         }
 
         protected override void Update()

From 59728ffebddcdb47c121d7eaf3b1f80687f0e63a Mon Sep 17 00:00:00 2001
From: smoogipoo <smoogipoo@smgi.me>
Date: Tue, 14 Apr 2020 15:24:34 +0900
Subject: [PATCH 25/26] Fix up/improve test scene

---
 .../Visual/Gameplay/TestSceneFailingLayer.cs           | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
index d831ea1835..a95e806862 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneFailingLayer.cs
@@ -20,7 +20,12 @@ namespace osu.Game.Tests.Visual.Gameplay
         [SetUpSteps]
         public void SetUpSteps()
         {
-            AddStep("create layer", () => Child = layer = new FailingLayer());
+            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);
         }
@@ -44,6 +49,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         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);
         }
 
@@ -51,6 +57,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         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);
         }
 
@@ -58,6 +65,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         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);
         }

From f3dbddd75ca735dfb75fb34efb15a2f14370a440 Mon Sep 17 00:00:00 2001
From: smoogipoo <smoogipoo@smgi.me>
Date: Tue, 14 Apr 2020 15:52:38 +0900
Subject: [PATCH 26/26] Update bindings in LoadComplete()

---
 osu.Game/Screens/Play/HUD/FailingLayer.cs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/osu.Game/Screens/Play/HUD/FailingLayer.cs b/osu.Game/Screens/Play/HUD/FailingLayer.cs
index cb8b5c1a9d..a49aa89a7c 100644
--- a/osu.Game/Screens/Play/HUD/FailingLayer.cs
+++ b/osu.Game/Screens/Play/HUD/FailingLayer.cs
@@ -75,7 +75,11 @@ namespace osu.Game.Screens.Play.HUD
 
             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();
         }
 
@@ -89,7 +93,7 @@ namespace osu.Game.Screens.Play.HUD
 
         private void updateBindings()
         {
-            if (configEnabled == null || healthProcessor == null)
+            if (LoadState < LoadState.Ready)
                 return;
 
             enabled.UnbindBindings();