Merge branch 'master' into remove-unnecessary-code

osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Catch.Difficulty.Skills;
+using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Difficulty;
@@ -22,16 +23,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         protected override int SectionLength => 750;
 
-        private readonly float halfCatchWidth;
-
         public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
-            var catcher = new CatcherArea.Catcher(beatmap.BeatmapInfo.BaseDifficulty);
-            halfCatchWidth = catcher.CatchWidth * 0.5f;
-
-            // We're only using 80% of the catcher's width to simulate imperfect gameplay.
-            halfCatchWidth *= 0.8f;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -53,6 +47,14 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
+            float halfCatchWidth;
+
+            using (var catcher = new CatcherArea.Catcher(beatmap.BeatmapInfo.BaseDifficulty))
+            {
+                halfCatchWidth = catcher.CatchWidth * 0.5f;
+                halfCatchWidth *= 0.8f; // We're only using 80% of the catcher's width to simulate imperfect gameplay.
+            }
+
             CatchHitObject lastObject = null;
 
             foreach (var hitObject in beatmap.HitObjects.OfType<CatchHitObject>())
@@ -88,5 +90,13 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         {
             new Movement(),
         };
+
+        protected override Mod[] DifficultyAdjustmentMods => new Mod[]
+        {
+            new CatchModDoubleTime(),
+            new CatchModHalfTime(),
+            new CatchModHardRock(),
+            new CatchModEasy(),
+        };
     }
 }

osu.Game.Rulesets.Catch/Mods/CatchModHardRock.cs

@@ -15,77 +15,100 @@ namespace osu.Game.Rulesets.Catch.Mods
         public override double ScoreMultiplier => 1.12;
         public override bool Ranked => true;
 
-        private float lastStartX;
+        private float? lastPosition;
-        private int lastStartTime;
+        private double lastStartTime;
 
         public void ApplyToHitObject(HitObject hitObject)
         {
+            if (!(hitObject is Fruit))
+                return;
+
             var catchObject = (CatchHitObject)hitObject;
 
             float position = catchObject.X;
-            int startTime = (int)hitObject.StartTime;
+            double startTime = hitObject.StartTime;
 
-            if (lastStartX == 0)
+            if (lastPosition == null)
             {
-                lastStartX = position;
+                lastPosition = position;
                 lastStartTime = startTime;
+
                 return;
             }
 
-            float diff = lastStartX - position;
+            float positionDiff = position - lastPosition.Value;
-            int timeDiff = startTime - lastStartTime;
+            double timeDiff = startTime - lastStartTime;
 
             if (timeDiff > 1000)
             {
-                lastStartX = position;
+                lastPosition = position;
                 lastStartTime = startTime;
                 return;
             }
 
-            if (diff == 0)
+            if (positionDiff == 0)
             {
-                bool right = RNG.NextBool();
+                applyRandomOffset(ref position, timeDiff / 4d);
-
-                float rand = Math.Min(20, (float)RNG.NextDouble(0, timeDiff / 4d)) / CatchPlayfield.BASE_WIDTH;
-
-                if (right)
-                {
-                    if (position + rand <= 1)
-                        position += rand;
-                    else
-                        position -= rand;
-                }
-                else
-                {
-                    if (position - rand >= 0)
-                        position -= rand;
-                    else
-                        position += rand;
-                }
-
                 catchObject.X = position;
-
                 return;
             }
 
-            if (Math.Abs(diff) < timeDiff / 3d)
+            if (Math.Abs(positionDiff * CatchPlayfield.BASE_WIDTH) < timeDiff / 3d)
-            {
+                applyOffset(ref position, positionDiff);
-                if (diff > 0)
-                {
-                    if (position - diff > 0)
-                        position -= diff;
-                }
-                else
-                {
-                    if (position - diff < 1)
-                        position -= diff;
-                }
-            }
 
             catchObject.X = position;
 
-            lastStartX = position;
+            lastPosition = position;
             lastStartTime = startTime;
         }
+
+        /// <summary>
+        /// Applies a random offset in a random direction to a position, ensuring that the final position remains within the boundary of the playfield.
+        /// </summary>
+        /// <param name="position">The position which the offset should be applied to.</param>
+        /// <param name="maxOffset">The maximum offset, cannot exceed 20px.</param>
+        private void applyRandomOffset(ref float position, double maxOffset)
+        {
+            bool right = RNG.NextBool();
+            float rand = Math.Min(20, (float)RNG.NextDouble(0, maxOffset)) / CatchPlayfield.BASE_WIDTH;
+
+            if (right)
+            {
+                // Clamp to the right bound
+                if (position + rand <= 1)
+                    position += rand;
+                else
+                    position -= rand;
+            }
+            else
+            {
+                // Clamp to the left bound
+                if (position - rand >= 0)
+                    position -= rand;
+                else
+                    position += rand;
+            }
+        }
+
+        /// <summary>
+        /// Applies an offset to a position, ensuring that the final position remains within the boundary of the playfield.
+        /// </summary>
+        /// <param name="position">The position which the offset should be applied to.</param>
+        /// <param name="amount">The amount to offset by.</param>
+        private void applyOffset(ref float position, float amount)
+        {
+            if (amount > 0)
+            {
+                // Clamp to the right bound
+                if (position + amount < 1)
+                    position += amount;
+            }
+            else
+            {
+                // Clamp to the left bound
+                if (position + amount > 0)
+                    position += amount;
+            }
+        }
     }
 }

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 if (lastPlateableFruit.IsLoaded)
                     action();
                 else
-                    lastPlateableFruit.OnLoadComplete = _ => action();
+                    lastPlateableFruit.OnLoadComplete += _ => action();
             }
 
             if (result.IsHit && fruit.CanBePlated)

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

@@ -22,22 +22,15 @@ namespace osu.Game.Rulesets.Mania.UI
                 JudgementText.Font = JudgementText.Font.With(size: 25);
         }
 
-        protected override void LoadComplete()
+        protected override double FadeInDuration => 50;
+
+        protected override void ApplyHitAnimations()
         {
-            base.LoadComplete();
+            JudgementBody.ScaleTo(0.8f);
+            JudgementBody.ScaleTo(1, 250, Easing.OutElastic);
 
-            this.FadeInFromZero(50, Easing.OutQuint);
+            JudgementBody.Delay(FadeInDuration).ScaleTo(0.75f, 250);
-
+            this.Delay(FadeInDuration).FadeOut(200);
-            if (Result.IsHit)
-            {
-                JudgementBody.ScaleTo(0.8f);
-                JudgementBody.ScaleTo(1, 250, Easing.OutElastic);
-
-                JudgementBody.Delay(50).ScaleTo(0.75f, 250);
-                this.Delay(50).FadeOut(200);
-            }
-
-            Expire();
         }
     }
 }

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

@@ -354,9 +354,9 @@ namespace osu.Game.Rulesets.Osu.Tests
                 judgementResults = new List<JudgementResult>();
             });
 
-            AddUntilStep(() => Beatmap.Value.Track.CurrentTime == 0, "Beatmap at 0");
+            AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
-            AddUntilStep(() => currentPlayer.IsCurrentScreen(), "Wait until player is loaded");
+            AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
-            AddUntilStep(() => allJudgedFired, "Wait for all judged");
+            AddUntilStep("Wait for all judged", () => allJudgedFired);
         }
 
         private class ScoreAccessibleReplayPlayer : ReplayPlayer

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

@@ -5,7 +5,6 @@ using osu.Framework.Graphics;
 using osuTK;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -16,12 +15,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
         }
 
-        protected override void LoadComplete()
+        protected override void ApplyHitAnimations()
         {
-            if (Result.Type != HitResult.Miss)
+            JudgementText?.TransformSpacingTo(new Vector2(14, 0), 1800, Easing.OutQuint);
-                JudgementText?.TransformSpacingTo(new Vector2(14, 0), 1800, Easing.OutQuint);
+            base.ApplyHitAnimations();
-
-            base.LoadComplete();
         }
     }
 }

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

@@ -132,6 +132,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             base.ClearTransformsAfter(time, false, targetMember);
         }
 
+        public override void ApplyTransformsAt(double time, bool propagateChildren = false)
+        {
+            // For the same reasons as above w.r.t rewinding, we shouldn't propagate to children here either.
+            base.ApplyTransformsAt(time, false);
+        }
+
         private bool tracking;
 
         public bool Tracking

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

@@ -39,12 +39,10 @@ namespace osu.Game.Rulesets.Taiko.UI
             }
         }
 
-        protected override void LoadComplete()
+        protected override void ApplyHitAnimations()
         {
-            if (Result.IsHit)
+            this.MoveToY(-100, 500);
-                this.MoveToY(-100, 500);
+            base.ApplyHitAnimations();
-
-            base.LoadComplete();
         }
     }
 }

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

@@ -0,0 +1,72 @@
+// 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.Globalization;
+using NUnit.Framework;
+using osu.Game.Beatmaps.Formats;
+
+namespace osu.Game.Tests.Beatmaps.Formats
+{
+    [TestFixture]
+    public class ParsingTest
+    {
+        [Test]
+        public void TestNaNHandling() => allThrow<FormatException>("NaN");
+
+        [Test]
+        public void TestBadStringHandling() => allThrow<FormatException>("Random string 123");
+
+        [TestCase(Parsing.MAX_PARSE_VALUE)]
+        [TestCase(-1)]
+        [TestCase(0)]
+        [TestCase(1)]
+        [TestCase(-Parsing.MAX_PARSE_VALUE)]
+        [TestCase(10, 10)]
+        [TestCase(-10, 10)]
+        public void TestValidRanges(double input, double limit = Parsing.MAX_PARSE_VALUE)
+        {
+            Assert.AreEqual(Parsing.ParseInt((input).ToString(CultureInfo.InvariantCulture), (int)limit), (int)input);
+            Assert.AreEqual(Parsing.ParseFloat((input).ToString(CultureInfo.InvariantCulture), (float)limit), (float)input);
+            Assert.AreEqual(Parsing.ParseDouble((input).ToString(CultureInfo.InvariantCulture), limit), input);
+        }
+
+        [TestCase(double.PositiveInfinity)]
+        [TestCase(double.NegativeInfinity)]
+        [TestCase(999999999999)]
+        [TestCase(Parsing.MAX_PARSE_VALUE * 1.1)]
+        [TestCase(-Parsing.MAX_PARSE_VALUE * 1.1)]
+        [TestCase(11, 10)]
+        [TestCase(-11, 10)]
+        public void TestOutOfRangeHandling(double input, double limit = Parsing.MAX_PARSE_VALUE)
+            => allThrow<OverflowException>(input.ToString(CultureInfo.InvariantCulture), limit);
+
+        private void allThrow<T>(string input, double limit = Parsing.MAX_PARSE_VALUE)
+            where T : Exception
+        {
+            Assert.Throws(getIntParseException(input) ?? typeof(T), () => Parsing.ParseInt(input, (int)limit));
+            Assert.Throws<T>(() => Parsing.ParseFloat(input, (float)limit));
+            Assert.Throws<T>(() => Parsing.ParseDouble(input, limit));
+        }
+
+        /// <summary>
+        /// <see cref="int"/> may not be able to parse some inputs.
+        /// In this case we expect to receive the raw parsing exception.
+        /// </summary>
+        /// <param name="input">The input attempting to be parsed.</param>
+        /// <returns>The type of exception thrown by <see cref="int.Parse(string)"/>. Null if no exception is thrown.</returns>
+        private Type getIntParseException(string input)
+        {
+            try
+            {
+                var _ = int.Parse(input);
+            }
+            catch (Exception e)
+            {
+                return e.GetType();
+            }
+
+            return null;
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseAutoplay.cs

@@ -27,8 +27,8 @@ namespace osu.Game.Tests.Visual
         protected override void AddCheckSteps(Func<Player> player)
         {
             base.AddCheckSteps(player);
-            AddUntilStep(() => ((ScoreAccessiblePlayer)player()).ScoreProcessor.TotalScore.Value > 0, "score above zero");
+            AddUntilStep("score above zero", () => ((ScoreAccessiblePlayer)player()).ScoreProcessor.TotalScore.Value > 0);
-            AddUntilStep(() => ((ScoreAccessiblePlayer)player()).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0), "key counter counted keys");
+            AddUntilStep("key counter counted keys", () => ((ScoreAccessiblePlayer)player()).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0));
         }
 
         private class ScoreAccessiblePlayer : Player

osu.Game.Tests/Visual/TestCaseBackgroundScreenBeatmap.cs

@@ -98,7 +98,7 @@ namespace osu.Game.Tests.Visual
         {
             setupUserSettings();
             AddStep("Start player loader", () => songSelect.Push(playerLoader = new DimAccessiblePlayerLoader(player = new DimAccessiblePlayer())));
-            AddUntilStep(() => playerLoader?.IsLoaded ?? false, "Wait for Player Loader to load");
+            AddUntilStep("Wait for Player Loader to load", () => playerLoader?.IsLoaded ?? false);
             AddAssert("Background retained from song select", () => songSelect.IsBackgroundCurrent());
             AddStep("Trigger background preview", () =>
             {
@@ -220,7 +220,7 @@ namespace osu.Game.Tests.Visual
             AddAssert("Screen is undimmed", () => songSelect.IsBackgroundUndimmed());
         }
 
-        private void waitForDim() => AddWaitStep(5, "Wait for dim");
+        private void waitForDim() => AddWaitStep("Wait for dim", 5);
 
         private void createFakeStoryboard() => AddStep("Create storyboard", () =>
         {
@@ -249,14 +249,14 @@ namespace osu.Game.Tests.Visual
                     Ready = true,
                 }));
             });
-            AddUntilStep(() => playerLoader.IsLoaded, "Wait for Player Loader to load");
+            AddUntilStep("Wait for Player Loader to load", () => playerLoader.IsLoaded);
             AddStep("Move mouse to center of screen", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));
-            AddUntilStep(() => player.IsLoaded, "Wait for player to load");
+            AddUntilStep("Wait for player to load", () => player.IsLoaded);
         }
 
         private void setupUserSettings()
         {
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap != null, "Song select has selection");
+            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() });

osu.Game.Tests/Visual/TestCaseBeatmapCarousel.cs

@@ -87,7 +87,7 @@ namespace osu.Game.Tests.Visual
                 carousel.BeatmapSetsChanged = () => changed = true;
                 carousel.BeatmapSets = beatmapSets;
             });
-            AddUntilStep(() => changed, "Wait for load");
+            AddUntilStep("Wait for load", () => changed);
         }
 
         private void ensureRandomFetchSuccess() =>
@@ -214,7 +214,7 @@ namespace osu.Game.Tests.Visual
             checkSelected(3, 2);
 
             AddStep("Un-filter (debounce)", () => carousel.Filter(new FilterCriteria()));
-            AddUntilStep(() => !carousel.PendingFilterTask, "Wait for debounce");
+            AddUntilStep("Wait for debounce", () => !carousel.PendingFilterTask);
             checkVisibleItemCount(diff: false, count: set_count);
             checkVisibleItemCount(diff: true, count: 3);
 
@@ -327,13 +327,13 @@ namespace osu.Game.Tests.Visual
             AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
             checkSelected(1);
 
-            AddUntilStep(() =>
+            AddUntilStep("Remove all", () =>
             {
                 if (!carousel.BeatmapSets.Any()) return true;
 
                 carousel.RemoveBeatmapSet(carousel.BeatmapSets.Last());
                 return false;
-            }, "Remove all");
+            });
 
             checkNoSelection();
         }

osu.Game.Tests/Visual/TestCaseBeatmapDetailArea.cs

@@ -1,8 +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;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
 using osu.Game.Screens.Select;
 using osuTK;
 
@@ -12,14 +16,145 @@ namespace osu.Game.Tests.Visual
     [System.ComponentModel.Description("PlaySongSelect leaderboard/details area")]
     public class TestCaseBeatmapDetailArea : OsuTestCase
     {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(BeatmapDetails) };
+
         public TestCaseBeatmapDetailArea()
         {
-            Add(new BeatmapDetailArea
+            BeatmapDetailArea detailsArea;
+            Add(detailsArea = new BeatmapDetailArea
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Size = new Vector2(550f, 450f),
             });
+
+            AddStep("all metrics", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Version = "All Metrics",
+                        Metadata = new BeatmapMetadata
+                        {
+                            Source = "osu!lazer",
+                            Tags = "this beatmap has all the metrics",
+                        },
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            CircleSize = 7,
+                            DrainRate = 1,
+                            OverallDifficulty = 5.7f,
+                            ApproachRate = 3.5f,
+                        },
+                        StarDifficulty = 5.3f,
+                        Metrics = new BeatmapMetrics
+                        {
+                            Ratings = Enumerable.Range(0, 11),
+                            Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                            Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                        },
+                    }
+                }
+            );
+
+            AddStep("all except source", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "All Metrics",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Tags = "this beatmap has all the metrics",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 7,
+                        DrainRate = 1,
+                        OverallDifficulty = 5.7f,
+                        ApproachRate = 3.5f,
+                    },
+                    StarDifficulty = 5.3f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Ratings = Enumerable.Range(0, 11),
+                        Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                        Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                    },
+                }
+            });
+
+            AddStep("ratings", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "Only Ratings",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has ratings metrics but not retries or fails",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 6,
+                        DrainRate = 9,
+                        OverallDifficulty = 6,
+                        ApproachRate = 6,
+                    },
+                    StarDifficulty = 4.8f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Ratings = Enumerable.Range(0, 11),
+                    },
+                }
+            });
+
+            AddStep("fails+retries", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "Only Retries and Fails",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has retries and fails but no ratings",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 3.7f,
+                        DrainRate = 6,
+                        OverallDifficulty = 6,
+                        ApproachRate = 7,
+                    },
+                    StarDifficulty = 2.91f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                        Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                    },
+                }
+            });
+
+            AddStep("null metrics", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "No Metrics",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has no metrics",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 5,
+                        DrainRate = 5,
+                        OverallDifficulty = 5.5f,
+                        ApproachRate = 6.5f,
+                    },
+                    StarDifficulty = 1.97f,
+                }
+            });
+
+            AddStep("null beatmap", () => detailsArea.Beatmap = null);
         }
     }
 }

osu.Game.Tests/Visual/TestCaseBeatmapInfoWedge.cs

@@ -56,11 +56,11 @@ namespace osu.Game.Tests.Visual
             // select part is redundant, but wait for load isn't
             selectBeatmap(Beatmap.Value.Beatmap);
 
-            AddWaitStep(3);
+            AddWaitStep("wait for select", 3);
 
             AddStep("hide", () => { infoWedge.State = Visibility.Hidden; });
 
-            AddWaitStep(3);
+            AddWaitStep("wait for hide", 3);
 
             AddStep("show", () => { infoWedge.State = Visibility.Visible; });
 
@@ -135,7 +135,7 @@ namespace osu.Game.Tests.Visual
                 infoWedge.Beatmap = Beatmap.Value = b == null ? Beatmap.Default : new TestWorkingBeatmap(b);
             });
 
-            AddUntilStep(() => infoWedge.Info != infoBefore, "wait for async load");
+            AddUntilStep("wait for async load", () => infoWedge.Info != infoBefore);
         }
 
         private IBeatmap createTestBeatmap(RulesetInfo ruleset)

osu.Game.Tests/Visual/TestCaseChannelTabControl.cs

@@ -90,7 +90,7 @@ namespace osu.Game.Tests.Visual
             AddStep("set second channel", () => channelTabControl.Current.Value = channelTabControl.Items.Skip(1).First());
             AddAssert("selector tab is inactive", () => !channelTabControl.ChannelSelectorActive.Value);
 
-            AddUntilStep(() =>
+            AddUntilStep("remove all channels", () =>
             {
                 var first = channelTabControl.Items.First();
                 if (first.Name == "+")
@@ -98,7 +98,7 @@ namespace osu.Game.Tests.Visual
 
                 channelTabControl.RemoveChannel(first);
                 return false;
-            }, "remove all channels");
+            });
 
             AddAssert("selector tab is active", () => channelTabControl.ChannelSelectorActive.Value);
         }

osu.Game.Tests/Visual/TestCaseChatLink.cs

@@ -159,7 +159,7 @@ namespace osu.Game.Tests.Visual
                     Scheduler.AddDelayed(() => newLine.Message = new DummyMessage(completeText ?? text), delay);
                 });
 
-                AddUntilStep(() => textContainer.All(line => line.Message is DummyMessage), $"wait for msg #{echoCounter}");
+                AddUntilStep($"wait for msg #{echoCounter}", () => textContainer.All(line => line.Message is DummyMessage));
             }
         }
 

osu.Game.Tests/Visual/TestCaseDisclaimer.cs

@@ -2,16 +2,31 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Game.Online.API;
 using osu.Game.Screens.Menu;
+using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual
 {
     public class TestCaseDisclaimer : ScreenTestCase
     {
+        [Cached(typeof(IAPIProvider))]
+        private readonly DummyAPIAccess api = new DummyAPIAccess();
+
         [BackgroundDependencyLoader]
         private void load()
         {
-            LoadScreen(new Disclaimer());
+            AddStep("load disclaimer", () => LoadScreen(new Disclaimer()));
+
+            AddStep("toggle support", () =>
+            {
+                api.LocalUser.Value = new User
+                {
+                    Username = api.LocalUser.Value.Username,
+                    Id = api.LocalUser.Value.Id,
+                    IsSupporter = !api.LocalUser.Value.IsSupporter,
+                };
+            });
         }
     }
 }

osu.Game.Tests/Visual/TestCaseHoldForMenuButton.cs

@@ -32,9 +32,9 @@ namespace osu.Game.Tests.Visual
             var text = holdForMenuButton.Children.OfType<SpriteText>().First();
 
             AddStep("Trigger text fade in", () => InputManager.MoveMouseTo(holdForMenuButton));
-            AddUntilStep(() => text.IsPresent && !exitAction, "Text visible");
+            AddUntilStep("Text visible", () => text.IsPresent && !exitAction);
             AddStep("Trigger text fade out", () => InputManager.MoveMouseTo(Vector2.One));
-            AddUntilStep(() => !text.IsPresent && !exitAction, "Text is not visible");
+            AddUntilStep("Text is not visible", () => !text.IsPresent && !exitAction);
 
             AddStep("Trigger exit action", () =>
             {
@@ -47,7 +47,7 @@ namespace osu.Game.Tests.Visual
             AddAssert("action not triggered", () => !exitAction);
 
             AddStep("Trigger exit action", () => InputManager.PressButton(MouseButton.Left));
-            AddUntilStep(() => exitAction, $"{nameof(holdForMenuButton.Action)} was triggered");
+            AddUntilStep($"{nameof(holdForMenuButton.Action)} was triggered", () => exitAction);
         }
     }
 }

osu.Game.Tests/Visual/TestCaseHoldToConfirmOverlay.cs

@@ -49,7 +49,7 @@ namespace osu.Game.Tests.Visual
 
             AddStep("start confirming", () => overlay.Begin());
 
-            AddUntilStep(() => fired, "wait until confirmed");
+            AddUntilStep("wait until confirmed", () => fired);
         }
 
         private class TestHoldToConfirmOverlay : ExitConfirmOverlay

osu.Game.Tests/Visual/TestCaseIdleTracker.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("move mouse to top left", () => InputManager.MoveMouseTo(box1.ScreenSpaceDrawQuad.Centre));
 
-            AddUntilStep(() => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle, "Wait for all idle");
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
 
             AddStep("nudge mouse", () => InputManager.MoveMouseTo(box1.ScreenSpaceDrawQuad.Centre + new Vector2(1)));
 
@@ -87,7 +87,7 @@ namespace osu.Game.Tests.Visual
             AddAssert("check idle", () => !box3.IsIdle);
             AddAssert("check idle", () => !box4.IsIdle);
 
-            AddUntilStep(() => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle, "Wait for all idle");
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
         }
 
         [Test]
@@ -96,13 +96,13 @@ namespace osu.Game.Tests.Visual
             AddStep("move mouse", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
 
             AddAssert("check not idle", () => !box1.IsIdle && !box2.IsIdle && !box3.IsIdle && !box4.IsIdle);
-            AddUntilStep(() => box1.IsIdle, "Wait for idle");
+            AddUntilStep("Wait for idle", () => box1.IsIdle);
             AddAssert("check not idle", () => !box2.IsIdle && !box3.IsIdle && !box4.IsIdle);
-            AddUntilStep(() => box2.IsIdle, "Wait for idle");
+            AddUntilStep("Wait for idle", () => box2.IsIdle);
             AddAssert("check not idle", () => !box3.IsIdle && !box4.IsIdle);
-            AddUntilStep(() => box3.IsIdle, "Wait for idle");
+            AddUntilStep("Wait for idle", () => box3.IsIdle);
 
-            AddUntilStep(() => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle, "Wait for all idle");
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
         }
 
         private class IdleTrackingBox : CompositeDrawable

osu.Game.Tests/Visual/TestCaseLoaderAnimation.cs

@@ -25,30 +25,30 @@ namespace osu.Game.Tests.Visual
 
             bool logoVisible = false;
             AddStep("almost instant display", () => Child = loader = new TestLoader(250));
-            AddUntilStep(() =>
+            AddUntilStep("loaded", () =>
             {
                 logoVisible = loader.Logo?.Alpha > 0;
                 return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
+            });
             AddAssert("logo not visible", () => !logoVisible);
 
             AddStep("short load", () => Child = loader = new TestLoader(800));
-            AddUntilStep(() =>
+            AddUntilStep("loaded", () =>
             {
                 logoVisible = loader.Logo?.Alpha > 0;
                 return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
+            });
             AddAssert("logo visible", () => logoVisible);
-            AddUntilStep(() => loader.Logo?.Alpha == 0, "logo gone");
+            AddUntilStep("logo gone", () => loader.Logo?.Alpha == 0);
 
             AddStep("longer load", () => Child = loader = new TestLoader(1400));
-            AddUntilStep(() =>
+            AddUntilStep("loaded", () =>
             {
                 logoVisible = loader.Logo?.Alpha > 0;
                 return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
+            });
             AddAssert("logo visible", () => logoVisible);
-            AddUntilStep(() => loader.Logo?.Alpha == 0, "logo gone");
+            AddUntilStep("logo gone", () => loader.Logo?.Alpha == 0);
         }
 
         private class TestLoader : Loader

osu.Game.Tests/Visual/TestCaseMatchLeaderboard.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Tests.Visual
         }
 
         [Resolved]
-        private APIAccess api { get; set; }
+        private IAPIProvider api { get; set; }
 
         [BackgroundDependencyLoader]
         private void load()

osu.Game.Tests/Visual/TestCaseMatchSettingsOverlay.cs

@@ -111,7 +111,7 @@ namespace osu.Game.Tests.Visual
                 settings.ApplyButton.Action.Invoke();
             });
 
-            AddUntilStep(() => !settings.ErrorText.IsPresent, "error not displayed");
+            AddUntilStep("error not displayed", () => !settings.ErrorText.IsPresent);
         }
 
         private class TestRoomSettings : MatchSettingsOverlay

osu.Game.Tests/Visual/TestCaseMods.cs

@@ -208,22 +208,22 @@ namespace osu.Game.Tests.Visual
         {
             checkLabelColor(Color4.White);
             selectNext(mod);
-            AddWaitStep(1, "wait for changing colour");
+            AddWaitStep("wait for changing colour", 1);
             checkLabelColor(colour);
             selectPrevious(mod);
-            AddWaitStep(1, "wait for changing colour");
+            AddWaitStep("wait for changing colour", 1);
             checkLabelColor(Color4.White);
         }
 
         private void testRankedText(Mod mod)
         {
-            AddWaitStep(1, "wait for fade");
+            AddWaitStep("wait for fade", 1);
             AddAssert("check for ranked", () => modSelect.UnrankedLabel.Alpha == 0);
             selectNext(mod);
-            AddWaitStep(1, "wait for fade");
+            AddWaitStep("wait for fade", 1);
             AddAssert("check for unranked", () => modSelect.UnrankedLabel.Alpha != 0);
             selectPrevious(mod);
-            AddWaitStep(1, "wait for fade");
+            AddWaitStep("wait for fade", 1);
             AddAssert("check for ranked", () => modSelect.UnrankedLabel.Alpha == 0);
         }
 

osu.Game.Tests/Visual/TestCaseNotificationOverlay.cs

@@ -60,7 +60,7 @@ namespace osu.Game.Tests.Visual
             setState(Visibility.Hidden);
 
             AddRepeatStep(@"add many simple", sendManyNotifications, 3);
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
 
             checkProgressingCount(0);
 
@@ -70,7 +70,7 @@ namespace osu.Game.Tests.Visual
 
             AddAssert("Displayed count is 33", () => manager.UnreadCount.Value == 33);
 
-            AddWaitStep(10);
+            AddWaitStep("wait some", 10);
 
             checkProgressingCount(0);
 

osu.Game.Tests/Visual/TestCasePlaySongSelect.cs

@@ -112,10 +112,10 @@ namespace osu.Game.Tests.Visual
             createSongSelect();
             AddAssert("dummy selected", () => songSelect.CurrentBeatmap == defaultBeatmap);
 
-            AddUntilStep(() => songSelect.CurrentBeatmapDetailsBeatmap == defaultBeatmap, "dummy shown on wedge");
+            AddUntilStep("dummy shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap == defaultBeatmap);
 
             addManyTestMaps();
-            AddWaitStep(3);
+            AddWaitStep("wait for select", 3);
 
             AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
         }
@@ -125,7 +125,7 @@ namespace osu.Game.Tests.Visual
         {
             createSongSelect();
             addManyTestMaps();
-            AddWaitStep(3);
+            AddWaitStep("wait for add", 3);
 
             AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
 
@@ -142,7 +142,7 @@ namespace osu.Game.Tests.Visual
             createSongSelect();
             changeRuleset(2);
             importForRuleset(0);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap == null, "no selection");
+            AddUntilStep("no selection", () => songSelect.Carousel.SelectedBeatmap == null);
         }
 
         [Test]
@@ -152,13 +152,13 @@ namespace osu.Game.Tests.Visual
             changeRuleset(2);
             importForRuleset(2);
             importForRuleset(1);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap.RulesetID == 2, "has selection");
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap.RulesetID == 2);
 
             changeRuleset(1);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap.RulesetID == 1, "has selection");
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap.RulesetID == 1);
 
             changeRuleset(0);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap == null, "no selection");
+            AddUntilStep("no selection", () => songSelect.Carousel.SelectedBeatmap == null);
         }
 
         [Test]
@@ -196,7 +196,7 @@ namespace osu.Game.Tests.Visual
         {
             createSongSelect();
             addManyTestMaps();
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap != null, "has selection");
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap != null);
 
             bool startRequested = false;
 
@@ -225,7 +225,7 @@ namespace osu.Game.Tests.Visual
         private void createSongSelect()
         {
             AddStep("create song select", () => LoadScreen(songSelect = new TestSongSelect()));
-            AddUntilStep(() => songSelect.IsCurrentScreen(), "wait for present");
+            AddUntilStep("wait for present", () => songSelect.IsCurrentScreen());
         }
 
         private void addManyTestMaps()

osu.Game.Tests/Visual/TestCasePlayerLoader.cs

@@ -37,15 +37,15 @@ namespace osu.Game.Tests.Visual
                 AllowResults = false,
             })));
 
-            AddUntilStep(() => loader.IsCurrentScreen(), "wait for current");
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
 
             AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
 
-            AddUntilStep(() => !loader.IsCurrentScreen(), "wait for no longer current");
+            AddUntilStep("wait for no longer current", () => !loader.IsCurrentScreen());
 
             AddStep("exit loader", () => loader.Exit());
 
-            AddUntilStep(() => !loader.IsAlive, "wait for no longer alive");
+            AddUntilStep("wait for no longer alive", () => !loader.IsAlive);
 
             AddStep("load slow dummy beatmap", () =>
             {
@@ -61,7 +61,7 @@ namespace osu.Game.Tests.Visual
                 Scheduler.AddDelayed(() => slow.Ready = true, 5000);
             });
 
-            AddUntilStep(() => !loader.IsCurrentScreen(), "wait for no longer current");
+            AddUntilStep("wait for no longer current", () => !loader.IsCurrentScreen());
         }
 
         protected class SlowLoadPlayer : Player

osu.Game.Tests/Visual/TestCaseReplay.cs

@@ -24,8 +24,8 @@ namespace osu.Game.Tests.Visual
         protected override void AddCheckSteps(Func<Player> player)
         {
             base.AddCheckSteps(player);
-            AddUntilStep(() => ((ScoreAccessibleReplayPlayer)player()).ScoreProcessor.TotalScore.Value > 0, "score above zero");
+            AddUntilStep("score above zero", () => ((ScoreAccessibleReplayPlayer)player()).ScoreProcessor.TotalScore.Value > 0);
-            AddUntilStep(() => ((ScoreAccessibleReplayPlayer)player()).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0), "key counter counted keys");
+            AddUntilStep("key counter counted keys", () => ((ScoreAccessibleReplayPlayer)player()).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0));
         }
 
         private class ScoreAccessibleReplayPlayer : ReplayPlayer

osu.Game.Tests/Visual/TestCaseScreenBreadcrumbControl.cs

@@ -74,7 +74,7 @@ namespace osu.Game.Tests.Visual
         }
 
         private void pushNext() => AddStep(@"push next screen", () => ((TestScreen)screenStack.CurrentScreen).PushNext());
-        private void waitForCurrent() => AddUntilStep(() => screenStack.CurrentScreen.IsCurrentScreen(), "current screen");
+        private void waitForCurrent() => AddUntilStep("current screen", () => screenStack.CurrentScreen.IsCurrentScreen());
 
         private abstract class TestScreen : OsuScreen
         {

osu.Game.Tests/Visual/TestCaseSongProgress.cs

@@ -46,23 +46,23 @@ namespace osu.Game.Tests.Visual
                 Origin = Anchor.TopLeft,
             });
 
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
             AddAssert("ensure not created", () => graph.CreationCount == 0);
 
             AddStep("display values", displayNewValues);
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
-            AddUntilStep(() => graph.CreationCount == 1, "wait for creation count");
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
 
             AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
-            AddUntilStep(() => graph.CreationCount == 1, "wait for creation count");
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
 
             AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
-            AddUntilStep(() => graph.CreationCount == 1, "wait for creation count");
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
             AddRepeatStep("New Values", displayNewValues, 5);
 
-            AddWaitStep(5);
+            AddWaitStep("wait some", 5);
             AddAssert("ensure debounced", () => graph.CreationCount == 2);
         }
 

osu.Game.Tests/Visual/TestCaseUpdateableBeatmapBackgroundSprite.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Tests.Visual
         private BeatmapManager beatmaps { get; set; }
 
         [BackgroundDependencyLoader]
-        private void load(OsuGameBase osu, APIAccess api, RulesetStore rulesets)
+        private void load(OsuGameBase osu, IAPIProvider api, RulesetStore rulesets)
         {
             Bindable<BeatmapInfo> beatmapBindable = new Bindable<BeatmapInfo>();
 
@@ -36,18 +36,18 @@ namespace osu.Game.Tests.Visual
             api.Queue(req);
 
             AddStep("load null beatmap", () => beatmapBindable.Value = null);
-            AddUntilStep(() => backgroundSprite.ChildCount == 1, "wait for cleanup...");
+            AddUntilStep("wait for cleanup...", () => backgroundSprite.ChildCount == 1);
             AddStep("load imported beatmap", () => beatmapBindable.Value = imported.Beatmaps.First());
-            AddUntilStep(() => backgroundSprite.ChildCount == 1, "wait for cleanup...");
+            AddUntilStep("wait for cleanup...", () => backgroundSprite.ChildCount == 1);
 
             if (api.IsLoggedIn)
             {
-                AddUntilStep(() => req.Result != null, "wait for api response");
+                AddUntilStep("wait for api response", () => req.Result != null);
                 AddStep("load online beatmap", () => beatmapBindable.Value = new BeatmapInfo
                 {
                     BeatmapSet = req.Result?.ToBeatmapSet(rulesets)
                 });
-                AddUntilStep(() => backgroundSprite.ChildCount == 1, "wait for cleanup...");
+                AddUntilStep("wait for cleanup...", () => backgroundSprite.ChildCount == 1);
             }
             else
             {

osu.Game.Tests/Visual/TestCaseUserProfile.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Tests.Visual
     public class TestCaseUserProfile : OsuTestCase
     {
         private readonly TestUserProfileOverlay profile;
-        private APIAccess api;
+        private IAPIProvider api;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -36,7 +36,7 @@ namespace osu.Game.Tests.Visual
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             this.api = api;
         }
@@ -108,7 +108,7 @@ namespace osu.Game.Tests.Visual
 
         private void checkSupporterTag(bool isSupporter)
         {
-            AddUntilStep(() => profile.Header.User != null, "wait for load");
+            AddUntilStep("wait for load", () => profile.Header.User != null);
             if (isSupporter)
                 AddAssert("is supporter", () => profile.Header.SupporterTag.Alpha == 1);
             else

osu.Game/Beatmaps/BeatmapManager.cs

@@ -64,7 +64,7 @@ namespace osu.Game.Beatmaps
 
         private readonly BeatmapStore beatmaps;
 
-        private readonly APIAccess api;
+        private readonly IAPIProvider api;
 
         private readonly AudioManager audioManager;
 
@@ -72,7 +72,7 @@ namespace osu.Game.Beatmaps
 
         private readonly List<DownloadBeatmapSetRequest> currentDownloads = new List<DownloadBeatmapSetRequest>();
 
-        public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, APIAccess api, AudioManager audioManager, GameHost host = null,
+        public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, AudioManager audioManager, GameHost host = null,
                               WorkingBeatmap defaultBeatmap = null)
             : base(storage, contextFactory, new BeatmapStore(contextFactory), host)
         {

osu.Game/Beatmaps/Drawables/UpdateableBeatmapBackgroundSprite.cs

@@ -51,7 +51,7 @@ namespace osu.Game.Beatmaps.Drawables
             drawable.Anchor = Anchor.Centre;
             drawable.Origin = Anchor.Centre;
             drawable.FillMode = FillMode.Fill;
-            drawable.OnLoadComplete = d => d.FadeInFromZero(400);
+            drawable.OnLoadComplete += d => d.FadeInFromZero(400);
 
             return drawable;
         }

osu.Game/Beatmaps/Drawables/UpdateableBeatmapSetCover.cs

@@ -67,16 +67,19 @@ namespace osu.Game.Beatmaps.Drawables
 
             if (beatmapSet != null)
             {
+                BeatmapSetCover cover;
+
                 Add(displayedCover = new DelayedLoadWrapper(
-                    new BeatmapSetCover(beatmapSet, coverType)
+                    cover = new BeatmapSetCover(beatmapSet, coverType)
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                         RelativeSizeAxes = Axes.Both,
                         FillMode = FillMode.Fill,
-                        OnLoadComplete = d => d.FadeInFromZero(400, Easing.Out),
                     })
                 );
+
+                cover.OnLoadComplete += d => d.FadeInFromZero(400, Easing.Out);
             }
         }
     }

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -26,7 +26,12 @@ namespace osu.Game.Beatmaps
                     Title = "no beatmaps available!"
                 },
                 BeatmapSet = new BeatmapSetInfo(),
-                BaseDifficulty = new BeatmapDifficulty(),
+                BaseDifficulty = new BeatmapDifficulty
+                {
+                    DrainRate = 0,
+                    CircleSize = 0,
+                    OverallDifficulty = 0,
+                },
                 Ruleset = new DummyRulesetInfo()
             })
         {

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -2,10 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Globalization;
 using System.IO;
 using System.Linq;
 using osu.Framework.IO.File;
+using osu.Framework.Logging;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Beatmaps.ControlPoints;
@@ -25,7 +25,7 @@ namespace osu.Game.Beatmaps.Formats
 
         public static void Register()
         {
-            AddDecoder<Beatmap>(@"osu file format v", m => new LegacyBeatmapDecoder(int.Parse(m.Split('v').Last())));
+            AddDecoder<Beatmap>(@"osu file format v", m => new LegacyBeatmapDecoder(Parsing.ParseInt(m.Split('v').Last())));
         }
 
         /// <summary>
@@ -104,25 +104,25 @@ namespace osu.Game.Beatmaps.Formats
                     metadata.AudioFile = FileSafety.PathStandardise(pair.Value);
                     break;
                 case @"AudioLeadIn":
-                    beatmap.BeatmapInfo.AudioLeadIn = int.Parse(pair.Value);
+                    beatmap.BeatmapInfo.AudioLeadIn = Parsing.ParseInt(pair.Value);
                     break;
                 case @"PreviewTime":
-                    metadata.PreviewTime = getOffsetTime(int.Parse(pair.Value));
+                    metadata.PreviewTime = getOffsetTime(Parsing.ParseInt(pair.Value));
                     break;
                 case @"Countdown":
-                    beatmap.BeatmapInfo.Countdown = int.Parse(pair.Value) == 1;
+                    beatmap.BeatmapInfo.Countdown = Parsing.ParseInt(pair.Value) == 1;
                     break;
                 case @"SampleSet":
                     defaultSampleBank = (LegacySampleBank)Enum.Parse(typeof(LegacySampleBank), pair.Value);
                     break;
                 case @"SampleVolume":
-                    defaultSampleVolume = int.Parse(pair.Value);
+                    defaultSampleVolume = Parsing.ParseInt(pair.Value);
                     break;
                 case @"StackLeniency":
-                    beatmap.BeatmapInfo.StackLeniency = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    beatmap.BeatmapInfo.StackLeniency = Parsing.ParseFloat(pair.Value);
                     break;
                 case @"Mode":
-                    beatmap.BeatmapInfo.RulesetID = int.Parse(pair.Value);
+                    beatmap.BeatmapInfo.RulesetID = Parsing.ParseInt(pair.Value);
 
                     switch (beatmap.BeatmapInfo.RulesetID)
                     {
@@ -142,13 +142,13 @@ namespace osu.Game.Beatmaps.Formats
 
                     break;
                 case @"LetterboxInBreaks":
-                    beatmap.BeatmapInfo.LetterboxInBreaks = int.Parse(pair.Value) == 1;
+                    beatmap.BeatmapInfo.LetterboxInBreaks = Parsing.ParseInt(pair.Value) == 1;
                     break;
                 case @"SpecialStyle":
-                    beatmap.BeatmapInfo.SpecialStyle = int.Parse(pair.Value) == 1;
+                    beatmap.BeatmapInfo.SpecialStyle = Parsing.ParseInt(pair.Value) == 1;
                     break;
                 case @"WidescreenStoryboard":
-                    beatmap.BeatmapInfo.WidescreenStoryboard = int.Parse(pair.Value) == 1;
+                    beatmap.BeatmapInfo.WidescreenStoryboard = Parsing.ParseInt(pair.Value) == 1;
                     break;
             }
         }
@@ -163,16 +163,16 @@ namespace osu.Game.Beatmaps.Formats
                     beatmap.BeatmapInfo.StoredBookmarks = pair.Value;
                     break;
                 case @"DistanceSpacing":
-                    beatmap.BeatmapInfo.DistanceSpacing = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    beatmap.BeatmapInfo.DistanceSpacing = Math.Max(0, Parsing.ParseDouble(pair.Value));
                     break;
                 case @"BeatDivisor":
-                    beatmap.BeatmapInfo.BeatDivisor = int.Parse(pair.Value);
+                    beatmap.BeatmapInfo.BeatDivisor = Parsing.ParseInt(pair.Value);
                     break;
                 case @"GridSize":
-                    beatmap.BeatmapInfo.GridSize = int.Parse(pair.Value);
+                    beatmap.BeatmapInfo.GridSize = Parsing.ParseInt(pair.Value);
                     break;
                 case @"TimelineZoom":
-                    beatmap.BeatmapInfo.TimelineZoom = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    beatmap.BeatmapInfo.TimelineZoom = Math.Max(0, Parsing.ParseDouble(pair.Value));
                     break;
             }
         }
@@ -209,10 +209,10 @@ namespace osu.Game.Beatmaps.Formats
                     beatmap.BeatmapInfo.Metadata.Tags = pair.Value;
                     break;
                 case @"BeatmapID":
-                    beatmap.BeatmapInfo.OnlineBeatmapID = int.Parse(pair.Value);
+                    beatmap.BeatmapInfo.OnlineBeatmapID = Parsing.ParseInt(pair.Value);
                     break;
                 case @"BeatmapSetID":
-                    beatmap.BeatmapInfo.BeatmapSet = new BeatmapSetInfo { OnlineBeatmapSetID = int.Parse(pair.Value) };
+                    beatmap.BeatmapInfo.BeatmapSet = new BeatmapSetInfo { OnlineBeatmapSetID = Parsing.ParseInt(pair.Value) };
                     break;
             }
         }
@@ -225,22 +225,22 @@ namespace osu.Game.Beatmaps.Formats
             switch (pair.Key)
             {
                 case @"HPDrainRate":
-                    difficulty.DrainRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    difficulty.DrainRate = Parsing.ParseFloat(pair.Value);
                     break;
                 case @"CircleSize":
-                    difficulty.CircleSize = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    difficulty.CircleSize = Parsing.ParseFloat(pair.Value);
                     break;
                 case @"OverallDifficulty":
-                    difficulty.OverallDifficulty = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    difficulty.OverallDifficulty = Parsing.ParseFloat(pair.Value);
                     break;
                 case @"ApproachRate":
-                    difficulty.ApproachRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    difficulty.ApproachRate = Parsing.ParseFloat(pair.Value);
                     break;
                 case @"SliderMultiplier":
-                    difficulty.SliderMultiplier = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    difficulty.SliderMultiplier = Parsing.ParseDouble(pair.Value);
                     break;
                 case @"SliderTickRate":
-                    difficulty.SliderTickRate = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    difficulty.SliderTickRate = Parsing.ParseDouble(pair.Value);
                     break;
             }
         }
@@ -260,10 +260,12 @@ namespace osu.Game.Beatmaps.Formats
                     beatmap.BeatmapInfo.Metadata.BackgroundFile = FileSafety.PathStandardise(filename);
                     break;
                 case EventType.Break:
+                    double start = getOffsetTime(Parsing.ParseDouble(split[1]));
+
                     var breakEvent = new BreakPeriod
                     {
-                        StartTime = getOffsetTime(double.Parse(split[1], NumberFormatInfo.InvariantInfo)),
+                        StartTime = start,
-                        EndTime = getOffsetTime(double.Parse(split[2], NumberFormatInfo.InvariantInfo))
+                        EndTime = Math.Max(start, getOffsetTime(Parsing.ParseDouble(split[2])))
                     };
 
                     if (!breakEvent.HasEffect)
@@ -280,25 +282,25 @@ namespace osu.Game.Beatmaps.Formats
             {
                 string[] split = line.Split(',');
 
-                double time = getOffsetTime(double.Parse(split[0].Trim(), NumberFormatInfo.InvariantInfo));
+                double time = getOffsetTime(Parsing.ParseDouble(split[0].Trim()));
-                double beatLength = double.Parse(split[1].Trim(), NumberFormatInfo.InvariantInfo);
+                double beatLength = Parsing.ParseDouble(split[1].Trim());
                 double speedMultiplier = beatLength < 0 ? 100.0 / -beatLength : 1;
 
                 TimeSignatures timeSignature = TimeSignatures.SimpleQuadruple;
                 if (split.Length >= 3)
-                    timeSignature = split[2][0] == '0' ? TimeSignatures.SimpleQuadruple : (TimeSignatures)int.Parse(split[2]);
+                    timeSignature = split[2][0] == '0' ? TimeSignatures.SimpleQuadruple : (TimeSignatures)Parsing.ParseInt(split[2]);
 
                 LegacySampleBank sampleSet = defaultSampleBank;
                 if (split.Length >= 4)
-                    sampleSet = (LegacySampleBank)int.Parse(split[3]);
+                    sampleSet = (LegacySampleBank)Parsing.ParseInt(split[3]);
 
                 int customSampleBank = 0;
                 if (split.Length >= 5)
-                    customSampleBank = int.Parse(split[4]);
+                    customSampleBank = Parsing.ParseInt(split[4]);
 
                 int sampleVolume = defaultSampleVolume;
                 if (split.Length >= 6)
-                    sampleVolume = int.Parse(split[5]);
+                    sampleVolume = Parsing.ParseInt(split[5]);
 
                 bool timingChange = true;
                 if (split.Length >= 7)
@@ -308,7 +310,7 @@ namespace osu.Game.Beatmaps.Formats
                 bool omitFirstBarSignature = false;
                 if (split.Length >= 8)
                 {
-                    EffectFlags effectFlags = (EffectFlags)int.Parse(split[7]);
+                    EffectFlags effectFlags = (EffectFlags)Parsing.ParseInt(split[7]);
                     kiaiMode = effectFlags.HasFlag(EffectFlags.Kiai);
                     omitFirstBarSignature = effectFlags.HasFlag(EffectFlags.OmitFirstBarLine);
                 }
@@ -348,8 +350,13 @@ namespace osu.Game.Beatmaps.Formats
                     CustomSampleBank = customSampleBank
                 });
             }
-            catch (FormatException e)
+            catch (FormatException)
             {
+                Logger.Log("A timing point could not be parsed correctly and will be ignored", LoggingTarget.Runtime, LogLevel.Important);
+            }
+            catch (OverflowException)
+            {
+                Logger.Log("A timing point could not be parsed correctly and will be ignored", LoggingTarget.Runtime, LogLevel.Important);
             }
         }
 

osu.Game/Beatmaps/Formats/Parsing.cs

@@ -0,0 +1,52 @@
+// 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.Globalization;
+
+namespace osu.Game.Beatmaps.Formats
+{
+    /// <summary>
+    /// Helper methods to parse from string to number and perform very basic validation.
+    /// </summary>
+    public static class Parsing
+    {
+        public const int MAX_COORDINATE_VALUE = 65536;
+
+        public const double MAX_PARSE_VALUE = int.MaxValue;
+
+        public static float ParseFloat(string input, float parseLimit = (float)MAX_PARSE_VALUE)
+        {
+            var output = float.Parse(input, CultureInfo.InvariantCulture);
+
+            if (output < -parseLimit) throw new OverflowException("Value is too low");
+            if (output > parseLimit) throw new OverflowException("Value is too high");
+
+            if (float.IsNaN(output)) throw new FormatException("Not a number");
+
+            return output;
+        }
+
+        public static double ParseDouble(string input, double parseLimit = MAX_PARSE_VALUE)
+        {
+            var output = double.Parse(input, CultureInfo.InvariantCulture);
+
+            if (output < -parseLimit) throw new OverflowException("Value is too low");
+            if (output > parseLimit) throw new OverflowException("Value is too high");
+
+            if (double.IsNaN(output)) throw new FormatException("Not a number");
+
+            return output;
+        }
+
+        public static int ParseInt(string input, int parseLimit = (int)MAX_PARSE_VALUE)
+        {
+            var output = int.Parse(input, CultureInfo.InvariantCulture);
+
+            if (output < -parseLimit) throw new OverflowException("Value is too low");
+            if (output > parseLimit) throw new OverflowException("Value is too high");
+
+            return output;
+        }
+    }
+}

osu.Game/Migrations/20180628011956_RemoveNegativeSetIDs.cs

@@ -13,7 +13,6 @@ namespace osu.Game.Migrations
 
         protected override void Down(MigrationBuilder migrationBuilder)
         {
-
         }
     }
 }

osu.Game/Online/API/APIAccess.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Online.API
         private readonly OsuConfigManager config;
         private readonly OAuth authentication;
 
-        public string Endpoint = @"https://osu.ppy.sh";
+        public string Endpoint => @"https://osu.ppy.sh";
         private const string client_id = @"5";
         private const string client_secret = @"FGc9GAtyHzeQDshWP5Ah7dega8hJACAJpQtw6OXk";
 

osu.Game/Online/API/APIRequest.cs

@@ -61,9 +61,12 @@ namespace osu.Game.Online.API
 
         private Action pendingFailure;
 
-        public void Perform(APIAccess api)
+        public void Perform(IAPIProvider api)
         {
-            API = api;
+            if (!(api is APIAccess apiAccess))
+                throw new NotSupportedException($"A {nameof(APIAccess)} is required to perform requests.");
+
+            API = apiAccess;
 
             if (checkAndScheduleFailure())
                 return;
@@ -71,7 +74,7 @@ namespace osu.Game.Online.API
             WebRequest = CreateWebRequest();
             WebRequest.Failed += Fail;
             WebRequest.AllowRetryOnTimeout = false;
-            WebRequest.AddHeader("Authorization", $"Bearer {api.AccessToken}");
+            WebRequest.AddHeader("Authorization", $"Bearer {API.AccessToken}");
 
             if (checkAndScheduleFailure())
                 return;
@@ -85,7 +88,7 @@ namespace osu.Game.Online.API
             if (checkAndScheduleFailure())
                 return;
 
-            api.Schedule(delegate { Success?.Invoke(); });
+            API.Schedule(delegate { Success?.Invoke(); });
         }
 
         public void Cancel() => Fail(new OperationCanceledException(@"Request cancelled"));

osu.Game/Online/API/DummyAPIAccess.cs

@@ -11,14 +11,16 @@ namespace osu.Game.Online.API
         public Bindable<User> LocalUser { get; } = new Bindable<User>(new User
         {
             Username = @"Dummy",
-            Id = 1,
+            Id = 1001,
         });
 
         public bool IsLoggedIn => true;
 
-        public void Update()
+        public string ProvidedUsername => LocalUser.Value.Username;
-        {
+
-        }
+        public string Endpoint => "http://localhost";
+
+        public APIState State => LocalUser.Value.Id == 1 ? APIState.Offline : APIState.Online;
 
         public virtual void Queue(APIRequest request)
         {
@@ -26,6 +28,28 @@ namespace osu.Game.Online.API
 
         public void Register(IOnlineComponent component)
         {
+            // todo: add support
         }
+
+        public void Unregister(IOnlineComponent component)
+        {
+            // todo: add support
+        }
+
+        public void Login(string username, string password)
+        {
+            LocalUser.Value = new User
+            {
+                Username = @"Dummy",
+                Id = 1001,
+            };
+        }
+
+        public void Logout()
+        {
+            LocalUser.Value = new GuestUser();
+        }
+
+        public RegistrationRequest.RegistrationRequestErrors CreateAccount(string email, string username, string password) => null;
     }
 }

osu.Game/Online/API/IAPIProvider.cs

@@ -18,6 +18,19 @@ namespace osu.Game.Online.API
         /// </summary>
         bool IsLoggedIn { get; }
 
+        /// <summary>
+        /// The last username provided by the end-user.
+        /// May not be authenticated.
+        /// </summary>
+        string ProvidedUsername { get; }
+
+        /// <summary>
+        /// The URL endpoint for this API. Does not include a trailing slash.
+        /// </summary>
+        string Endpoint { get; }
+
+        APIState State { get; }
+
         /// <summary>
         /// Queue a new request.
         /// </summary>
@@ -29,5 +42,32 @@ namespace osu.Game.Online.API
         /// </summary>
         /// <param name="component">The component to register.</param>
         void Register(IOnlineComponent component);
+
+        /// <summary>
+        /// Unregisters a component to receive state changes.
+        /// </summary>
+        /// <param name="component">The component to unregister.</param>
+        void Unregister(IOnlineComponent component);
+
+        /// <summary>
+        /// Attempt to login using the provided credentials. This is a non-blocking operation.
+        /// </summary>
+        /// <param name="username">The user's username.</param>
+        /// <param name="password">The user's password.</param>
+        void Login(string username, string password);
+
+        /// <summary>
+        /// Log out the current user.
+        /// </summary>
+        void Logout();
+
+        /// <summary>
+        /// Create a new user account. This is a blocking operation.
+        /// </summary>
+        /// <param name="email">The email to create the account with.</param>
+        /// <param name="username">The username to create the account with.</param>
+        /// <param name="password">The password to create the account with.</param>
+        /// <returns>Any errors encoutnered during account creation.</returns>
+        RegistrationRequest.RegistrationRequestErrors CreateAccount(string email, string username, string password);
     }
 }

osu.Game/Online/API/IOnlineComponent.cs

@@ -5,6 +5,6 @@ namespace osu.Game.Online.API
 {
     public interface IOnlineComponent
     {
-        void APIStateChanged(APIAccess api, APIState state);
+        void APIStateChanged(IAPIProvider api, APIState state);
     }
 }

osu.Game/Online/Leaderboards/Leaderboard.cs

@@ -174,12 +174,12 @@ namespace osu.Game.Online.Leaderboards
             };
         }
 
-        private APIAccess api;
+        private IAPIProvider api;
 
         private ScheduledDelegate pendingUpdateScores;
 
         [BackgroundDependencyLoader(true)]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             this.api = api;
             api?.Register(this);
@@ -195,7 +195,7 @@ namespace osu.Game.Online.Leaderboards
 
         private APIRequest getScoresRequest;
 
-        public void APIStateChanged(APIAccess api, APIState state)
+        public void APIStateChanged(IAPIProvider api, APIState state)
         {
             if (state == APIState.Online)
                 UpdateScores();

osu.Game/Online/Leaderboards/LeaderboardScore.cs

@@ -64,6 +64,8 @@ namespace osu.Game.Online.Leaderboards
 
             statisticsLabels = GetStatistics(score).Select(s => new ScoreComponentLabel(s)).ToList();
 
+            Avatar innerAvatar;
+
             Children = new Drawable[]
             {
                 new Container
@@ -109,12 +111,11 @@ namespace osu.Game.Online.Leaderboards
                             Children = new[]
                             {
                                 avatar = new DelayedLoadWrapper(
-                                    new Avatar(user)
+                                    innerAvatar = new Avatar(user)
                                     {
                                         RelativeSizeAxes = Axes.Both,
                                         CornerRadius = corner_radius,
                                         Masking = true,
-                                        OnLoadComplete = d => d.FadeInFromZero(200),
                                         EdgeEffect = new EdgeEffectParameters
                                         {
                                             Type = EdgeEffectType.Shadow,
@@ -214,6 +215,8 @@ namespace osu.Game.Online.Leaderboards
                     },
                 },
             };
+
+            innerAvatar.OnLoadComplete += d => d.FadeInFromZero(200);
         }
 
         public override void Show()

osu.Game/OsuGameBase.cs

@@ -152,7 +152,6 @@ namespace osu.Game
 
             API = new APIAccess(LocalConfig);
 
-            dependencies.Cache(API);
             dependencies.CacheAs<IAPIProvider>(API);
 
             var defaultBeatmap = new DummyWorkingBeatmap(this);

osu.Game/Overlays/AccountCreation/ScreenEntry.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Overlays.AccountCreation
         private OsuTextBox emailTextBox;
         private OsuPasswordTextBox passwordTextBox;
 
-        private APIAccess api;
+        private IAPIProvider api;
         private ShakeContainer registerShake;
         private IEnumerable<Drawable> characterCheckText;
 
@@ -42,7 +42,7 @@ namespace osu.Game.Overlays.AccountCreation
         private GameHost host;
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, APIAccess api, GameHost host)
+        private void load(OsuColour colours, IAPIProvider api, GameHost host)
         {
             this.api = api;
             this.host = host;

osu.Game/Overlays/AccountCreation/ScreenWarning.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Overlays.AccountCreation
     {
         private OsuTextFlowContainer multiAccountExplanationText;
         private LinkFlowContainer furtherAssistance;
-        private APIAccess api;
+        private IAPIProvider api;
 
         private const string help_centre_url = "/help/wiki/Help_Centre#login";
 
@@ -39,7 +39,7 @@ namespace osu.Game.Overlays.AccountCreation
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(OsuColour colours, APIAccess api, OsuGame game, TextureStore textures)
+        private void load(OsuColour colours, IAPIProvider api, OsuGame game, TextureStore textures)
         {
             this.api = api;
 

osu.Game/Overlays/AccountCreationOverlay.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Overlays
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, APIAccess api)
+        private void load(OsuColour colours, IAPIProvider api)
         {
             api.Register(this);
 
@@ -96,7 +96,7 @@ namespace osu.Game.Overlays
             this.FadeOut(100);
         }
 
-        public void APIStateChanged(APIAccess api, APIState state)
+        public void APIStateChanged(IAPIProvider api, APIState state)
         {
             switch (state)
             {

osu.Game/Overlays/BeatmapSet/Buttons/DownloadButton.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Overlays.BeatmapSet.Buttons
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api, BeatmapManager beatmaps)
+        private void load(IAPIProvider api, BeatmapManager beatmaps)
         {
             FillFlowContainer textSprites;
 

osu.Game/Overlays/BeatmapSet/Scores/ScoresContainer.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
         }
 
         private GetScoresRequest getScoresRequest;
-        private APIAccess api;
+        private IAPIProvider api;
 
         public BeatmapInfo Beatmap
         {
@@ -129,7 +129,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             this.api = api;
             updateDisplay();

osu.Game/Overlays/BeatmapSetOverlay.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Overlays
 
         private readonly Header header;
 
-        private APIAccess api;
+        private IAPIProvider api;
         private RulesetStore rulesets;
 
         private readonly ScrollContainer scroll;
@@ -101,7 +101,7 @@ namespace osu.Game.Overlays
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api, RulesetStore rulesets)
+        private void load(IAPIProvider api, RulesetStore rulesets)
         {
             this.api = api;
             this.rulesets = rulesets;

osu.Game/Overlays/Chat/Tabs/PrivateChannelTabItem.cs

@@ -28,6 +28,8 @@ namespace osu.Game.Overlays.Chat.Tabs
             if (value.Type != ChannelType.PM)
                 throw new ArgumentException("Argument value needs to have the targettype user!");
 
+            Avatar avatar;
+
             AddRange(new Drawable[]
             {
                 new Container
@@ -49,11 +51,10 @@ namespace osu.Game.Overlays.Chat.Tabs
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
                             Masking = true,
-                            Child = new DelayedLoadWrapper(new Avatar(value.Users.First())
+                            Child = new DelayedLoadWrapper(avatar = new Avatar(value.Users.First())
                             {
                                 RelativeSizeAxes = Axes.Both,
                                 OpenOnClick = { Value = false },
-                                OnLoadComplete = d => d.FadeInFromZero(300, Easing.OutQuint),
                             })
                             {
                                 RelativeSizeAxes = Axes.Both,
@@ -63,6 +64,8 @@ namespace osu.Game.Overlays.Chat.Tabs
                 },
             });
 
+            avatar.OnLoadComplete += d => d.FadeInFromZero(300, Easing.OutQuint);
+
             Text.X = ChatOverlay.TAB_AREA_HEIGHT;
             TextBold.X = ChatOverlay.TAB_AREA_HEIGHT;
         }

osu.Game/Overlays/Direct/DirectGridPanel.cs

@@ -185,10 +185,7 @@ namespace osu.Game.Overlays.Direct
                     Margin = new MarginPadding { Top = vertical_padding, Right = vertical_padding },
                     Children = new[]
                     {
-                        new Statistic(FontAwesome.fa_play_circle, SetInfo.OnlineInfo?.PlayCount ?? 0)
+                        new Statistic(FontAwesome.fa_play_circle, SetInfo.OnlineInfo?.PlayCount ?? 0),
-                        {
-                            Margin = new MarginPadding { Right = 1 },
-                        },
                         new Statistic(FontAwesome.fa_heart, SetInfo.OnlineInfo?.FavouriteCount ?? 0),
                     },
                 },

osu.Game/Overlays/Direct/DirectListPanel.cs

@@ -160,10 +160,7 @@ namespace osu.Game.Overlays.Direct
                                     Direction = FillDirection.Vertical,
                                     Children = new Drawable[]
                                     {
-                                        new Statistic(FontAwesome.fa_play_circle, SetInfo.OnlineInfo?.PlayCount ?? 0)
+                                        new Statistic(FontAwesome.fa_play_circle, SetInfo.OnlineInfo?.PlayCount ?? 0),
-                                        {
-                                            Margin = new MarginPadding { Right = 1 },
-                                        },
                                         new Statistic(FontAwesome.fa_heart, SetInfo.OnlineInfo?.FavouriteCount ?? 0),
                                         new FillFlowContainer
                                         {

osu.Game/Overlays/DirectOverlay.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Overlays
     {
         private const float panel_padding = 10f;
 
-        private APIAccess api;
+        private IAPIProvider api;
         private RulesetStore rulesets;
 
         private readonly FillFlowContainer resultCountsContainer;
@@ -164,7 +164,7 @@ namespace osu.Game.Overlays
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, APIAccess api, RulesetStore rulesets, PreviewTrackManager previewTrackManager)
+        private void load(OsuColour colours, IAPIProvider api, RulesetStore rulesets, PreviewTrackManager previewTrackManager)
         {
             this.api = api;
             this.rulesets = rulesets;

osu.Game/Overlays/MedalSplash/DrawableMedal.cs

@@ -109,7 +109,7 @@ namespace osu.Game.Overlays.MedalSplash
                 s.Font = s.Font.With(size: 16);
             });
 
-            medalContainer.OnLoadComplete = d =>
+            medalContainer.OnLoadComplete += d =>
             {
                 unlocked.Position = new Vector2(0f, medalContainer.DrawSize.Y / 2 + 10);
                 infoFlow.Position = new Vector2(0f, unlocked.Position.Y + 90);

osu.Game/Overlays/Profile/ProfileHeader.cs

@@ -335,9 +335,12 @@ namespace osu.Game.Overlays.Profile
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 FillMode = FillMode.Fill,
-                OnLoadComplete = d => d.FadeInFromZero(200),
                 Depth = float.MaxValue,
-            }, coverContainer.Add);
+            }, background =>
+            {
+                coverContainer.Add(background);
+                background.FadeInFromZero(200);
+            });
 
             if (user.IsSupporter)
                 SupporterTag.Show();

osu.Game/Overlays/Profile/Sections/PaginatedContainer.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Overlays.Profile.Sections
 
         protected readonly Bindable<User> User = new Bindable<User>();
 
-        protected APIAccess Api;
+        protected IAPIProvider Api;
         protected APIRequest RetrievalRequest;
         protected RulesetStore Rulesets;
 
@@ -84,7 +84,7 @@ namespace osu.Game.Overlays.Profile.Sections
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api, RulesetStore rulesets)
+        private void load(IAPIProvider api, RulesetStore rulesets)
         {
             Api = api;
             Rulesets = rulesets;

osu.Game/Overlays/Profile/Sections/Recent/DrawableRecentActivity.cs

@@ -16,7 +16,7 @@ namespace osu.Game.Overlays.Profile.Sections.Recent
 {
     public class DrawableRecentActivity : DrawableProfileRow
     {
-        private APIAccess api;
+        private IAPIProvider api;
 
         private readonly APIRecentActivity activity;
 
@@ -28,7 +28,7 @@ namespace osu.Game.Overlays.Profile.Sections.Recent
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             this.api = api;
 

osu.Game/Overlays/Settings/Sections/General/LoginSettings.cs

@@ -58,14 +58,14 @@ namespace osu.Game.Overlays.Settings.Sections.General
         }
 
         [BackgroundDependencyLoader(permitNulls: true)]
-        private void load(OsuColour colours, APIAccess api)
+        private void load(OsuColour colours, IAPIProvider api)
         {
             this.colours = colours;
 
             api?.Register(this);
         }
 
-        public void APIStateChanged(APIAccess api, APIState state)
+        public void APIStateChanged(IAPIProvider api, APIState state)
         {
             form = null;
 
@@ -194,7 +194,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
         {
             private TextBox username;
             private TextBox password;
-            private APIAccess api;
+            private IAPIProvider api;
 
             public Action RequestHide;
 
@@ -205,7 +205,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
             }
 
             [BackgroundDependencyLoader(permitNulls: true)]
-            private void load(APIAccess api, OsuConfigManager config, AccountCreationOverlay accountCreation)
+            private void load(IAPIProvider api, OsuConfigManager config, AccountCreationOverlay accountCreation)
             {
                 this.api = api;
                 Direction = FillDirection.Vertical;

osu.Game/Overlays/SocialOverlay.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Overlays
 {
     public class SocialOverlay : SearchableListOverlay<SocialTab, SocialSortCriteria, SortDirection>, IOnlineComponent
     {
-        private APIAccess api;
+        private IAPIProvider api;
         private readonly LoadingAnimation loading;
         private FillFlowContainer<SocialPanel> panels;
 
@@ -89,7 +89,7 @@ namespace osu.Game.Overlays
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             this.api = api;
             api.Register(this);
@@ -193,7 +193,7 @@ namespace osu.Game.Overlays
             }
         }
 
-        public void APIStateChanged(APIAccess api, APIState state)
+        public void APIStateChanged(IAPIProvider api, APIState state)
         {
             switch (state)
             {

osu.Game/Overlays/Toolbar/ToolbarUserButton.cs

@@ -43,12 +43,12 @@ namespace osu.Game.Overlays.Toolbar
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             api.Register(this);
         }
 
-        public void APIStateChanged(APIAccess api, APIState state)
+        public void APIStateChanged(IAPIProvider api, APIState state)
         {
             switch (state)
             {

osu.Game/Overlays/UserProfileOverlay.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Overlays
         private ProfileSection lastSection;
         private ProfileSection[] sections;
         private GetUserRequest userReq;
-        private APIAccess api;
+        private IAPIProvider api;
         protected ProfileHeader Header;
         private SectionsContainer<ProfileSection> sectionsContainer;
         private ProfileTabControl tabs;
@@ -56,7 +56,7 @@ namespace osu.Game.Overlays
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             this.api = api;
         }

osu.Game/Rulesets/Judgements/DrawableJudgement.cs

@@ -32,6 +32,12 @@ namespace osu.Game.Rulesets.Judgements
         protected Container JudgementBody;
         protected SpriteText JudgementText;
 
+        /// <summary>
+        /// Duration of initial fade in.
+        /// Default fade out will start immediately after this duration.
+        /// </summary>
+        protected virtual double FadeInDuration => 100;
+
         /// <summary>
         /// Creates a drawable which visualises a <see cref="Judgements.Judgement"/>.
         /// </summary>
@@ -65,11 +71,19 @@ namespace osu.Game.Rulesets.Judgements
             };
         }
 
+        protected virtual void ApplyHitAnimations()
+        {
+            JudgementBody.ScaleTo(0.9f);
+            JudgementBody.ScaleTo(1, 500, Easing.OutElastic);
+
+            this.Delay(FadeInDuration).FadeOut(400);
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            this.FadeInFromZero(100, Easing.OutQuint);
+            this.FadeInFromZero(FadeInDuration, Easing.OutQuint);
 
             switch (Result.Type)
             {
@@ -85,10 +99,7 @@ namespace osu.Game.Rulesets.Judgements
                     this.Delay(600).FadeOut(200);
                     break;
                 default:
-                    JudgementBody.ScaleTo(0.9f);
+                    ApplyHitAnimations();
-                    JudgementBody.ScaleTo(1, 500, Easing.OutElastic);
-
-                    this.Delay(100).FadeOut(400);
                     break;
             }
 

osu.Game/Rulesets/Mods/ModDaycore.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Mods
         public override void ApplyToClock(IAdjustableClock clock)
         {
             if (clock is IHasPitchAdjust pitchAdjust)
-                pitchAdjust.PitchAdjust = 0.75;
+                pitchAdjust.PitchAdjust *= RateAdjust;
             else
                 base.ApplyToClock(clock);
         }

osu.Game/Rulesets/Mods/ModDoubleTime.cs

@@ -2,12 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Timing;
+using System.Linq;
 using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
-    public abstract class ModDoubleTime : Mod, IApplicableToClock
+    public abstract class ModDoubleTime : ModTimeAdjust, IApplicableToClock
     {
         public override string Name => "Double Time";
         public override string Acronym => "DT";
@@ -15,11 +15,9 @@ namespace osu.Game.Rulesets.Mods
         public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => "Zoooooooooom...";
         public override bool Ranked => true;
-        public override Type[] IncompatibleMods => new[] { typeof(ModHalfTime), typeof(ModTimeRamp) };
 
-        public virtual void ApplyToClock(IAdjustableClock clock)
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModHalfTime)).ToArray();
-        {
+
-            clock.Rate = 1.5;
+        protected override double RateAdjust => 1.5;
-        }
     }
 }

osu.Game/Rulesets/Mods/ModHalfTime.cs

@@ -2,12 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Timing;
+using System.Linq;
 using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mods
 {
-    public abstract class ModHalfTime : Mod, IApplicableToClock
+    public abstract class ModHalfTime : ModTimeAdjust, IApplicableToClock
     {
         public override string Name => "Half Time";
         public override string Acronym => "HT";
@@ -15,11 +15,9 @@ namespace osu.Game.Rulesets.Mods
         public override ModType Type => ModType.DifficultyReduction;
         public override string Description => "Less zoom...";
         public override bool Ranked => true;
-        public override Type[] IncompatibleMods => new[] { typeof(ModDoubleTime), typeof(ModTimeRamp) };
 
-        public virtual void ApplyToClock(IAdjustableClock clock)
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModDoubleTime)).ToArray();
-        {
+
-            clock.Rate = 0.75;
+        protected override double RateAdjust => 0.75;
-        }
     }
 }

osu.Game/Rulesets/Mods/ModNightcore.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Mods
         public override void ApplyToClock(IAdjustableClock clock)
         {
             if (clock is IHasPitchAdjust pitchAdjust)
-                pitchAdjust.PitchAdjust = 1.5;
+                pitchAdjust.PitchAdjust *= RateAdjust;
             else
                 base.ApplyToClock(clock);
         }

osu.Game/Rulesets/Mods/ModTimeAdjust.cs

@@ -0,0 +1,24 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Audio;
+using osu.Framework.Timing;
+
+namespace osu.Game.Rulesets.Mods
+{
+    public abstract class ModTimeAdjust : Mod
+    {
+        public override Type[] IncompatibleMods => new[] { typeof(ModTimeRamp) };
+
+        protected abstract double RateAdjust { get; }
+
+        public virtual void ApplyToClock(IAdjustableClock clock)
+        {
+            if (clock is IHasTempoAdjust tempo)
+                tempo.TempoAdjust *= RateAdjust;
+            else
+                clock.Rate *= RateAdjust;
+        }
+    }
+}

osu.Game/Rulesets/Mods/ModTimeRamp.cs

@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Mods
 {
     public abstract class ModTimeRamp : Mod
     {
-        public override Type[] IncompatibleMods => new[] { typeof(ModDoubleTime), typeof(ModHalfTime) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModTimeAdjust) };
 
         protected abstract double FinalRateAdjustment { get; }
     }
@@ -29,8 +29,6 @@ namespace osu.Game.Rulesets.Mods
 
         private IAdjustableClock clock;
 
-        private IHasPitchAdjust pitchAdjust;
-
         /// <summary>
         /// The point in the beatmap at which the final ramping rate should be reached.
         /// </summary>
@@ -39,10 +37,11 @@ namespace osu.Game.Rulesets.Mods
         public virtual void ApplyToClock(IAdjustableClock clock)
         {
             this.clock = clock;
-            pitchAdjust = (IHasPitchAdjust)clock;
 
-            // for preview purposes
+            lastAdjust = 1;
-            pitchAdjust.PitchAdjust = 1.0 + FinalRateAdjustment;
+
+            // for preview purposes. during gameplay, Update will overwrite this setting.
+            applyAdjustment(1);
         }
 
         public virtual void ApplyToBeatmap(Beatmap<T> beatmap)
@@ -55,10 +54,36 @@ namespace osu.Game.Rulesets.Mods
 
         public virtual void Update(Playfield playfield)
         {
-            var absRate = Math.Abs(FinalRateAdjustment);
+            applyAdjustment((clock.CurrentTime - beginRampTime) / finalRateTime);
-            var adjustment = MathHelper.Clamp(absRate * ((clock.CurrentTime - beginRampTime) / finalRateTime), 0, absRate);
+        }
 
-            pitchAdjust.PitchAdjust = 1 + Math.Sign(FinalRateAdjustment) * adjustment;
+        private double lastAdjust = 1;
+
+        /// <summary>
+        /// Adjust the rate along the specified ramp
+        /// </summary>
+        /// <param name="amount">The amount of adjustment to apply (from 0..1).</param>
+        private void applyAdjustment(double amount)
+        {
+            double adjust = 1 + (Math.Sign(FinalRateAdjustment) * MathHelper.Clamp(amount, 0, 1) * Math.Abs(FinalRateAdjustment));
+
+            switch (clock)
+            {
+                case IHasPitchAdjust pitch:
+                    pitch.PitchAdjust /= lastAdjust;
+                    pitch.PitchAdjust *= adjust;
+                    break;
+                case IHasTempoAdjust tempo:
+                    tempo.TempoAdjust /= lastAdjust;
+                    tempo.TempoAdjust *= adjust;
+                    break;
+                default:
+                    clock.Rate /= lastAdjust;
+                    clock.Rate *= adjust;
+                    break;
+            }
+
+            lastAdjust = adjust;
         }
     }
 }

osu.Game/Rulesets/Mods/ModWindDown.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.Linq;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects;
 
@@ -14,6 +16,9 @@ namespace osu.Game.Rulesets.Mods
         public override string Description => "Sloooow doooown...";
         public override FontAwesome Icon => FontAwesome.fa_chevron_circle_down;
         public override double ScoreMultiplier => 1.0;
+
         protected override double FinalRateAdjustment => -0.25;
+
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModWindUp<T>)).ToArray();
     }
 }

osu.Game/Rulesets/Mods/ModWindUp.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.Linq;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects;
 
@@ -14,6 +16,9 @@ namespace osu.Game.Rulesets.Mods
         public override string Description => "Can you keep up?";
         public override FontAwesome Icon => FontAwesome.fa_chevron_circle_up;
         public override double ScoreMultiplier => 1.0;
+
         protected override double FinalRateAdjustment => 0.5;
+
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModWindDown<T>)).ToArray();
     }
-}
+}

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

@@ -5,7 +5,6 @@ using osuTK;
 using osu.Game.Rulesets.Objects.Types;
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.IO;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Audio;
@@ -46,9 +45,11 @@ namespace osu.Game.Rulesets.Objects.Legacy
             {
                 string[] split = text.Split(',');
 
-                Vector2 pos = new Vector2((int)Convert.ToSingle(split[0], CultureInfo.InvariantCulture), (int)Convert.ToSingle(split[1], CultureInfo.InvariantCulture));
+                Vector2 pos = new Vector2((int)Parsing.ParseFloat(split[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseFloat(split[1], Parsing.MAX_COORDINATE_VALUE));
 
-                ConvertHitObjectType type = (ConvertHitObjectType)int.Parse(split[3]);
+                double startTime = Parsing.ParseDouble(split[2]) + Offset;
+
+                ConvertHitObjectType type = (ConvertHitObjectType)Parsing.ParseInt(split[3]);
 
                 int comboOffset = (int)(type & ConvertHitObjectType.ComboOffset) >> 4;
                 type &= ~ConvertHitObjectType.ComboOffset;
@@ -56,7 +57,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
                 bool combo = type.HasFlag(ConvertHitObjectType.NewCombo);
                 type &= ~ConvertHitObjectType.NewCombo;
 
-                var soundType = (LegacySoundType)int.Parse(split[4]);
+                var soundType = (LegacySoundType)Parsing.ParseInt(split[4]);
                 var bankInfo = new SampleBankInfo();
 
                 HitObject result = null;
@@ -107,7 +108,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
                         }
 
                         string[] temp = t.Split(':');
-                        points[pointIndex++] = new Vector2((int)Convert.ToDouble(temp[0], CultureInfo.InvariantCulture), (int)Convert.ToDouble(temp[1], CultureInfo.InvariantCulture)) - pos;
+                        points[pointIndex++] = new Vector2((int)Parsing.ParseDouble(temp[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseDouble(temp[1], Parsing.MAX_COORDINATE_VALUE)) - pos;
                     }
 
                     // osu-stable special-cased colinear perfect curves to a CurveType.Linear
@@ -116,7 +117,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
                     if (points.Length == 3 && pathType == PathType.PerfectCurve && isLinear(points))
                         pathType = PathType.Linear;
 
-                    int repeatCount = Convert.ToInt32(split[6], CultureInfo.InvariantCulture);
+                    int repeatCount = Parsing.ParseInt(split[6]);
 
                     if (repeatCount > 9000)
                         throw new ArgumentOutOfRangeException(nameof(repeatCount), @"Repeat count is way too high");
@@ -125,7 +126,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
                     repeatCount = Math.Max(0, repeatCount - 1);
 
                     if (split.Length > 7)
-                        length = Convert.ToDouble(split[7], CultureInfo.InvariantCulture);
+                        length = Math.Max(0, Parsing.ParseDouble(split[7]));
 
                     if (split.Length > 10)
                         readCustomSampleBanks(split[10], bankInfo);
@@ -184,7 +185,9 @@ namespace osu.Game.Rulesets.Objects.Legacy
                 }
                 else if (type.HasFlag(ConvertHitObjectType.Spinner))
                 {
-                    result = CreateSpinner(new Vector2(512, 384) / 2, combo, comboOffset, Convert.ToDouble(split[5], CultureInfo.InvariantCulture) + Offset);
+                    double endTime = Math.Max(startTime, Parsing.ParseDouble(split[5]) + Offset);
+
+                    result = CreateSpinner(new Vector2(512, 384) / 2, combo, comboOffset, endTime);
 
                     if (split.Length > 6)
                         readCustomSampleBanks(split[6], bankInfo);
@@ -193,12 +196,12 @@ namespace osu.Game.Rulesets.Objects.Legacy
                 {
                     // Note: Hold is generated by BMS converts
 
-                    double endTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture);
+                    double endTime = Math.Max(startTime, Parsing.ParseDouble(split[2]));
 
                     if (split.Length > 5 && !string.IsNullOrEmpty(split[5]))
                     {
                         string[] ss = split[5].Split(':');
-                        endTime = Convert.ToDouble(ss[0], CultureInfo.InvariantCulture);
+                        endTime = Math.Max(startTime, Parsing.ParseDouble(ss[0]));
                         readCustomSampleBanks(string.Join(":", ss.Skip(1)), bankInfo);
                     }
 
@@ -211,7 +214,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
                     return null;
                 }
 
-                result.StartTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture) + Offset;
+                result.StartTime = startTime;
 
                 if (result.Samples.Count == 0)
                     result.Samples = convertSoundType(soundType, bankInfo);
@@ -222,8 +225,14 @@ namespace osu.Game.Rulesets.Objects.Legacy
             }
             catch (FormatException)
             {
-                throw new FormatException("One or more hit objects were malformed.");
+                Logger.Log("A hitobject could not be parsed correctly and will be ignored", LoggingTarget.Runtime, LogLevel.Important);
             }
+            catch (OverflowException)
+            {
+                Logger.Log("A hitobject could not be parsed correctly and will be ignored", LoggingTarget.Runtime, LogLevel.Important);
+            }
+
+            return null;
         }
 
         private void readCustomSampleBanks(string str, SampleBankInfo bankInfo)
@@ -233,8 +242,8 @@ namespace osu.Game.Rulesets.Objects.Legacy
 
             string[] split = str.Split(':');
 
-            var bank = (LegacyBeatmapDecoder.LegacySampleBank)int.Parse(split[0]);
+            var bank = (LegacyBeatmapDecoder.LegacySampleBank)Parsing.ParseInt(split[0]);
-            var addbank = (LegacyBeatmapDecoder.LegacySampleBank)int.Parse(split[1]);
+            var addbank = (LegacyBeatmapDecoder.LegacySampleBank)Parsing.ParseInt(split[1]);
 
             string stringBank = bank.ToString().ToLowerInvariant();
             if (stringBank == @"none")
@@ -247,10 +256,10 @@ namespace osu.Game.Rulesets.Objects.Legacy
             bankInfo.Add = string.IsNullOrEmpty(stringAddBank) ? stringBank : stringAddBank;
 
             if (split.Length > 2)
-                bankInfo.CustomSampleBank = int.Parse(split[2]);
+                bankInfo.CustomSampleBank = Parsing.ParseInt(split[2]);
 
             if (split.Length > 3)
-                bankInfo.Volume = int.Parse(split[3]);
+                bankInfo.Volume = Math.Max(0, Parsing.ParseInt(split[3]));
 
             bankInfo.Filename = split.Length > 4 ? split[4] : null;
         }

osu.Game/Rulesets/Objects/SliderEventGenerator.cs

@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Objects
 
                     for (var d = tickDistance; d <= length; d += tickDistance)
                     {
-                        if (d > length - minDistanceFromEnd)
+                        if (d >= length - minDistanceFromEnd)
                             break;
 
                         var pathProgress = d / length;

osu.Game/Rulesets/UI/FrameStabilityContainer.cs

@@ -0,0 +1,153 @@
+// 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.Timing;
+using osu.Game.Input.Handlers;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Rulesets.UI
+{
+    /// <summary>
+    /// A container which consumes a parent gameplay clock and standardises frame counts for children.
+    /// Will ensure a minimum of 40 frames per clock second is maintained, regardless of any system lag or seeks.
+    /// </summary>
+    public class FrameStabilityContainer : Container, IHasReplayHandler
+    {
+        public FrameStabilityContainer()
+        {
+            RelativeSizeAxes = Axes.Both;
+            gameplayClock = new GameplayClock(framedClock = new FramedClock(manualClock = new ManualClock()));
+        }
+
+        private readonly ManualClock manualClock;
+
+        private readonly FramedClock framedClock;
+
+        [Cached]
+        private GameplayClock gameplayClock;
+
+        private IFrameBasedClock parentGameplayClock;
+
+        [BackgroundDependencyLoader(true)]
+        private void load(GameplayClock clock)
+        {
+            if (clock != null)
+                parentGameplayClock = clock;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            setClock();
+        }
+
+        /// <summary>
+        /// Whether we are running up-to-date with our parent clock.
+        /// If not, we will need to keep processing children until we catch up.
+        /// </summary>
+        private bool requireMoreUpdateLoops;
+
+        /// <summary>
+        /// Whether we are in a valid state (ie. should we keep processing children frames).
+        /// This should be set to false when the replay is, for instance, waiting for future frames to arrive.
+        /// </summary>
+        private bool validState;
+
+        protected override bool RequiresChildrenUpdate => base.RequiresChildrenUpdate && validState;
+
+        private bool isAttached => ReplayInputHandler != null;
+
+        private const int max_catch_up_updates_per_frame = 50;
+
+        private const double sixty_frame_time = 1000.0 / 60;
+
+        public override bool UpdateSubTree()
+        {
+            requireMoreUpdateLoops = true;
+            validState = true;
+
+            int loops = 0;
+
+            while (validState && requireMoreUpdateLoops && loops++ < max_catch_up_updates_per_frame)
+            {
+                updateClock();
+
+                if (validState)
+                {
+                    base.UpdateSubTree();
+                    UpdateSubTreeMasking(this, ScreenSpaceDrawQuad.AABBFloat);
+                }
+            }
+
+            return true;
+        }
+
+        private void updateClock()
+        {
+            if (parentGameplayClock == null)
+                setClock(); // LoadComplete may not be run yet, but we still want the clock.
+
+            validState = true;
+
+            manualClock.Rate = parentGameplayClock.Rate;
+            manualClock.IsRunning = parentGameplayClock.IsRunning;
+
+            var newProposedTime = parentGameplayClock.CurrentTime;
+
+            try
+            {
+                if (Math.Abs(manualClock.CurrentTime - newProposedTime) > sixty_frame_time * 1.2f)
+                {
+                    newProposedTime = manualClock.Rate > 0
+                        ? Math.Min(newProposedTime, manualClock.CurrentTime + sixty_frame_time)
+                        : Math.Max(newProposedTime, manualClock.CurrentTime - sixty_frame_time);
+                }
+
+                if (!isAttached)
+                {
+                    manualClock.CurrentTime = newProposedTime;
+                }
+                else
+                {
+                    double? newTime = ReplayInputHandler.SetFrameFromTime(newProposedTime);
+
+                    if (newTime == null)
+                    {
+                        // we shouldn't execute for this time value. probably waiting on more replay data.
+                        validState = false;
+
+                        requireMoreUpdateLoops = true;
+                        manualClock.CurrentTime = newProposedTime;
+                        return;
+                    }
+
+                    manualClock.CurrentTime = newTime.Value;
+                }
+
+                requireMoreUpdateLoops = manualClock.CurrentTime != parentGameplayClock.CurrentTime;
+            }
+            finally
+            {
+                // The manual clock time has changed in the above code. The framed clock now needs to be updated
+                // to ensure that the its time is valid for our children before input is processed
+                framedClock.ProcessFrame();
+            }
+        }
+
+        private void setClock()
+        {
+            // in case a parent gameplay clock isn't available, just use the parent clock.
+            if (parentGameplayClock == null)
+                parentGameplayClock = Clock;
+
+            Clock = gameplayClock;
+            ProcessCustomClock = false;
+        }
+
+        public ReplayInputHandler ReplayInputHandler { get; set; }
+    }
+}

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -132,6 +132,8 @@ namespace osu.Game.Rulesets.UI
 
         protected virtual ReplayInputHandler CreateReplayInputHandler(Replay replay) => null;
 
+        protected FrameStabilityContainer FrameStabilityContainer;
+
         public Score ReplayScore { get; private set; }
 
         /// <summary>
@@ -149,7 +151,11 @@ namespace osu.Game.Rulesets.UI
                 throw new InvalidOperationException($"A {nameof(KeyBindingInputManager)} which supports replay loading is not available");
 
             ReplayScore = replayScore;
-            ReplayInputManager.ReplayInputHandler = replayScore != null ? CreateReplayInputHandler(replayScore.Replay) : null;
+
+            var handler = replayScore != null ? CreateReplayInputHandler(replayScore.Replay) : null;
+
+            ReplayInputManager.ReplayInputHandler = handler;
+            FrameStabilityContainer.ReplayInputHandler = handler;
 
             HasReplayLoaded.Value = ReplayInputManager.ReplayInputHandler != null;
         }
@@ -243,7 +249,6 @@ namespace osu.Game.Rulesets.UI
             Beatmap = (Beatmap<TObject>)workingBeatmap.GetPlayableBeatmap(ruleset.RulesetInfo);
 
             KeyBindingInputManager = CreateInputManager();
-            KeyBindingInputManager.RelativeSizeAxes = Axes.Both;
 
             applyBeatmapMods(Mods);
         }
@@ -262,7 +267,10 @@ namespace osu.Game.Rulesets.UI
 
             InternalChildren = new Drawable[]
             {
-                KeyBindingInputManager,
+                FrameStabilityContainer = new FrameStabilityContainer
+                {
+                    Child = KeyBindingInputManager,
+                },
                 Overlays = new Container { RelativeSizeAxes = Axes.Both }
             };
 

osu.Game/Rulesets/UI/RulesetInputManager.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 System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -12,7 +11,6 @@ using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Input.StateChanges.Events;
 using osu.Framework.Input.States;
-using osu.Framework.Timing;
 using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
 using osu.Game.Input.Handlers;
@@ -41,7 +39,12 @@ namespace osu.Game.Rulesets.UI
         protected RulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
         {
             InternalChild = KeyBindingContainer = CreateKeyBindingContainer(ruleset, variant, unique);
-            gameplayClock = new GameplayClock(framedClock = new FramedClock(manualClock = new ManualClock()));
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(OsuConfigManager config)
+        {
+            mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
         }
 
         #region Action mapping (for replays)
@@ -85,137 +88,6 @@ namespace osu.Game.Rulesets.UI
 
         #endregion
 
-        #region Clock control
-
-        private readonly ManualClock manualClock;
-
-        private readonly FramedClock framedClock;
-
-        [Cached]
-        private GameplayClock gameplayClock;
-
-        private IFrameBasedClock parentGameplayClock;
-
-        [BackgroundDependencyLoader(true)]
-        private void load(OsuConfigManager config, GameplayClock clock)
-        {
-            mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
-
-            if (clock != null)
-                parentGameplayClock = clock;
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            setClock();
-        }
-
-        /// <summary>
-        /// Whether we are running up-to-date with our parent clock.
-        /// If not, we will need to keep processing children until we catch up.
-        /// </summary>
-        private bool requireMoreUpdateLoops;
-
-        /// <summary>
-        /// Whether we are in a valid state (ie. should we keep processing children frames).
-        /// This should be set to false when the replay is, for instance, waiting for future frames to arrive.
-        /// </summary>
-        private bool validState;
-
-        protected override bool RequiresChildrenUpdate => base.RequiresChildrenUpdate && validState;
-
-        private bool isAttached => replayInputHandler != null && !UseParentInput;
-
-        private const int max_catch_up_updates_per_frame = 50;
-
-        private const double sixty_frame_time = 1000.0 / 60;
-
-        public override bool UpdateSubTree()
-        {
-            requireMoreUpdateLoops = true;
-            validState = true;
-
-            int loops = 0;
-
-            while (validState && requireMoreUpdateLoops && loops++ < max_catch_up_updates_per_frame)
-            {
-                updateClock();
-
-                if (validState)
-                {
-                    base.UpdateSubTree();
-                    UpdateSubTreeMasking(this, ScreenSpaceDrawQuad.AABBFloat);
-                }
-            }
-
-            return true;
-        }
-
-        private void updateClock()
-        {
-            if (parentGameplayClock == null)
-                setClock(); // LoadComplete may not be run yet, but we still want the clock.
-
-            validState = true;
-
-            manualClock.Rate = parentGameplayClock.Rate;
-            manualClock.IsRunning = parentGameplayClock.IsRunning;
-
-            var newProposedTime = parentGameplayClock.CurrentTime;
-
-            try
-            {
-                if (Math.Abs(manualClock.CurrentTime - newProposedTime) > sixty_frame_time * 1.2f)
-                {
-                    newProposedTime = manualClock.Rate > 0
-                        ? Math.Min(newProposedTime, manualClock.CurrentTime + sixty_frame_time)
-                        : Math.Max(newProposedTime, manualClock.CurrentTime - sixty_frame_time);
-                }
-
-                if (!isAttached)
-                {
-                    manualClock.CurrentTime = newProposedTime;
-                }
-                else
-                {
-                    double? newTime = replayInputHandler.SetFrameFromTime(newProposedTime);
-
-                    if (newTime == null)
-                    {
-                        // we shouldn't execute for this time value. probably waiting on more replay data.
-                        validState = false;
-
-                        requireMoreUpdateLoops = true;
-                        manualClock.CurrentTime = newProposedTime;
-                        return;
-                    }
-
-                    manualClock.CurrentTime = newTime.Value;
-                }
-
-                requireMoreUpdateLoops = manualClock.CurrentTime != parentGameplayClock.CurrentTime;
-            }
-            finally
-            {
-                // The manual clock time has changed in the above code. The framed clock now needs to be updated
-                // to ensure that the its time is valid for our children before input is processed
-                framedClock.ProcessFrame();
-            }
-        }
-
-        private void setClock()
-        {
-            // in case a parent gameplay clock isn't available, just use the parent clock.
-            if (parentGameplayClock == null)
-                parentGameplayClock = Clock;
-
-            Clock = gameplayClock;
-            ProcessCustomClock = false;
-        }
-
-        #endregion
-
         #region Setting application (disables etc.)
 
         private Bindable<bool> mouseDisabled;

osu.Game/Screens/Menu/ButtonSystem.cs

@@ -97,7 +97,7 @@ namespace osu.Game.Screens.Menu
         private OsuGame game { get; set; }
 
         [Resolved]
-        private APIAccess api { get; set; }
+        private IAPIProvider api { get; set; }
 
         [Resolved(CanBeNull = true)]
         private NotificationOverlay notifications { get; set; }

osu.Game/Screens/Menu/Disclaimer.cs

@@ -2,11 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Screens;
 using osu.Game.Graphics;
@@ -25,16 +26,17 @@ namespace osu.Game.Screens.Menu
         private SpriteIcon icon;
         private Color4 iconColour;
         private LinkFlowContainer textFlow;
+        private LinkFlowContainer supportFlow;
 
         public override bool HideOverlaysOnEnter => true;
         public override OverlayActivation InitialOverlayActivationMode => OverlayActivation.Disabled;
 
         public override bool CursorVisible => false;
 
-        private readonly List<Drawable> supporterDrawables = new List<Drawable>();
         private Drawable heart;
 
         private const float icon_y = -85;
+        private const float icon_size = 30;
 
         private readonly Bindable<User> currentUser = new Bindable<User>();
 
@@ -44,7 +46,7 @@ namespace osu.Game.Screens.Menu
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, APIAccess api)
+        private void load(OsuColour colours, IAPIProvider api)
         {
             InternalChildren = new Drawable[]
             {
@@ -53,19 +55,39 @@ namespace osu.Game.Screens.Menu
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Icon = FontAwesome.fa_warning,
-                    Size = new Vector2(30),
+                    Size = new Vector2(icon_size),
                     Y = icon_y,
                 },
-                textFlow = new LinkFlowContainer
+                new FillFlowContainer
                 {
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
-                    Padding = new MarginPadding(50),
+                    Direction = FillDirection.Vertical,
-                    TextAnchor = Anchor.TopCentre,
+                    Y = icon_y + icon_size,
-                    Y = -110,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.TopCentre,
-                    Spacing = new Vector2(0, 2),
+                    Children = new Drawable[]
+                    {
+                        textFlow = new LinkFlowContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            TextAnchor = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            Spacing = new Vector2(0, 2),
+                        },
+                        supportFlow = new LinkFlowContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            TextAnchor = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            Alpha = 0,
+                            Spacing = new Vector2(0, 2),
+                        },
+                    }
                 }
             };
 
@@ -88,28 +110,45 @@ namespace osu.Game.Screens.Menu
             textFlow.NewParagraph();
             textFlow.NewParagraph();
 
-            supporterDrawables.AddRange(textFlow.AddText("Consider becoming an ", format));
-            supporterDrawables.AddRange(textFlow.AddLink("osu!supporter", "https://osu.ppy.sh/home/support", creationParameters: format));
-            supporterDrawables.AddRange(textFlow.AddText(" to help support the game", format));
-
-            supporterDrawables.Add(heart = textFlow.AddIcon(FontAwesome.fa_heart, t =>
-            {
-                t.Padding = new MarginPadding { Left = 5 };
-                t.Font = t.Font.With(size: 12);
-                t.Colour = colours.Pink;
-                t.Origin = Anchor.Centre;
-            }).First());
-
             iconColour = colours.Yellow;
 
             currentUser.BindTo(api.LocalUser);
             currentUser.BindValueChanged(e =>
             {
+                supportFlow.Children.ForEach(d => d.FadeOut().Expire());
+
                 if (e.NewValue.IsSupporter)
-                    supporterDrawables.ForEach(d => d.FadeOut(500, Easing.OutQuint).Expire());
+                {
+                    supportFlow.AddText("Thank you for supporting osu!", format);
+                }
+                else
+                {
+                    supportFlow.AddText("Consider becoming an ", format);
+                    supportFlow.AddLink("osu!supporter", "https://osu.ppy.sh/home/support", creationParameters: format);
+                    supportFlow.AddText(" to help support the game", format);
+                }
+
+                heart = supportFlow.AddIcon(FontAwesome.fa_heart, t =>
+                {
+                    t.Padding = new MarginPadding { Left = 5 };
+                    t.Font = t.Font.With(size: 12);
+                    t.Origin = Anchor.Centre;
+                    t.Colour = colours.Pink;
+                }).First();
+
+                if (IsLoaded)
+                    animateHeart();
+
+                if (supportFlow.IsPresent)
+                    supportFlow.FadeInFromZero(500);
             }, true);
         }
 
+        private void animateHeart()
+        {
+            heart.FlashColour(Color4.White, 750, Easing.OutQuint).Loop();
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -128,7 +167,9 @@ namespace osu.Game.Screens.Menu
                 .MoveToY(icon_y, 160, Easing.InCirc)
                 .RotateTo(0, 160, Easing.InCirc);
 
-            supporterDrawables.ForEach(d => d.FadeOut().Delay(2000).FadeIn(500));
+            supportFlow.FadeOut().Delay(2000).FadeIn(500);
+
+            animateHeart();
 
             this
                 .FadeInFromZero(500)
@@ -136,8 +177,6 @@ namespace osu.Game.Screens.Menu
                 .FadeOut(250)
                 .ScaleTo(0.9f, 250, Easing.InQuint)
                 .Finally(d => this.Push(intro));
-
-            heart.FlashColour(Color4.White, 750, Easing.OutQuint).Loop();
         }
     }
 }

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

@@ -246,7 +246,7 @@ namespace osu.Game.Screens.Multi.Lounge.Components
             }
 
             [Resolved]
-            private APIAccess api { get; set; }
+            private IAPIProvider api { get; set; }
 
             private GetRoomScoresRequest request;
 

osu.Game/Screens/Multi/Match/Components/Participants.cs

@@ -52,12 +52,18 @@ namespace osu.Game.Screens.Multi.Match.Components
 
             Participants.BindValueChanged(participants =>
             {
-                usersFlow.Children = participants.NewValue.Select(u => new UserPanel(u)
+                usersFlow.Children = participants.NewValue.Select(u =>
                 {
-                    Anchor = Anchor.TopCentre,
+                    var panel = new UserPanel(u)
-                    Origin = Anchor.TopCentre,
+                    {
-                    Width = 300,
+                        Anchor = Anchor.TopCentre,
-                    OnLoadComplete = d => d.FadeInFromZero(60),
+                        Origin = Anchor.TopCentre,
+                        Width = 300,
+                    };
+
+                    panel.OnLoadComplete += d => d.FadeInFromZero(60);
+
+                    return panel;
                 }).ToList();
             }, true);
         }

osu.Game/Screens/Multi/Multiplayer.cs

@@ -54,7 +54,7 @@ namespace osu.Game.Screens.Multi
         private OsuGameBase game { get; set; }
 
         [Resolved]
-        private APIAccess api { get; set; }
+        private IAPIProvider api { get; set; }
 
         [Resolved(CanBeNull = true)]
         private OsuLogo logo { get; set; }
@@ -163,7 +163,7 @@ namespace osu.Game.Screens.Multi
             this.Push(new PlayerLoader(player));
         }
 
-        public void APIStateChanged(APIAccess api, APIState state)
+        public void APIStateChanged(IAPIProvider api, APIState state)
         {
             if (state != APIState.Online)
                 forcefullyExit();

osu.Game/Screens/Multi/Play/TimeshiftPlayer.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Screens.Multi.Play
         private readonly PlaylistItem playlistItem;
 
         [Resolved]
-        private APIAccess api { get; set; }
+        private IAPIProvider api { get; set; }
 
         [Resolved]
         private IBindable<RulesetInfo> ruleset { get; set; }

osu.Game/Screens/Multi/RoomManager.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Screens.Multi
         private Bindable<FilterCriteria> currentFilter { get; set; }
 
         [Resolved]
-        private APIAccess api { get; set; }
+        private IAPIProvider api { get; set; }
 
         [Resolved]
         private RulesetStore rulesets { get; set; }

osu.Game/Screens/Play/GameplayClockContainer.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -141,11 +142,15 @@ namespace osu.Game.Screens.Play
         {
             if (sourceClock == null) return;
 
-            sourceClock.Rate = 1;
+            sourceClock.ResetSpeedAdjustments();
+
+            if (sourceClock is IHasTempoAdjust tempo)
+                tempo.TempoAdjust = UserPlaybackRate.Value;
+            else
+                sourceClock.Rate = UserPlaybackRate.Value;
+
             foreach (var mod in beatmap.Mods.Value.OfType<IApplicableToClock>())
                 mod.ApplyToClock(sourceClock);
-
-            sourceClock.Rate *= UserPlaybackRate.Value;
         }
     }
 }

osu.Game/Screens/Play/Player.cs

@@ -60,7 +60,7 @@ namespace osu.Game.Screens.Play
 
         private RulesetInfo ruleset;
 
-        private APIAccess api;
+        private IAPIProvider api;
 
         private SampleChannel sampleRestart;
 
@@ -85,7 +85,7 @@ namespace osu.Game.Screens.Play
         private GameplayClockContainer gameplayClockContainer;
 
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio, APIAccess api, OsuConfigManager config)
+        private void load(AudioManager audio, IAPIProvider api, OsuConfigManager config)
         {
             this.api = api;
 

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -577,7 +577,7 @@ namespace osu.Game.Screens.Select
                             else
                             {
                                 float y = currentY;
-                                d.OnLoadComplete = _ => performMove(y, setY);
+                                d.OnLoadComplete += _ => performMove(y, setY);
                             }
 
                             break;

osu.Game/Screens/Select/BeatmapDetails.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Screens.Select
         private readonly FailRetryGraph failRetryGraph;
         private readonly DimmedLoadingAnimation loading;
 
-        private APIAccess api;
+        private IAPIProvider api;
 
         private ScheduledDelegate pendingBeatmapSwitch;
 
@@ -160,7 +160,7 @@ namespace osu.Game.Screens.Select
         }
 
         [BackgroundDependencyLoader]
-        private void load(APIAccess api)
+        private void load(IAPIProvider api)
         {
             this.api = api;
         }
@@ -175,21 +175,22 @@ namespace osu.Game.Screens.Select
 
         private void updateStatistics()
         {
-            if (Beatmap == null)
+            advanced.Beatmap = Beatmap;
+            description.Text = Beatmap?.Version;
+            source.Text = Beatmap?.Metadata?.Source;
+            tags.Text = Beatmap?.Metadata?.Tags;
+
+            // metrics may have been previously fetched
+            if (Beatmap?.Metrics != null)
             {
-                clearStats();
+                updateMetrics(Beatmap.Metrics);
                 return;
             }
 
-            ratingsContainer.FadeIn(transition_duration);
+            // metrics may not be fetched but can be
-            advanced.Beatmap = Beatmap;
+            if (Beatmap?.OnlineBeatmapID != null)
-            description.Text = Beatmap.Version;
-            source.Text = Beatmap.Metadata.Source;
-            tags.Text = Beatmap.Metadata.Tags;
-
-            var requestedBeatmap = Beatmap;
-            if (requestedBeatmap.Metrics == null)
             {
+                var requestedBeatmap = Beatmap;
                 var lookup = new GetBeatmapDetailsRequest(requestedBeatmap);
                 lookup.Success += res =>
                 {
@@ -198,39 +199,34 @@ namespace osu.Game.Screens.Select
                         return;
 
                     requestedBeatmap.Metrics = res;
-                    Schedule(() => displayMetrics(res));
+                    Schedule(() => updateMetrics(res));
                 };
-                lookup.Failure += e => Schedule(() => displayMetrics(null));
+                lookup.Failure += e => Schedule(() => updateMetrics());
-
                 api.Queue(lookup);
                 loading.Show();
+                return;
             }
 
-            displayMetrics(requestedBeatmap.Metrics, false);
+            updateMetrics();
         }
 
-        private void displayMetrics(BeatmapMetrics metrics, bool failOnMissing = true)
+        private void updateMetrics(BeatmapMetrics metrics = null)
         {
             var hasRatings = metrics?.Ratings?.Any() ?? false;
             var hasRetriesFails = (metrics?.Retries?.Any() ?? false) && (metrics.Fails?.Any() ?? false);
 
-            if (failOnMissing) loading.Hide();
-
             if (hasRatings)
             {
                 ratings.Metrics = metrics;
-                ratings.FadeIn(transition_duration);
+                ratingsContainer.FadeIn(transition_duration);
             }
-            else if (failOnMissing)
+            else
             {
                 ratings.Metrics = new BeatmapMetrics
                 {
                     Ratings = new int[10],
                 };
-            }
+                ratingsContainer.FadeTo(0.25f, transition_duration);
-            else
-            {
-                ratings.FadeTo(0.25f, transition_duration);
             }
 
             if (hasRetriesFails)
@@ -238,41 +234,17 @@ namespace osu.Game.Screens.Select
                 failRetryGraph.Metrics = metrics;
                 failRetryContainer.FadeIn(transition_duration);
             }
-            else if (failOnMissing)
+            else
             {
                 failRetryGraph.Metrics = new BeatmapMetrics
                 {
                     Fails = new int[100],
                     Retries = new int[100],
                 };
+                failRetryContainer.FadeOut(transition_duration);
             }
-            else
-            {
-                failRetryContainer.FadeTo(0.25f, transition_duration);
-            }
-        }
-
-        private void clearStats()
-        {
-            description.Text = null;
-            source.Text = null;
-            tags.Text = null;
-
-            advanced.Beatmap = new BeatmapInfo
-            {
-                StarDifficulty = 0,
-                BaseDifficulty = new BeatmapDifficulty
-                {
-                    CircleSize = 0,
-                    DrainRate = 0,
-                    OverallDifficulty = 0,
-                    ApproachRate = 0,
-                },
-            };
 
             loading.Hide();
-            ratingsContainer.FadeOut(transition_duration);
-            failRetryContainer.FadeOut(transition_duration);
         }
 
         private class DetailBox : Container

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

@@ -49,11 +49,16 @@ namespace osu.Game.Screens.Select.Carousel
             Children = new Drawable[]
             {
                 new DelayedLoadUnloadWrapper(() =>
-                        new PanelBackground(manager.GetWorkingBeatmap(beatmapSet.Beatmaps.FirstOrDefault()))
+                    {
+                        var background = new PanelBackground(manager.GetWorkingBeatmap(beatmapSet.Beatmaps.FirstOrDefault()))
                         {
                             RelativeSizeAxes = Axes.Both,
-                            OnLoadComplete = d => d.FadeInFromZero(1000, Easing.OutQuint),
+                        };
-                        }, 300, 5000
+
+                        background.OnLoadComplete += d => d.FadeInFromZero(1000, Easing.OutQuint);
+
+                        return background;
+                    }, 300, 5000
                 ),
                 new FillFlowContainer
                 {

osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs

@@ -43,7 +43,7 @@ namespace osu.Game.Screens.Select.Leaderboards
         private IBindable<RulesetInfo> ruleset { get; set; }
 
         [Resolved]
-        private APIAccess api { get; set; }
+        private IAPIProvider api { get; set; }
 
         [BackgroundDependencyLoader]
         private void load()

osu.Game/Storyboards/Drawables/DrawableStoryboard.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Textures;
 using osu.Game.IO;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Storyboards.Drawables
 {
@@ -55,9 +56,12 @@ namespace osu.Game.Storyboards.Drawables
             });
         }
 
-        [BackgroundDependencyLoader]
+        [BackgroundDependencyLoader(true)]
-        private void load(FileStore fileStore)
+        private void load(FileStore fileStore, GameplayClock clock)
         {
+            if (clock != null)
+                Clock = clock;
+
             dependencies.Cache(new TextureStore(new TextureLoaderStore(fileStore.Store), false, scaleAdjust: 1));
 
             foreach (var layer in Storyboard.Layers)

osu.Game/Tests/Visual/RateAdjustedBeatmapTestCase.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Tests.Visual
             base.Update();
 
             // note that this will override any mod rate application
-            Beatmap.Value.Track.Rate = Clock.Rate;
+            Beatmap.Value.Track.TempoAdjust = Clock.Rate;
         }
     }
 }

osu.Game/Tests/Visual/TestCasePlayer.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Tests.Visual
                     AddStep(r.Name, () => p = loadPlayerFor(r));
                     AddCheckSteps(() => p);
 
-                    AddUntilStep(() =>
+                    AddUntilStep("no leaked beatmaps", () =>
                     {
                         p = null;
 
@@ -65,9 +65,9 @@ namespace osu.Game.Tests.Visual
 
                         workingWeakReferences.ForEachAlive(_ => count++);
                         return count == 1;
-                    }, "no leaked beatmaps");
+                    });
 
-                    AddUntilStep(() =>
+                    AddUntilStep("no leaked players", () =>
                     {
                         GC.Collect();
                         GC.WaitForPendingFinalizers();
@@ -75,14 +75,14 @@ namespace osu.Game.Tests.Visual
 
                         playerWeakReferences.ForEachAlive(_ => count++);
                         return count == 1;
-                    }, "no leaked players");
+                    });
                 }
             }
         }
 
         protected virtual void AddCheckSteps(Func<Player> player)
         {
-            AddUntilStep(() => player().IsLoaded, "player loaded");
+            AddUntilStep("player loaded", () => player().IsLoaded);
         }
 
         protected virtual IBeatmap CreateBeatmap(Ruleset ruleset) => new TestBeatmap(ruleset.RulesetInfo);

osu.Game/Users/UpdateableAvatar.cs

@@ -57,9 +57,9 @@ namespace osu.Game.Users
                 var avatar = new Avatar(user)
                 {
                     RelativeSizeAxes = Axes.Both,
-                    OnLoadComplete = d => d.FadeInFromZero(300, Easing.OutQuint),
                 };
 
+                avatar.OnLoadComplete += d => d.FadeInFromZero(300, Easing.OutQuint);
                 avatar.OpenOnClick.BindTo(OpenOnClick);
 
                 Add(displayedAvatar = new DelayedLoadWrapper(avatar));

osu.Game/Users/UserPanel.cs

@@ -59,6 +59,8 @@ namespace osu.Game.Users
 
             FillFlowContainer infoContainer;
 
+            UserCoverBackground coverBackground;
+
             AddInternal(content = new Container
             {
                 RelativeSizeAxes = Axes.Both,
@@ -73,13 +75,12 @@ namespace osu.Game.Users
 
                 Children = new Drawable[]
                 {
-                    new DelayedLoadWrapper(new UserCoverBackground(user)
+                    new DelayedLoadWrapper(coverBackground = new UserCoverBackground(user)
                     {
                         RelativeSizeAxes = Axes.Both,
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                         FillMode = FillMode.Fill,
-                        OnLoadComplete = d => d.FadeInFromZero(400, Easing.Out)
                     }, 300) { RelativeSizeAxes = Axes.Both },
                     new Box
                     {
@@ -181,6 +182,8 @@ namespace osu.Game.Users
                 }
             });
 
+            coverBackground.OnLoadComplete += d => d.FadeInFromZero(400, Easing.Out);
+
             if (user.IsSupporter)
             {
                 infoContainer.Add(new SupporterIcon

osu.Game/osu.Game.csproj

@@ -16,7 +16,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.1" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.128.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2019.308.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2019.319.0" />
     <PackageReference Include="SharpCompress" Version="0.22.0" />
     <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />

osu.iOS.props

@@ -105,8 +105,8 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.1" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.128.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2019.308.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2019.319.0" />
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.308.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.319.0" />
     <PackageReference Include="SharpCompress" Version="0.22.0" />
     <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />

osu.iOS/Application.cs

@@ -13,4 +13,3 @@ namespace osu.iOS
         }
     }
 }
-