Merge branch 'master' into results-dynamic-pp-calc

osu.Game.Tests/Beatmaps/BeatmapDifficultyManagerTest.cs

@@ -28,5 +28,28 @@ namespace osu.Game.Tests.Beatmaps
 
             Assert.That(key1, Is.EqualTo(key2));
         }
+
+        [TestCase(1.3, DifficultyRating.Easy)]
+        [TestCase(1.993, DifficultyRating.Easy)]
+        [TestCase(1.998, DifficultyRating.Normal)]
+        [TestCase(2.4, DifficultyRating.Normal)]
+        [TestCase(2.693, DifficultyRating.Normal)]
+        [TestCase(2.698, DifficultyRating.Hard)]
+        [TestCase(3.5, DifficultyRating.Hard)]
+        [TestCase(3.993, DifficultyRating.Hard)]
+        [TestCase(3.997, DifficultyRating.Insane)]
+        [TestCase(5.0, DifficultyRating.Insane)]
+        [TestCase(5.292, DifficultyRating.Insane)]
+        [TestCase(5.297, DifficultyRating.Expert)]
+        [TestCase(6.2, DifficultyRating.Expert)]
+        [TestCase(6.493, DifficultyRating.Expert)]
+        [TestCase(6.498, DifficultyRating.ExpertPlus)]
+        [TestCase(8.3, DifficultyRating.ExpertPlus)]
+        public void TestDifficultyRatingMapping(double starRating, DifficultyRating expectedBracket)
+        {
+            var actualBracket = BeatmapDifficultyManager.GetDifficultyRating(starRating);
+
+            Assert.AreEqual(expectedBracket, actualBracket);
+        }
     }
 }

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

@@ -651,5 +651,63 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.IsInstanceOf<LegacyDifficultyCalculatorBeatmapDecoder>(decoder);
             }
         }
+
+        [Test]
+        public void TestMultiSegmentSliders()
+        {
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
+
+            using (var resStream = TestResources.OpenResource("multi-segment-slider.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var decoded = decoder.Decode(stream);
+
+                // Multi-segment
+                var first = ((IHasPath)decoded.HitObjects[0]).Path;
+
+                Assert.That(first.ControlPoints[0].Position.Value, Is.EqualTo(Vector2.Zero));
+                Assert.That(first.ControlPoints[0].Type.Value, Is.EqualTo(PathType.PerfectCurve));
+                Assert.That(first.ControlPoints[1].Position.Value, Is.EqualTo(new Vector2(161, -244)));
+                Assert.That(first.ControlPoints[1].Type.Value, Is.EqualTo(null));
+
+                Assert.That(first.ControlPoints[2].Position.Value, Is.EqualTo(new Vector2(376, -3)));
+                Assert.That(first.ControlPoints[2].Type.Value, Is.EqualTo(PathType.Bezier));
+                Assert.That(first.ControlPoints[3].Position.Value, Is.EqualTo(new Vector2(68, 15)));
+                Assert.That(first.ControlPoints[3].Type.Value, Is.EqualTo(null));
+                Assert.That(first.ControlPoints[4].Position.Value, Is.EqualTo(new Vector2(259, -132)));
+                Assert.That(first.ControlPoints[4].Type.Value, Is.EqualTo(null));
+                Assert.That(first.ControlPoints[5].Position.Value, Is.EqualTo(new Vector2(92, -107)));
+                Assert.That(first.ControlPoints[5].Type.Value, Is.EqualTo(null));
+
+                // Single-segment
+                var second = ((IHasPath)decoded.HitObjects[1]).Path;
+
+                Assert.That(second.ControlPoints[0].Position.Value, Is.EqualTo(Vector2.Zero));
+                Assert.That(second.ControlPoints[0].Type.Value, Is.EqualTo(PathType.PerfectCurve));
+                Assert.That(second.ControlPoints[1].Position.Value, Is.EqualTo(new Vector2(161, -244)));
+                Assert.That(second.ControlPoints[1].Type.Value, Is.EqualTo(null));
+                Assert.That(second.ControlPoints[2].Position.Value, Is.EqualTo(new Vector2(376, -3)));
+                Assert.That(second.ControlPoints[2].Type.Value, Is.EqualTo(null));
+
+                // Implicit multi-segment
+                var third = ((IHasPath)decoded.HitObjects[2]).Path;
+
+                Assert.That(third.ControlPoints[0].Position.Value, Is.EqualTo(Vector2.Zero));
+                Assert.That(third.ControlPoints[0].Type.Value, Is.EqualTo(PathType.Bezier));
+                Assert.That(third.ControlPoints[1].Position.Value, Is.EqualTo(new Vector2(0, 192)));
+                Assert.That(third.ControlPoints[1].Type.Value, Is.EqualTo(null));
+                Assert.That(third.ControlPoints[2].Position.Value, Is.EqualTo(new Vector2(224, 192)));
+                Assert.That(third.ControlPoints[2].Type.Value, Is.EqualTo(null));
+
+                Assert.That(third.ControlPoints[3].Position.Value, Is.EqualTo(new Vector2(224, 0)));
+                Assert.That(third.ControlPoints[3].Type.Value, Is.EqualTo(PathType.Bezier));
+                Assert.That(third.ControlPoints[4].Position.Value, Is.EqualTo(new Vector2(224, -192)));
+                Assert.That(third.ControlPoints[4].Type.Value, Is.EqualTo(null));
+                Assert.That(third.ControlPoints[5].Position.Value, Is.EqualTo(new Vector2(480, -192)));
+                Assert.That(third.ControlPoints[5].Type.Value, Is.EqualTo(null));
+                Assert.That(third.ControlPoints[6].Position.Value, Is.EqualTo(new Vector2(480, 0)));
+                Assert.That(third.ControlPoints[6].Type.Value, Is.EqualTo(null));
+            }
+        }
     }
 }

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

@@ -30,7 +30,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
     {
         private static readonly DllResourceStore beatmaps_resource_store = TestResources.GetStore();
 
-        private static IEnumerable<string> allBeatmaps = beatmaps_resource_store.GetAvailableResources().Where(res => res.EndsWith(".osu"));
+        private static IEnumerable<string> allBeatmaps = beatmaps_resource_store.GetAvailableResources().Where(res => res.EndsWith(".osu", StringComparison.Ordinal));
 
         [TestCaseSource(nameof(allBeatmaps))]
         public void TestEncodeDecodeStability(string name)

osu.Game.Tests/Editing/TransactionalCommitComponentTest.cs

@@ -0,0 +1,100 @@
+// 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 NUnit.Framework;
+using osu.Game.Screens.Edit;
+
+namespace osu.Game.Tests.Editing
+{
+    [TestFixture]
+    public class TransactionalCommitComponentTest
+    {
+        private TestHandler handler;
+
+        [SetUp]
+        public void SetUp()
+        {
+            handler = new TestHandler();
+        }
+
+        [Test]
+        public void TestCommitTransaction()
+        {
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+
+            handler.BeginChange();
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+            handler.EndChange();
+
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestSaveOutsideOfTransactionTriggersUpdates()
+        {
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+
+            handler.SaveState();
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(1));
+
+            handler.SaveState();
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestEventsFire()
+        {
+            int transactionBegan = 0;
+            int transactionEnded = 0;
+            int stateSaved = 0;
+
+            handler.TransactionBegan += () => transactionBegan++;
+            handler.TransactionEnded += () => transactionEnded++;
+            handler.SaveStateTriggered += () => stateSaved++;
+
+            handler.BeginChange();
+            Assert.That(transactionBegan, Is.EqualTo(1));
+
+            handler.EndChange();
+            Assert.That(transactionEnded, Is.EqualTo(1));
+
+            Assert.That(stateSaved, Is.EqualTo(0));
+            handler.SaveState();
+            Assert.That(stateSaved, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestSaveDuringTransactionDoesntTriggerUpdate()
+        {
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+
+            handler.BeginChange();
+
+            handler.SaveState();
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+
+            handler.EndChange();
+
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestEndWithoutBeginThrows()
+        {
+            handler.BeginChange();
+            handler.EndChange();
+            Assert.That(() => handler.EndChange(), Throws.TypeOf<InvalidOperationException>());
+        }
+
+        private class TestHandler : TransactionalCommitComponent
+        {
+            public int StateUpdateCount { get; private set; }
+
+            protected override void UpdateState()
+            {
+                StateUpdateCount++;
+            }
+        }
+    }
+}

osu.Game.Tests/NonVisual/CustomDataDirectoryTest.cs

@@ -111,6 +111,7 @@ namespace osu.Game.Tests.NonVisual
 
                     var osu = LoadOsuIntoHost(host);
                     var storage = osu.Dependencies.Get<Storage>();
+                    var osuStorage = storage as MigratableStorage;
 
                     // Store the current storage's path. We'll need to refer to this for assertions in the original directory after the migration completes.
                     string originalDirectory = storage.GetFullPath(".");
@@ -137,13 +138,15 @@ namespace osu.Game.Tests.NonVisual
                     Assert.That(!Directory.Exists(Path.Combine(originalDirectory, "test-nested", "cache")));
                     Assert.That(storage.ExistsDirectory(Path.Combine("test-nested", "cache")));
 
-                    foreach (var file in OsuStorage.IGNORE_FILES)
+                    Assert.That(osuStorage, Is.Not.Null);
+
+                    foreach (var file in osuStorage.IgnoreFiles)
                     {
                         Assert.That(File.Exists(Path.Combine(originalDirectory, file)));
                         Assert.That(storage.Exists(file), Is.False);
                     }
 
-                    foreach (var dir in OsuStorage.IGNORE_DIRECTORIES)
+                    foreach (var dir in osuStorage.IgnoreDirectories)
                     {
                         Assert.That(Directory.Exists(Path.Combine(originalDirectory, dir)));
                         Assert.That(storage.ExistsDirectory(dir), Is.False);

osu.Game.Tests/NonVisual/DifficultyAdjustmentModCombinationsTest.cs

@@ -94,6 +94,52 @@ namespace osu.Game.Tests.NonVisual
             Assert.IsTrue(combinations[2] is ModIncompatibleWithAofA);
         }
 
+        [Test]
+        public void TestMultiModFlattening()
+        {
+            var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModB(), new ModC())).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(4, combinations.Length);
+            Assert.IsTrue(combinations[0] is ModNoMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is MultiMod);
+            Assert.IsTrue(combinations[3] is MultiMod);
+
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[2] is ModC);
+            Assert.IsTrue(((MultiMod)combinations[3]).Mods[0] is ModB);
+            Assert.IsTrue(((MultiMod)combinations[3]).Mods[1] is ModC);
+        }
+
+        [Test]
+        public void TestIncompatibleThroughMultiMod()
+        {
+            var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModB(), new ModIncompatibleWithA())).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(3, combinations.Length);
+            Assert.IsTrue(combinations[0] is ModNoMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is MultiMod);
+
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModB);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModIncompatibleWithA);
+        }
+
+        [Test]
+        public void TestIncompatibleWithSameInstanceViaMultiMod()
+        {
+            var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModA(), new ModB())).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(3, combinations.Length);
+            Assert.IsTrue(combinations[0] is ModNoMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is MultiMod);
+
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
+        }
+
         private class ModA : Mod
         {
             public override string Name => nameof(ModA);
@@ -112,6 +158,13 @@ namespace osu.Game.Tests.NonVisual
             public override Type[] IncompatibleMods => new[] { typeof(ModIncompatibleWithAAndB) };
         }
 
+        private class ModC : Mod
+        {
+            public override string Name => nameof(ModC);
+            public override string Acronym => nameof(ModC);
+            public override double ScoreMultiplier => 1;
+        }
+
         private class ModIncompatibleWithA : Mod
         {
             public override string Name => $"Incompatible With {nameof(ModA)}";

osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs

@@ -197,5 +197,22 @@ namespace osu.Game.Tests.NonVisual.Filtering
             carouselItem.Filter(criteria);
             Assert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
+
+        [TestCase("202010", true)]
+        [TestCase("20201010", false)]
+        [TestCase("153", true)]
+        [TestCase("1535", false)]
+        public void TestCriteriaMatchingBeatmapIDs(string query, bool filtered)
+        {
+            var beatmap = getExampleBeatmap();
+            beatmap.OnlineBeatmapID = 20201010;
+            beatmap.BeatmapSet = new BeatmapSetInfo { OnlineBeatmapSetID = 1535 };
+
+            var criteria = new FilterCriteria { SearchText = query };
+            var carouselItem = new CarouselBeatmap(beatmap);
+            carouselItem.Filter(criteria);
+
+            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+        }
     }
 }

osu.Game.Tests/Resources/multi-segment-slider.osu

@@ -0,0 +1,11 @@
+osu file format v128
+
+[HitObjects]
+// Multi-segment
+63,301,1000,6,0,P|224:57|B|439:298|131:316|322:169|155:194,1,1040,0|0,0:0|0:0,0:0:0:0:
+
+// Single-segment
+63,301,2000,6,0,P|224:57|439:298,1,1040,0|0,0:0|0:0,0:0:0:0:
+
+// Implicit multi-segment
+32,192,3000,6,0,B|32:384|256:384|256:192|256:192|256:0|512:0|512:192,1,800

osu.Game.Tests/Resources/old-skin/skin.ini

@@ -0,0 +1,2 @@
+[General]
+Version: 1.0

osu.Game.Tests/Rulesets/Scoring/ScoreProcessorTest.cs

@@ -53,5 +53,263 @@ namespace osu.Game.Tests.Rulesets.Scoring
 
             Assert.IsTrue(Precision.AlmostEquals(expectedScore, scoreProcessor.TotalScore.Value));
         }
+
+        /// <summary>
+        /// Test to see that all <see cref="HitResult"/>s contribute to score portions in correct amounts.
+        /// </summary>
+        /// <param name="scoringMode">Scoring mode to test.</param>
+        /// <param name="hitResult">The <see cref="HitResult"/> that will be applied to selected hit objects.</param>
+        /// <param name="maxResult">The maximum <see cref="HitResult"/> achievable.</param>
+        /// <param name="expectedScore">Expected score after all objects have been judged, rounded to the nearest integer.</param>
+        /// <remarks>
+        /// This test intentionally misses the 3rd hitobject to achieve lower than 75% accuracy and 50% max combo.
+        /// <para>
+        /// For standardised scoring, <paramref name="expectedScore"/> is calculated using the following formula:
+        /// 1_000_000 * (((3 * <paramref name="hitResult"/>) / (4 * <paramref name="maxResult"/>)) * 30% + (bestCombo / maxCombo) * 70%)
+        /// </para>
+        /// <para>
+        /// For classic scoring, <paramref name="expectedScore"/> is calculated using the following formula:
+        /// <paramref name="hitResult"/> / <paramref name="maxResult"/> * 936
+        /// where 936 is simplified from:
+        /// 75% * 4 * 300 * (1 + 1/25)
+        /// </para>
+        /// </remarks>
+        [TestCase(ScoringMode.Standardised, HitResult.Miss, HitResult.Great, 0)] // (3 * 0) / (4 * 300) * 300_000 + (0 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Meh, HitResult.Great, 387_500)] // (3 * 50) / (4 * 300) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Ok, HitResult.Great, 425_000)] // (3 * 100) / (4 * 300) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Good, HitResult.Perfect, 478_571)] // (3 * 200) / (4 * 350) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Great, HitResult.Great, 575_000)] // (3 * 300) / (4 * 300) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Perfect, HitResult.Perfect, 575_000)] // (3 * 350) / (4 * 350) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.SmallTickMiss, HitResult.SmallTickHit, 700_000)] // (3 * 0) / (4 * 10) * 300_000 + 700_000 (max combo 0)
+        [TestCase(ScoringMode.Standardised, HitResult.SmallTickHit, HitResult.SmallTickHit, 925_000)] // (3 * 10) / (4 * 10) * 300_000 + 700_000 (max combo 0)
+        [TestCase(ScoringMode.Standardised, HitResult.LargeTickMiss, HitResult.LargeTickHit, 0)] // (3 * 0) / (4 * 30) * 300_000 + (0 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.LargeTickHit, HitResult.LargeTickHit, 575_000)] // (3 * 30) / (4 * 30) * 300_000 + (0 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.SmallBonus, HitResult.SmallBonus, 700_030)] // 0 * 300_000 + 700_000 (max combo 0) + 3 * 10 (bonus points)
+        [TestCase(ScoringMode.Standardised, HitResult.LargeBonus, HitResult.LargeBonus, 700_150)] // 0 * 300_000 + 700_000 (max combo 0) + 3 * 50 (bonus points)
+        [TestCase(ScoringMode.Classic, HitResult.Miss, HitResult.Great, 0)] // (0 * 4 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Meh, HitResult.Great, 156)] // (((3 * 50) / (4 * 300)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Ok, HitResult.Great, 312)] // (((3 * 100) / (4 * 300)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Good, HitResult.Perfect, 535)] // (((3 * 200) / (4 * 350)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Great, HitResult.Great, 936)] // (((3 * 300) / (4 * 300)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Perfect, HitResult.Perfect, 936)] // (((3 * 350) / (4 * 350)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.SmallTickMiss, HitResult.SmallTickHit, 0)] // (0 * 1 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.SmallTickHit, HitResult.SmallTickHit, 225)] // (((3 * 10) / (4 * 10)) * 1 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.LargeTickMiss, HitResult.LargeTickHit, 0)] // (0 * 4 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.LargeTickHit, HitResult.LargeTickHit, 936)] // (((3 * 50) / (4 * 50)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.SmallBonus, HitResult.SmallBonus, 30)] // (0 * 1 * 300) * (1 + 0 / 25) + 3 * 10 (bonus points)
+        [TestCase(ScoringMode.Classic, HitResult.LargeBonus, HitResult.LargeBonus, 150)] // (0 * 1 * 300) * (1 + 0 / 25) * 3 * 50 (bonus points)
+        public void TestFourVariousResultsOneMiss(ScoringMode scoringMode, HitResult hitResult, HitResult maxResult, int expectedScore)
+        {
+            var minResult = new TestJudgement(hitResult).MinResult;
+
+            IBeatmap fourObjectBeatmap = new TestBeatmap(new RulesetInfo())
+            {
+                HitObjects = new List<HitObject>(Enumerable.Repeat(new TestHitObject(maxResult), 4))
+            };
+            scoreProcessor.Mode.Value = scoringMode;
+            scoreProcessor.ApplyBeatmap(fourObjectBeatmap);
+
+            for (int i = 0; i < 4; i++)
+            {
+                var judgementResult = new JudgementResult(fourObjectBeatmap.HitObjects[i], new Judgement())
+                {
+                    Type = i == 2 ? minResult : hitResult
+                };
+                scoreProcessor.ApplyResult(judgementResult);
+            }
+
+            Assert.IsTrue(Precision.AlmostEquals(expectedScore, scoreProcessor.TotalScore.Value, 0.5));
+        }
+
+        /// <remarks>
+        /// This test uses a beatmap with four small ticks and one object with the <see cref="Judgement.MaxResult"/> of <see cref="HitResult.Ok"/>.
+        /// Its goal is to ensure that with the <see cref="ScoringMode"/> of <see cref="ScoringMode.Standardised"/>,
+        /// small ticks contribute to the accuracy portion, but not the combo portion.
+        /// In contrast, <see cref="ScoringMode.Classic"/> does not have separate combo and accuracy portion (they are multiplied by each other).
+        /// </remarks>
+        [TestCase(ScoringMode.Standardised, HitResult.SmallTickHit, 978_571)] // (3 * 10 + 100) / (4 * 10 + 100) * 300_000 + (1 / 1) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.SmallTickMiss, 914_286)] // (3 * 0 + 100) / (4 * 10 + 100) * 300_000 + (1 / 1) * 700_000
+        [TestCase(ScoringMode.Classic, HitResult.SmallTickHit, 279)] // (((3 * 10 + 100) / (4 * 10 + 100)) * 1 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.SmallTickMiss, 214)] // (((3 * 0 + 100) / (4 * 10 + 100)) * 1 * 300) * (1 + 0 / 25)
+        public void TestSmallTicksAccuracy(ScoringMode scoringMode, HitResult hitResult, int expectedScore)
+        {
+            IEnumerable<HitObject> hitObjects = Enumerable
+                                                .Repeat(new TestHitObject(HitResult.SmallTickHit), 4)
+                                                .Append(new TestHitObject(HitResult.Ok));
+            IBeatmap fiveObjectBeatmap = new TestBeatmap(new RulesetInfo())
+            {
+                HitObjects = hitObjects.ToList()
+            };
+            scoreProcessor.Mode.Value = scoringMode;
+            scoreProcessor.ApplyBeatmap(fiveObjectBeatmap);
+
+            for (int i = 0; i < 4; i++)
+            {
+                var judgementResult = new JudgementResult(fiveObjectBeatmap.HitObjects[i], new Judgement())
+                {
+                    Type = i == 2 ? HitResult.SmallTickMiss : hitResult
+                };
+                scoreProcessor.ApplyResult(judgementResult);
+            }
+
+            var lastJudgementResult = new JudgementResult(fiveObjectBeatmap.HitObjects.Last(), new Judgement())
+            {
+                Type = HitResult.Ok
+            };
+            scoreProcessor.ApplyResult(lastJudgementResult);
+
+            Assert.IsTrue(Precision.AlmostEquals(expectedScore, scoreProcessor.TotalScore.Value, 0.5));
+        }
+
+        [Test]
+        public void TestEmptyBeatmap(
+            [Values(ScoringMode.Standardised, ScoringMode.Classic)]
+            ScoringMode scoringMode)
+        {
+            scoreProcessor.Mode.Value = scoringMode;
+            scoreProcessor.ApplyBeatmap(new TestBeatmap(new RulesetInfo()));
+
+            Assert.IsTrue(Precision.AlmostEquals(0, scoreProcessor.TotalScore.Value));
+        }
+
+        [TestCase(HitResult.IgnoreHit, HitResult.IgnoreMiss)]
+        [TestCase(HitResult.Meh, HitResult.Miss)]
+        [TestCase(HitResult.Ok, HitResult.Miss)]
+        [TestCase(HitResult.Good, HitResult.Miss)]
+        [TestCase(HitResult.Great, HitResult.Miss)]
+        [TestCase(HitResult.Perfect, HitResult.Miss)]
+        [TestCase(HitResult.SmallTickHit, HitResult.SmallTickMiss)]
+        [TestCase(HitResult.LargeTickHit, HitResult.LargeTickMiss)]
+        [TestCase(HitResult.SmallBonus, HitResult.IgnoreMiss)]
+        [TestCase(HitResult.LargeBonus, HitResult.IgnoreMiss)]
+        public void TestMinResults(HitResult hitResult, HitResult expectedMinResult)
+        {
+            Assert.AreEqual(expectedMinResult, new TestJudgement(hitResult).MinResult);
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, false)]
+        [TestCase(HitResult.Miss, true)]
+        [TestCase(HitResult.Meh, true)]
+        [TestCase(HitResult.Ok, true)]
+        [TestCase(HitResult.Good, true)]
+        [TestCase(HitResult.Great, true)]
+        [TestCase(HitResult.Perfect, true)]
+        [TestCase(HitResult.SmallTickMiss, false)]
+        [TestCase(HitResult.SmallTickHit, false)]
+        [TestCase(HitResult.LargeTickMiss, true)]
+        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SmallBonus, false)]
+        [TestCase(HitResult.LargeBonus, false)]
+        public void TestAffectsCombo(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.AffectsCombo());
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, false)]
+        [TestCase(HitResult.Miss, true)]
+        [TestCase(HitResult.Meh, true)]
+        [TestCase(HitResult.Ok, true)]
+        [TestCase(HitResult.Good, true)]
+        [TestCase(HitResult.Great, true)]
+        [TestCase(HitResult.Perfect, true)]
+        [TestCase(HitResult.SmallTickMiss, true)]
+        [TestCase(HitResult.SmallTickHit, true)]
+        [TestCase(HitResult.LargeTickMiss, true)]
+        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SmallBonus, false)]
+        [TestCase(HitResult.LargeBonus, false)]
+        public void TestAffectsAccuracy(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.AffectsAccuracy());
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, false)]
+        [TestCase(HitResult.Miss, false)]
+        [TestCase(HitResult.Meh, false)]
+        [TestCase(HitResult.Ok, false)]
+        [TestCase(HitResult.Good, false)]
+        [TestCase(HitResult.Great, false)]
+        [TestCase(HitResult.Perfect, false)]
+        [TestCase(HitResult.SmallTickMiss, false)]
+        [TestCase(HitResult.SmallTickHit, false)]
+        [TestCase(HitResult.LargeTickMiss, false)]
+        [TestCase(HitResult.LargeTickHit, false)]
+        [TestCase(HitResult.SmallBonus, true)]
+        [TestCase(HitResult.LargeBonus, true)]
+        public void TestIsBonus(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.IsBonus());
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, true)]
+        [TestCase(HitResult.Miss, false)]
+        [TestCase(HitResult.Meh, true)]
+        [TestCase(HitResult.Ok, true)]
+        [TestCase(HitResult.Good, true)]
+        [TestCase(HitResult.Great, true)]
+        [TestCase(HitResult.Perfect, true)]
+        [TestCase(HitResult.SmallTickMiss, false)]
+        [TestCase(HitResult.SmallTickHit, true)]
+        [TestCase(HitResult.LargeTickMiss, false)]
+        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SmallBonus, true)]
+        [TestCase(HitResult.LargeBonus, true)]
+        public void TestIsHit(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.IsHit());
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, false)]
+        [TestCase(HitResult.Miss, true)]
+        [TestCase(HitResult.Meh, true)]
+        [TestCase(HitResult.Ok, true)]
+        [TestCase(HitResult.Good, true)]
+        [TestCase(HitResult.Great, true)]
+        [TestCase(HitResult.Perfect, true)]
+        [TestCase(HitResult.SmallTickMiss, true)]
+        [TestCase(HitResult.SmallTickHit, true)]
+        [TestCase(HitResult.LargeTickMiss, true)]
+        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SmallBonus, true)]
+        [TestCase(HitResult.LargeBonus, true)]
+        public void TestIsScorable(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.IsScorable());
+        }
+
+        private class TestJudgement : Judgement
+        {
+            public override HitResult MaxResult { get; }
+
+            public TestJudgement(HitResult maxResult)
+            {
+                MaxResult = maxResult;
+            }
+        }
+
+        private class TestHitObject : HitObject
+        {
+            private readonly HitResult maxResult;
+
+            public override Judgement CreateJudgement()
+            {
+                return new TestJudgement(maxResult);
+            }
+
+            public TestHitObject(HitResult maxResult)
+            {
+                this.maxResult = maxResult;
+            }
+        }
     }
 }

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

@@ -192,6 +192,7 @@ namespace osu.Game.Tests.Visual.Background
 
             AddStep("Transition to Results", () => player.Push(results = new FadeAccessibleResults(new ScoreInfo
             {
+                Ruleset = new OsuRuleset().RulesetInfo,
                 User = new User { Username = "osu!" },
                 Beatmap = new TestBeatmap(Ruleset.Value).BeatmapInfo,
                 Ruleset = Ruleset.Value,

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

@@ -5,7 +5,6 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Screens.Edit.Compose.Components;
-using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -13,7 +12,7 @@ namespace osu.Game.Tests.Visual.Editing
     [TestFixture]
     public class TestSceneTimelineTickDisplay : TimelineTestScene
     {
-        public override Drawable CreateTestComponent() => new TimelineTickDisplay();
+        public override Drawable CreateTestComponent() => Empty(); // tick display is implicitly inside the timeline.
 
         [BackgroundDependencyLoader]
         private void load()

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -76,7 +77,7 @@ namespace osu.Game.Tests.Visual.Editing
                 };
             });
 
-            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+            AddUntilStep("wait for load", () => graph.Loaded.IsSet);
         }
 
         [Test]
@@ -98,12 +99,18 @@ namespace osu.Game.Tests.Visual.Editing
                 };
             });
 
-            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+            AddUntilStep("wait for load", () => graph.Loaded.IsSet);
         }
 
         public class TestWaveformGraph : WaveformGraph
         {
-            public new Waveform ResampledWaveform => base.ResampledWaveform;
+            public readonly ManualResetEventSlim Loaded = new ManualResetEventSlim();
+
+            protected override void OnWaveformRegenerated(Waveform waveform)
+            {
+                base.OnWaveformRegenerated(waveform);
+                Loaded.Set();
+            }
         }
     }
 }

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

@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneComboCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableComboCounter> comboCounters => CreatedDrawables.OfType<SkinnableComboCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var comboCounter = new SkinnableComboCounter();
+                comboCounter.Current.Value = 1;
+                return comboCounter;
+            }));
+        }
+
+        [Test]
+        public void TestComboCounterIncrementing()
+        {
+            AddRepeatStep("increase combo", () =>
+            {
+                foreach (var counter in comboCounters)
+                    counter.Current.Value++;
+            }, 10);
+
+            AddStep("reset combo", () =>
+            {
+                foreach (var counter in comboCounters)
+                    counter.Current.Value = 0;
+            });
+        }
+    }
+}

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

@@ -26,7 +26,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("get variables", () =>
             {
-                gameplayClock = Player.ChildrenOfType<FrameStabilityContainer>().First().GameplayClock;
+                gameplayClock = Player.ChildrenOfType<FrameStabilityContainer>().First();
                 slider = Player.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First();
                 samples = slider.ChildrenOfType<DrawableSample>().ToArray();
             });

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

@@ -2,23 +2,29 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Configuration;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Play;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneHUDOverlay : OsuManualInputManagerTestScene
+    public class TestSceneHUDOverlay : SkinnableTestScene
     {
         private HUDOverlay hudOverlay;
 
+        private IEnumerable<HUDOverlay> hudOverlays => CreatedDrawables.OfType<HUDOverlay>();
+
         // best way to check without exposing.
         private Drawable hideTarget => hudOverlay.KeyCounter;
         private FillFlowContainer<KeyCounter> keyCounterFlow => hudOverlay.KeyCounter.ChildrenOfType<FillFlowContainer<KeyCounter>>().First();
@@ -26,6 +32,24 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Resolved]
         private OsuConfigManager config { get; set; }
 
+        [Test]
+        public void TestComboCounterIncrementing()
+        {
+            createNew();
+
+            AddRepeatStep("increase combo", () =>
+            {
+                foreach (var hud in hudOverlays)
+                    hud.ComboCounter.Current.Value++;
+            }, 10);
+
+            AddStep("reset combo", () =>
+            {
+                foreach (var hud in hudOverlays)
+                    hud.ComboCounter.Current.Value = 0;
+            });
+        }
+
         [Test]
         public void TestShownByDefault()
         {
@@ -45,7 +69,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             createNew(h => h.OnLoadComplete += _ => initialAlpha = hideTarget.Alpha);
             AddUntilStep("wait for load", () => hudOverlay.IsAlive);
-            AddAssert("initial alpha was less than 1", () => initialAlpha != null && initialAlpha < 1);
+            AddAssert("initial alpha was less than 1", () => initialAlpha < 1);
         }
 
         [Test]
@@ -53,7 +77,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             createNew();
 
-            AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
+            AddStep("set showhud false", () => hudOverlays.ForEach(h => h.ShowHud.Value = false));
 
             AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
             AddAssert("pause button is still visible", () => hudOverlay.HoldToQuit.IsPresent);
@@ -89,14 +113,14 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("set keycounter visible false", () =>
             {
                 config.Set<bool>(OsuSetting.KeyOverlay, false);
-                hudOverlay.KeyCounter.AlwaysVisible.Value = false;
+                hudOverlays.ForEach(h => h.KeyCounter.AlwaysVisible.Value = false);
             });
 
-            AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
+            AddStep("set showhud false", () => hudOverlays.ForEach(h => h.ShowHud.Value = false));
             AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
             AddAssert("key counters hidden", () => !keyCounterFlow.IsPresent);
 
-            AddStep("set showhud true", () => hudOverlay.ShowHud.Value = true);
+            AddStep("set showhud true", () => hudOverlays.ForEach(h => h.ShowHud.Value = true));
             AddUntilStep("hidetarget is visible", () => hideTarget.IsPresent);
             AddAssert("key counters still hidden", () => !keyCounterFlow.IsPresent);
 
@@ -107,13 +131,22 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create overlay", () =>
             {
-                Child = hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
+                SetContents(() =>
+                {
+                    hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
 
-                // Add any key just to display the key counter visually.
-                hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
+                    // Add any key just to display the key counter visually.
+                    hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
 
-                action?.Invoke(hudOverlay);
+                    hudOverlay.ComboCounter.Current.Value = 1;
+
+                    action?.Invoke(hudOverlay);
+
+                    return hudOverlay;
+                });
             });
         }
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
     }
 }

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

@@ -22,8 +22,10 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         private BarHitErrorMeter barMeter;
         private BarHitErrorMeter barMeter2;
+        private BarHitErrorMeter barMeter3;
         private ColourHitErrorMeter colourMeter;
         private ColourHitErrorMeter colourMeter2;
+        private ColourHitErrorMeter colourMeter3;
         private HitWindows hitWindows;
 
         public TestSceneHitErrorMeter()
@@ -115,6 +117,13 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Origin = Anchor.CentreLeft,
             });
 
+            Add(barMeter3 = new BarHitErrorMeter(hitWindows, true)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.CentreLeft,
+                Rotation = 270,
+            });
+
             Add(colourMeter = new ColourHitErrorMeter(hitWindows)
             {
                 Anchor = Anchor.CentreRight,
@@ -128,6 +137,14 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Origin = Anchor.CentreLeft,
                 Margin = new MarginPadding { Left = 50 }
             });
+
+            Add(colourMeter3 = new ColourHitErrorMeter(hitWindows)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.CentreLeft,
+                Rotation = 270,
+                Margin = new MarginPadding { Left = 50 }
+            });
         }
 
         private void newJudgement(double offset = 0)
@@ -140,8 +157,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             barMeter.OnNewJudgement(judgement);
             barMeter2.OnNewJudgement(judgement);
+            barMeter3.OnNewJudgement(judgement);
             colourMeter.OnNewJudgement(judgement);
             colourMeter2.OnNewJudgement(judgement);
+            colourMeter3.OnNewJudgement(judgement);
         }
     }
 }

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

@@ -3,6 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Bindables;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 
@@ -23,33 +24,41 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestGameplayOverlayActivation()
         {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
             AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
         }
 
         [Test]
         public void TestGameplayOverlayActivationPaused()
         {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
             AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
             AddStep("pause gameplay", () => Player.Pause());
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
             AddUntilStep("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
         }
 
         [Test]
         public void TestGameplayOverlayActivationReplayLoaded()
         {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
             AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
             AddStep("load a replay", () => Player.DrawableRuleset.HasReplayLoaded.Value = true);
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
             AddAssert("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
         }
 
         [Test]
         public void TestGameplayOverlayActivationBreaks()
         {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
             AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
             AddStep("seek to break", () => Player.GameplayClockContainer.Seek(Beatmap.Value.Beatmap.Breaks.First().StartTime));
             AddUntilStep("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
             AddStep("seek to break end", () => Player.GameplayClockContainer.Seek(Beatmap.Value.Beatmap.Breaks.First().EndTime));
             AddUntilStep("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
         }
 
         protected override TestPlayer CreatePlayer(Ruleset ruleset) => new OverlayTestPlayer();
@@ -57,6 +66,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         protected class OverlayTestPlayer : TestPlayer
         {
             public new OverlayActivation OverlayActivationMode => base.OverlayActivationMode.Value;
+            public new Bindable<bool> LocalUserPlaying => base.LocalUserPlaying;
         }
     }
 }

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

@@ -1,68 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Screens.Play.HUD;
-using osuTK;
-
-namespace osu.Game.Tests.Visual.Gameplay
-{
-    [TestFixture]
-    public class TestSceneScoreCounter : OsuTestScene
-    {
-        public TestSceneScoreCounter()
-        {
-            int numerator = 0, denominator = 0;
-
-            ScoreCounter score = new ScoreCounter(7)
-            {
-                Origin = Anchor.TopRight,
-                Anchor = Anchor.TopRight,
-                Margin = new MarginPadding(20),
-            };
-            Add(score);
-
-            ComboCounter comboCounter = new StandardComboCounter
-            {
-                Origin = Anchor.BottomLeft,
-                Anchor = Anchor.BottomLeft,
-                Margin = new MarginPadding(10),
-            };
-            Add(comboCounter);
-
-            PercentageCounter accuracyCounter = new PercentageCounter
-            {
-                Origin = Anchor.TopRight,
-                Anchor = Anchor.TopRight,
-                Position = new Vector2(-20, 60),
-            };
-            Add(accuracyCounter);
-
-            AddStep(@"Reset all", delegate
-            {
-                score.Current.Value = 0;
-                comboCounter.Current.Value = 0;
-                numerator = denominator = 0;
-                accuracyCounter.SetFraction(0, 0);
-            });
-
-            AddStep(@"Hit! :D", delegate
-            {
-                score.Current.Value += 300 + (ulong)(300.0 * (comboCounter.Current.Value > 0 ? comboCounter.Current.Value - 1 : 0) / 25.0);
-                comboCounter.Increment();
-                numerator++;
-                denominator++;
-                accuracyCounter.SetFraction(numerator, denominator);
-            });
-
-            AddStep(@"miss...", delegate
-            {
-                comboCounter.Current.Value = 0;
-                denominator++;
-                accuracyCounter.SetFraction(numerator, denominator);
-            });
-        }
-    }
-}

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

@@ -0,0 +1,49 @@
+// 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.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableAccuracyCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableAccuracyCounter> accuracyCounters => CreatedDrawables.OfType<SkinnableAccuracyCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var accuracyCounter = new SkinnableAccuracyCounter();
+
+                accuracyCounter.Current.Value = 1;
+
+                return accuracyCounter;
+            }));
+        }
+
+        [Test]
+        public void TestChangingAccuracy()
+        {
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in accuracyCounters)
+                    s.Current.Value = 1;
+            });
+
+            AddStep(@"Hit! :D", delegate
+            {
+                foreach (var s in accuracyCounters)
+                    s.Current.Value -= 0.023f;
+            });
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+// 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.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableHealthDisplay : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableHealthDisplay> healthDisplays => CreatedDrawables.OfType<SkinnableHealthDisplay>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create health displays", () =>
+            {
+                SetContents(() => new SkinnableHealthDisplay());
+            });
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in healthDisplays)
+                    s.Current.Value = 1;
+            });
+        }
+
+        [Test]
+        public void TestHealthDisplayIncrementing()
+        {
+            AddRepeatStep(@"decrease hp", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                    healthDisplay.Current.Value -= 0.08f;
+            }, 10);
+
+            AddRepeatStep(@"increase hp without flash", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                    healthDisplay.Current.Value += 0.1f;
+            }, 3);
+
+            AddRepeatStep(@"increase hp with flash", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                {
+                    healthDisplay.Current.Value += 0.1f;
+                    healthDisplay.Flash(new JudgementResult(null, new OsuJudgement()));
+                }
+            }, 3);
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+// 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.IEnumerableExtensions;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableScoreCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableScoreCounter> scoreCounters => CreatedDrawables.OfType<SkinnableScoreCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var comboCounter = new SkinnableScoreCounter();
+                comboCounter.Current.Value = 1;
+                return comboCounter;
+            }));
+        }
+
+        [Test]
+        public void TestScoreCounterIncrementing()
+        {
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in scoreCounters)
+                    s.Current.Value = 0;
+            });
+
+            AddStep(@"Hit! :D", delegate
+            {
+                foreach (var s in scoreCounters)
+                    s.Current.Value += 300;
+            });
+        }
+
+        [Test]
+        public void TestVeryLargeScore()
+        {
+            AddStep("set large score", () => scoreCounters.ForEach(counter => counter.Current.Value = 1_000_000_000));
+        }
+    }
+}

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

@@ -13,7 +13,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Testing;
-using osu.Framework.Timing;
 using osu.Game.Audio;
 using osu.Game.Screens.Play;
 using osu.Game.Skinning;
@@ -22,27 +21,24 @@ namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestSceneSkinnableSound : OsuTestScene
     {
-        [Cached(typeof(ISamplePlaybackDisabler))]
-        private GameplayClock gameplayClock = new GameplayClock(new FramedClock());
-
         private TestSkinSourceContainer skinSource;
         private PausableSkinnableSound skinnableSound;
 
         [SetUp]
-        public void SetUp() => Schedule(() =>
+        public void SetUpSteps()
         {
-            gameplayClock.IsPaused.Value = false;
-
-            Children = new Drawable[]
+            AddStep("setup hierarchy", () =>
             {
-                skinSource = new TestSkinSourceContainer
+                Children = new Drawable[]
                 {
-                    Clock = gameplayClock,
-                    RelativeSizeAxes = Axes.Both,
-                    Child = skinnableSound = new PausableSkinnableSound(new SampleInfo("normal-sliderslide"))
-                },
-            };
-        });
+                    skinSource = new TestSkinSourceContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = skinnableSound = new PausableSkinnableSound(new SampleInfo("normal-sliderslide"))
+                    },
+                };
+            });
+        }
 
         [Test]
         public void TestStoppedSoundDoesntResumeAfterPause()
@@ -62,8 +58,9 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
 
-            AddStep("pause gameplay clock", () => gameplayClock.IsPaused.Value = true);
-            AddStep("resume gameplay clock", () => gameplayClock.IsPaused.Value = false);
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
 
             AddWaitStep("wait a bit", 5);
             AddAssert("sample not playing", () => !sample.Playing);
@@ -82,8 +79,11 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddUntilStep("wait for sample to start playing", () => sample.Playing);
 
-            AddStep("pause gameplay clock", () => gameplayClock.IsPaused.Value = true);
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
             AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+            AddUntilStep("wait for sample to start playing", () => sample.Playing);
         }
 
         [Test]
@@ -98,10 +98,11 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddAssert("sample playing", () => sample.Playing);
 
-            AddStep("pause gameplay clock", () => gameplayClock.IsPaused.Value = true);
-            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
 
-            AddStep("resume gameplay clock", () => gameplayClock.IsPaused.Value = false);
+            AddUntilStep("sample not playing", () => !sample.Playing);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
 
             AddAssert("sample not playing", () => !sample.Playing);
             AddAssert("sample not playing", () => !sample.Playing);
@@ -120,7 +121,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddAssert("sample playing", () => sample.Playing);
 
-            AddStep("pause gameplay clock", () => gameplayClock.IsPaused.Value = true);
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
             AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
 
             AddStep("trigger skin change", () => skinSource.TriggerSourceChanged());
@@ -133,20 +134,25 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
 
             AddAssert("new sample stopped", () => !sample.Playing);
-            AddStep("resume gameplay clock", () => gameplayClock.IsPaused.Value = false);
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
 
             AddWaitStep("wait a bit", 5);
             AddAssert("new sample not played", () => !sample.Playing);
         }
 
         [Cached(typeof(ISkinSource))]
-        private class TestSkinSourceContainer : Container, ISkinSource
+        [Cached(typeof(ISamplePlaybackDisabler))]
+        private class TestSkinSourceContainer : Container, ISkinSource, ISamplePlaybackDisabler
         {
             [Resolved]
             private ISkinSource source { get; set; }
 
             public event Action SourceChanged;
 
+            public Bindable<bool> SamplePlaybackDisabled { get; } = new Bindable<bool>();
+
+            IBindable<bool> ISamplePlaybackDisabler.SamplePlaybackDisabled => SamplePlaybackDisabled;
+
             public Drawable GetDrawableComponent(ISkinComponent component) => source?.GetDrawableComponent(component);
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => source?.GetTexture(componentName, wrapModeS, wrapModeT);
             public SampleChannel GetSample(ISampleInfo sampleInfo) => source?.GetSample(sampleInfo);

osu.Game.Tests/Visual/Ranking/TestSceneHitEventTimingDistributionGraph.cs

@@ -23,6 +23,12 @@ namespace osu.Game.Tests.Visual.Ranking
             createTest(CreateDistributedHitEvents());
         }
 
+        [Test]
+        public void TestAroundCentre()
+        {
+            createTest(Enumerable.Range(-150, 300).Select(i => new HitEvent(i / 50f, HitResult.Perfect, new HitCircle(), new HitCircle(), null)).ToList());
+        }
+
         [Test]
         public void TestZeroTimeOffset()
         {

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

@@ -394,7 +394,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("Sort by author", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Author }, false));
             AddAssert("Check zzzzz is at bottom", () => carousel.BeatmapSets.Last().Metadata.AuthorString == "zzzzz");
             AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
-            AddAssert($"Check #{set_count} is at bottom", () => carousel.BeatmapSets.Last().Metadata.Title.EndsWith($"#{set_count}!"));
+            AddAssert($"Check #{set_count} is at bottom", () => carousel.BeatmapSets.Last().Metadata.Title.EndsWith($"#{set_count}!", StringComparison.Ordinal));
         }
 
         [Test]

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

@@ -9,6 +9,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Utils;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
@@ -18,10 +19,11 @@ using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.UI;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
-    public class TestSceneModSettings : OsuTestScene
+    public class TestSceneModSettings : OsuManualInputManagerTestScene
     {
         private TestModSelectOverlay modSelect;
 
@@ -95,6 +97,41 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddAssert("copy has original value", () => Precision.AlmostEquals(1.5, copy.SpeedChange.Value));
         }
 
+        [Test]
+        public void TestMultiModSettingsUnboundWhenCopied()
+        {
+            MultiMod original = null;
+            MultiMod copy = null;
+
+            AddStep("create mods", () =>
+            {
+                original = new MultiMod(new OsuModDoubleTime());
+                copy = (MultiMod)original.CreateCopy();
+            });
+
+            AddStep("change property", () => ((OsuModDoubleTime)original.Mods[0]).SpeedChange.Value = 2);
+
+            AddAssert("original has new value", () => Precision.AlmostEquals(2.0, ((OsuModDoubleTime)original.Mods[0]).SpeedChange.Value));
+            AddAssert("copy has original value", () => Precision.AlmostEquals(1.5, ((OsuModDoubleTime)copy.Mods[0]).SpeedChange.Value));
+        }
+
+        [Test]
+        public void TestCustomisationMenuNoClickthrough()
+        {
+            createModSelect();
+            openModSelect();
+
+            AddStep("change mod settings menu width to full screen", () => modSelect.SetModSettingsWidth(1.0f));
+            AddStep("select cm2", () => modSelect.SelectMod(testCustomisableAutoOpenMod));
+            AddAssert("Customisation opened", () => modSelect.ModSettingsContainer.Alpha == 1);
+            AddStep("hover over mod behind settings menu", () => InputManager.MoveMouseTo(modSelect.GetModButton(testCustomisableMod)));
+            AddAssert("Mod is not considered hovered over", () => !modSelect.GetModButton(testCustomisableMod).IsHovered);
+            AddStep("left click mod", () => InputManager.Click(MouseButton.Left));
+            AddAssert("only cm2 is active", () => SelectedMods.Value.Count == 1);
+            AddStep("right click mod", () => InputManager.Click(MouseButton.Right));
+            AddAssert("only cm2 is active", () => SelectedMods.Value.Count == 1);
+        }
+
         private void createModSelect()
         {
             AddStep("create mod select", () =>
@@ -121,9 +158,16 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             public bool ButtonsLoaded => ModSectionsContainer.Children.All(c => c.ModIconsLoaded);
 
+            public ModButton GetModButton(Mod mod)
+            {
+                return ModSectionsContainer.ChildrenOfType<ModButton>().Single(b => b.Mods.Any(m => m.GetType() == mod.GetType()));
+            }
+
             public void SelectMod(Mod mod) =>
-                ModSectionsContainer.Children.Single(s => s.ModType == mod.Type)
-                                    .ButtonsContainer.OfType<ModButton>().Single(b => b.Mods.Any(m => m.GetType() == mod.GetType())).SelectNext(1);
+                GetModButton(mod).SelectNext(1);
+
+            public void SetModSettingsWidth(float newWidth) =>
+                ModSettingsContainer.Width = newWidth;
         }
 
         public class TestRulesetInfo : RulesetInfo

osu.Game.Tests/WaveformTestBeatmap.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.IO;
 using System.Linq;
 using osu.Framework.Audio;
@@ -59,7 +60,7 @@ namespace osu.Game.Tests
             get
             {
                 using (var reader = getZipReader())
-                    return reader.Filenames.First(f => f.EndsWith(".mp3"));
+                    return reader.Filenames.First(f => f.EndsWith(".mp3", StringComparison.Ordinal));
             }
         }
 
@@ -73,7 +74,7 @@ namespace osu.Game.Tests
             protected override Beatmap CreateBeatmap()
             {
                 using (var reader = getZipReader())
-                using (var beatmapStream = reader.GetStream(reader.Filenames.First(f => f.EndsWith(".osu"))))
+                using (var beatmapStream = reader.GetStream(reader.Filenames.First(f => f.EndsWith(".osu", StringComparison.Ordinal))))
                 using (var beatmapReader = new LineBufferedReader(beatmapStream))
                     return Decoder.GetDecoder<Beatmap>(beatmapReader).Decode(beatmapReader);
             }