Merge remote-tracking branch 'origin/master' into fix-new-inspections

# Conflicts:
#	osu.Game.Rulesets.Catch/Judgements/CatchDropletJudgement.cs
#	osu.Game.Rulesets.Catch/Judgements/CatchJudgement.cs
#	osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs
#	osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs
#	osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs
#	osu.Game.Tests/Visual/SongSelect/TestCaseBeatmapScoresContainer.cs
#	osu.Game/Graphics/OsuFont.cs
#	osu.Game/Online/API/Requests/Responses/APILegacyScoreInfo.cs
#	osu.Game/Overlays/Profile/Header/BadgeContainer.cs
#	osu.Game/Overlays/Profile/ProfileHeader.cs
#	osu.Game/Screens/Select/PlaySongSelect.cs
#	osu.Game/Skinning/LegacySkinDecoder.cs

appveyor.yml

@@ -1,6 +1,6 @@
 clone_depth: 1
 version: '{branch}-{build}'
-image: Visual Studio 2017
+image: Previous Visual Studio 2017
 test: off
 install:
   - cmd: git submodule update --init --recursive --depth=5

build/build.cake

@@ -1,5 +1,5 @@
 #addin "nuget:?package=CodeFileSanity&version=0.0.21"
-#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2018.2.2"
+#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2018.3.4"
 #tool "nuget:?package=NVika.MSBuild&version=1.0.1"
 var nVikaToolPath = GetFiles("./tools/NVika.MSBuild.*/tools/NVika.exe").First();
 
@@ -46,7 +46,9 @@ Task("InspectCode")
             OutputFile = "inspectcodereport.xml",
         });
 
-        StartProcess(nVikaToolPath, @"parsereport ""inspectcodereport.xml"" --treatwarningsaserrors");
+        int returnCode = StartProcess(nVikaToolPath, $@"parsereport ""inspectcodereport.xml"" --treatwarningsaserrors");
+        if (returnCode != 0)
+            throw new Exception($"inspectcode failed with return code {returnCode}");
     });
 
 Task("CodeFileSanity")

osu.Desktop/Overlays/VersionManager.cs

@@ -111,7 +111,7 @@ namespace osu.Desktop.Overlays
             public UpdateCompleteNotification(string version, Action<string> openUrl = null)
             {
                 Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
-                Icon = FontAwesome.CheckSquare;
+                Icon = FontAwesome.Solid.CheckSquare;
                 Activated = delegate
                 {
                     openUrl?.Invoke($"https://osu.ppy.sh/home/changelog/lazer/{version}");

osu.Desktop/Updater/SimpleUpdateManager.cs

@@ -54,7 +54,7 @@ namespace osu.Desktop.Updater
                     {
                         Text = $"A newer release of osu! has been found ({version} → {latest.TagName}).\n\n"
                                + "Click here to download the new version, which can be installed over the top of your existing installation",
-                        Icon = FontAwesome.Upload,
+                        Icon = FontAwesome.Solid.Upload,
                         Activated = () =>
                         {
                             host.OpenUrlExternally(getBestUrl(latest));

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -159,7 +159,7 @@ namespace osu.Desktop.Updater
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Icon = FontAwesome.Upload,
+                        Icon = FontAwesome.Solid.Upload,
                         Colour = Color4.White,
                         Size = new Vector2(20),
                     }

osu.Game.Rulesets.Catch.Tests/TestCaseAutoJuiceStream.cs

@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         protected override Player CreatePlayer(Ruleset ruleset)
         {
-            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
+            Mods.Value = Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() }).ToArray();
             return base.CreatePlayer(ruleset);
         }
     }

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs

@@ -23,19 +23,19 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 {
                     Name = @"Fruit Count",
                     Content = fruits.ToString(),
-                    Icon = FontAwesome.CircleOutline
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Juice Stream Count",
                     Content = juiceStreams.ToString(),
-                    Icon = FontAwesome.Circle
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Banana Shower Count",
                     Content = bananaShowers.ToString(),
-                    Icon = FontAwesome.Circle
+                    Icon = FontAwesome.Regular.Circle
                 }
             };
         }

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch
 {
     public class CatchRuleset : Ruleset
     {
-        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap) => new DrawableCatchRuleset(this, beatmap);
+        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap, IReadOnlyList<Mod> mods) => new DrawableCatchRuleset(this, beatmap, mods);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new CatchBeatmapConverter(beatmap);
         public override IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => new CatchBeatmapProcessor(beatmap);
 

osu.Game.Rulesets.Catch/Judgements/CatchBananaJudgement.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
                     return 0;
 
                 case HitResult.Perfect:
-                    return 8;
+                    return 0.008;
             }
         }
 

osu.Game.Rulesets.Catch/Judgements/CatchDropletJudgement.cs

@@ -24,10 +24,10 @@ namespace osu.Game.Rulesets.Catch.Judgements
             switch (result)
             {
                 default:
-                    return 0;
+                    return base.HealthIncreaseFor(result);
 
                 case HitResult.Perfect:
-                    return 7;
+                    return 0.007;
             }
         }
     }

osu.Game.Rulesets.Catch/Judgements/CatchJudgement.cs

@@ -28,10 +28,10 @@ namespace osu.Game.Rulesets.Catch.Judgements
             switch (result)
             {
                 default:
-                    return 0;
+                    return -0.02;
 
                 case HitResult.Perfect:
-                    return 10.2;
+                    return 0.01;
             }
         }
 

osu.Game.Rulesets.Catch/Judgements/CatchTinyDropletJudgement.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
                     return 0;
 
                 case HitResult.Perfect:
-                    return 4;
+                    return 0.004;
             }
         }
     }

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableFruit.cs

@@ -6,6 +6,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;

osu.Game.Rulesets.Catch/Objects/Drawable/Pieces/Pulp.cs

@@ -3,7 +3,7 @@
 
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osuTK.Graphics;

osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Judgements;
@@ -27,20 +26,15 @@ namespace osu.Game.Rulesets.Catch.Scoring
             hpDrainRate = beatmap.BeatmapInfo.BaseDifficulty.DrainRate;
         }
 
-        private const double harshness = 0.01;
+        protected override double HealthAdjustmentFactorFor(JudgementResult result)
-
-        protected override void ApplyResult(JudgementResult result)
         {
-            base.ApplyResult(result);
+            switch (result.Type)
-
-            if (result.Type == HitResult.Miss)
             {
-                if (!result.Judgement.IsBonus)
+                case HitResult.Miss:
-                    Health.Value -= hpDrainRate * (harshness * 2);
+                    return hpDrainRate;
-                return;
+                default:
+                    return 10.2 - hpDrainRate; // Award less HP as drain rate is increased
             }
-
-            Health.Value += Math.Max(result.Judgement.HealthIncreaseFor(result) - hpDrainRate, 0) * harshness;
         }
 
         public override HitWindows CreateHitWindows() => new CatchHitWindows();

osu.Game.Rulesets.Catch/UI/DrawableCatchRuleset.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.Collections.Generic;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
@@ -10,6 +11,7 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Catch.Scoring;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
@@ -23,8 +25,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
-        public DrawableCatchRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableCatchRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            : base(ruleset, beatmap)
+            : base(ruleset, beatmap, mods)
         {
             Direction.Value = ScrollingDirection.Down;
             TimeRange.Value = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450);

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

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -8,6 +10,7 @@ using osu.Framework.Timing;
 using osu.Game.Rulesets.Mania.Edit;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
@@ -21,6 +24,9 @@ namespace osu.Game.Rulesets.Mania.Tests
     {
         private readonly Column column;
 
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
+
         protected ManiaPlacementBlueprintTestCase()
         {
             Add(column = new Column(0)

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

@@ -13,6 +13,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -31,6 +32,9 @@ namespace osu.Game.Rulesets.Mania.Tests
             typeof(ColumnHitObjectArea)
         };
 
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
+
         private readonly List<Column> columns = new List<Column>();
 
         public TestCaseColumn()

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -13,6 +14,7 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -24,6 +26,9 @@ namespace osu.Game.Rulesets.Mania.Tests
     {
         private const int columns = 4;
 
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
+
         private readonly List<ManiaStage> stages = new List<ManiaStage>();
 
         private FillFlowContainer<ScrollingTestContainer> fill;

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs

@@ -42,13 +42,13 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                 {
                     Name = @"Note Count",
                     Content = notes.ToString(),
-                    Icon = FontAwesome.CircleOutline
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Hold Note Count",
                     Content = holdnotes.ToString(),
-                    Icon = FontAwesome.Circle
+                    Icon = FontAwesome.Regular.Circle
                 },
             };
         }

osu.Game.Rulesets.Mania/Edit/DrawableManiaEditRuleset.cs

@@ -1,10 +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.Collections.Generic;
 using osu.Framework.Graphics;
 using osuTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 
@@ -14,8 +16,8 @@ namespace osu.Game.Rulesets.Mania.Edit
     {
         public new IScrollingInfo ScrollingInfo => base.ScrollingInfo;
 
-        public DrawableManiaEditRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableManiaEditRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            : base(ruleset, beatmap)
+            : base(ruleset, beatmap, mods)
         {
         }
 

osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs

@@ -11,6 +11,7 @@ using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
@@ -41,9 +42,9 @@ namespace osu.Game.Rulesets.Mania.Edit
 
         public int TotalColumns => ((ManiaPlayfield)DrawableRuleset.Playfield).TotalColumns;
 
-        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+        protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
         {
-            DrawableRuleset = new DrawableManiaEditRuleset(ruleset, beatmap);
+            DrawableRuleset = new DrawableManiaEditRuleset(ruleset, beatmap, mods);
 
             // This is the earliest we can cache the scrolling info to ourselves, before masks are added to the hierarchy and inject it
             dependencies.CacheAs(DrawableRuleset.ScrollingInfo);

osu.Game.Rulesets.Mania/Judgements/HoldNoteTickJudgement.cs

@@ -10,5 +10,16 @@ namespace osu.Game.Rulesets.Mania.Judgements
         public override bool AffectsCombo => false;
 
         protected override int NumericResultFor(HitResult result) => 20;
+
+        protected override double HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Miss:
+                    return 0;
+                default:
+                    return 0.040;
+            }
+        }
     }
 }

osu.Game.Rulesets.Mania/Judgements/ManiaJudgement.cs

@@ -29,5 +29,26 @@ namespace osu.Game.Rulesets.Mania.Judgements
                     return 300;
             }
         }
+
+        protected override double HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Miss:
+                    return -0.125;
+                case HitResult.Meh:
+                    return 0.005;
+                case HitResult.Ok:
+                    return 0.010;
+                case HitResult.Good:
+                    return 0.035;
+                case HitResult.Great:
+                    return 0.055;
+                case HitResult.Perfect:
+                    return 0.065;
+                default:
+                    return 0;
+            }
+        }
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaRuleset : Ruleset
     {
-        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap) => new DrawableManiaRuleset(this, beatmap);
+        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap, IReadOnlyList<Mod> mods) => new DrawableManiaRuleset(this, beatmap, mods);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap);
         public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new ManiaPerformanceCalculator(this, beatmap, score);
 

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

@@ -7,6 +7,7 @@ using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Scoring;
 

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

@@ -5,7 +5,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osuTK.Graphics;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Scoring;

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/BodyPiece.cs

@@ -7,6 +7,7 @@ using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/GlowPiece.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osuTK.Graphics;

osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs

@@ -3,7 +3,6 @@
 
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
@@ -28,36 +27,6 @@ namespace osu.Game.Rulesets.Mania.Scoring
         /// </summary>
         private const double hp_multiplier_max = 1;
 
-        /// <summary>
-        /// The default BAD hit HP increase.
-        /// </summary>
-        private const double hp_increase_bad = 0.005;
-
-        /// <summary>
-        /// The default OK hit HP increase.
-        /// </summary>
-        private const double hp_increase_ok = 0.010;
-
-        /// <summary>
-        /// The default GOOD hit HP increase.
-        /// </summary>
-        private const double hp_increase_good = 0.035;
-
-        /// <summary>
-        /// The default tick hit HP increase.
-        /// </summary>
-        private const double hp_increase_tick = 0.040;
-
-        /// <summary>
-        /// The default GREAT hit HP increase.
-        /// </summary>
-        private const double hp_increase_great = 0.055;
-
-        /// <summary>
-        /// The default PERFECT hit HP increase.
-        /// </summary>
-        private const double hp_increase_perfect = 0.065;
-
         /// <summary>
         /// The MISS HP multiplier at OD = 0.
         /// </summary>
@@ -73,11 +42,6 @@ namespace osu.Game.Rulesets.Mania.Scoring
         /// </summary>
         private const double hp_multiplier_miss_max = 1;
 
-        /// <summary>
-        /// The default MISS HP increase.
-        /// </summary>
-        private const double hp_increase_miss = -0.125;
-
         /// <summary>
         /// The MISS HP multiplier. This is multiplied to the miss hp increase.
         /// </summary>
@@ -88,10 +52,6 @@ namespace osu.Game.Rulesets.Mania.Scoring
         /// </summary>
         private double hpMultiplier = 1;
 
-        public ManiaScoreProcessor()
-        {
-        }
-
         public ManiaScoreProcessor(DrawableRuleset<ManiaHitObject> drawableRuleset)
             : base(drawableRuleset)
         {
@@ -122,47 +82,13 @@ namespace osu.Game.Rulesets.Mania.Scoring
             }
         }
 
-        protected override void ApplyResult(JudgementResult result)
+        protected override double HealthAdjustmentFactorFor(JudgementResult result)
-        {
+            => result.Type == HitResult.Miss ? hpMissMultiplier : hpMultiplier;
-            base.ApplyResult(result);
 
-            bool isTick = result.Judgement is HoldNoteTickJudgement;
 
-            if (isTick)
-            {
-                if (result.IsHit)
-                    Health.Value += hpMultiplier * hp_increase_tick;
-            }
-            else
-            {
-                switch (result.Type)
-                {
-                    case HitResult.Miss:
-                        Health.Value += hpMissMultiplier * hp_increase_miss;
-                        break;
 
-                    case HitResult.Meh:
-                        Health.Value += hpMultiplier * hp_increase_bad;
-                        break;
 
-                    case HitResult.Ok:
-                        Health.Value += hpMultiplier * hp_increase_ok;
-                        break;
 
-                    case HitResult.Good:
-                        Health.Value += hpMultiplier * hp_increase_good;
-                        break;
-
-                    case HitResult.Great:
-                        Health.Value += hpMultiplier * hp_increase_great;
-                        break;
-
-                    case HitResult.Perfect:
-                        Health.Value += hpMultiplier * hp_increase_perfect;
-                        break;
-                }
-            }
-        }
 
         public override HitWindows CreateHitWindows() => new ManiaHitWindows();
     }

osu.Game.Rulesets.Mania/UI/Components/ColumnHitObjectArea.cs

@@ -6,6 +6,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI;

osu.Game.Rulesets.Mania/UI/Components/ColumnKeyArea.cs

@@ -7,6 +7,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;

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

@@ -18,6 +18,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -39,8 +40,8 @@ namespace osu.Game.Rulesets.Mania.UI
 
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
 
-        public DrawableManiaRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableManiaRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            : base(ruleset, beatmap)
+            : base(ruleset, beatmap, mods)
         {
             // Generate the bar lines
             double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;

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

@@ -4,6 +4,7 @@
 using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Mania.Objects.Drawables;

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

@@ -1,11 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.IO;
 using System.Linq;
 using System.Text;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Beatmaps;
 using Decoder = osu.Game.Beatmaps.Formats.Decoder;
@@ -22,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             using (var reader = new StreamReader(stream))
             {
                 var beatmap = Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
-                var converted = new TestWorkingBeatmap(beatmap).GetPlayableBeatmap(new OsuRuleset().RulesetInfo);
+                var converted = new TestWorkingBeatmap(beatmap).GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>());
 
                 var objects = converted.HitObjects.ToList();
 

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

@@ -30,7 +30,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         protected override Container<Drawable> Content => content;
 
         private int depthIndex;
-        protected readonly List<Mod> Mods = new List<Mod>();
 
         public TestCaseHitCircle()
         {
@@ -68,7 +67,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 Depth = depthIndex++
             };
 
-            foreach (var mod in Mods.OfType<IApplicableToDrawableHitObjects>())
+            foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
 
             Add(drawable);

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         public TestCaseHitCircleHidden()
         {
-            Mods.Add(new OsuModHidden());
+            Mods.Value = new[] { new OsuModHidden() };
         }
     }
 }

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

@@ -0,0 +1,70 @@
+// 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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestCaseResumeOverlay : ManualInputManagerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(OsuResumeOverlay),
+        };
+
+        public TestCaseResumeOverlay()
+        {
+            ManualOsuInputManager osuInputManager;
+            CursorContainer cursor;
+            ResumeOverlay resume;
+
+            bool resumeFired = false;
+
+            Child = osuInputManager = new ManualOsuInputManager(new OsuRuleset().RulesetInfo)
+            {
+                Children = new Drawable[]
+                {
+                    cursor = new CursorContainer(),
+                    resume = new OsuResumeOverlay
+                    {
+                        GameplayCursor = cursor
+                    },
+                }
+            };
+
+            resume.ResumeAction = () => resumeFired = true;
+
+            AddStep("move mouse to center", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
+            AddStep("show", () => resume.Show());
+
+            AddStep("move mouse away", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.TopLeft));
+            AddStep("click", () => osuInputManager.GameClick());
+            AddAssert("not dismissed", () => !resumeFired && resume.State == Visibility.Visible);
+
+            AddStep("move mouse back", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
+            AddStep("click", () => osuInputManager.GameClick());
+            AddAssert("dismissed", () => resumeFired && resume.State == Visibility.Hidden);
+        }
+
+        private class ManualOsuInputManager : OsuInputManager
+        {
+            public ManualOsuInputManager(RulesetInfo ruleset)
+                : base(ruleset)
+            {
+            }
+
+            public void GameClick()
+            {
+                KeyBindingContainer.TriggerPressed(OsuAction.LeftButton);
+                KeyBindingContainer.TriggerReleased(OsuAction.LeftButton);
+            }
+        }
+    }
+}

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

@@ -44,7 +44,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         protected override Container<Drawable> Content => content;
 
         private int depthIndex;
-        protected readonly List<Mod> Mods = new List<Mod>();
 
         public TestCaseSlider()
         {
@@ -292,7 +291,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 Depth = depthIndex++
             };
 
-            foreach (var mod in Mods.OfType<IApplicableToDrawableHitObjects>())
+            foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
 
             drawable.OnNewResult += onNewResult;

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         public TestCaseSliderHidden()
         {
-            Mods.Add(new OsuModHidden());
+            Mods.Value = new[] { new OsuModHidden() };
         }
     }
 }

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

@@ -31,7 +31,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         protected override Container<Drawable> Content => content;
 
         private int depthIndex;
-        protected readonly List<Mod> Mods = new List<Mod>();
 
         public TestCaseSpinner()
         {
@@ -57,7 +56,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 Depth = depthIndex++
             };
 
-            foreach (var mod in Mods.OfType<IApplicableToDrawableHitObjects>())
+            foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
 
             Add(drawable);

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         public TestCaseSpinnerHidden()
         {
-            Mods.Add(new OsuModHidden());
+            Mods.Value = new[] { new OsuModHidden() };
         }
     }
 }

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs

@@ -23,19 +23,19 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 {
                     Name = @"Circle Count",
                     Content = circles.ToString(),
-                    Icon = FontAwesome.CircleOutline
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Slider Count",
                     Content = sliders.ToString(),
-                    Icon = FontAwesome.Circle
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Spinner Count",
                     Content = spinners.ToString(),
-                    Icon = FontAwesome.Circle
+                    Icon = FontAwesome.Regular.Circle
                 }
             };
         }

osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs

@@ -16,15 +16,16 @@ namespace osu.Game.Rulesets.Osu.Configuration
         protected override void InitialiseDefaults()
         {
             base.InitialiseDefaults();
-
             Set(OsuRulesetSetting.SnakingInSliders, true);
             Set(OsuRulesetSetting.SnakingOutSliders, true);
+            Set(OsuRulesetSetting.ShowCursorTrail, true);
         }
     }
 
     public enum OsuRulesetSetting
     {
         SnakingInSliders,
-        SnakingOutSliders
+        SnakingOutSliders,
+        ShowCursorTrail
     }
 }

osu.Game.Rulesets.Osu/Edit/DrawableOsuEditRuleset.cs

@@ -1,7 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
 using osuTK;
@@ -10,8 +12,8 @@ namespace osu.Game.Rulesets.Osu.Edit
 {
     public class DrawableOsuEditRuleset : DrawableOsuRuleset
     {
-        public DrawableOsuEditRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableOsuEditRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            : base(ruleset, beatmap)
+            : base(ruleset, beatmap, mods)
         {
         }
 

osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
@@ -23,8 +24,8 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            => new DrawableOsuEditRuleset(ruleset, beatmap);
+            => new DrawableOsuEditRuleset(ruleset, beatmap, mods);
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {

osu.Game.Rulesets.Osu/Judgements/OsuJudgement.cs

@@ -27,5 +27,20 @@ namespace osu.Game.Rulesets.Osu.Judgements
                     return 300;
             }
         }
+
+        protected override double HealthIncreaseFor(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.Miss:
+                    return -0.02;
+                case HitResult.Meh:
+                case HitResult.Good:
+                case HitResult.Great:
+                    return 0.01;
+                default:
+                    return 0;
+            }
+        }
     }
 }

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

@@ -12,6 +12,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
 using osuTK;
 using osuTK.Graphics;
 
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Description => "Play with blinds on your screen.";
         public override string Acronym => "BL";
 
-        public override IconUsage Icon => FontAwesome.Adjust;
+        public override IconUsage Icon => FontAwesome.Solid.Adjust;
         public override ModType Type => ModType.DifficultyIncrease;
 
         public override bool Ranked => false;
@@ -41,6 +42,8 @@ namespace osu.Game.Rulesets.Osu.Mods
             scoreProcessor.Health.ValueChanged += health => { blinds.AnimateClosedness((float)health.NewValue); };
         }
 
+        public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
+
         /// <summary>
         /// Element for the Blinds mod drawing 2 black boxes covering the whole screen which resize inside a restricted area with some leniency.
         /// </summary>

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

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override string Acronym => "GR";
 
-        public override IconUsage Icon => FontAwesome.ArrowsV;
+        public override IconUsage Icon => FontAwesome.Solid.ArrowsAltV;
 
         public override ModType Type => ModType.Fun;
 

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Transform";
         public override string Acronym => "TR";
-        public override IconUsage Icon => FontAwesome.Arrows;
+        public override IconUsage Icon => FontAwesome.Solid.ArrowsAlt;
         public override ModType Type => ModType.Fun;
         public override string Description => "Everything rotates. EVERYTHING.";
         public override double ScoreMultiplier => 1;

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

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Wiggle";
         public override string Acronym => "WG";
-        public override IconUsage Icon => FontAwesome.Certificate;
+        public override IconUsage Icon => FontAwesome.Solid.Certificate;
         public override ModType Type => ModType.Fun;
         public override string Description => "They just won't stay still...";
         public override double ScoreMultiplier => 1;

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPoint.cs

@@ -6,6 +6,7 @@ using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Skinning;
 

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

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 new SkinnableDrawable("Play/osu/reversearrow", _ => new SpriteIcon
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Icon = FontAwesome.ChevronRight
+                    Icon = FontAwesome.Solid.ChevronRight
                 }, restrictSize: false)
             };
         }

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

@@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
                             Size = new Vector2(48),
-                            Icon = FontAwesome.Asterisk,
+                            Icon = FontAwesome.Solid.Asterisk,
                             Shadow = false,
                         },
                     }

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

@@ -4,6 +4,7 @@
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Game.Graphics.Sprites;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;

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

@@ -4,6 +4,7 @@
 using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 

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

@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Osu
 {
     public class OsuRuleset : Ruleset
     {
-        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap) => new DrawableOsuRuleset(this, beatmap);
+        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap, IReadOnlyList<Mod> mods) => new DrawableOsuRuleset(this, beatmap, mods);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new OsuBeatmapConverter(beatmap);
         public override IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => new OsuBeatmapProcessor(beatmap);
 

osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs

@@ -37,8 +37,6 @@ namespace osu.Game.Rulesets.Osu.Scoring
             comboResultCounts.Clear();
         }
 
-        private const double harshness = 0.01;
-
         protected override void ApplyResult(JudgementResult result)
         {
             base.ApplyResult(result);
@@ -47,28 +45,29 @@ namespace osu.Game.Rulesets.Osu.Scoring
 
             if (result.Type != HitResult.None)
                 comboResultCounts[osuResult.ComboType] = comboResultCounts.GetOrDefault(osuResult.ComboType) + 1;
+        }
 
+        protected override double HealthAdjustmentFactorFor(JudgementResult result)
+        {
             switch (result.Type)
             {
                 case HitResult.Great:
-                    Health.Value += (10.2 - hpDrainRate) * harshness;
+                    return 10.2 - hpDrainRate;
-                    break;
 
                 case HitResult.Good:
-                    Health.Value += (8 - hpDrainRate) * harshness;
+                    return 8 - hpDrainRate;
-                    break;
 
                 case HitResult.Meh:
-                    Health.Value += (4 - hpDrainRate) * harshness;
+                    return 4 - hpDrainRate;
-                    break;
 
-                /*case HitResult.SliderTick:
+                // case HitResult.SliderTick:
-                    Health.Value += Math.Max(7 - hpDrainRate, 0) * 0.01;
+                //     return Math.Max(7 - hpDrainRate, 0) * 0.01;
-                    break;*/
 
                 case HitResult.Miss:
-                    Health.Value -= hpDrainRate * (harshness * 2);
+                    return hpDrainRate;
-                    break;
+
+                default:
+                    return 0;
             }
         }
 

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

@@ -43,22 +43,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
         private readonly InputResampler resampler = new InputResampler();
 
-        protected override DrawNode CreateDrawNode() => new TrailDrawNode();
+        protected override DrawNode CreateDrawNode() => new TrailDrawNode(this);
-
-        protected override void ApplyDrawNode(DrawNode node)
-        {
-            base.ApplyDrawNode(node);
-
-            TrailDrawNode tNode = (TrailDrawNode)node;
-            tNode.Shader = shader;
-            tNode.Texture = texture;
-            tNode.Size = size;
-            tNode.Time = time;
-
-            for (int i = 0; i < parts.Length; ++i)
-                if (parts[i].InvalidationID > tNode.Parts[i].InvalidationID)
-                    tNode.Parts[i] = parts[i];
-        }
 
         public CursorTrail()
         {
@@ -167,34 +152,53 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
         private class TrailDrawNode : DrawNode
         {
-            public IShader Shader;
+            protected new CursorTrail Source => (CursorTrail)base.Source;
-            public Texture Texture;
 
-            public float Time;
+            private IShader shader;
+            private Texture texture;
 
-            public readonly TrailPart[] Parts = new TrailPart[max_sprites];
+            private float time;
-            public Vector2 Size;
+
+            private readonly TrailPart[] parts = new TrailPart[max_sprites];
+            private Vector2 size;
 
             private readonly VertexBuffer<TexturedTrailVertex> vertexBuffer = new QuadVertexBuffer<TexturedTrailVertex>(max_sprites, BufferUsageHint.DynamicDraw);
 
-            public TrailDrawNode()
+            public TrailDrawNode(CursorTrail source)
+                : base(source)
             {
                 for (int i = 0; i < max_sprites; i++)
                 {
-                    Parts[i].InvalidationID = 0;
+                    parts[i].InvalidationID = 0;
-                    Parts[i].WasUpdated = false;
+                    parts[i].WasUpdated = false;
+                }
+            }
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                shader = Source.shader;
+                texture = Source.texture;
+                size = Source.size;
+                time = Source.time;
+
+                for (int i = 0; i < Source.parts.Length; ++i)
+                {
+                    if (Source.parts[i].InvalidationID > parts[i].InvalidationID)
+                        parts[i] = Source.parts[i];
                 }
             }
 
             public override void Draw(Action<TexturedVertex2D> vertexAction)
             {
-                Shader.GetUniform<float>("g_FadeClock").UpdateValue(ref Time);
+                shader.GetUniform<float>("g_FadeClock").UpdateValue(ref time);
 
                 int updateStart = -1, updateEnd = 0;
 
-                for (int i = 0; i < Parts.Length; ++i)
+                for (int i = 0; i < parts.Length; ++i)
                 {
-                    if (Parts[i].WasUpdated)
+                    if (parts[i].WasUpdated)
                     {
                         if (updateStart == -1)
                             updateStart = i;
@@ -203,22 +207,22 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                         int start = i * 4;
                         int end = start;
 
-                        Vector2 pos = Parts[i].Position;
+                        Vector2 pos = parts[i].Position;
-                        float time = Parts[i].Time;
+                        float localTime = parts[i].Time;
 
-                        Texture.DrawQuad(
+                        texture.DrawQuad(
-                            new Quad(pos.X - Size.X / 2, pos.Y - Size.Y / 2, Size.X, Size.Y),
+                            new Quad(pos.X - size.X / 2, pos.Y - size.Y / 2, size.X, size.Y),
                             DrawColourInfo.Colour,
                             null,
                             v => vertexBuffer.Vertices[end++] = new TexturedTrailVertex
                             {
                                 Position = v.Position,
                                 TexturePosition = v.TexturePosition,
-                                Time = time + 1,
+                                Time = localTime + 1,
                                 Colour = v.Colour,
                             });
 
-                        Parts[i].WasUpdated = false;
+                        parts[i].WasUpdated = false;
                     }
                     else if (updateStart != -1)
                     {
@@ -233,12 +237,12 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
                 base.Draw(vertexAction);
 
-                Shader.Bind();
+                shader.Bind();
 
-                Texture.TextureGL.Bind();
+                texture.TextureGL.Bind();
                 vertexBuffer.Draw();
 
-                Shader.Unbind();
+                shader.Unbind();
             }
 
             protected override void Dispose(bool isDisposing)

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

@@ -0,0 +1,149 @@
+// 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.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.UI.Cursor
+{
+    public class OsuCursor : SkinReloadableDrawable
+    {
+        private bool cursorExpand;
+
+        private Bindable<double> cursorScale;
+        private Bindable<bool> autoCursorScale;
+        private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
+
+        private Container expandTarget;
+        private Drawable scaleTarget;
+
+        public OsuCursor()
+        {
+            Origin = Anchor.Centre;
+            Size = new Vector2(28);
+        }
+
+        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+        {
+            cursorExpand = skin.GetValue<SkinConfiguration, bool>(s => s.CursorExpand ?? true);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config, IBindable<WorkingBeatmap> beatmap)
+        {
+            InternalChild = expandTarget = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                Child = scaleTarget = new SkinnableDrawable("cursor", _ => new CircularContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    BorderThickness = Size.X / 6,
+                    BorderColour = Color4.White,
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Type = EdgeEffectType.Shadow,
+                        Colour = Color4.Pink.Opacity(0.5f),
+                        Radius = 5,
+                    },
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true,
+                        },
+                        new CircularContainer
+                        {
+                            Origin = Anchor.Centre,
+                            Anchor = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Masking = true,
+                            BorderThickness = Size.X / 3,
+                            BorderColour = Color4.White.Opacity(0.5f),
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Alpha = 0,
+                                    AlwaysPresent = true,
+                                },
+                            },
+                        },
+                        new CircularContainer
+                        {
+                            Origin = Anchor.Centre,
+                            Anchor = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Scale = new Vector2(0.1f),
+                            Masking = true,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.White,
+                                },
+                            },
+                        },
+                    }
+                }, restrictSize: false)
+                {
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                }
+            };
+
+            this.beatmap.BindTo(beatmap);
+            this.beatmap.ValueChanged += _ => calculateScale();
+
+            cursorScale = config.GetBindable<double>(OsuSetting.GameplayCursorSize);
+            cursorScale.ValueChanged += _ => calculateScale();
+
+            autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
+            autoCursorScale.ValueChanged += _ => calculateScale();
+
+            calculateScale();
+        }
+
+        private void calculateScale()
+        {
+            float scale = (float)cursorScale.Value;
+
+            if (autoCursorScale.Value && beatmap.Value != null)
+            {
+                // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
+                scale *= (float)(1 - 0.7 * (1 + beatmap.Value.BeatmapInfo.BaseDifficulty.CircleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY);
+            }
+
+            scaleTarget.Scale = new Vector2(scale);
+        }
+
+        private const float pressed_scale = 1.2f;
+        private const float released_scale = 1f;
+
+        public void Expand()
+        {
+            if (!cursorExpand) return;
+
+            expandTarget.ScaleTo(released_scale).ScaleTo(pressed_scale, 100, Easing.OutQuad);
+        }
+
+        public void Contract() => expandTarget.ScaleTo(released_scale, 100, Easing.OutQuad);
+    }
+}

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

@@ -3,16 +3,10 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
-using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Configuration;
-using osu.Game.Configuration;
-using osu.Game.Skinning;
-using osuTK;
-using osuTK.Graphics;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu.UI.Cursor
@@ -25,6 +19,10 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
         private readonly Container<Drawable> fadeContainer;
 
+        private readonly Bindable<bool> showTrail = new Bindable<bool>(true);
+
+        private readonly CursorTrail cursorTrail;
+
         public OsuCursorContainer()
         {
             InternalChild = fadeContainer = new Container
@@ -32,11 +30,19 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
                 {
-                    new CursorTrail { Depth = 1 }
+                    cursorTrail = new CursorTrail { Depth = 1 }
                 }
             };
         }
 
+        [BackgroundDependencyLoader(true)]
+        private void load(OsuRulesetConfigManager config)
+        {
+            config?.BindWith(OsuRulesetSetting.ShowCursorTrail, showTrail);
+
+            showTrail.BindValueChanged(v => cursorTrail.FadeTo(v.NewValue ? 1 : 0, 200), true);
+        }
+
         private int downCount;
 
         private void updateExpandedState()
@@ -88,136 +94,5 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             fadeContainer.FadeTo(0.05f, 450, Easing.OutQuint);
             ActiveCursor.ScaleTo(0.8f, 450, Easing.OutQuint);
         }
-
-        public class OsuCursor : SkinReloadableDrawable
-        {
-            private bool cursorExpand;
-
-            private Bindable<double> cursorScale;
-            private Bindable<bool> autoCursorScale;
-            private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
-
-            private Container expandTarget;
-            private Drawable scaleTarget;
-
-            public OsuCursor()
-            {
-                Origin = Anchor.Centre;
-                Size = new Vector2(28);
-            }
-
-            protected override void SkinChanged(ISkinSource skin, bool allowFallback)
-            {
-                cursorExpand = skin.GetValue<SkinConfiguration, bool>(s => s.CursorExpand ?? true);
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuConfigManager config, IBindable<WorkingBeatmap> beatmap)
-            {
-                InternalChild = expandTarget = new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Origin = Anchor.Centre,
-                    Anchor = Anchor.Centre,
-                    Child = scaleTarget = new SkinnableDrawable("cursor", _ => new CircularContainer
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Masking = true,
-                        BorderThickness = Size.X / 6,
-                        BorderColour = Color4.White,
-                        EdgeEffect = new EdgeEffectParameters
-                        {
-                            Type = EdgeEffectType.Shadow,
-                            Colour = Color4.Pink.Opacity(0.5f),
-                            Radius = 5,
-                        },
-                        Children = new Drawable[]
-                        {
-                            new Box
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Alpha = 0,
-                                AlwaysPresent = true,
-                            },
-                            new CircularContainer
-                            {
-                                Origin = Anchor.Centre,
-                                Anchor = Anchor.Centre,
-                                RelativeSizeAxes = Axes.Both,
-                                Masking = true,
-                                BorderThickness = Size.X / 3,
-                                BorderColour = Color4.White.Opacity(0.5f),
-                                Children = new Drawable[]
-                                {
-                                    new Box
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Alpha = 0,
-                                        AlwaysPresent = true,
-                                    },
-                                },
-                            },
-                            new CircularContainer
-                            {
-                                Origin = Anchor.Centre,
-                                Anchor = Anchor.Centre,
-                                RelativeSizeAxes = Axes.Both,
-                                Scale = new Vector2(0.1f),
-                                Masking = true,
-                                Children = new Drawable[]
-                                {
-                                    new Box
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Colour = Color4.White,
-                                    },
-                                },
-                            },
-                        }
-                    }, restrictSize: false)
-                    {
-                        Origin = Anchor.Centre,
-                        Anchor = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Both,
-                    }
-                };
-
-                this.beatmap.BindTo(beatmap);
-                this.beatmap.ValueChanged += _ => calculateScale();
-
-                cursorScale = config.GetBindable<double>(OsuSetting.GameplayCursorSize);
-                cursorScale.ValueChanged += _ => calculateScale();
-
-                autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
-                autoCursorScale.ValueChanged += _ => calculateScale();
-
-                calculateScale();
-            }
-
-            private void calculateScale()
-            {
-                float scale = (float)cursorScale.Value;
-
-                if (autoCursorScale.Value && beatmap.Value != null)
-                {
-                    // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
-                    scale *= (float)(1 - 0.7 * (1 + beatmap.Value.BeatmapInfo.BaseDifficulty.CircleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY);
-                }
-
-                scaleTarget.Scale = new Vector2(scale);
-            }
-
-            private const float pressed_scale = 1.2f;
-            private const float released_scale = 1f;
-
-            public void Expand()
-            {
-                if (!cursorExpand) return;
-
-                expandTarget.ScaleTo(released_scale).ScaleTo(pressed_scale, 100, Easing.OutQuad);
-            }
-
-            public void Contract() => expandTarget.ScaleTo(released_scale, 100, Easing.OutQuad);
-        }
     }
 }

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

@@ -1,11 +1,14 @@
 // 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.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Objects;
@@ -14,6 +17,7 @@ using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
@@ -21,8 +25,8 @@ namespace osu.Game.Rulesets.Osu.UI
     {
         protected new OsuRulesetConfigManager Config => (OsuRulesetConfigManager)base.Config;
 
-        public DrawableOsuRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableOsuRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            : base(ruleset, beatmap)
+            : base(ruleset, beatmap, mods)
         {
         }
 
@@ -34,6 +38,8 @@ namespace osu.Game.Rulesets.Osu.UI
 
         public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new OsuPlayfieldAdjustmentContainer();
 
+        protected override ResumeOverlay CreateResumeOverlay() => new OsuResumeOverlay();
+
         public override DrawableHitObject<OsuHitObject> CreateDrawableRepresentation(OsuHitObject h)
         {
             switch (h)
@@ -58,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.UI
             get
             {
                 var first = (OsuHitObject)Objects.First();
-                return first.StartTime - first.TimePreempt;
+                return first.StartTime - Math.Max(2000, first.TimePreempt);
             }
         }
     }

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

@@ -0,0 +1,109 @@
+// 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.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public class OsuResumeOverlay : ResumeOverlay
+    {
+        private OsuClickToResumeCursor clickToResumeCursor;
+
+        private GameplayCursorContainer localCursorContainer;
+
+        public override CursorContainer LocalCursor => State == Visibility.Visible ? localCursorContainer : null;
+
+        protected override string Message => "Click the orange cursor to resume";
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(clickToResumeCursor = new OsuClickToResumeCursor { ResumeRequested = Resume });
+        }
+
+        public override void Show()
+        {
+            base.Show();
+            clickToResumeCursor.ShowAt(GameplayCursor.ActiveCursor.Position);
+
+            if (localCursorContainer == null)
+                Add(localCursorContainer = new OsuCursorContainer());
+        }
+
+        public override void Hide()
+        {
+            localCursorContainer?.Expire();
+            localCursorContainer = null;
+
+            base.Hide();
+        }
+
+        protected override bool OnHover(HoverEvent e) => true;
+
+        public class OsuClickToResumeCursor : OsuCursor, IKeyBindingHandler<OsuAction>
+        {
+            public override bool HandlePositionalInput => true;
+
+            public Action ResumeRequested;
+
+            public OsuClickToResumeCursor()
+            {
+                RelativePositionAxes = Axes.Both;
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateColour();
+                return base.OnHover(e);
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                updateColour();
+                base.OnHoverLost(e);
+            }
+
+            public bool OnPressed(OsuAction action)
+            {
+                switch (action)
+                {
+                    case OsuAction.LeftButton:
+                    case OsuAction.RightButton:
+                        if (!IsHovered) return false;
+
+                        this.ScaleTo(new Vector2(2), TRANSITION_TIME, Easing.OutQuint);
+
+                        ResumeRequested?.Invoke();
+                        return true;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(OsuAction action) => false;
+
+            public void ShowAt(Vector2 activeCursorPosition) => Schedule(() =>
+            {
+                updateColour();
+                this.MoveTo(activeCursorPosition);
+                this.ScaleTo(new Vector2(4)).Then().ScaleTo(Vector2.One, 1000, Easing.OutQuint);
+            });
+
+            private void updateColour()
+            {
+                this.FadeColour(IsHovered ? Color4.White : Color4.Orange, 400, Easing.OutQuint);
+            }
+        }
+    }
+}

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

@@ -34,6 +34,11 @@ namespace osu.Game.Rulesets.Osu.UI
                     LabelText = "Snaking out sliders",
                     Bindable = config.GetBindable<bool>(OsuRulesetSetting.SnakingOutSliders)
                 },
+                new SettingsCheckbox
+                {
+                    LabelText = "Cursor trail",
+                    Bindable = config.GetBindable<bool>(OsuRulesetSetting.ShowCursorTrail)
+                },
             };
         }
     }

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

@@ -11,6 +11,7 @@ using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
@@ -86,7 +87,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
                 Origin = Anchor.Centre,
                 RelativeSizeAxes = Axes.X,
                 Height = 768,
-                Children = new[] { drawableRuleset = new DrawableTaikoRuleset(new TaikoRuleset(), beatmap) }
+                Children = new[] { drawableRuleset = new DrawableTaikoRuleset(new TaikoRuleset(), beatmap, Array.Empty<Mod>()) }
             });
         }
 

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs

@@ -23,19 +23,19 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 {
                     Name = @"Hit Count",
                     Content = hits.ToString(),
-                    Icon = FontAwesome.CircleOutline
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Drumroll Count",
                     Content = drumrolls.ToString(),
-                    Icon = FontAwesome.Circle
+                    Icon = FontAwesome.Regular.Circle
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Swell Count",
                     Content = swells.ToString(),
-                    Icon = FontAwesome.Circle
+                    Icon = FontAwesome.Regular.Circle
                 }
             };
         }

osu.Game.Rulesets.Taiko/Objects/Drawables/Pieces/CirclePiece.cs

@@ -9,6 +9,7 @@ using osu.Game.Graphics.Backgrounds;
 using osuTK.Graphics;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Framework.Audio.Track;
+using osu.Framework.Graphics.Effects;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
 {

osu.Game.Rulesets.Taiko/Objects/Drawables/Pieces/SwellSymbolPiece.cs

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
                 new SpriteIcon
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Icon = FontAwesome.Asterisk,
+                    Icon = FontAwesome.Solid.Asterisk,
                     Shadow = false
                 }
             };

osu.Game.Rulesets.Taiko/Scoring/TaikoScoreProcessor.cs

@@ -46,19 +46,8 @@ namespace osu.Game.Rulesets.Taiko.Scoring
             hpMissMultiplier = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.DrainRate, 0.0018, 0.0075, 0.0120);
         }
 
-        protected override void ApplyResult(JudgementResult result)
+        protected override double HealthAdjustmentFactorFor(JudgementResult result)
-        {
+            => result.Type == HitResult.Miss ? hpMissMultiplier : hpMultiplier;
-            base.ApplyResult(result);
-
-            double hpIncrease = result.Judgement.HealthIncreaseFor(result);
-
-            if (result.Type == HitResult.Miss)
-                hpIncrease *= hpMissMultiplier;
-            else
-                hpIncrease *= hpMultiplier;
-
-            Health.Value += hpIncrease;
-        }
 
         protected override void Reset(bool storeResults)
         {

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Taiko
 {
     public class TaikoRuleset : Ruleset
     {
-        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap) => new DrawableTaikoRuleset(this, beatmap);
+        public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap, IReadOnlyList<Mod> mods) => new DrawableTaikoRuleset(this, beatmap, mods);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new TaikoBeatmapConverter(beatmap);
 
         public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]

osu.Game.Rulesets.Taiko/UI/DrawableTaikoRuleset.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.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -16,6 +17,7 @@ using osu.Framework.Input;
 using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Taiko.UI
@@ -26,8 +28,8 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
-        public DrawableTaikoRuleset(Ruleset ruleset, WorkingBeatmap beatmap)
+        public DrawableTaikoRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            : base(ruleset, beatmap)
+            : base(ruleset, beatmap, mods)
         {
             Direction.Value = ScrollingDirection.Left;
             TimeRange.Value = 7000;

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

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

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

@@ -6,6 +6,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.IO;
 using NUnit.Framework;
 using osuTK;
@@ -13,6 +14,7 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Catch.Beatmaps;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Osu;
@@ -39,7 +41,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 Assert.AreEqual(6, working.BeatmapInfo.BeatmapVersion);
                 Assert.AreEqual(6, working.Beatmap.BeatmapInfo.BeatmapVersion);
-                Assert.AreEqual(6, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapVersion);
+                Assert.AreEqual(6, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapInfo.BeatmapVersion);
             }
         }
 

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

@@ -267,7 +267,7 @@ namespace osu.Game.Tests.Visual.Background
             AddUntilStep("Song select has selection", () => songSelect.Carousel.SelectedBeatmap != null);
             AddStep("Set default user settings", () =>
             {
-                Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { new OsuModNoFail() });
+                Mods.Value = Mods.Value.Concat(new[] { new OsuModNoFail() }).ToArray();
                 songSelect.DimLevel.Value = 0.7f;
                 songSelect.BlurLevel.Value = 0.4f;
             });

osu.Game.Tests/Visual/Editor/TestCaseWaveform.cs

@@ -3,12 +3,13 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
-using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.Editor
@@ -16,35 +17,38 @@ namespace osu.Game.Tests.Visual.Editor
     [TestFixture]
     public class TestCaseWaveform : OsuTestCase
     {
+        private WorkingBeatmap waveformBeatmap;
+
         [BackgroundDependencyLoader]
         private void load()
         {
-            Beatmap.Value = new WaveformTestBeatmap();
+            waveformBeatmap = new WaveformTestBeatmap();
+        }
 
-            FillFlowContainer flow;
+        [TestCase(1f)]
-            Child = flow = new FillFlowContainer
+        [TestCase(1f / 2)]
+        [TestCase(1f / 4)]
+        [TestCase(1f / 8)]
+        [TestCase(1f / 16)]
+        [TestCase(0f)]
+        public void TestResolution(float resolution)
         {
-                RelativeSizeAxes = Axes.Both,
+            TestWaveformGraph graph = null;
-                Direction = FillDirection.Vertical,
-                Spacing = new Vector2(0, 10),
-            };
 
-            for (int i = 1; i <= 16; i *= 2)
+            AddStep("add graph", () =>
             {
-                var newDisplay = new WaveformGraph
+                Child = new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Resolution = 1f / i,
-                    Waveform = Beatmap.Value.Waveform,
-                };
-
-                flow.Add(new Container
                 {
                     RelativeSizeAxes = Axes.X,
                     Height = 100,
                     Children = new Drawable[]
                     {
-                        newDisplay,
+                        graph = new TestWaveformGraph
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Resolution = resolution,
+                            Waveform = waveformBeatmap.Waveform,
+                        },
                         new Container
                         {
                             Anchor = Anchor.Centre,
@@ -62,13 +66,42 @@ namespace osu.Game.Tests.Visual.Editor
                                 {
                                     Anchor = Anchor.Centre,
                                     Origin = Anchor.Centre,
-                                    Text = $"Resolution: {1f / i:0.00}"
+                                    Text = $"Resolution: {resolution:0.00}"
                                 }
                             }
                         }
                     }
+                };
             });
+
+            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
         }
+
+        [Test]
+        public void TestDefaultBeatmap()
+        {
+            TestWaveformGraph graph = null;
+
+            AddStep("add graph", () =>
+            {
+                Child = new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = 100,
+                    Child = graph = new TestWaveformGraph
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Waveform = new DummyWorkingBeatmap().Waveform,
+                    },
+                };
+            });
+
+            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+        }
+
+        public class TestWaveformGraph : WaveformGraph
+        {
+            public new Waveform ResampledWaveform => base.ResampledWaveform;
         }
     }
 }

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

@@ -14,7 +14,7 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         protected override Player CreatePlayer(Ruleset ruleset)
         {
-            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
+            Mods.Value = Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() }).ToArray();
             return new ScoreAccessiblePlayer();
         }
 

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

@@ -0,0 +1,150 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestCaseFrameStabilityContainer : OsuTestCase
+    {
+        private readonly ManualClock manualClock;
+
+        private readonly Container mainContainer;
+
+        private ClockConsumingChild consumer;
+
+        public TestCaseFrameStabilityContainer()
+        {
+            Child = mainContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Clock = new FramedClock(manualClock = new ManualClock()),
+            };
+        }
+
+        [Test]
+        public void TestLargeJumps()
+        {
+            seekManualTo(0);
+            createStabilityContainer();
+            seekManualTo(100000);
+
+            confirmSeek(100000);
+            checkFrameCount(6000);
+
+            seekManualTo(0);
+
+            confirmSeek(0);
+            checkFrameCount(12000);
+        }
+
+        [Test]
+        public void TestSmallJumps()
+        {
+            seekManualTo(0);
+            createStabilityContainer();
+            seekManualTo(40);
+
+            confirmSeek(40);
+            checkFrameCount(3);
+
+            seekManualTo(0);
+
+            confirmSeek(0);
+            checkFrameCount(6);
+        }
+
+        [Test]
+        public void TestSingleFrameJump()
+        {
+            seekManualTo(0);
+            createStabilityContainer();
+            seekManualTo(8);
+            confirmSeek(8);
+            checkFrameCount(1);
+
+            seekManualTo(16);
+            confirmSeek(16);
+            checkFrameCount(2);
+        }
+
+        [Test]
+        public void TestInitialSeek()
+        {
+            seekManualTo(100000);
+            createStabilityContainer();
+
+            confirmSeek(100000);
+            checkFrameCount(0);
+        }
+
+        private void createStabilityContainer() => AddStep("create container", () => mainContainer.Child = new FrameStabilityContainer().WithChild(consumer = new ClockConsumingChild()));
+
+        private void seekManualTo(double time) => AddStep($"seek manual clock to {time}", () => manualClock.CurrentTime = time);
+
+        private void confirmSeek(double time) => AddUntilStep($"wait for seek to {time}", () => consumer.Clock.CurrentTime == time);
+
+        private void checkFrameCount(int frames) =>
+            AddAssert($"elapsed frames is {frames}", () => consumer.ElapsedFrames == frames);
+
+        public class ClockConsumingChild : CompositeDrawable
+        {
+            private readonly OsuSpriteText text;
+            private readonly OsuSpriteText text2;
+            private readonly OsuSpriteText text3;
+
+            public ClockConsumingChild()
+            {
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                InternalChildren = new Drawable[]
+                {
+                    new FillFlowContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Children = new Drawable[]
+                        {
+                            text = new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            },
+                            text2 = new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            },
+                            text3 = new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            },
+                        }
+                    },
+                };
+            }
+
+            public int ElapsedFrames;
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (Clock.ElapsedFrameTime != 0)
+                    ElapsedFrames++;
+
+                text.Text = $"current time: {Clock.CurrentTime:F0}";
+                if (Clock.ElapsedFrameTime != 0)
+                    text2.Text = $"last elapsed frame time: {Clock.ElapsedFrameTime:F0}";
+                text3.Text = $"total frames: {ElapsedFrames:F0}";
+            }
+        }
+    }
+}

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

@@ -1,13 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Screens;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Cursor;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
+using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -15,14 +21,52 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         protected new PausePlayer Player => (PausePlayer)base.Player;
 
+        private readonly Container content;
+
+        protected override Container<Drawable> Content => content;
+
         public TestCasePause()
             : base(new OsuRuleset())
         {
+            base.Content.Add(content = new MenuCursorContainer { RelativeSizeAxes = Axes.Both });
         }
 
         [Test]
         public void TestPauseResume()
         {
+            AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
+            pauseAndConfirm();
+            resumeAndConfirm();
+        }
+
+        [Test]
+        public void TestResumeWithResumeOverlay()
+        {
+            AddStep("move cursor to center", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for hitobjects", () => Player.ScoreProcessor.Health.Value < 1);
+
+            pauseAndConfirm();
+            resume();
+
+            confirmClockRunning(false);
+            confirmPauseOverlayShown(false);
+
+            AddStep("click to resume", () =>
+            {
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            confirmClockRunning(true);
+        }
+
+        [Test]
+        public void TestResumeWithResumeOverlaySkipped()
+        {
+            AddStep("move cursor to button", () =>
+                InputManager.MoveMouseTo(Player.HUDOverlay.HoldToQuit.Children.OfType<HoldToConfirmContainer>().First().ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for hitobjects", () => Player.ScoreProcessor.Health.Value < 1);
+
             pauseAndConfirm();
             resumeAndConfirm();
         }
@@ -30,6 +74,8 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestPauseTooSoon()
         {
+            AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
+
             pauseAndConfirm();
             resumeAndConfirm();
 
@@ -144,9 +190,16 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
 
+            public new HUDOverlay HUDOverlay => base.HUDOverlay;
+
             public bool FailOverlayVisible => FailOverlay.State == Visibility.Visible;
 
             public bool PauseOverlayVisible => PauseOverlay.State == Visibility.Visible;
+
+            public PausePlayer()
+            {
+                PauseOnFocusLost = false;
+            }
         }
     }
 }

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

@@ -1,43 +1,43 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
+using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Screens;
-using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Screens;
 using osu.Game.Screens.Play;
+using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestCasePlayerLoader : ManualInputManagerTestCase
     {
         private PlayerLoader loader;
-        private readonly OsuScreenStack stack;
+        private OsuScreenStack stack;
 
-        public TestCasePlayerLoader()
+        [SetUp]
+        public void Setup() => Schedule(() =>
         {
-            InputManager.Add(stack = new OsuScreenStack { RelativeSizeAxes = Axes.Both });
+            InputManager.Child = stack = new OsuScreenStack { RelativeSizeAxes = Axes.Both };
-        }
+            Beatmap.Value = new TestWorkingBeatmap(new TestBeatmap(new OsuRuleset().RulesetInfo), Clock);
+        });
 
-        [BackgroundDependencyLoader]
+        [Test]
-        private void load(OsuGameBase game)
+        public void TestLoadContinuation()
         {
-            Beatmap.Value = new DummyWorkingBeatmap(game);
-
             AddStep("load dummy beatmap", () => stack.Push(loader = new PlayerLoader(() => new Player(false, false))));
-
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
-
             AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
-
             AddUntilStep("wait for no longer current", () => !loader.IsCurrentScreen());
-
-            AddStep("exit loader", () => loader.Exit());
-
-            AddUntilStep("wait for no longer alive", () => !loader.IsAlive);
-
             AddStep("load slow dummy beatmap", () =>
             {
                 SlowLoadPlayer slow = null;
@@ -50,6 +50,67 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("wait for no longer current", () => !loader.IsCurrentScreen());
         }
 
+        [Test]
+        public void TestModReinstantiation()
+        {
+            TestPlayer player = null;
+            TestMod gameMod = null;
+            TestMod playerMod1 = null;
+            TestMod playerMod2 = null;
+
+            AddStep("load player", () =>
+            {
+                Mods.Value = new[] { gameMod = new TestMod() };
+                stack.Push(loader = new PlayerLoader(() => player = new TestPlayer()));
+            });
+
+            AddUntilStep("wait for loader to become current", () => loader.IsCurrentScreen());
+            AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
+            AddStep("retrieve mods", () => playerMod1 = (TestMod)player.Mods.Value.Single());
+            AddAssert("game mods not applied", () => gameMod.Applied == false);
+            AddAssert("player mods applied", () => playerMod1.Applied);
+
+            AddStep("restart player", () =>
+            {
+                var lastPlayer = player;
+                player = null;
+                lastPlayer.Restart();
+            });
+
+            AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
+            AddStep("retrieve mods", () => playerMod2 = (TestMod)player.Mods.Value.Single());
+            AddAssert("game mods not applied", () => gameMod.Applied == false);
+            AddAssert("player has different mods", () => playerMod1 != playerMod2);
+            AddAssert("player mods applied", () => playerMod2.Applied);
+        }
+
+        private class TestMod : Mod, IApplicableToScoreProcessor
+        {
+            public override string Name => string.Empty;
+            public override string Acronym => string.Empty;
+            public override double ScoreMultiplier => 1;
+
+            public bool Applied { get; private set; }
+
+            public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+            {
+                Applied = true;
+            }
+
+            public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
+        }
+
+        private class TestPlayer : Player
+        {
+            public new Bindable<IReadOnlyList<Mod>> Mods => base.Mods;
+
+            public TestPlayer()
+                : base(false, false)
+            {
+            }
+        }
+
         protected class SlowLoadPlayer : Player
         {
             public bool Ready;

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

@@ -1,9 +1,11 @@
 // 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.ComponentModel;
 using System.Linq;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
@@ -15,7 +17,7 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         protected override Player CreatePlayer(Ruleset ruleset)
         {
-            var beatmap = Beatmap.Value.GetPlayableBeatmap(ruleset.RulesetInfo);
+            var beatmap = Beatmap.Value.GetPlayableBeatmap(ruleset.RulesetInfo, Array.Empty<Mod>());
 
             return new ScoreAccessibleReplayPlayer(ruleset.GetAutoplayMod().CreateReplayScore(beatmap));
         }

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

@@ -4,11 +4,13 @@
 using System;
 using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Timing;
@@ -23,6 +25,9 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(Playfield) };
 
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
+
         private readonly ScrollingTestContainer[] scrollContainers = new ScrollingTestContainer[4];
         private readonly TestPlayfield[] playfields = new TestPlayfield[4];
 

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

@@ -120,12 +120,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             }
         }
 
-        private class SecondarySource : ISkinSource
+        private class SecondarySource : ISkin
         {
-            public event Action SourceChanged;
-
-            public void TriggerSourceChanged() => SourceChanged?.Invoke();
-
             public Drawable GetDrawableComponent(string componentName) => new SecondarySourceBox();
 
             public Texture GetTexture(string componentName) => throw new NotImplementedException();
@@ -135,12 +131,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             public TValue GetValue<TConfiguration, TValue>(Func<TConfiguration, TValue> query) where TConfiguration : SkinConfiguration => throw new NotImplementedException();
         }
 
-        private class SkinSourceContainer : Container, ISkinSource
+        private class SkinSourceContainer : Container, ISkin
         {
-            public event Action SourceChanged;
-
-            public void TriggerSourceChanged() => SourceChanged?.Invoke();
-
             public Drawable GetDrawableComponent(string componentName) => new BaseSourceBox();
 
             public Texture GetTexture(string componentName) => throw new NotImplementedException();

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

@@ -23,7 +23,11 @@ namespace osu.Game.Tests.Visual.Menus
 
         public TestCaseLoaderAnimation()
         {
-            Child = logo = new OsuLogo { Depth = float.MinValue };
+            Child = logo = new OsuLogo
+            {
+                Alpha = 0,
+                Depth = float.MinValue
+            };
         }
 
         [Test]
@@ -39,7 +43,7 @@ namespace osu.Game.Tests.Visual.Menus
                 LoadScreen(loader);
             });
 
-            AddAssert("loaded", () =>
+            AddUntilStep("loaded", () =>
             {
                 logoVisible = loader.Logo?.Alpha > 0;
                 return loader.Logo != null && loader.ScreenLoaded;

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

@@ -1,62 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Game.Overlays.Profile.Header;
-using osu.Game.Users;
-
-namespace osu.Game.Tests.Visual.Online
-{
-    [TestFixture]
-    public class TestCaseBadgeContainer : OsuTestCase
-    {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(BadgeContainer) };
-
-        public TestCaseBadgeContainer()
-        {
-            BadgeContainer badgeContainer;
-
-            Child = badgeContainer = new BadgeContainer
-            {
-                RelativeSizeAxes = Axes.Both
-            };
-
-            AddStep("Show 1 badge", () => badgeContainer.ShowBadges(new[]
-            {
-                new Badge
-                {
-                    AwardedAt = DateTimeOffset.Now,
-                    Description = "Appreciates compasses",
-                    ImageUrl = "https://assets.ppy.sh/profile-badges/mg2018-1star.png",
-                }
-            }));
-
-            AddStep("Show 2 badges", () => badgeContainer.ShowBadges(new[]
-            {
-                new Badge
-                {
-                    AwardedAt = DateTimeOffset.Now,
-                    Description = "Contributed to osu!lazer testing",
-                    ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.png",
-                },
-                new Badge
-                {
-                    AwardedAt = DateTimeOffset.Now,
-                    Description = "Appreciates compasses",
-                    ImageUrl = "https://assets.ppy.sh/profile-badges/mg2018-1star.png",
-                }
-            }));
-
-            AddStep("Show many badges", () => badgeContainer.ShowBadges(Enumerable.Range(1, 20).Select(i => new Badge
-            {
-                AwardedAt = DateTimeOffset.Now,
-                Description = $"Contributed to osu!lazer testing {i} times",
-                ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg",
-            }).ToArray()));
-        }
-    }
-}

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

@@ -1,9 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
@@ -13,6 +10,9 @@ using osu.Game.Overlays.BeatmapSet.Buttons;
 using osu.Game.Overlays.BeatmapSet.Scores;
 using osu.Game.Rulesets;
 using osu.Game.Users;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace osu.Game.Tests.Visual.Online
 {
@@ -24,8 +24,8 @@ namespace osu.Game.Tests.Visual.Online
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(Header),
-            typeof(ClickableUsername),
+            typeof(ScoreTable),
-            typeof(DrawableScore),
+            typeof(ScoreTableRowBackground),
             typeof(DrawableTopScore),
             typeof(ScoresContainer),
             typeof(AuthorInfo),

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

@@ -9,7 +9,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Overlays.Profile.Header;
+using osu.Game.Overlays.Profile.Header.Components;
 using osu.Game.Users;
 using osuTK;
 

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

@@ -0,0 +1,185 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.MathUtils;
+using osu.Game.Graphics;
+using osu.Game.Overlays.BeatmapSet.Scores;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestCaseScoresContainer : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(DrawableTopScore),
+            typeof(TopScoreUserSection),
+            typeof(TopScoreStatisticsSection),
+            typeof(ScoreTable),
+            typeof(ScoreTableRowBackground),
+        };
+
+        private readonly Box background;
+
+        public TestCaseScoresContainer()
+        {
+            ScoresContainer scoresContainer;
+
+            Child = new Container
+            {
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Width = 0.8f,
+                Children = new Drawable[]
+                {
+                    background = new Box { RelativeSizeAxes = Axes.Both },
+                    scoresContainer = new ScoresContainer(),
+                }
+            };
+
+            var scores = new List<ScoreInfo>
+            {
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 6602580,
+                        Username = @"waaiiru",
+                        Country = new Country
+                        {
+                            FullName = @"Spain",
+                            FlagName = @"ES",
+                        },
+                    },
+                    Mods = new Mod[]
+                    {
+                        new OsuModDoubleTime(),
+                        new OsuModHidden(),
+                        new OsuModFlashlight(),
+                        new OsuModHardRock(),
+                    },
+                    Rank = ScoreRank.XH,
+                    PP = 200,
+                    MaxCombo = 1234,
+                    TotalScore = 1234567890,
+                    Accuracy = 1,
+                },
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 4608074,
+                        Username = @"Skycries",
+                        Country = new Country
+                        {
+                            FullName = @"Brazil",
+                            FlagName = @"BR",
+                        },
+                    },
+                    Mods = new Mod[]
+                    {
+                        new OsuModDoubleTime(),
+                        new OsuModHidden(),
+                        new OsuModFlashlight(),
+                    },
+                    Rank = ScoreRank.S,
+                    PP = 190,
+                    MaxCombo = 1234,
+                    TotalScore = 1234789,
+                    Accuracy = 0.9997,
+                },
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 1014222,
+                        Username = @"eLy",
+                        Country = new Country
+                        {
+                            FullName = @"Japan",
+                            FlagName = @"JP",
+                        },
+                    },
+                    Mods = new Mod[]
+                    {
+                        new OsuModDoubleTime(),
+                        new OsuModHidden(),
+                    },
+                    Rank = ScoreRank.B,
+                    PP = 180,
+                    MaxCombo = 1234,
+                    TotalScore = 12345678,
+                    Accuracy = 0.9854,
+                },
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 1541390,
+                        Username = @"Toukai",
+                        Country = new Country
+                        {
+                            FullName = @"Canada",
+                            FlagName = @"CA",
+                        },
+                    },
+                    Mods = new Mod[]
+                    {
+                        new OsuModDoubleTime(),
+                    },
+                    Rank = ScoreRank.C,
+                    PP = 170,
+                    MaxCombo = 1234,
+                    TotalScore = 1234567,
+                    Accuracy = 0.8765,
+                },
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 7151382,
+                        Username = @"Mayuri Hana",
+                        Country = new Country
+                        {
+                            FullName = @"Thailand",
+                            FlagName = @"TH",
+                        },
+                    },
+                    Rank = ScoreRank.F,
+                    PP = 160,
+                    MaxCombo = 1234,
+                    TotalScore = 123456,
+                    Accuracy = 0.6543,
+                },
+            };
+
+            foreach (var s in scores)
+            {
+                s.Statistics.Add(HitResult.Great, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Good, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Miss, RNG.Next(2000));
+            }
+
+            scoresContainer.Scores = scores;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            background.Colour = colours.Gray2;
+        }
+    }
+}

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

@@ -38,6 +38,7 @@ namespace osu.Game.Tests.Visual.Online
                         Country = new Country { FlagName = @"AU" },
                         CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
                         IsSupporter = true,
+                        SupportLevel = 3,
                     }) { Width = 300 },
                 },
             });

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

@@ -6,11 +6,12 @@ using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Profile;
-using osu.Game.Overlays.Profile.Header;
+using osu.Game.Overlays.Profile.Header.Components;
 using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual.Online
@@ -19,7 +20,9 @@ namespace osu.Game.Tests.Visual.Online
     public class TestCaseUserProfile : OsuTestCase
     {
         private readonly TestUserProfileOverlay profile;
-        private IAPIProvider api;
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -27,25 +30,11 @@ namespace osu.Game.Tests.Visual.Online
             typeof(UserProfileOverlay),
             typeof(RankGraph),
             typeof(LineGraph),
-            typeof(BadgeContainer)
+            typeof(SectionsContainer<>),
+            typeof(SupporterIcon)
         };
 
-        public TestCaseUserProfile()
+        public static readonly User TEST_USER = new User
-        {
-            Add(profile = new TestUserProfileOverlay());
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(IAPIProvider api)
-        {
-            this.api = api;
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            AddStep("Show offline dummy", () => profile.ShowUser(new User
         {
             Username = @"Somebody",
             Id = 1,
@@ -58,6 +47,11 @@ namespace osu.Game.Tests.Visual.Online
             {
                 Ranks = new UserStatistics.UserRanks { Global = 2148, Country = 1 },
                 PP = 4567.89m,
+                Level = new UserStatistics.LevelInfo
+                {
+                    Current = 727,
+                    Progress = 69,
+                }
             },
             RankHistory = new User.RankHistoryData
             {
@@ -72,10 +66,22 @@ namespace osu.Game.Tests.Visual.Online
                     Description = "Outstanding help by being a voluntary test subject.",
                     ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg"
                 }
-                }
+            },
-            }, false));
+            Title = "osu!volunteer",
+            Colour = "ff0000",
+            Achievements = new User.UserAchievement[0],
+        };
 
-            checkSupporterTag(false);
+        public TestCaseUserProfile()
+        {
+            Add(profile = new TestUserProfileOverlay());
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddStep("Show offline dummy", () => profile.ShowUser(TEST_USER, false));
 
             AddStep("Show null dummy", () => profile.ShowUser(new User
             {
@@ -92,8 +98,6 @@ namespace osu.Game.Tests.Visual.Online
                 CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg"
             }, api.IsLoggedIn));
 
-            checkSupporterTag(true);
-
             AddStep("Show flyte", () => profile.ShowUser(new User
             {
                 Username = @"flyte",
@@ -106,15 +110,6 @@ namespace osu.Game.Tests.Visual.Online
             AddStep("Show without reload", profile.Show);
         }
 
-        private void checkSupporterTag(bool isSupporter)
-        {
-            AddUntilStep("wait for load", () => profile.Header.User != null);
-            if (isSupporter)
-                AddAssert("is supporter", () => profile.Header.SupporterTag.Alpha == 1);
-            else
-                AddAssert("no supporter", () => profile.Header.SupporterTag.Alpha == 0);
-        }
-
         private class TestUserProfileOverlay : UserProfileOverlay
         {
             public new ProfileHeader Header => base.Header;

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

@@ -0,0 +1,81 @@
+// 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 osu.Framework.Allocation;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Overlays.Profile;
+using osu.Game.Overlays.Profile.Header;
+using osu.Game.Overlays.Profile.Header.Components;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestCaseUserProfileHeader : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ProfileHeader),
+            typeof(RankGraph),
+            typeof(LineGraph),
+            typeof(ProfileHeaderTabControl),
+            typeof(CentreHeaderContainer),
+            typeof(BottomHeaderContainer),
+            typeof(DetailHeaderContainer),
+            typeof(ProfileHeaderButton)
+        };
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        private readonly ProfileHeader header;
+
+        public TestCaseUserProfileHeader()
+        {
+            header = new ProfileHeader();
+            Add(header);
+
+            AddStep("Show offline dummy", () => header.User.Value = TestCaseUserProfile.TEST_USER);
+
+            AddStep("Show null dummy", () => header.User.Value = new User
+            {
+                Username = "Null"
+            });
+
+            addOnlineStep("Show ppy", new User
+            {
+                Username = @"peppy",
+                Id = 2,
+                IsSupporter = true,
+                Country = new Country { FullName = @"Australia", FlagName = @"AU" },
+                CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg"
+            });
+
+            addOnlineStep("Show flyte", new User
+            {
+                Username = @"flyte",
+                Id = 3103765,
+                Country = new Country { FullName = @"Japan", FlagName = @"JP" },
+                CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c6.jpg"
+            });
+        }
+
+        private void addOnlineStep(string name, User fallback)
+        {
+            AddStep(name, () =>
+            {
+                if (api.IsLoggedIn)
+                {
+                    var request = new GetUserRequest(fallback.Id);
+                    request.Success += user => header.User.Value = user;
+                    api.Queue(request);
+                }
+                else
+                    header.User.Value = fallback;
+            });
+        }
+    }
+}

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

@@ -16,10 +16,10 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             var overlay = new BeatmapOptionsOverlay();
 
-            overlay.AddButton(@"Remove", @"from unplayed", FontAwesome.TimesCircleOutline, Color4.Purple, null, Key.Number1);
+            overlay.AddButton(@"Remove", @"from unplayed", FontAwesome.Regular.TimesCircle, Color4.Purple, null, Key.Number1);
-            overlay.AddButton(@"Clear", @"local scores", FontAwesome.Eraser, Color4.Purple, null, Key.Number2);
+            overlay.AddButton(@"Clear", @"local scores", FontAwesome.Solid.Eraser, Color4.Purple, null, Key.Number2);
-            overlay.AddButton(@"Edit", @"Beatmap", FontAwesome.Pencil, Color4.Yellow, null, Key.Number3);
+            overlay.AddButton(@"Edit", @"Beatmap", FontAwesome.Solid.PencilAlt, Color4.Yellow, null, Key.Number3);
-            overlay.AddButton(@"Delete", @"Beatmap", FontAwesome.Trash, Color4.Pink, null, Key.Number4, float.MaxValue);
+            overlay.AddButton(@"Delete", @"Beatmap", FontAwesome.Solid.Trash, Color4.Pink, null, Key.Number4, float.MaxValue);
 
             Add(overlay);
 

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

@@ -1,313 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.MathUtils;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Overlays.BeatmapSet.Scores;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Scoring;
-using osu.Game.Users;
-
-namespace osu.Game.Tests.Visual.SongSelect
-{
-    [System.ComponentModel.Description("in BeatmapOverlay")]
-    public class TestCaseBeatmapScoresContainer : OsuTestCase
-    {
-        private readonly Box background;
-
-        public TestCaseBeatmapScoresContainer()
-        {
-            Container container;
-            ScoresContainer scoresContainer;
-
-            Child = container = new Container
-            {
-                Anchor = Anchor.TopCentre,
-                Origin = Anchor.TopCentre,
-                AutoSizeAxes = Axes.Y,
-                RelativeSizeAxes = Axes.X,
-                Width = 0.8f,
-                Children = new Drawable[]
-                {
-                    background = new Box { RelativeSizeAxes = Axes.Both },
-                    scoresContainer = new ScoresContainer(),
-                }
-            };
-
-            IEnumerable<ScoreInfo> scores = new[]
-            {
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 6602580,
-                        Username = @"waaiiru",
-                        Country = new Country
-                        {
-                            FullName = @"Spain",
-                            FlagName = @"ES",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                        new OsuModFlashlight(),
-                        new OsuModHardRock(),
-                    },
-                    Rank = ScoreRank.XH,
-                    TotalScore = 1234567890,
-                    Accuracy = 1,
-                },
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 4608074,
-                        Username = @"Skycries",
-                        Country = new Country
-                        {
-                            FullName = @"Brazil",
-                            FlagName = @"BR",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                        new OsuModFlashlight(),
-                    },
-                    Rank = ScoreRank.S,
-                    TotalScore = 1234789,
-                    Accuracy = 0.9997,
-                },
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 1014222,
-                        Username = @"eLy",
-                        Country = new Country
-                        {
-                            FullName = @"Japan",
-                            FlagName = @"JP",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                    },
-                    Rank = ScoreRank.B,
-                    TotalScore = 12345678,
-                    Accuracy = 0.9854,
-                },
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 1541390,
-                        Username = @"Toukai",
-                        Country = new Country
-                        {
-                            FullName = @"Canada",
-                            FlagName = @"CA",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                    },
-                    Rank = ScoreRank.C,
-                    TotalScore = 1234567,
-                    Accuracy = 0.8765,
-                },
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 7151382,
-                        Username = @"Mayuri Hana",
-                        Country = new Country
-                        {
-                            FullName = @"Thailand",
-                            FlagName = @"TH",
-                        },
-                    },
-                    Rank = ScoreRank.F,
-                    TotalScore = 123456,
-                    Accuracy = 0.6543,
-                },
-            };
-
-            foreach (var s in scores)
-            {
-                s.Statistics.Add(HitResult.Great, RNG.Next(2000));
-                s.Statistics.Add(HitResult.Good, RNG.Next(2000));
-                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
-            }
-
-            IEnumerable<ScoreInfo> anotherScores = new[]
-            {
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 4608074,
-                        Username = @"Skycries",
-                        Country = new Country
-                        {
-                            FullName = @"Brazil",
-                            FlagName = @"BR",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                        new OsuModFlashlight(),
-                    },
-                    Rank = ScoreRank.S,
-                    TotalScore = 1234789,
-                    Accuracy = 0.9997,
-                },
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 6602580,
-                        Username = @"waaiiru",
-                        Country = new Country
-                        {
-                            FullName = @"Spain",
-                            FlagName = @"ES",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                        new OsuModFlashlight(),
-                        new OsuModHardRock(),
-                    },
-                    Rank = ScoreRank.XH,
-                    TotalScore = 1234567890,
-                    Accuracy = 1,
-                },
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 7151382,
-                        Username = @"Mayuri Hana",
-                        Country = new Country
-                        {
-                            FullName = @"Thailand",
-                            FlagName = @"TH",
-                        },
-                    },
-                    Rank = ScoreRank.F,
-                    TotalScore = 123456,
-                    Accuracy = 0.6543,
-                },
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 1014222,
-                        Username = @"eLy",
-                        Country = new Country
-                        {
-                            FullName = @"Japan",
-                            FlagName = @"JP",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                    },
-                    Rank = ScoreRank.B,
-                    TotalScore = 12345678,
-                    Accuracy = 0.9854,
-                },
-                new ScoreInfo
-                {
-                    User = new User
-                    {
-                        Id = 1541390,
-                        Username = @"Toukai",
-                        Country = new Country
-                        {
-                            FullName = @"Canada",
-                            FlagName = @"CA",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                    },
-                    Rank = ScoreRank.C,
-                    TotalScore = 1234567,
-                    Accuracy = 0.8765,
-                },
-            };
-
-            foreach (var s in anotherScores)
-            {
-                s.Statistics.Add(HitResult.Great, RNG.Next(2000));
-                s.Statistics.Add(HitResult.Good, RNG.Next(2000));
-                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
-            }
-
-            var topScoreInfo = new ScoreInfo
-            {
-                User = new User
-                {
-                    Id = 2705430,
-                    Username = @"Mooha",
-                    Country = new Country
-                    {
-                        FullName = @"France",
-                        FlagName = @"FR",
-                    },
-                },
-                Mods = new Mod[]
-                {
-                    new OsuModDoubleTime(),
-                    new OsuModFlashlight(),
-                    new OsuModHardRock(),
-                },
-                Rank = ScoreRank.B,
-                TotalScore = 987654321,
-                Accuracy = 0.8487,
-            };
-            topScoreInfo.Statistics.Add(HitResult.Great, RNG.Next(2000));
-            topScoreInfo.Statistics.Add(HitResult.Good, RNG.Next(2000));
-            topScoreInfo.Statistics.Add(HitResult.Meh, RNG.Next(2000));
-
-            AddStep("scores pack 1", () => scoresContainer.Scores = scores);
-            AddStep("scores pack 2", () => scoresContainer.Scores = anotherScores);
-            AddStep("only top score", () => scoresContainer.Scores = new[] { topScoreInfo });
-            AddStep("remove scores", () => scoresContainer.Scores = null);
-            AddStep("resize to big", () => container.ResizeWidthTo(1, 300));
-            AddStep("resize to normal", () => container.ResizeWidthTo(0.8f, 300));
-            AddStep("online scores", () => scoresContainer.Beatmap = new BeatmapInfo { OnlineBeatmapID = 75, Ruleset = new OsuRuleset().RulesetInfo });
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            background.Colour = colours.Gray2;
-        }
-    }
-}

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

@@ -35,10 +35,6 @@ namespace osu.Game.Tests.Visual.SongSelect
         private WorkingBeatmap defaultBeatmap;
         private DatabaseContextFactory factory;
 
-        [Cached]
-        [Cached(Type = typeof(IBindable<IEnumerable<Mod>>))]
-        private readonly Bindable<IEnumerable<Mod>> selectedMods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
-
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(Screens.Select.SongSelect),
@@ -175,19 +171,19 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddStep("change ruleset", () =>
             {
-                songSelect.CurrentBeatmap.Mods.ValueChanged += onModChange;
+                Mods.ValueChanged += onModChange;
                 songSelect.Ruleset.ValueChanged += onRulesetChange;
 
                 Ruleset.Value = new TaikoRuleset().RulesetInfo;
 
-                songSelect.CurrentBeatmap.Mods.ValueChanged -= onModChange;
+                Mods.ValueChanged -= onModChange;
                 songSelect.Ruleset.ValueChanged -= onRulesetChange;
             });
 
             AddAssert("mods changed before ruleset", () => modChangeIndex < rulesetChangeIndex);
-            AddAssert("empty mods", () => !selectedMods.Value.Any());
+            AddAssert("empty mods", () => !Mods.Value.Any());
 
-            void onModChange(ValueChangedEvent<IEnumerable<Mod>> e) => modChangeIndex = actionIndex++;
+            void onModChange(ValueChangedEvent<IReadOnlyList<Mod>> e) => modChangeIndex = actionIndex++;
             void onRulesetChange(ValueChangedEvent<RulesetInfo> e) => rulesetChangeIndex = actionIndex--;
         }
 
@@ -218,7 +214,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private static int importId;
         private int getImportId() => ++importId;
 
-        private void changeMods(params Mod[] mods) => AddStep($"change mods to {string.Join(", ", mods.Select(m => m.Acronym))}", () => selectedMods.Value = mods);
+        private void changeMods(params Mod[] mods) => AddStep($"change mods to {string.Join(", ", mods.Select(m => m.Acronym))}", () => Mods.Value = mods);
 
         private void changeRuleset(int id) => AddStep($"change ruleset to {id}", () => Ruleset.Value = rulesets.AvailableRulesets.First(r => r.ID == id));
 

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

@@ -36,7 +36,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                     RelativeSizeAxes = Axes.Both,
                 },
                 buttons = new ButtonSystem(),
-                logo = new OsuLogo()
+                logo = new OsuLogo { RelativePositionAxes = Axes.Both }
             };
 
             buttons.SetOsuLogo(logo);

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

@@ -19,7 +19,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             AddStep("dialog #1", () => overlay.Push(new PopupDialog
             {
-                Icon = FontAwesome.TrashOutline,
+                Icon = FontAwesome.Regular.TrashAlt,
                 HeaderText = @"Confirm deletion of",
                 BodyText = @"Ayase Rie - Yuima-ru*World TVver.",
                 Buttons = new PopupDialogButton[]
@@ -39,7 +39,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             AddStep("dialog #2", () => overlay.Push(new PopupDialog
             {
-                Icon = FontAwesome.Gear,
+                Icon = FontAwesome.Solid.Cog,
                 HeaderText = @"What do you want to do with",
                 BodyText = "Camellia as \"Bang Riot\" - Blastix Riotz",
                 Buttons = new PopupDialogButton[]

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

@@ -0,0 +1,299 @@
+// 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 NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.MathUtils;
+using osu.Framework.Testing;
+using osu.Game.Graphics.Containers;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.Play;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestCaseLogoTrackingContainer : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(PlayerLoader),
+            typeof(Player),
+            typeof(LogoTrackingContainer),
+            typeof(ButtonSystem),
+            typeof(ButtonSystemState),
+            typeof(Menu),
+            typeof(MainMenu)
+        };
+
+        private OsuLogo logo;
+        private TestLogoTrackingContainer trackingContainer;
+        private Container transferContainer;
+        private Box visualBox;
+        private Box transferContainerBox;
+        private Drawable logoFacade;
+        private bool randomPositions;
+
+        private const float visual_box_size = 72;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Clear facades", () =>
+            {
+                Clear();
+                Add(logo = new OsuLogo { Scale = new Vector2(0.15f), RelativePositionAxes = Axes.Both });
+                trackingContainer = null;
+                transferContainer = null;
+            });
+        }
+
+        /// <summary>
+        /// Move the facade to 0,0, then move it to a random new location while the logo is still transforming to it.
+        /// Check if the logo is still tracking the facade.
+        /// </summary>
+        [Test]
+        public void TestMoveFacade()
+        {
+            AddToggleStep("Toggle move continuously", b => randomPositions = b);
+            AddStep("Add tracking containers", addFacadeContainers);
+            AddStep("Move facade to random position", moveLogoFacade);
+            waitForMove();
+            AddAssert("Logo is tracking", () => trackingContainer.IsLogoTracking);
+        }
+
+        /// <summary>
+        /// Check if the facade is removed from the container, the logo stops tracking.
+        /// </summary>
+        [Test]
+        public void TestRemoveFacade()
+        {
+            AddStep("Add tracking containers", addFacadeContainers);
+            AddStep("Move facade to random position", moveLogoFacade);
+            AddStep("Remove facade from FacadeContainer", removeFacade);
+            waitForMove();
+            AddAssert("Logo is not tracking", () => !trackingContainer.IsLogoTracking);
+        }
+
+        /// <summary>
+        /// Check if the facade gets added to a new container, tracking starts on the new facade.
+        /// </summary>
+        [Test]
+        public void TestTransferFacade()
+        {
+            AddStep("Add tracking containers", addFacadeContainers);
+            AddStep("Move facade to random position", moveLogoFacade);
+            AddStep("Remove facade from FacadeContainer", removeFacade);
+            AddStep("Transfer facade to a new container", () =>
+            {
+                transferContainer.Add(logoFacade);
+                transferContainerBox.Colour = Color4.Tomato;
+                moveLogoFacade();
+            });
+
+            waitForMove();
+            AddAssert("Logo is tracking", () => trackingContainer.IsLogoTracking);
+        }
+
+        /// <summary>
+        /// Add a facade to a flow container, move the logo to the center of the screen, then start tracking on the facade.
+        /// </summary>
+        [Test]
+        public void TestFlowContainer()
+        {
+            FillFlowContainer flowContainer;
+
+            AddStep("Create new flow container with facade", () =>
+            {
+                Add(trackingContainer = new TestLogoTrackingContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Origin = Anchor.TopCentre,
+                    Anchor = Anchor.TopCentre,
+                    Child = flowContainer = new FillFlowContainer
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Origin = Anchor.TopCentre,
+                        Anchor = Anchor.TopCentre,
+                        Direction = FillDirection.Vertical,
+                    }
+                });
+                flowContainer.Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        Origin = Anchor.TopCentre,
+                        Anchor = Anchor.TopCentre,
+                        Colour = Color4.Azure,
+                        Size = new Vector2(visual_box_size)
+                    },
+                    new Container
+                    {
+                        Alpha = 0.35f,
+                        RelativeSizeAxes = Axes.None,
+                        Size = new Vector2(visual_box_size),
+                        Origin = Anchor.TopCentre,
+                        Anchor = Anchor.TopCentre,
+                        Children = new Drawable[]
+                        {
+                            visualBox = new Box
+                            {
+                                Colour = Color4.White,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            trackingContainer.LogoFacade,
+                        }
+                    },
+                    new Box
+                    {
+                        Origin = Anchor.TopCentre,
+                        Anchor = Anchor.TopCentre,
+                        Colour = Color4.Azure,
+                        Size = new Vector2(visual_box_size)
+                    },
+                };
+            });
+
+            AddStep("Perform logo movements", () =>
+            {
+                trackingContainer.StopTracking();
+                logo.MoveTo(new Vector2(0.5f), 500, Easing.InOutExpo);
+
+                visualBox.Colour = Color4.White;
+
+                Scheduler.AddDelayed(() =>
+                {
+                    trackingContainer.StartTracking(logo, 1000, Easing.InOutExpo);
+                    visualBox.Colour = Color4.Tomato;
+                }, 700);
+            });
+
+            waitForMove(8);
+            AddAssert("Logo is tracking", () => trackingContainer.IsLogoTracking);
+        }
+
+        [Test]
+        public void TestSetFacadeSize()
+        {
+            bool failed = false;
+
+            AddStep("Set up scenario", () =>
+            {
+                failed = false;
+                addFacadeContainers();
+            });
+
+            AddStep("Try setting facade size", () =>
+            {
+                try
+                {
+                    logoFacade.Size = new Vector2(0, 0);
+                }
+                catch (Exception e)
+                {
+                    if (e is InvalidOperationException)
+                        failed = true;
+                }
+            });
+
+            AddAssert("Exception thrown", () => failed);
+        }
+
+        [Test]
+        public void TestSetMultipleContainers()
+        {
+            bool failed = false;
+            LogoTrackingContainer newContainer = new LogoTrackingContainer();
+
+            AddStep("Set up scenario", () =>
+            {
+                failed = false;
+                newContainer = new LogoTrackingContainer();
+                addFacadeContainers();
+                moveLogoFacade();
+            });
+
+            AddStep("Try tracking new container", () =>
+            {
+                try
+                {
+                    newContainer.StartTracking(logo);
+                }
+                catch (Exception e)
+                {
+                    if (e is InvalidOperationException)
+                        failed = true;
+                }
+            });
+
+            AddAssert("Exception thrown", () => failed);
+        }
+
+        private void addFacadeContainers()
+        {
+            AddRange(new Drawable[]
+            {
+                trackingContainer = new TestLogoTrackingContainer
+                {
+                    Alpha = 0.35f,
+                    RelativeSizeAxes = Axes.None,
+                    Size = new Vector2(visual_box_size),
+                    Child = visualBox = new Box
+                    {
+                        Colour = Color4.Tomato,
+                        RelativeSizeAxes = Axes.Both,
+                    }
+                },
+                transferContainer = new Container
+                {
+                    Alpha = 0.35f,
+                    RelativeSizeAxes = Axes.None,
+                    Size = new Vector2(visual_box_size),
+                    Child = transferContainerBox = new Box
+                    {
+                        Colour = Color4.White,
+                        RelativeSizeAxes = Axes.Both,
+                    }
+                },
+            });
+
+            trackingContainer.Add(logoFacade = trackingContainer.LogoFacade);
+            trackingContainer.StartTracking(logo, 1000);
+        }
+
+        private void waitForMove(int count = 5) => AddWaitStep("Wait for transforms to finish", count);
+
+        private void removeFacade()
+        {
+            trackingContainer.Remove(logoFacade);
+            visualBox.Colour = Color4.White;
+            moveLogoFacade();
+        }
+
+        private void moveLogoFacade()
+        {
+            if (logoFacade?.Transforms.Count == 0 && transferContainer?.Transforms.Count == 0)
+            {
+                Random random = new Random();
+                trackingContainer.Delay(500).MoveTo(new Vector2(random.Next(0, (int)logo.Parent.DrawWidth), random.Next(0, (int)logo.Parent.DrawHeight)), 300);
+                transferContainer.Delay(500).MoveTo(new Vector2(random.Next(0, (int)logo.Parent.DrawWidth), random.Next(0, (int)logo.Parent.DrawHeight)), 300);
+            }
+
+            if (randomPositions)
+                Schedule(moveLogoFacade);
+        }
+
+        private class TestLogoTrackingContainer : LogoTrackingContainer
+        {
+            /// <summary>
+            /// Check that the logo is tracking the position of the facade, with an acceptable precision lenience.
+            /// </summary>
+            public bool IsLogoTracking => Precision.AlmostEquals(Logo.Position, ComputeLogoTrackingPosition());
+        }
+    }
+}

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

@@ -253,7 +253,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private class TestModSelectOverlay : ModSelectOverlay
         {
-            public new Bindable<IEnumerable<Mod>> SelectedMods => base.SelectedMods;
+            public new Bindable<IReadOnlyList<Mod>> SelectedMods => base.SelectedMods;
 
             public ModButton GetModButton(Mod mod)
             {

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

@@ -17,7 +17,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             {
                 RelativeSizeAxes = Axes.Both,
                 State = Framework.Graphics.Containers.Visibility.Visible,
-                Icon = FontAwesome.AssistiveListeningSystems,
+                Icon = FontAwesome.Solid.AssistiveListeningSystems,
                 HeaderText = @"This is a test popup",
                 BodyText = "I can say lots of stuff and even wrap my words!",
                 Buttons = new PopupDialogButton[]