Merge branch 'master' into true-gameplay-rate

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

@@ -362,10 +362,12 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             return breaks.Any(breakPeriod =>
             {
-                var firstObjAfterBreak = originalHitObjects.First(obj => almostBigger(obj.StartTime, breakPeriod.EndTime));
+                OsuHitObject? firstObjAfterBreak = originalHitObjects.FirstOrDefault(obj => almostBigger(obj.StartTime, breakPeriod.EndTime));
 
                 return almostBigger(time, breakPeriod.StartTime)
-                       && definitelyBigger(firstObjAfterBreak.StartTime, time);
+                       // There should never really be a break section with no objects after it, but we've seen crashes from users with malformed beatmaps,
+                       // so it's best to guard against this.
+                       && (firstObjAfterBreak == null || definitelyBigger(firstObjAfterBreak.StartTime, time));
             });
         }
 

osu.Game.Rulesets.Taiko.Tests/Judgements/JudgementTest.cs

@@ -0,0 +1,96 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions.TypeExtensions;
+using osu.Framework.Screens;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Judgements
+{
+    public class JudgementTest : RateAdjustedBeatmapTestScene
+    {
+        private ScoreAccessibleReplayPlayer currentPlayer = null!;
+        protected List<JudgementResult> JudgementResults { get; private set; } = null!;
+
+        protected void AssertJudgementCount(int count)
+        {
+            AddAssert($"{count} judgement{(count > 0 ? "s" : "")}", () => JudgementResults, () => Has.Count.EqualTo(count));
+        }
+
+        protected void AssertResult<T>(int index, HitResult expectedResult)
+        {
+            AddAssert($"{typeof(T).ReadableName()} ({index}) judged as {expectedResult}",
+                () => JudgementResults.Where(j => j.HitObject is T).OrderBy(j => j.HitObject.StartTime).ElementAt(index).Type,
+                () => Is.EqualTo(expectedResult));
+        }
+
+        protected void PerformTest(List<ReplayFrame> frames, Beatmap<TaikoHitObject>? beatmap = null)
+        {
+            AddStep("load player", () =>
+            {
+                Beatmap.Value = CreateWorkingBeatmap(beatmap);
+
+                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
+
+                p.OnLoadComplete += _ =>
+                {
+                    p.ScoreProcessor.NewJudgement += result =>
+                    {
+                        if (currentPlayer == p) JudgementResults.Add(result);
+                    };
+                };
+
+                LoadScreen(currentPlayer = p);
+                JudgementResults = new List<JudgementResult>();
+            });
+
+            AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
+            AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
+        }
+
+        protected Beatmap<TaikoHitObject> CreateBeatmap(params TaikoHitObject[] hitObjects)
+        {
+            var beatmap = new Beatmap<TaikoHitObject>
+            {
+                HitObjects = hitObjects.ToList(),
+                BeatmapInfo =
+                {
+                    Difficulty = new BeatmapDifficulty { SliderTickRate = 4 },
+                    Ruleset = new TaikoRuleset().RulesetInfo
+                },
+            };
+
+            beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 0.1f });
+            return beatmap;
+        }
+
+        private class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            protected override bool PauseOnFocusLost => false;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score, new PlayerConfiguration
+                {
+                    AllowPause = false,
+                    ShowResults = false,
+                })
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneDrumRollJudgements.cs

@@ -0,0 +1,201 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Judgements
+{
+    public class TestSceneDrumRollJudgements : JudgementTest
+    {
+        [Test]
+        public void TestHitAllDrumRoll()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000
+            }));
+
+            AssertJudgementCount(3);
+            AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitSomeDrumRoll()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000
+            }));
+
+            AssertJudgementCount(3);
+            AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitNoneDrumRoll()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000
+            }));
+
+            AssertJudgementCount(3);
+            AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
+            AssertResult<DrumRollTick>(1, HitResult.IgnoreMiss);
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitAllStrongDrumRollWithOneKey()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(6);
+
+            AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(0, HitResult.LargeBonus);
+
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitSomeStrongDrumRollWithOneKey()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(6);
+
+            AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
+            AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
+
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitAllStrongDrumRollWithBothKeys()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(1000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(1001),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(6);
+
+            AssertResult<DrumRollTick>(0, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(0, HitResult.LargeBonus);
+
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+        }
+
+        [Test]
+        public void TestHitSomeStrongDrumRollWithBothKeys()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2000, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+                new TaikoReplayFrame(2001),
+            }, CreateBeatmap(new DrumRoll
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(6);
+
+            AssertResult<DrumRollTick>(0, HitResult.IgnoreMiss);
+            AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
+
+            AssertResult<DrumRollTick>(1, HitResult.SmallBonus);
+            AssertResult<StrongNestedHitObject>(1, HitResult.LargeBonus);
+
+            AssertResult<DrumRoll>(0, HitResult.IgnoreHit);
+            AssertResult<StrongNestedHitObject>(2, HitResult.IgnoreHit);
+        }
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneHitJudgements.cs

@@ -0,0 +1,133 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Judgements
+{
+    public class TestSceneHitJudgements : JudgementTest
+    {
+        [Test]
+        public void TestHitCentreHit()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(hit_time, TaikoAction.LeftCentre),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time
+            }));
+
+            AssertJudgementCount(1);
+            AssertResult<Hit>(0, HitResult.Great);
+        }
+
+        [Test]
+        public void TestHitRimHit()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(hit_time, TaikoAction.LeftRim),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Rim,
+                StartTime = hit_time
+            }));
+
+            AssertJudgementCount(1);
+            AssertResult<Hit>(0, HitResult.Great);
+        }
+
+        [Test]
+        public void TestMissHit()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0)
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time
+            }));
+
+            AssertJudgementCount(1);
+            AssertResult<Hit>(0, HitResult.Miss);
+        }
+
+        [Test]
+        public void TestHitStrongHitWithOneKey()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(hit_time, TaikoAction.LeftCentre),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(2);
+            AssertResult<Hit>(0, HitResult.Great);
+            AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
+        }
+
+        [Test]
+        public void TestHitStrongHitWithBothKeys()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(hit_time, TaikoAction.LeftCentre, TaikoAction.RightCentre),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(2);
+            AssertResult<Hit>(0, HitResult.Great);
+            AssertResult<StrongNestedHitObject>(0, HitResult.LargeBonus);
+        }
+
+        [Test]
+        public void TestMissStrongHit()
+        {
+            const double hit_time = 1000;
+
+            PerformTest(new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+            }, CreateBeatmap(new Hit
+            {
+                Type = HitType.Centre,
+                StartTime = hit_time,
+                IsStrong = true
+            }));
+
+            AssertJudgementCount(2);
+            AssertResult<Hit>(0, HitResult.Miss);
+            AssertResult<StrongNestedHitObject>(0, HitResult.IgnoreMiss);
+        }
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneSwellJudgements.cs

@@ -0,0 +1,118 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Judgements
+{
+    public class TestSceneSwellJudgements : JudgementTest
+    {
+        [Test]
+        public void TestHitAllSwell()
+        {
+            const double hit_time = 1000;
+
+            Swell swell = new Swell
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                RequiredHits = 10
+            };
+
+            List<ReplayFrame> frames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2001),
+            };
+
+            for (int i = 0; i < swell.RequiredHits; i++)
+            {
+                double frameTime = 1000 + i * 50;
+                frames.Add(new TaikoReplayFrame(frameTime, i % 2 == 0 ? TaikoAction.LeftCentre : TaikoAction.LeftRim));
+                frames.Add(new TaikoReplayFrame(frameTime + 10));
+            }
+
+            PerformTest(frames, CreateBeatmap(swell));
+
+            AssertJudgementCount(11);
+
+            for (int i = 0; i < swell.RequiredHits; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreHit);
+
+            AssertResult<Swell>(0, HitResult.LargeBonus);
+        }
+
+        [Test]
+        public void TestHitSomeSwell()
+        {
+            const double hit_time = 1000;
+
+            Swell swell = new Swell
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                RequiredHits = 10
+            };
+
+            List<ReplayFrame> frames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2001),
+            };
+
+            for (int i = 0; i < swell.RequiredHits / 2; i++)
+            {
+                double frameTime = 1000 + i * 50;
+                frames.Add(new TaikoReplayFrame(frameTime, i % 2 == 0 ? TaikoAction.LeftCentre : TaikoAction.LeftRim));
+                frames.Add(new TaikoReplayFrame(frameTime + 10));
+            }
+
+            PerformTest(frames, CreateBeatmap(swell));
+
+            AssertJudgementCount(11);
+
+            for (int i = 0; i < swell.RequiredHits / 2; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreHit);
+            for (int i = swell.RequiredHits / 2; i < swell.RequiredHits; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreMiss);
+
+            AssertResult<Swell>(0, HitResult.IgnoreMiss);
+        }
+
+        [Test]
+        public void TestHitNoneSwell()
+        {
+            const double hit_time = 1000;
+
+            Swell swell = new Swell
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                RequiredHits = 10
+            };
+
+            List<ReplayFrame> frames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2001),
+            };
+
+            PerformTest(frames, CreateBeatmap(swell));
+
+            AssertJudgementCount(11);
+
+            for (int i = 0; i < swell.RequiredHits; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreMiss);
+
+            AssertResult<Swell>(0, HitResult.IgnoreMiss);
+
+            AddAssert("all tick offsets are 0", () => JudgementResults.Where(r => r.HitObject is SwellTick).All(r => r.TimeOffset == 0));
+        }
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModPerfect.cs

@@ -25,11 +25,11 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods
 
         [TestCase(false)]
         [TestCase(true)]
-        public void TestDrumRoll(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new DrumRoll { StartTime = 1000, EndTime = 3000 }), shouldMiss);
+        public void TestDrumRoll(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new DrumRoll { StartTime = 1000, EndTime = 3000 }, false), shouldMiss);
 
         [TestCase(false)]
         [TestCase(true)]
-        public void TestSwell(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Swell { StartTime = 1000, EndTime = 3000 }), shouldMiss);
+        public void TestSwell(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Swell { StartTime = 1000, EndTime = 3000 }, false), shouldMiss);
 
         private class TestTaikoRuleset : TaikoRuleset
         {

osu.Game.Rulesets.Taiko.Tests/Skinning/TestSceneDrawableTaikoMascot.cs

@@ -112,7 +112,6 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
 
             assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Idle);
             assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Miss }, TaikoMascotAnimationState.Fail);
-            assertStateAfterResult(new JudgementResult(new DrumRoll(), new TaikoDrumRollJudgement()) { Type = HitResult.Great }, TaikoMascotAnimationState.Idle);
             assertStateAfterResult(new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Ok }, TaikoMascotAnimationState.Idle);
         }
 

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

@@ -1,38 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-#nullable disable
-
-using System.Linq;
-using NUnit.Framework;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Taiko.Objects;
-
-namespace osu.Game.Rulesets.Taiko.Tests
-{
-    public class TestSceneDrumRollJudgements : TestSceneTaikoPlayer
-    {
-        [Test]
-        public void TestStrongDrumRollFullyJudgedOnKilled()
-        {
-            AddUntilStep("gameplay finished", () => Player.ScoreProcessor.HasCompleted.Value);
-            AddAssert("all judgements are misses", () => Player.Results.All(r => r.Type == r.Judgement.MinResult));
-        }
-
-        protected override bool Autoplay => false;
-
-        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap<TaikoHitObject>
-        {
-            BeatmapInfo = { Ruleset = new TaikoRuleset().RulesetInfo },
-            HitObjects =
-            {
-                new DrumRoll
-                {
-                    StartTime = 1000,
-                    Duration = 1000,
-                    IsStrong = true
-                }
-            }
-        };
-    }
-}

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

@@ -1,42 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-#nullable disable
-
-using System.Linq;
-using NUnit.Framework;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Taiko.Objects;
-
-namespace osu.Game.Rulesets.Taiko.Tests
-{
-    public class TestSceneSwellJudgements : TestSceneTaikoPlayer
-    {
-        [Test]
-        public void TestZeroTickTimeOffsets()
-        {
-            AddUntilStep("gameplay finished", () => Player.ScoreProcessor.HasCompleted.Value);
-            AddAssert("all tick offsets are 0", () => Player.Results.Where(r => r.HitObject is SwellTick).All(r => r.TimeOffset == 0));
-        }
-
-        protected override bool Autoplay => true;
-
-        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
-        {
-            var beatmap = new Beatmap<TaikoHitObject>
-            {
-                BeatmapInfo = { Ruleset = new TaikoRuleset().RulesetInfo },
-                HitObjects =
-                {
-                    new Swell
-                    {
-                        StartTime = 1000,
-                        Duration = 1000,
-                    }
-                }
-            };
-
-            return beatmap;
-        }
-    }
-}

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

@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             };
 
         [Test]
-        public void TestSpinnerDoesFail()
+        public void TestSwellDoesNotFail()
         {
             bool judged = false;
             AddStep("Setup judgements", () =>
@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
                 Player.ScoreProcessor.NewJudgement += _ => judged = true;
             });
             AddUntilStep("swell judged", () => judged);
-            AddAssert("failed", () => Player.GameplayState.HasFailed);
+            AddAssert("not failed", () => !Player.GameplayState.HasFailed);
         }
     }
 }

osu.Game.Rulesets.Taiko/Judgements/TaikoDrumRollJudgement.cs

@@ -1,25 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-#nullable disable
-
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Taiko.Judgements
-{
-    public class TaikoDrumRollJudgement : TaikoJudgement
-    {
-        protected override double HealthIncreaseFor(HitResult result)
-        {
-            // Drum rolls can be ignored with no health penalty
-            switch (result)
-            {
-                case HitResult.Miss:
-                    return 0;
-
-                default:
-                    return base.HealthIncreaseFor(result);
-            }
-        }
-    }
-}

osu.Game.Rulesets.Taiko/Judgements/TaikoDrumRollTickJudgement.cs

@@ -9,18 +9,8 @@ namespace osu.Game.Rulesets.Taiko.Judgements
 {
     public class TaikoDrumRollTickJudgement : TaikoJudgement
     {
-        public override HitResult MaxResult => HitResult.SmallTickHit;
+        public override HitResult MaxResult => HitResult.SmallBonus;
 
-        protected override double HealthIncreaseFor(HitResult result)
-        {
-            switch (result)
-            {
-                case HitResult.SmallTickHit:
-                    return 0.15;
-
-                default:
-                    return 0;
-            }
-        }
+        protected override double HealthIncreaseFor(HitResult result) => 0;
     }
 }

osu.Game.Rulesets.Taiko/Judgements/TaikoStrongJudgement.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Taiko.Judgements
 {
     public class TaikoStrongJudgement : TaikoJudgement
     {
-        public override HitResult MaxResult => HitResult.SmallBonus;
+        public override HitResult MaxResult => HitResult.LargeBonus;
 
         // MainObject already changes the HP
         protected override double HealthIncreaseFor(HitResult result) => 0;

osu.Game.Rulesets.Taiko/Judgements/TaikoSwellJudgement.cs

@@ -9,11 +9,13 @@ namespace osu.Game.Rulesets.Taiko.Judgements
 {
     public class TaikoSwellJudgement : TaikoJudgement
     {
+        public override HitResult MaxResult => HitResult.LargeBonus;
+
         protected override double HealthIncreaseFor(HitResult result)
         {
             switch (result)
             {
-                case HitResult.Miss:
+                case HitResult.IgnoreMiss:
                     return -0.65;
 
                 default:

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

@@ -4,7 +4,6 @@
 #nullable disable
 
 using System;
-using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Utils;
@@ -17,7 +16,6 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Skinning;
 using osuTK;
@@ -43,6 +41,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         private Color4 colourIdle;
         private Color4 colourEngaged;
 
+        public override bool DisplayResult => false;
+
         public DrawableDrumRoll()
             : this(null)
         {
@@ -143,14 +143,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             if (timeOffset < 0)
                 return;
 
-            int countHit = NestedHitObjects.Count(o => o.IsHit);
-
-            if (countHit >= HitObject.RequiredGoodHits)
-            {
-                ApplyResult(r => r.Type = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Ok);
-            }
-            else
-                ApplyResult(r => r.Type = r.Judgement.MinResult);
+            ApplyResult(r => r.Type = r.Judgement.MaxResult);
         }
 
         protected override void UpdateHitStateTransforms(ArmedState state)

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

@@ -16,7 +16,6 @@ using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Skinning;
 
@@ -39,6 +38,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         private readonly CircularContainer targetRing;
         private readonly CircularContainer expandingRing;
 
+        public override bool DisplayResult => false;
+
         public DrawableSwell()
             : this(null)
         {
@@ -201,7 +202,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 expandingRing.ScaleTo(1f + Math.Min(target_ring_scale - 1f, (target_ring_scale - 1f) * completion * 1.3f), 260, Easing.OutQuint);
 
                 if (numHits == HitObject.RequiredHits)
-                    ApplyResult(r => r.Type = HitResult.Great);
+                    ApplyResult(r => r.Type = r.Judgement.MaxResult);
             }
             else
             {
@@ -222,7 +223,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                         tick.TriggerResult(false);
                 }
 
-                ApplyResult(r => r.Type = numHits > HitObject.RequiredHits / 2 ? HitResult.Ok : r.Judgement.MinResult);
+                ApplyResult(r => r.Type = numHits == HitObject.RequiredHits ? r.Judgement.MaxResult : r.Judgement.MinResult);
             }
         }
 

osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs

@@ -4,7 +4,6 @@
 #nullable disable
 
 using osu.Game.Rulesets.Objects.Types;
-using System;
 using System.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -12,7 +11,6 @@ using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Taiko.Judgements;
 using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.Objects
@@ -42,24 +40,12 @@ namespace osu.Game.Rulesets.Taiko.Objects
         /// </summary>
         public int TickRate = 1;
 
-        /// <summary>
-        /// Number of drum roll ticks required for a "Good" hit.
-        /// </summary>
-        public double RequiredGoodHits { get; protected set; }
-
-        /// <summary>
-        /// Number of drum roll ticks required for a "Great" hit.
-        /// </summary>
-        public double RequiredGreatHits { get; protected set; }
-
         /// <summary>
         /// The length (in milliseconds) between ticks of this drumroll.
         /// <para>Half of this value is the hit window of the ticks.</para>
         /// </summary>
         private double tickSpacing = 100;
 
-        private float overallDifficulty = BeatmapDifficulty.DEFAULT_DIFFICULTY;
-
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, IBeatmapDifficultyInfo difficulty)
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
@@ -70,16 +56,12 @@ namespace osu.Game.Rulesets.Taiko.Objects
             Velocity = scoringDistance / timingPoint.BeatLength;
 
             tickSpacing = timingPoint.BeatLength / TickRate;
-            overallDifficulty = difficulty.OverallDifficulty;
         }
 
         protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
         {
             createTicks(cancellationToken);
 
-            RequiredGoodHits = NestedHitObjects.Count * Math.Min(0.15, 0.05 + 0.10 / 6 * overallDifficulty);
-            RequiredGreatHits = NestedHitObjects.Count * Math.Min(0.30, 0.10 + 0.20 / 6 * overallDifficulty);
-
             base.CreateNestedHitObjects(cancellationToken);
         }
 
@@ -106,7 +88,7 @@ namespace osu.Game.Rulesets.Taiko.Objects
             }
         }
 
-        public override Judgement CreateJudgement() => new TaikoDrumRollJudgement();
+        public override Judgement CreateJudgement() => new IgnoreJudgement();
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
 
@@ -114,6 +96,8 @@ namespace osu.Game.Rulesets.Taiko.Objects
 
         public class StrongNestedHit : StrongNestedHitObject
         {
+            // The strong hit of the drum roll doesn't actually provide any score.
+            public override Judgement CreateJudgement() => new IgnoreJudgement();
         }
 
         #region LegacyBeatmapEncoder

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -199,11 +199,8 @@ namespace osu.Game.Rulesets.Taiko
         {
             switch (result)
             {
-                case HitResult.SmallTickHit:
-                    return "drum tick";
-
                 case HitResult.SmallBonus:
-                    return "strong bonus";
+                    return "bonus";
             }
 
             return base.GetDisplayNameForHitResult(result);

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

@@ -317,6 +317,9 @@ namespace osu.Game.Rulesets.Taiko.UI
                     break;
 
                 default:
+                    if (!result.Type.IsScorable())
+                        break;
+
                     judgementContainer.Add(judgementPools[result.Type].Get(j =>
                     {
                         j.Apply(result, judgedObject);

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

@@ -67,6 +67,24 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        [Test]
+        public void TestDecodeTaikoReplay()
+        {
+            var decoder = new TestLegacyScoreDecoder();
+
+            using (var resourceStream = TestResources.OpenResource("Replays/taiko-replay.osr"))
+            {
+                var score = decoder.Parse(resourceStream);
+
+                Assert.AreEqual(1, score.ScoreInfo.Ruleset.OnlineID);
+                Assert.AreEqual(4, score.ScoreInfo.Statistics[HitResult.Great]);
+                Assert.AreEqual(2, score.ScoreInfo.Statistics[HitResult.LargeBonus]);
+                Assert.AreEqual(4, score.ScoreInfo.MaxCombo);
+
+                Assert.That(score.Replay.Frames, Is.Not.Empty);
+            }
+        }
+
         [TestCase(3, true)]
         [TestCase(6, false)]
         [TestCase(LegacyBeatmapDecoder.LATEST_VERSION, false)]

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

@@ -117,6 +117,26 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        [Test]
+        public void TestEarliestStartTimeWithLoopAlphas()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+
+            using (var resStream = TestResources.OpenResource("loop-containing-earlier-non-zero-fade.osb"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var storyboard = decoder.Decode(stream);
+
+                StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
+                Assert.AreEqual(2, background.Elements.Count);
+
+                Assert.AreEqual(1000, background.Elements[0].StartTime);
+                Assert.AreEqual(1000, background.Elements[1].StartTime);
+
+                Assert.AreEqual(1000, storyboard.EarliestEventTime);
+            }
+        }
+
         [Test]
         public void TestDecodeVariableWithSuffix()
         {

osu.Game.Tests/Resources/loop-containing-earlier-non-zero-fade.osb

@@ -0,0 +1,14 @@
+osu file format v14
+
+[Events]
+//Storyboard Layer 0 (Background)
+Sprite,Background,TopCentre,"img.jpg",320,240
+ L,1000,1
+  F,0,0,,1       // fade inside a loop with non-zero alpha and an earlier start time should be the true start time..
+ F,0,2000,,0     // ..not a zero alpha fade with a later start time
+
+Sprite,Background,TopCentre,"img.jpg",320,240
+ L,2000,1
+  F,0,0,24,0     // fade inside a loop with zero alpha but later start time than the top-level zero alpha start time.
+  F,0,24,48,1
+ F,0,1000,,1     // ..so this should be the true start time

osu.Game.Tests/Visual/Editing/TestSceneDifficultyDelete.cs

@@ -0,0 +1,85 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Beatmaps.IO;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneDifficultyDelete : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+        protected override bool IsolateSavingFromDatabase => false;
+
+        [Resolved]
+        private OsuGameBase game { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapManager beatmaps { get; set; } = null!;
+
+        private BeatmapSetInfo importedBeatmapSet = null!;
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null!)
+            => beatmaps.GetWorkingBeatmap(importedBeatmapSet.Beatmaps.First());
+
+        public override void SetUpSteps()
+        {
+            AddStep("import test beatmap", () => importedBeatmapSet = BeatmapImportHelper.LoadOszIntoOsu(game, virtualTrack: true).GetResultSafely());
+            base.SetUpSteps();
+        }
+
+        [Test]
+        public void TestDeleteDifficulties()
+        {
+            Guid deletedDifficultyID = Guid.Empty;
+            int countBeforeDeletion = 0;
+            string beatmapSetHashBefore = string.Empty;
+
+            for (int i = 0; i < 12; i++)
+            {
+                // Will be reloaded after each deletion.
+                AddUntilStep("wait for editor to load", () => Editor?.ReadyForUse == true);
+
+                AddStep("store selected difficulty", () =>
+                {
+                    deletedDifficultyID = EditorBeatmap.BeatmapInfo.ID;
+                    countBeforeDeletion = Beatmap.Value.BeatmapSetInfo.Beatmaps.Count;
+                    beatmapSetHashBefore = Beatmap.Value.BeatmapSetInfo.Hash;
+                });
+
+                AddStep("click File", () => this.ChildrenOfType<DrawableOsuMenuItem>().First().TriggerClick());
+
+                if (i == 11)
+                {
+                    // last difficulty shouldn't be able to be deleted.
+                    AddAssert("Delete menu item disabled", () => getDeleteMenuItem().Item.Action.Disabled);
+                }
+                else
+                {
+                    AddStep("click delete", () => getDeleteMenuItem().TriggerClick());
+                    AddUntilStep("wait for dialog", () => DialogOverlay.CurrentDialog != null);
+                    AddStep("confirm", () => InputManager.Key(Key.Number1));
+
+                    AddAssert($"difficulty {i} is deleted", () => Beatmap.Value.BeatmapSetInfo.Beatmaps.Select(b => b.ID), () => Does.Not.Contain(deletedDifficultyID));
+                    AddAssert("count decreased by one", () => Beatmap.Value.BeatmapSetInfo.Beatmaps.Count, () => Is.EqualTo(countBeforeDeletion - 1));
+                    AddAssert("set hash changed", () => Beatmap.Value.BeatmapSetInfo.Hash, () => Is.Not.EqualTo(beatmapSetHashBefore));
+                }
+            }
+        }
+
+        private DrawableOsuMenuItem getDeleteMenuItem() => this.ChildrenOfType<DrawableOsuMenuItem>()
+                                                               .Single(item => item.ChildrenOfType<SpriteText>().Any(text => text.Text.ToString().StartsWith("Delete", StringComparison.Ordinal)));
+    }
+}

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

@@ -1,8 +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.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -73,6 +71,17 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("origin flipped", () => sprites.All(s => s.Origin == Anchor.BottomRight));
         }
 
+        [Test]
+        public void TestZeroScale()
+        {
+            const string lookup_name = "hitcircleoverlay";
+
+            AddStep("allow skin lookup", () => storyboard.UseSkinSprites = true);
+            AddStep("create sprites", () => SetContents(_ => createSprite(lookup_name, Anchor.TopLeft, Vector2.Zero)));
+            AddStep("scale sprite", () => sprites.ForEach(s => s.VectorScale = new Vector2(0, 1)));
+            AddAssert("zero width", () => sprites.All(s => s.ScreenSpaceDrawQuad.Width == 0));
+        }
+
         [Test]
         public void TestNegativeScale()
         {

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

@@ -66,18 +66,20 @@ namespace osu.Game.Tests.Visual.Gameplay
         [TestCase(-10000, -10000, true)]
         public void TestStoryboardProducesCorrectStartTimeFadeInAfterOtherEvents(double firstStoryboardEvent, double expectedStartTime, bool addEventToLoop)
         {
+            const double loop_start_time = -20000;
+
             var storyboard = new Storyboard();
 
             var sprite = new StoryboardSprite("unknown", Anchor.TopLeft, Vector2.Zero);
 
             // these should be ignored as we have an alpha visibility blocker proceeding this command.
-            sprite.TimelineGroup.Scale.Add(Easing.None, -20000, -18000, 0, 1);
-            var loopGroup = sprite.AddLoop(-20000, 50);
-            loopGroup.Scale.Add(Easing.None, -20000, -18000, 0, 1);
+            sprite.TimelineGroup.Scale.Add(Easing.None, loop_start_time, -18000, 0, 1);
+            var loopGroup = sprite.AddLoop(loop_start_time, 50);
+            loopGroup.Scale.Add(Easing.None, loop_start_time, -18000, 0, 1);
 
             var target = addEventToLoop ? loopGroup : sprite.TimelineGroup;
-            double targetTime = addEventToLoop ? 20000 : 0;
-            target.Alpha.Add(Easing.None, targetTime + firstStoryboardEvent, targetTime + firstStoryboardEvent + 500, 0, 1);
+            double loopRelativeOffset = addEventToLoop ? -loop_start_time : 0;
+            target.Alpha.Add(Easing.None, loopRelativeOffset + firstStoryboardEvent, loopRelativeOffset + firstStoryboardEvent + 500, 0, 1);
 
             // these should be ignored due to being in the future.
             sprite.TimelineGroup.Alpha.Add(Easing.None, 18000, 20000, 0, 1);

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

@@ -301,7 +301,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddAssert("check for notification", () => notificationOverlay.UnreadCount.Value, () => Is.EqualTo(1));
 
-            clickNotificationIfAny();
+            clickNotification();
 
             AddAssert("check " + volumeName, assert);
 
@@ -370,8 +370,12 @@ namespace osu.Game.Tests.Visual.Gameplay
                 batteryInfo.SetChargeLevel(chargeLevel);
             }));
             AddUntilStep("wait for player", () => player?.LoadState == LoadState.Ready);
-            AddAssert($"notification {(shouldWarn ? "triggered" : "not triggered")}", () => notificationOverlay.UnreadCount.Value == (shouldWarn ? 1 : 0));
-            clickNotificationIfAny();
+
+            if (shouldWarn)
+                clickNotification();
+            else
+                AddAssert("notification not triggered", () => notificationOverlay.UnreadCount.Value == 0);
+
             AddUntilStep("wait for player load", () => player.IsLoaded);
         }
 
@@ -436,9 +440,13 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("skip button not visible", () => !checkSkipButtonVisible());
         }
 
-        private void clickNotificationIfAny()
+        private void clickNotification()
         {
-            AddStep("click notification", () => notificationOverlay.ChildrenOfType<Notification>().FirstOrDefault()?.TriggerClick());
+            Notification notification = null;
+
+            AddUntilStep("wait for notification", () => (notification = notificationOverlay.ChildrenOfType<Notification>().FirstOrDefault()) != null);
+            AddStep("open notification overlay", () => notificationOverlay.Show());
+            AddStep("click notification", () => notification.TriggerClick());
         }
 
         private EpilepsyWarning getWarning() => loader.ChildrenOfType<EpilepsyWarning>().SingleOrDefault();

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

@@ -1,8 +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.
 
-#nullable disable
-
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -24,8 +22,9 @@ namespace osu.Game.Tests.Visual.Gameplay
     [TestFixture]
     public class TestSceneStoryboard : OsuTestScene
     {
-        private Container<DrawableStoryboard> storyboardContainer;
-        private DrawableStoryboard storyboard;
+        private Container<DrawableStoryboard> storyboardContainer = null!;
+
+        private DrawableStoryboard? storyboard;
 
         [Test]
         public void TestStoryboard()
@@ -40,7 +39,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestStoryboardMissingVideo()
         {
-            AddStep("Load storyboard with missing video", loadStoryboardNoVideo);
+            AddStep("Load storyboard with missing video", () => loadStoryboard("storyboard_no_video.osu"));
         }
 
         [BackgroundDependencyLoader]
@@ -77,18 +76,18 @@ namespace osu.Game.Tests.Visual.Gameplay
             Beatmap.BindValueChanged(beatmapChanged, true);
         }
 
-        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e) => loadStoryboard(e.NewValue);
+        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e) => loadStoryboard(e.NewValue.Storyboard);
 
         private void restart()
         {
             var track = Beatmap.Value.Track;
 
             track.Reset();
-            loadStoryboard(Beatmap.Value);
+            loadStoryboard(Beatmap.Value.Storyboard);
             track.Start();
         }
 
-        private void loadStoryboard(IWorkingBeatmap working)
+        private void loadStoryboard(Storyboard toLoad)
         {
             if (storyboard != null)
                 storyboardContainer.Remove(storyboard, true);
@@ -96,34 +95,25 @@ namespace osu.Game.Tests.Visual.Gameplay
             var decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true };
             storyboardContainer.Clock = decoupledClock;
 
-            storyboard = working.Storyboard.CreateDrawable(SelectedMods.Value);
+            storyboard = toLoad.CreateDrawable(SelectedMods.Value);
             storyboard.Passing = false;
 
-            storyboardContainer.Add(storyboard);
-            decoupledClock.ChangeSource(working.Track);
-        }
-
-        private void loadStoryboardNoVideo()
-        {
-            if (storyboard != null)
-                storyboardContainer.Remove(storyboard, true);
-
-            var decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true };
-            storyboardContainer.Clock = decoupledClock;
-
-            Storyboard sb;
-
-            using (var str = TestResources.OpenResource("storyboard_no_video.osu"))
-            using (var bfr = new LineBufferedReader(str))
-            {
-                var decoder = new LegacyStoryboardDecoder();
-                sb = decoder.Decode(bfr);
-            }
-
-            storyboard = sb.CreateDrawable(SelectedMods.Value);
-
             storyboardContainer.Add(storyboard);
             decoupledClock.ChangeSource(Beatmap.Value.Track);
         }
+
+        private void loadStoryboard(string filename)
+        {
+            Storyboard loaded;
+
+            using (var str = TestResources.OpenResource(filename))
+            using (var bfr = new LineBufferedReader(str))
+            {
+                var decoder = new LegacyStoryboardDecoder();
+                loaded = decoder.Decode(bfr);
+            }
+
+            loadStoryboard(loaded);
+        }
     }
 }

osu.Game.Tests/Visual/Navigation/TestSceneStartupImport.cs

@@ -1,8 +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.
 
-#nullable disable
-
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
@@ -13,7 +11,7 @@ namespace osu.Game.Tests.Visual.Navigation
 {
     public class TestSceneStartupImport : OsuGameTestScene
     {
-        private string importFilename;
+        private string? importFilename;
 
         protected override TestOsuGame CreateTestGame() => new TestOsuGame(LocalStorage, API, new[] { importFilename });
 

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

@@ -173,7 +173,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                     if (isIterating)
                         AddUntilStep("selection changed", () => !carousel.SelectedBeatmapInfo?.Equals(selection) == true);
                     else
-                        AddUntilStep("selection not changed", () => carousel.SelectedBeatmapInfo.Equals(selection));
+                        AddUntilStep("selection not changed", () => carousel.SelectedBeatmapInfo?.Equals(selection) == true);
                 }
             }
         }
@@ -382,7 +382,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             // buffer the selection
             setSelected(3, 2);
 
-            AddStep("get search text", () => searchText = carousel.SelectedBeatmapSet.Metadata.Title);
+            AddStep("get search text", () => searchText = carousel.SelectedBeatmapSet!.Metadata.Title);
 
             setSelected(1, 3);
 
@@ -701,7 +701,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             setSelected(2, 1);
             AddAssert("Selection is non-null", () => currentSelection != null);
 
-            AddStep("Remove selected", () => carousel.RemoveBeatmapSet(carousel.SelectedBeatmapSet));
+            AddStep("Remove selected", () => carousel.RemoveBeatmapSet(carousel.SelectedBeatmapSet!));
             waitForSelection(2);
 
             AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
@@ -804,7 +804,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("filter to ruleset 0", () =>
                 carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) }, false));
             AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testMixed.Beatmaps[1], false));
-            AddAssert("unfiltered beatmap not selected", () => carousel.SelectedBeatmapInfo.Ruleset.OnlineID == 0);
+            AddAssert("unfiltered beatmap not selected", () => carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 0);
 
             AddStep("remove mixed set", () =>
             {
@@ -854,7 +854,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 AddStep("Restore no filter", () =>
                 {
                     carousel.Filter(new FilterCriteria(), false);
-                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
+                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet!.ID);
                 });
             }
 
@@ -899,10 +899,10 @@ namespace osu.Game.Tests.Visual.SongSelect
                 AddStep("Restore different ruleset filter", () =>
                 {
                     carousel.Filter(new FilterCriteria { Ruleset = rulesets.GetRuleset(1) }, false);
-                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
+                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet!.ID);
                 });
 
-                AddAssert("selection changed", () => !carousel.SelectedBeatmapInfo.Equals(manySets.First().Beatmaps.First()));
+                AddAssert("selection changed", () => !carousel.SelectedBeatmapInfo!.Equals(manySets.First().Beatmaps.First()));
             }
 
             AddAssert("Selection was random", () => eagerSelectedIDs.Count > 2);

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

@@ -7,6 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
@@ -23,9 +24,12 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private SpriteText displayedCount = null!;
 
+        public double TimeToCompleteProgress { get; set; } = 2000;
+
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
+            TimeToCompleteProgress = 2000;
             progressingNotifications.Clear();
 
             Content.Children = new Drawable[]
@@ -41,10 +45,36 @@ namespace osu.Game.Tests.Visual.UserInterface
             notificationOverlay.UnreadCount.ValueChanged += count => { displayedCount.Text = $"displayed count: {count.NewValue}"; };
         });
 
+        [Test]
+        public void TestPresence()
+        {
+            AddAssert("tray not present", () => !notificationOverlay.ChildrenOfType<NotificationOverlayToastTray>().Single().IsPresent);
+            AddAssert("overlay not present", () => !notificationOverlay.IsPresent);
+
+            AddStep(@"post notification", sendBackgroundNotification);
+
+            AddUntilStep("wait tray not present", () => !notificationOverlay.ChildrenOfType<NotificationOverlayToastTray>().Single().IsPresent);
+            AddUntilStep("wait overlay not present", () => !notificationOverlay.IsPresent);
+        }
+
+        [Test]
+        public void TestPresenceWithManualDismiss()
+        {
+            AddAssert("tray not present", () => !notificationOverlay.ChildrenOfType<NotificationOverlayToastTray>().Single().IsPresent);
+            AddAssert("overlay not present", () => !notificationOverlay.IsPresent);
+
+            AddStep(@"post notification", sendBackgroundNotification);
+            AddStep("click notification", () => notificationOverlay.ChildrenOfType<Notification>().Single().TriggerClick());
+
+            AddUntilStep("wait tray not present", () => !notificationOverlay.ChildrenOfType<NotificationOverlayToastTray>().Single().IsPresent);
+            AddUntilStep("wait overlay not present", () => !notificationOverlay.IsPresent);
+        }
+
         [Test]
         public void TestCompleteProgress()
         {
             ProgressNotification notification = null!;
+
             AddStep("add progress notification", () =>
             {
                 notification = new ProgressNotification
@@ -57,6 +87,31 @@ namespace osu.Game.Tests.Visual.UserInterface
             });
 
             AddUntilStep("wait completion", () => notification.State == ProgressNotificationState.Completed);
+
+            AddAssert("Completion toast shown", () => notificationOverlay.ToastCount == 1);
+            AddUntilStep("wait forwarded", () => notificationOverlay.ToastCount == 0);
+        }
+
+        [Test]
+        public void TestCompleteProgressSlow()
+        {
+            ProgressNotification notification = null!;
+
+            AddStep("Set progress slow", () => TimeToCompleteProgress *= 2);
+            AddStep("add progress notification", () =>
+            {
+                notification = new ProgressNotification
+                {
+                    Text = @"Uploading to BSS...",
+                    CompletionText = "Uploaded to BSS!",
+                };
+                notificationOverlay.Post(notification);
+                progressingNotifications.Add(notification);
+            });
+
+            AddUntilStep("wait completion", () => notification.State == ProgressNotificationState.Completed);
+
+            AddAssert("Completion toast shown", () => notificationOverlay.ToastCount == 1);
         }
 
         [Test]
@@ -177,7 +232,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             foreach (var n in progressingNotifications.FindAll(n => n.State == ProgressNotificationState.Active))
             {
                 if (n.Progress < 1)
-                    n.Progress += (float)(Time.Elapsed / 2000);
+                    n.Progress += (float)(Time.Elapsed / TimeToCompleteProgress);
                 else
                     n.State = ProgressNotificationState.Completed;
             }

osu.Game.Tournament/Screens/Gameplay/Components/TeamScoreDisplay.cs

@@ -25,6 +25,7 @@ namespace osu.Game.Tournament.Screens.Gameplay.Components
 
         public bool ShowScore
         {
+            get => teamDisplay.ShowScore;
             set => teamDisplay.ShowScore = value;
         }
 
@@ -92,10 +93,14 @@ namespace osu.Game.Tournament.Screens.Gameplay.Components
 
         private void teamChanged(ValueChangedEvent<TournamentTeam> team)
         {
+            bool wasShowingScores = teamDisplay?.ShowScore ?? false;
+
             InternalChildren = new Drawable[]
             {
                 teamDisplay = new TeamDisplay(team.NewValue, teamColour, currentTeamScore, currentMatch.Value?.PointsToWin ?? 0),
             };
+
+            teamDisplay.ShowScore = wasShowingScores;
         }
     }
 }

osu.Game.Tournament/Screens/Ladder/Components/DrawableTournamentMatch.cs

@@ -280,7 +280,7 @@ namespace osu.Game.Tournament.Screens.Ladder.Components
 
         protected override bool OnClick(ClickEvent e)
         {
-            if (editorInfo == null || Match is ConditionalTournamentMatch)
+            if (editorInfo == null || Match is ConditionalTournamentMatch || e.Button != MouseButton.Left)
                 return false;
 
             Selected = true;

osu.Game.Tournament/Screens/MapPool/MapPoolScreen.cs

@@ -46,7 +46,10 @@ namespace osu.Game.Tournament.Screens.MapPool
                     Loop = true,
                     RelativeSizeAxes = Axes.Both,
                 },
-                new MatchHeader(),
+                new MatchHeader
+                {
+                    ShowScores = true,
+                },
                 mapFlows = new FillFlowContainer<FillFlowContainer<TournamentBeatmapPanel>>
                 {
                     Y = 160,

osu.Game/Beatmaps/BeatmapManager.cs

@@ -319,8 +319,7 @@ namespace osu.Game.Beatmaps
 
                 AddFile(setInfo, stream, createBeatmapFilenameFromMetadata(beatmapInfo));
 
-                setInfo.Hash = beatmapImporter.ComputeHash(setInfo);
-                setInfo.Status = BeatmapOnlineStatus.LocallyModified;
+                updateHashAndMarkDirty(setInfo);
 
                 Realm.Write(r =>
                 {
@@ -363,6 +362,33 @@ namespace osu.Game.Beatmaps
             });
         }
 
+        /// <summary>
+        /// Delete a beatmap difficulty immediately.
+        /// </summary>
+        /// <remarks>
+        /// There's no undoing this operation, as we don't have a soft-deletion flag on <see cref="BeatmapInfo"/>.
+        /// This may be a future consideration if there's a user requirement for undeleting support.
+        /// </remarks>
+        public void DeleteDifficultyImmediately(BeatmapInfo beatmapInfo)
+        {
+            Realm.Write(r =>
+            {
+                if (!beatmapInfo.IsManaged)
+                    beatmapInfo = r.Find<BeatmapInfo>(beatmapInfo.ID);
+
+                Debug.Assert(beatmapInfo.BeatmapSet != null);
+                Debug.Assert(beatmapInfo.File != null);
+
+                var setInfo = beatmapInfo.BeatmapSet;
+
+                DeleteFile(setInfo, beatmapInfo.File);
+                setInfo.Beatmaps.Remove(beatmapInfo);
+
+                updateHashAndMarkDirty(setInfo);
+                workingBeatmapCache.Invalidate(setInfo);
+            });
+        }
+
         /// <summary>
         /// Delete videos from a list of beatmaps.
         /// This will post notifications tracking progress.
@@ -416,6 +442,12 @@ namespace osu.Game.Beatmaps
         public Task<Live<BeatmapSetInfo>?> ImportAsUpdate(ProgressNotification notification, ImportTask importTask, BeatmapSetInfo original) =>
             beatmapImporter.ImportAsUpdate(notification, importTask, original);
 
+        private void updateHashAndMarkDirty(BeatmapSetInfo setInfo)
+        {
+            setInfo.Hash = beatmapImporter.ComputeHash(setInfo);
+            setInfo.Status = BeatmapOnlineStatus.LocallyModified;
+        }
+
         #region Implementation of ICanAcceptFiles
 
         public Task Import(params string[] paths) => beatmapImporter.Import(paths);

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -88,6 +88,7 @@ namespace osu.Game.Graphics.UserInterface
                 if (Text.Length > 0)
                 {
                     Text = string.Empty;
+                    PlayFeedbackSample(FeedbackSampleType.TextRemove);
                     return true;
                 }
             }

osu.Game/Graphics/UserInterface/OsuTextBox.cs

@@ -47,7 +47,7 @@ namespace osu.Game.Graphics.UserInterface
         private bool selectionStarted;
         private double sampleLastPlaybackTime;
 
-        private enum FeedbackSampleType
+        protected enum FeedbackSampleType
         {
             TextAdd,
             TextAddCaps,
@@ -117,30 +117,30 @@ namespace osu.Game.Graphics.UserInterface
                 return;
 
             if (added.Any(char.IsUpper) && AllowUniqueCharacterSamples)
-                playSample(FeedbackSampleType.TextAddCaps);
+                PlayFeedbackSample(FeedbackSampleType.TextAddCaps);
             else
-                playSample(FeedbackSampleType.TextAdd);
+                PlayFeedbackSample(FeedbackSampleType.TextAdd);
         }
 
         protected override void OnUserTextRemoved(string removed)
         {
             base.OnUserTextRemoved(removed);
 
-            playSample(FeedbackSampleType.TextRemove);
+            PlayFeedbackSample(FeedbackSampleType.TextRemove);
         }
 
         protected override void NotifyInputError()
         {
             base.NotifyInputError();
 
-            playSample(FeedbackSampleType.TextInvalid);
+            PlayFeedbackSample(FeedbackSampleType.TextInvalid);
         }
 
         protected override void OnTextCommitted(bool textChanged)
         {
             base.OnTextCommitted(textChanged);
 
-            playSample(FeedbackSampleType.TextConfirm);
+            PlayFeedbackSample(FeedbackSampleType.TextConfirm);
         }
 
         protected override void OnCaretMoved(bool selecting)
@@ -148,7 +148,7 @@ namespace osu.Game.Graphics.UserInterface
             base.OnCaretMoved(selecting);
 
             if (!selecting)
-                playSample(FeedbackSampleType.CaretMove);
+                PlayFeedbackSample(FeedbackSampleType.CaretMove);
         }
 
         protected override void OnTextSelectionChanged(TextSelectionType selectionType)
@@ -158,15 +158,15 @@ namespace osu.Game.Graphics.UserInterface
             switch (selectionType)
             {
                 case TextSelectionType.Character:
-                    playSample(FeedbackSampleType.SelectCharacter);
+                    PlayFeedbackSample(FeedbackSampleType.SelectCharacter);
                     break;
 
                 case TextSelectionType.Word:
-                    playSample(selectionStarted ? FeedbackSampleType.SelectCharacter : FeedbackSampleType.SelectWord);
+                    PlayFeedbackSample(selectionStarted ? FeedbackSampleType.SelectCharacter : FeedbackSampleType.SelectWord);
                     break;
 
                 case TextSelectionType.All:
-                    playSample(FeedbackSampleType.SelectAll);
+                    PlayFeedbackSample(FeedbackSampleType.SelectAll);
                     break;
             }
 
@@ -179,7 +179,7 @@ namespace osu.Game.Graphics.UserInterface
 
             if (!selectionStarted) return;
 
-            playSample(FeedbackSampleType.Deselect);
+            PlayFeedbackSample(FeedbackSampleType.Deselect);
 
             selectionStarted = false;
         }
@@ -198,13 +198,13 @@ namespace osu.Game.Graphics.UserInterface
 
                     case 1:
                         // composition probably ended by pressing backspace, or was cancelled.
-                        playSample(FeedbackSampleType.TextRemove);
+                        PlayFeedbackSample(FeedbackSampleType.TextRemove);
                         return;
 
                     default:
                         // longer text removed, composition ended because it was cancelled.
                         // could be a different sample if desired.
-                        playSample(FeedbackSampleType.TextRemove);
+                        PlayFeedbackSample(FeedbackSampleType.TextRemove);
                         return;
                 }
             }
@@ -212,7 +212,7 @@ namespace osu.Game.Graphics.UserInterface
             if (addedTextLength > 0)
             {
                 // some text was added, probably due to typing new text or by changing the candidate.
-                playSample(FeedbackSampleType.TextAdd);
+                PlayFeedbackSample(FeedbackSampleType.TextAdd);
                 return;
             }
 
@@ -220,14 +220,14 @@ namespace osu.Game.Graphics.UserInterface
             {
                 // text was probably removed by backspacing.
                 // it's also possible that a candidate that only removed text was changed to.
-                playSample(FeedbackSampleType.TextRemove);
+                PlayFeedbackSample(FeedbackSampleType.TextRemove);
                 return;
             }
 
             if (caretMoved)
             {
                 // only the caret/selection was moved.
-                playSample(FeedbackSampleType.CaretMove);
+                PlayFeedbackSample(FeedbackSampleType.CaretMove);
             }
         }
 
@@ -238,13 +238,13 @@ namespace osu.Game.Graphics.UserInterface
             if (successful)
             {
                 // composition was successfully completed, usually by pressing the enter key.
-                playSample(FeedbackSampleType.TextConfirm);
+                PlayFeedbackSample(FeedbackSampleType.TextConfirm);
             }
             else
             {
                 // composition was prematurely ended, eg. by clicking inside the textbox.
                 // could be a different sample if desired.
-                playSample(FeedbackSampleType.TextConfirm);
+                PlayFeedbackSample(FeedbackSampleType.TextConfirm);
             }
         }
 
@@ -283,7 +283,7 @@ namespace osu.Game.Graphics.UserInterface
             return samples[RNG.Next(0, samples.Length)]?.GetChannel();
         }
 
-        private void playSample(FeedbackSampleType feedbackSample) => Schedule(() =>
+        protected void PlayFeedbackSample(FeedbackSampleType feedbackSample) => Schedule(() =>
         {
             if (Time.Current < sampleLastPlaybackTime + 15) return;
 

osu.Game/Overlays/NotificationOverlay.cs

@@ -71,7 +71,6 @@ namespace osu.Game.Overlays
                 },
                 mainContent = new Container
                 {
-                    AlwaysPresent = true,
                     RelativeSizeAxes = Axes.Both,
                     Children = new Drawable[]
                     {
@@ -137,7 +136,9 @@ namespace osu.Game.Overlays
 
         private readonly Scheduler postScheduler = new Scheduler();
 
-        public override bool IsPresent => base.IsPresent || postScheduler.HasPendingTasks;
+        public override bool IsPresent =>
+            // Delegate presence as we need to consider the toast tray in addition to the main overlay.
+            State.Value == Visibility.Visible || mainContent.IsPresent || toastTray.IsPresent || postScheduler.HasPendingTasks;
 
         private bool processingPosts = true;
 

osu.Game/Overlays/NotificationOverlayToastTray.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
@@ -23,6 +24,8 @@ namespace osu.Game.Overlays
     /// </summary>
     public class NotificationOverlayToastTray : CompositeDrawable
     {
+        public override bool IsPresent => toastContentBackground.Height > 0 || toastFlow.Count > 0;
+
         public bool IsDisplayingToasts => toastFlow.Count > 0;
 
         private FillFlowContainer<Notification> toastFlow = null!;
@@ -33,8 +36,12 @@ namespace osu.Game.Overlays
 
         public Action<Notification>? ForwardNotificationToPermanentStore { get; set; }
 
-        public int UnreadCount => toastFlow.Count(n => !n.WasClosed && !n.Read)
-                                  + InternalChildren.OfType<Notification>().Count(n => !n.WasClosed && !n.Read);
+        public int UnreadCount => allDisplayedNotifications.Count(n => !n.WasClosed && !n.Read);
+
+        /// <summary>
+        /// Notifications contained in the toast flow, or in a detached state while they animate during forwarding to the main overlay.
+        /// </summary>
+        private IEnumerable<Notification> allDisplayedNotifications => toastFlow.Concat(InternalChildren.OfType<Notification>());
 
         private int runningDepth;
 
@@ -55,6 +62,7 @@ namespace osu.Game.Overlays
                         colourProvider.Background6.Opacity(0.7f),
                         colourProvider.Background6.Opacity(0.5f)),
                     RelativeSizeAxes = Axes.Both,
+                    Height = 0,
                 }.WithEffect(new BlurEffect
                 {
                     PadExtent = true,
@@ -66,7 +74,7 @@ namespace osu.Game.Overlays
                     postEffectDrawable.AutoSizeAxes = Axes.None;
                     postEffectDrawable.RelativeSizeAxes = Axes.X;
                 })),
-                toastFlow = new AlwaysUpdateFillFlowContainer<Notification>
+                toastFlow = new FillFlowContainer<Notification>
                 {
                     LayoutDuration = 150,
                     LayoutEasing = Easing.OutQuart,
@@ -143,8 +151,8 @@ namespace osu.Game.Overlays
         {
             base.Update();
 
-            float height = toastFlow.DrawHeight + 120;
-            float alpha = IsDisplayingToasts ? MathHelper.Clamp(toastFlow.DrawHeight / 40, 0, 1) * toastFlow.Children.Max(n => n.Alpha) : 0;
+            float height = toastFlow.Count > 0 ? toastFlow.DrawHeight + 120 : 0;
+            float alpha = toastFlow.Count > 0 ? MathHelper.Clamp(toastFlow.DrawHeight / 41, 0, 1) * toastFlow.Children.Max(n => n.Alpha) : 0;
 
             toastContentBackground.Height = (float)Interpolation.DampContinuously(toastContentBackground.Height, height, 10, Clock.ElapsedFrameTime);
             toastContentBackground.Alpha = (float)Interpolation.DampContinuously(toastContentBackground.Alpha, alpha, 10, Clock.ElapsedFrameTime);

osu.Game/Overlays/Notifications/ProgressCompletionNotification.cs

@@ -1,8 +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.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
 using osu.Framework.Graphics.Colour;

osu.Game/Overlays/Notifications/ProgressNotification.cs

@@ -71,7 +71,7 @@ namespace osu.Game.Overlays.Notifications
             base.LoadComplete();
 
             // we may have received changes before we were displayed.
-            updateState();
+            Scheduler.AddOnce(updateState);
         }
 
         private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
@@ -87,8 +87,8 @@ namespace osu.Game.Overlays.Notifications
 
                 state = value;
 
-                if (IsLoaded)
-                    Schedule(updateState);
+                Scheduler.AddOnce(updateState);
+                attemptPostCompletion();
             }
         }
 
@@ -141,11 +141,33 @@ namespace osu.Game.Overlays.Notifications
 
                 case ProgressNotificationState.Completed:
                     loadingSpinner.Hide();
-                    Completed();
+                    attemptPostCompletion();
+                    base.Close();
                     break;
             }
         }
 
+        private bool completionSent;
+
+        /// <summary>
+        /// Attempt to post a completion notification.
+        /// </summary>
+        private void attemptPostCompletion()
+        {
+            if (state != ProgressNotificationState.Completed) return;
+
+            // This notification may not have been posted yet (and thus may not have a target to post the completion to).
+            // Completion posting will be re-attempted in a scheduled invocation.
+            if (CompletionTarget == null)
+                return;
+
+            if (completionSent)
+                return;
+
+            CompletionTarget.Invoke(CreateCompletionNotification());
+            completionSent = true;
+        }
+
         private ProgressNotificationState state;
 
         protected virtual Notification CreateCompletionNotification() => new ProgressCompletionNotification
@@ -154,14 +176,10 @@ namespace osu.Game.Overlays.Notifications
             Text = CompletionText
         };
 
-        protected void Completed()
-        {
-            CompletionTarget?.Invoke(CreateCompletionNotification());
-            base.Close();
-        }
-
         public override bool DisplayOnTop => false;
 
+        public override bool IsImportant => false;
+
         private readonly ProgressBar progressBar;
         private Color4 colourQueued;
         private Color4 colourActive;

osu.Game/Scoring/Legacy/ScoreInfoExtensions.cs

@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System.Collections.Generic;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Scoring.Legacy
@@ -13,6 +14,9 @@ namespace osu.Game.Scoring.Legacy
         {
             switch (scoreInfo.Ruleset.OnlineID)
             {
+                case 1:
+                    return getCount(scoreInfo, HitResult.LargeBonus);
+
                 case 3:
                     return getCount(scoreInfo, HitResult.Perfect);
             }
@@ -24,6 +28,12 @@ namespace osu.Game.Scoring.Legacy
         {
             switch (scoreInfo.Ruleset.OnlineID)
             {
+                // For legacy scores, Geki indicates hit300 + perfect strong note hit.
+                // Lazer only has one result for a perfect strong note hit (LargeBonus).
+                case 1:
+                    scoreInfo.Statistics[HitResult.LargeBonus] = scoreInfo.Statistics.GetValueOrDefault(HitResult.LargeBonus) + value;
+                    break;
+
                 case 3:
                     scoreInfo.Statistics[HitResult.Perfect] = value;
                     break;
@@ -38,11 +48,15 @@ namespace osu.Game.Scoring.Legacy
         {
             switch (scoreInfo.Ruleset.OnlineID)
             {
-                case 3:
-                    return getCount(scoreInfo, HitResult.Good);
+                // For taiko, Katu is bundled into Geki.
+                case 1:
+                    break;
 
                 case 2:
                     return getCount(scoreInfo, HitResult.SmallTickMiss);
+
+                case 3:
+                    return getCount(scoreInfo, HitResult.Good);
             }
 
             return null;
@@ -52,13 +66,19 @@ namespace osu.Game.Scoring.Legacy
         {
             switch (scoreInfo.Ruleset.OnlineID)
             {
-                case 3:
-                    scoreInfo.Statistics[HitResult.Good] = value;
+                // For legacy scores, Katu indicates hit100 + perfect strong note hit.
+                // Lazer only has one result for a perfect strong note hit (LargeBonus).
+                case 1:
+                    scoreInfo.Statistics[HitResult.LargeBonus] = scoreInfo.Statistics.GetValueOrDefault(HitResult.LargeBonus) + value;
                     break;
 
                 case 2:
                     scoreInfo.Statistics[HitResult.SmallTickMiss] = value;
                     break;
+
+                case 3:
+                    scoreInfo.Statistics[HitResult.Good] = value;
+                    break;
             }
         }
 

osu.Game/Screens/Edit/DeleteDifficultyConfirmationDialog.cs

@@ -0,0 +1,18 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Beatmaps;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Screens.Edit
+{
+    public class DeleteDifficultyConfirmationDialog : DeleteConfirmationDialog
+    {
+        public DeleteDifficultyConfirmationDialog(BeatmapInfo beatmapInfo, Action deleteAction)
+        {
+            BodyText = $"\"{beatmapInfo.DifficultyName}\" difficulty";
+            DeleteAction = deleteAction;
+        }
+    }
+}

osu.Game/Screens/Edit/Editor.cs

@@ -5,7 +5,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework;
@@ -879,35 +878,61 @@ namespace osu.Game.Screens.Edit
                 clock.SeekForward(!trackPlaying, amount);
         }
 
+        private void updateLastSavedHash()
+        {
+            lastSavedHash = changeHandler?.CurrentStateHash;
+        }
+
+        private List<MenuItem> createFileMenuItems() => new List<MenuItem>
+        {
+            new EditorMenuItem("Save", MenuItemType.Standard, () => Save()),
+            new EditorMenuItem("Export package", MenuItemType.Standard, exportBeatmap) { Action = { Disabled = !RuntimeInfo.IsDesktop } },
+            new EditorMenuItemSpacer(),
+            createDifficultyCreationMenu(),
+            createDifficultySwitchMenu(),
+            new EditorMenuItemSpacer(),
+            new EditorMenuItem("Delete difficulty", MenuItemType.Standard, deleteDifficulty) { Action = { Disabled = Beatmap.Value.BeatmapSetInfo.Beatmaps.Count < 2 } },
+            new EditorMenuItemSpacer(),
+            new EditorMenuItem("Exit", MenuItemType.Standard, this.Exit)
+        };
+
         private void exportBeatmap()
         {
             Save();
             new LegacyBeatmapExporter(storage).Export(Beatmap.Value.BeatmapSetInfo);
         }
 
-        private void updateLastSavedHash()
-        {
-            lastSavedHash = changeHandler?.CurrentStateHash;
-        }
+        /// <summary>
+        /// Beatmaps of the currently edited set, grouped by ruleset and ordered by difficulty.
+        /// </summary>
+        private IOrderedEnumerable<IGrouping<RulesetInfo, BeatmapInfo>> groupedOrderedBeatmaps => Beatmap.Value.BeatmapSetInfo.Beatmaps
+                                                                                                         .OrderBy(b => b.StarRating)
+                                                                                                         .GroupBy(b => b.Ruleset)
+                                                                                                         .OrderBy(group => group.Key);
 
-        private List<MenuItem> createFileMenuItems()
+        private void deleteDifficulty()
         {
-            var fileMenuItems = new List<MenuItem>
+            if (dialogOverlay == null)
+                delete();
+            else
+                dialogOverlay.Push(new DeleteDifficultyConfirmationDialog(Beatmap.Value.BeatmapInfo, delete));
+
+            void delete()
             {
-                new EditorMenuItem("Save", MenuItemType.Standard, () => Save())
-            };
+                BeatmapInfo difficultyToDelete = playableBeatmap.BeatmapInfo;
 
-            if (RuntimeInfo.IsDesktop)
-                fileMenuItems.Add(new EditorMenuItem("Export package", MenuItemType.Standard, exportBeatmap));
+                var difficultiesBeforeDeletion = groupedOrderedBeatmaps.SelectMany(g => g).ToList();
 
-            fileMenuItems.Add(new EditorMenuItemSpacer());
+                beatmapManager.DeleteDifficultyImmediately(difficultyToDelete);
 
-            fileMenuItems.Add(createDifficultyCreationMenu());
-            fileMenuItems.Add(createDifficultySwitchMenu());
+                int deletedIndex = difficultiesBeforeDeletion.IndexOf(difficultyToDelete);
+                // of note, we're still working with the cloned version, so indices are all prior to deletion.
+                BeatmapInfo nextToShow = difficultiesBeforeDeletion[deletedIndex == 0 ? 1 : deletedIndex - 1];
 
-            fileMenuItems.Add(new EditorMenuItemSpacer());
-            fileMenuItems.Add(new EditorMenuItem("Exit", MenuItemType.Standard, this.Exit));
-            return fileMenuItems;
+                Beatmap.Value = beatmapManager.GetWorkingBeatmap(nextToShow);
+
+                SwitchToDifficulty(nextToShow);
+            }
         }
 
         private EditorMenuItem createDifficultyCreationMenu()
@@ -939,18 +964,14 @@ namespace osu.Game.Screens.Edit
 
         private EditorMenuItem createDifficultySwitchMenu()
         {
-            var beatmapSet = playableBeatmap.BeatmapInfo.BeatmapSet;
-
-            Debug.Assert(beatmapSet != null);
-
             var difficultyItems = new List<MenuItem>();
 
-            foreach (var rulesetBeatmaps in beatmapSet.Beatmaps.GroupBy(b => b.Ruleset).OrderBy(group => group.Key))
+            foreach (var rulesetBeatmaps in groupedOrderedBeatmaps)
             {
                 if (difficultyItems.Count > 0)
                     difficultyItems.Add(new EditorMenuItemSpacer());
 
-                foreach (var beatmap in rulesetBeatmaps.OrderBy(b => b.StarRating))
+                foreach (var beatmap in rulesetBeatmaps)
                 {
                     bool isCurrentDifficulty = playableBeatmap.BeatmapInfo.Equals(beatmap);
                     difficultyItems.Add(new DifficultyMenuItem(beatmap, isCurrentDifficulty, SwitchToDifficulty));

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -1,8 +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.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -49,31 +47,31 @@ namespace osu.Game.Screens.Select
         /// <summary>
         /// Triggered when the <see cref="BeatmapSets"/> loaded change and are completely loaded.
         /// </summary>
-        public Action BeatmapSetsChanged;
+        public Action? BeatmapSetsChanged;
 
         /// <summary>
         /// The currently selected beatmap.
         /// </summary>
-        public BeatmapInfo SelectedBeatmapInfo => selectedBeatmap?.BeatmapInfo;
+        public BeatmapInfo? SelectedBeatmapInfo => selectedBeatmap?.BeatmapInfo;
 
-        private CarouselBeatmap selectedBeatmap => selectedBeatmapSet?.Beatmaps.FirstOrDefault(s => s.State.Value == CarouselItemState.Selected);
+        private CarouselBeatmap? selectedBeatmap => selectedBeatmapSet?.Beatmaps.FirstOrDefault(s => s.State.Value == CarouselItemState.Selected);
 
         /// <summary>
         /// The currently selected beatmap set.
         /// </summary>
-        public BeatmapSetInfo SelectedBeatmapSet => selectedBeatmapSet?.BeatmapSet;
+        public BeatmapSetInfo? SelectedBeatmapSet => selectedBeatmapSet?.BeatmapSet;
 
         /// <summary>
         /// A function to optionally decide on a recommended difficulty from a beatmap set.
         /// </summary>
-        public Func<IEnumerable<BeatmapInfo>, BeatmapInfo> GetRecommendedBeatmap;
+        public Func<IEnumerable<BeatmapInfo>, BeatmapInfo>? GetRecommendedBeatmap;
 
-        private CarouselBeatmapSet selectedBeatmapSet;
+        private CarouselBeatmapSet? selectedBeatmapSet;
 
         /// <summary>
         /// Raised when the <see cref="SelectedBeatmapInfo"/> is changed.
         /// </summary>
-        public Action<BeatmapInfo> SelectionChanged;
+        public Action<BeatmapInfo?>? SelectionChanged;
 
         public override bool HandleNonPositionalInput => AllowSelection;
         public override bool HandlePositionalInput => AllowSelection;
@@ -151,15 +149,15 @@ namespace osu.Game.Screens.Select
 
         private CarouselRoot root;
 
-        private IDisposable subscriptionSets;
-        private IDisposable subscriptionDeletedSets;
-        private IDisposable subscriptionBeatmaps;
-        private IDisposable subscriptionHiddenBeatmaps;
+        private IDisposable? subscriptionSets;
+        private IDisposable? subscriptionDeletedSets;
+        private IDisposable? subscriptionBeatmaps;
+        private IDisposable? subscriptionHiddenBeatmaps;
 
         private readonly DrawablePool<DrawableCarouselBeatmapSet> setPool = new DrawablePool<DrawableCarouselBeatmapSet>(100);
 
-        private Sample spinSample;
-        private Sample randomSelectSample;
+        private Sample? spinSample;
+        private Sample? randomSelectSample;
 
         private int visibleSetsCount;
 
@@ -200,7 +198,7 @@ namespace osu.Game.Screens.Select
         }
 
         [Resolved]
-        private RealmAccess realm { get; set; }
+        private RealmAccess realm { get; set; } = null!;
 
         protected override void LoadComplete()
         {
@@ -215,7 +213,7 @@ namespace osu.Game.Screens.Select
             subscriptionHiddenBeatmaps = realm.RegisterForNotifications(r => r.All<BeatmapInfo>().Where(b => b.Hidden), beatmapsChanged);
         }
 
-        private void deletedBeatmapSetsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet changes, Exception error)
+        private void deletedBeatmapSetsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet? changes, Exception? error)
         {
             // If loading test beatmaps, avoid overwriting with realm subscription callbacks.
             if (loadedTestBeatmaps)
@@ -228,7 +226,7 @@ namespace osu.Game.Screens.Select
                 removeBeatmapSet(sender[i].ID);
         }
 
-        private void beatmapSetsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet changes, Exception error)
+        private void beatmapSetsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet? changes, Exception? error)
         {
             // If loading test beatmaps, avoid overwriting with realm subscription callbacks.
             if (loadedTestBeatmaps)
@@ -266,8 +264,11 @@ namespace osu.Game.Screens.Select
             foreach (int i in changes.InsertedIndices)
                 UpdateBeatmapSet(sender[i].Detach());
 
-            if (changes.DeletedIndices.Length > 0)
+            if (changes.DeletedIndices.Length > 0 && SelectedBeatmapInfo != null)
             {
+                // If SelectedBeatmapInfo is non-null, the set should also be non-null.
+                Debug.Assert(SelectedBeatmapSet != null);
+
                 // To handle the beatmap update flow, attempt to track selection changes across delete-insert transactions.
                 // When an update occurs, the previous beatmap set is either soft or hard deleted.
                 // Check if the current selection was potentially deleted by re-querying its validity.
@@ -304,7 +305,7 @@ namespace osu.Game.Screens.Select
             }
         }
 
-        private void beatmapsChanged(IRealmCollection<BeatmapInfo> sender, ChangeSet changes, Exception error)
+        private void beatmapsChanged(IRealmCollection<BeatmapInfo> sender, ChangeSet? changes, Exception? error)
         {
             // we only care about actual changes in hidden status.
             if (changes == null)
@@ -367,7 +368,7 @@ namespace osu.Game.Screens.Select
 
                 // check if we can/need to maintain our current selection.
                 if (previouslySelectedID != null)
-                    select((CarouselItem)newSet.Beatmaps.FirstOrDefault(b => b.BeatmapInfo.ID == previouslySelectedID) ?? newSet);
+                    select((CarouselItem?)newSet.Beatmaps.FirstOrDefault(b => b.BeatmapInfo.ID == previouslySelectedID) ?? newSet);
             }
 
             itemsCache.Invalidate();
@@ -384,7 +385,7 @@ namespace osu.Game.Screens.Select
         /// <param name="beatmapInfo">The beatmap to select.</param>
         /// <param name="bypassFilters">Whether to select the beatmap even if it is filtered (i.e., not visible on carousel).</param>
         /// <returns>True if a selection was made, False if it wasn't.</returns>
-        public bool SelectBeatmap(BeatmapInfo beatmapInfo, bool bypassFilters = true)
+        public bool SelectBeatmap(BeatmapInfo? beatmapInfo, bool bypassFilters = true)
         {
             // ensure that any pending events from BeatmapManager have been run before attempting a selection.
             Scheduler.Update();
@@ -442,6 +443,9 @@ namespace osu.Game.Screens.Select
 
         private void selectNextSet(int direction, bool skipDifficulties)
         {
+            if (selectedBeatmap == null || selectedBeatmapSet == null)
+                return;
+
             var unfilteredSets = beatmapSets.Where(s => !s.Filtered.Value).ToList();
 
             var nextSet = unfilteredSets[(unfilteredSets.IndexOf(selectedBeatmapSet) + direction + unfilteredSets.Count) % unfilteredSets.Count];
@@ -454,7 +458,7 @@ namespace osu.Game.Screens.Select
 
         private void selectNextDifficulty(int direction)
         {
-            if (selectedBeatmap == null)
+            if (selectedBeatmap == null || selectedBeatmapSet == null)
                 return;
 
             var unfilteredDifficulties = selectedBeatmapSet.Items.Where(s => !s.Filtered.Value).ToList();
@@ -483,7 +487,7 @@ namespace osu.Game.Screens.Select
             if (!visibleSets.Any())
                 return false;
 
-            if (selectedBeatmap != null)
+            if (selectedBeatmap != null && selectedBeatmapSet != null)
             {
                 randomSelectedBeatmaps.Push(selectedBeatmap);
 
@@ -526,11 +530,13 @@ namespace osu.Game.Screens.Select
 
                 if (!beatmap.Filtered.Value)
                 {
-                    if (RandomAlgorithm.Value == RandomSelectAlgorithm.RandomPermutation)
-                        previouslyVisitedRandomSets.Remove(selectedBeatmapSet);
-
                     if (selectedBeatmapSet != null)
+                    {
+                        if (RandomAlgorithm.Value == RandomSelectAlgorithm.RandomPermutation)
+                            previouslyVisitedRandomSets.Remove(selectedBeatmapSet);
+
                         playSpinSample(distanceBetween(beatmap, selectedBeatmapSet));
+                    }
 
                     select(beatmap);
                     break;
@@ -542,14 +548,18 @@ namespace osu.Game.Screens.Select
 
         private void playSpinSample(double distance)
         {
-            var chan = spinSample.GetChannel();
-            chan.Frequency.Value = 1f + Math.Min(1f, distance / visibleSetsCount);
-            chan.Play();
+            var chan = spinSample?.GetChannel();
+
+            if (chan != null)
+            {
+                chan.Frequency.Value = 1f + Math.Min(1f, distance / visibleSetsCount);
+                chan.Play();
+            }
 
             randomSelectSample?.Play();
         }
 
-        private void select(CarouselItem item)
+        private void select(CarouselItem? item)
         {
             if (!AllowSelection)
                 return;
@@ -561,7 +571,7 @@ namespace osu.Game.Screens.Select
 
         private FilterCriteria activeCriteria = new FilterCriteria();
 
-        protected ScheduledDelegate PendingFilter;
+        protected ScheduledDelegate? PendingFilter;
 
         public bool AllowSelection = true;
 
@@ -593,7 +603,7 @@ namespace osu.Game.Screens.Select
             }
         }
 
-        public void Filter(FilterCriteria newCriteria, bool debounce = true)
+        public void Filter(FilterCriteria? newCriteria, bool debounce = true)
         {
             if (newCriteria != null)
                 activeCriteria = newCriteria;
@@ -796,7 +806,7 @@ namespace osu.Game.Screens.Select
             return (firstIndex, lastIndex);
         }
 
-        private CarouselBeatmapSet createCarouselSet(BeatmapSetInfo beatmapSet)
+        private CarouselBeatmapSet? createCarouselSet(BeatmapSetInfo beatmapSet)
         {
             // This can be moved to the realm query if required using:
             // .Filter("DeletePending == false && Protected == false && ANY Beatmaps.Hidden == false")
@@ -962,7 +972,7 @@ namespace osu.Game.Screens.Select
         /// </summary>
         /// <param name="item">The item to be updated.</param>
         /// <param name="parent">For nested items, the parent of the item to be updated.</param>
-        private void updateItem(DrawableCarouselItem item, DrawableCarouselItem parent = null)
+        private void updateItem(DrawableCarouselItem item, DrawableCarouselItem? parent = null)
         {
             Vector2 posInScroll = Scroll.ScrollContent.ToLocalSpace(item.Header.ScreenSpaceDrawQuad.Centre);
             float itemDrawY = posInScroll.Y - visibleUpperBound;
@@ -990,13 +1000,13 @@ namespace osu.Game.Screens.Select
         /// </summary>
         private class CarouselBoundsItem : CarouselItem
         {
-            public override DrawableCarouselItem CreateDrawableRepresentation() =>
-                throw new NotImplementedException();
+            public override DrawableCarouselItem CreateDrawableRepresentation() => throw new NotImplementedException();
         }
 
         private class CarouselRoot : CarouselGroupEagerSelect
         {
-            private readonly BeatmapCarousel carousel;
+            // May only be null during construction (State.Value set causes PerformSelection to be triggered).
+            private readonly BeatmapCarousel? carousel;
 
             public readonly Dictionary<Guid, CarouselBeatmapSet> BeatmapSetsByID = new Dictionary<Guid, CarouselBeatmapSet>();
 
@@ -1017,7 +1027,7 @@ namespace osu.Game.Screens.Select
                 base.AddItem(i);
             }
 
-            public CarouselBeatmapSet RemoveChild(Guid beatmapSetID)
+            public CarouselBeatmapSet? RemoveChild(Guid beatmapSetID)
             {
                 if (BeatmapSetsByID.TryGetValue(beatmapSetID, out var carouselBeatmapSet))
                 {

osu.Game/Storyboards/CommandTimelineGroup.cs

@@ -47,30 +47,11 @@ namespace osu.Game.Storyboards
             };
         }
 
-        /// <summary>
-        /// Returns the earliest visible time. Will be null unless this group's first <see cref="Alpha"/> command has a start value of zero.
-        /// </summary>
-        public double? EarliestDisplayedTime
-        {
-            get
-            {
-                var first = Alpha.Commands.FirstOrDefault();
-
-                return first?.StartValue == 0 ? first.StartTime : null;
-            }
-        }
-
         [JsonIgnore]
         public double CommandsStartTime
         {
             get
             {
-                // if the first alpha command starts at zero it should be given priority over anything else.
-                // this is due to it creating a state where the target is not present before that time, causing any other events to not be visible.
-                double? earliestDisplay = EarliestDisplayedTime;
-                if (earliestDisplay != null)
-                    return earliestDisplay.Value;
-
                 double min = double.MaxValue;
 
                 for (int i = 0; i < timelines.Length; i++)

osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs

@@ -56,11 +56,6 @@ namespace osu.Game.Storyboards.Drawables
             get => vectorScale;
             set
             {
-                if (Math.Abs(value.X) < Precision.FLOAT_EPSILON)
-                    value.X = Precision.FLOAT_EPSILON;
-                if (Math.Abs(value.Y) < Precision.FLOAT_EPSILON)
-                    value.Y = Precision.FLOAT_EPSILON;
-
                 if (vectorScale == value)
                     return;
 

osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs

@@ -55,11 +55,6 @@ namespace osu.Game.Storyboards.Drawables
             get => vectorScale;
             set
             {
-                if (Math.Abs(value.X) < Precision.FLOAT_EPSILON)
-                    value.X = Precision.FLOAT_EPSILON;
-                if (Math.Abs(value.Y) < Precision.FLOAT_EPSILON)
-                    value.Y = Precision.FLOAT_EPSILON;
-
                 if (vectorScale == value)
                     return;
 

osu.Game/Storyboards/StoryboardSprite.cs

@@ -30,24 +30,35 @@ namespace osu.Game.Storyboards
         {
             get
             {
-                // check for presence affecting commands as an initial pass.
-                double earliestStartTime = TimelineGroup.EarliestDisplayedTime ?? double.MaxValue;
+                // To get the initial start time, we need to check whether the first alpha command to exist (across all loops) has a StartValue of zero.
+                // A StartValue of zero governs, above all else, the first valid display time of a sprite.
+                //
+                // You can imagine that the first command of each type decides that type's start value, so if the initial alpha is zero,
+                // anything before that point can be ignored (the sprite is not visible after all).
+                var alphaCommands = new List<(double startTime, bool isZeroStartValue)>();
 
-                foreach (var l in loops)
+                var command = TimelineGroup.Alpha.Commands.FirstOrDefault();
+                if (command != null) alphaCommands.Add((command.StartTime, command.StartValue == 0));
+
+                foreach (var loop in loops)
                 {
-                    if (l.EarliestDisplayedTime is double loopEarliestDisplayTime)
-                        earliestStartTime = Math.Min(earliestStartTime, l.LoopStartTime + loopEarliestDisplayTime);
+                    command = loop.Alpha.Commands.FirstOrDefault();
+                    if (command != null) alphaCommands.Add((command.StartTime + loop.LoopStartTime, command.StartValue == 0));
                 }
 
-                if (earliestStartTime < double.MaxValue)
-                    return earliestStartTime;
+                if (alphaCommands.Count > 0)
+                {
+                    var firstAlpha = alphaCommands.OrderBy(t => t.startTime).First();
 
-                // if an alpha-affecting command was not found, use the earliest of any command.
-                earliestStartTime = TimelineGroup.StartTime;
+                    if (firstAlpha.isZeroStartValue)
+                        return firstAlpha.startTime;
+                }
 
+                // If we got to this point, either no alpha commands were present, or the earliest had a non-zero start value.
+                // The sprite's StartTime will be determined by the earliest command, regardless of type.
+                double earliestStartTime = TimelineGroup.StartTime;
                 foreach (var l in loops)
                     earliestStartTime = Math.Min(earliestStartTime, l.StartTime);
-
                 return earliestStartTime;
             }
         }