Merge pull request #10250 from smoogipoo/fix-taiko-crash

Fix potential taiko crash on rewind

README.md

@@ -38,7 +38,13 @@ If you are looking to install or test osu! without setting up a development envi
 
 If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.
 
-## Developing or debugging
+## Developing a custom ruleset
+
+osu! is designed to have extensible modular gameplay modes, called "rulesets". Building one of these allows a developer to harness the power of osu! for their own game style. To get started working on a ruleset, we have some templates available [here](https://github.com/ppy/osu-templates).
+
+You can see some examples of custom rulesets by visiting the [custom ruleset directory](https://github.com/ppy/osu/issues/5852).
+
+## Developing osu!
 
 Please make sure you have the following prerequisites:
 

osu.Android.props

@@ -52,6 +52,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.904.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.910.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.925.0" />
   </ItemGroup>
 </Project>

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

@@ -87,7 +87,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                 Schedule(() =>
                 {
                     area.AttemptCatch(fruit);
-                    area.OnResult(drawable, new JudgementResult(fruit, new CatchJudgement()) { Type = miss ? HitResult.Miss : HitResult.Great });
+                    area.OnNewResult(drawable, new JudgementResult(fruit, new CatchJudgement()) { Type = miss ? HitResult.Miss : HitResult.Great });
 
                     drawable.Expire();
                 });

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

@@ -0,0 +1,65 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneComboCounter : CatchSkinnableTestScene
+    {
+        private ScoreProcessor scoreProcessor;
+
+        private Color4 judgedObjectColour = Color4.White;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            scoreProcessor = new ScoreProcessor();
+
+            SetContents(() => new CatchComboDisplay
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Scale = new Vector2(2.5f),
+            });
+        });
+
+        [Test]
+        public void TestCatchComboCounter()
+        {
+            AddRepeatStep("perform hit", () => performJudgement(HitResult.Perfect), 20);
+            AddStep("perform miss", () => performJudgement(HitResult.Miss));
+
+            AddStep("randomize judged object colour", () =>
+            {
+                judgedObjectColour = new Color4(
+                    RNG.NextSingle(1f),
+                    RNG.NextSingle(1f),
+                    RNG.NextSingle(1f),
+                    1f
+                );
+            });
+        }
+
+        private void performJudgement(HitResult type, Judgement judgement = null)
+        {
+            var judgedObject = new DrawableFruit(new Fruit()) { AccentColour = { Value = judgedObjectColour } };
+
+            var result = new JudgementResult(judgedObject.HitObject, judgement ?? new Judgement()) { Type = type };
+            scoreProcessor.ApplyResult(result);
+
+            foreach (var counter in CreatedDrawables.Cast<CatchComboDisplay>())
+                counter.OnNewResult(judgedObject, result);
+        }
+    }
+}

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

@@ -5,6 +5,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Objects;
 using osu.Framework.Extensions.IEnumerableExtensions;
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
         public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
 
-        protected override IEnumerable<CatchHitObject> ConvertHitObject(HitObject obj, IBeatmap beatmap)
+        protected override IEnumerable<CatchHitObject> ConvertHitObject(HitObject obj, IBeatmap beatmap, CancellationToken cancellationToken)
         {
             var positionData = obj as IHasXPosition;
             var comboData = obj as IHasCombo;

osu.Game.Rulesets.Catch/CatchSkinComponents.cs

@@ -13,6 +13,7 @@ namespace osu.Game.Rulesets.Catch
         Droplet,
         CatcherIdle,
         CatcherFail,
-        CatcherKiai
+        CatcherKiai,
+        CatchComboCounter
     }
 }

osu.Game.Rulesets.Catch/Skinning/CatchLegacySkinTransformer.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
+using static osu.Game.Skinning.LegacySkinConfiguration;
 
 namespace osu.Game.Rulesets.Catch.Skinning
 {
@@ -52,6 +53,15 @@ namespace osu.Game.Rulesets.Catch.Skinning
                 case CatchSkinComponents.CatcherKiai:
                     return this.GetAnimation("fruit-catcher-kiai", true, true, true) ??
                            this.GetAnimation("fruit-ryuuta", true, true, true);
+
+                case CatchSkinComponents.CatchComboCounter:
+                    var comboFont = GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score";
+
+                    // For simplicity, let's use legacy combo font texture existence as a way to identify legacy skins from default.
+                    if (this.HasFont(comboFont))
+                        return new LegacyComboCounter(Source);
+
+                    break;
             }
 
             return null;

osu.Game.Rulesets.Catch/Skinning/LegacyComboCounter.cs

@@ -0,0 +1,103 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
+using static osu.Game.Skinning.LegacySkinConfiguration;
+
+namespace osu.Game.Rulesets.Catch.Skinning
+{
+    /// <summary>
+    /// A combo counter implementation that visually behaves almost similar to stable's osu!catch combo counter.
+    /// </summary>
+    public class LegacyComboCounter : CompositeDrawable, ICatchComboCounter
+    {
+        private readonly LegacyRollingCounter counter;
+
+        private readonly LegacyRollingCounter explosion;
+
+        public LegacyComboCounter(ISkin skin)
+        {
+            var fontName = skin.GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score";
+            var fontOverlap = skin.GetConfig<LegacySetting, float>(LegacySetting.ComboOverlap)?.Value ?? -2f;
+
+            AutoSizeAxes = Axes.Both;
+
+            Alpha = 0f;
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            Scale = new Vector2(0.8f);
+
+            InternalChildren = new Drawable[]
+            {
+                explosion = new LegacyRollingCounter(skin, fontName, fontOverlap)
+                {
+                    Alpha = 0.65f,
+                    Blending = BlendingParameters.Additive,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Scale = new Vector2(1.5f),
+                },
+                counter = new LegacyRollingCounter(skin, fontName, fontOverlap)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+            };
+        }
+
+        private int lastDisplayedCombo;
+
+        public void UpdateCombo(int combo, Color4? hitObjectColour = null)
+        {
+            if (combo == lastDisplayedCombo)
+                return;
+
+            // There may still be existing transforms to the counter (including value change after 250ms),
+            // finish them immediately before new transforms.
+            counter.SetCountWithoutRolling(lastDisplayedCombo);
+
+            lastDisplayedCombo = combo;
+
+            if (Time.Elapsed < 0)
+            {
+                // needs more work to make rewind somehow look good.
+                // basically we want the previous increment to play... or turning off RemoveCompletedTransforms (not feasible from a performance angle).
+                Hide();
+                return;
+            }
+
+            // Combo fell to zero, roll down and fade out the counter.
+            if (combo == 0)
+            {
+                counter.Current.Value = 0;
+                explosion.Current.Value = 0;
+
+                this.FadeOut(400, Easing.Out);
+            }
+            else
+            {
+                this.FadeInFromZero().Then().Delay(1000).FadeOut(300);
+
+                counter.ScaleTo(1.5f)
+                       .ScaleTo(0.8f, 250, Easing.Out)
+                       .OnComplete(c => c.SetCountWithoutRolling(combo));
+
+                counter.Delay(250)
+                       .ScaleTo(1f)
+                       .ScaleTo(1.1f, 60).Then().ScaleTo(1f, 30);
+
+                explosion.Colour = hitObjectColour ?? Color4.White;
+
+                explosion.SetCountWithoutRolling(combo);
+                explosion.ScaleTo(1.5f)
+                         .ScaleTo(1.9f, 400, Easing.Out)
+                         .FadeOutFromOne(400);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,62 @@
+// 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 JetBrains.Annotations;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    /// <summary>
+    /// Represents a component that displays a skinned <see cref="ICatchComboCounter"/> and handles combo judgement results for updating it accordingly.
+    /// </summary>
+    public class CatchComboDisplay : SkinnableDrawable
+    {
+        private int currentCombo;
+
+        [CanBeNull]
+        public ICatchComboCounter ComboCounter => Drawable as ICatchComboCounter;
+
+        public CatchComboDisplay()
+            : base(new CatchSkinComponent(CatchSkinComponents.CatchComboCounter), _ => Empty())
+        {
+        }
+
+        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+        {
+            base.SkinChanged(skin, allowFallback);
+            ComboCounter?.UpdateCombo(currentCombo);
+        }
+
+        public void OnNewResult(DrawableCatchHitObject judgedObject, JudgementResult result)
+        {
+            if (!result.Judgement.AffectsCombo || !result.HasResult)
+                return;
+
+            if (result.Type == HitResult.Miss)
+            {
+                updateCombo(0, null);
+                return;
+            }
+
+            updateCombo(result.ComboAtJudgement + 1, judgedObject.AccentColour.Value);
+        }
+
+        public void OnRevertResult(DrawableCatchHitObject judgedObject, JudgementResult result)
+        {
+            if (!result.Judgement.AffectsCombo || !result.HasResult)
+                return;
+
+            updateCombo(result.ComboAtJudgement, judgedObject.AccentColour.Value);
+        }
+
+        private void updateCombo(int newCombo, Color4? hitObjectColour)
+        {
+            currentCombo = newCombo;
+            ComboCounter?.UpdateCombo(newCombo, hitObjectColour);
+        }
+    }
+}

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

@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 explodingFruitContainer,
                 CatcherArea.MovableCatcher.CreateProxiedContent(),
                 HitObjectContainer,
-                CatcherArea
+                CatcherArea,
             };
         }
 
@@ -62,6 +62,7 @@ namespace osu.Game.Rulesets.Catch.UI
         public override void Add(DrawableHitObject h)
         {
             h.OnNewResult += onNewResult;
+            h.OnRevertResult += onRevertResult;
 
             base.Add(h);
 
@@ -70,6 +71,9 @@ namespace osu.Game.Rulesets.Catch.UI
         }
 
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
-            => CatcherArea.OnResult((DrawableCatchHitObject)judgedObject, result);
+            => CatcherArea.OnNewResult((DrawableCatchHitObject)judgedObject, result);
+
+        private void onRevertResult(DrawableHitObject judgedObject, JudgementResult result)
+            => CatcherArea.OnRevertResult((DrawableCatchHitObject)judgedObject, result);
     }
 }

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

@@ -23,6 +23,7 @@ namespace osu.Game.Rulesets.Catch.UI
         public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> CreateDrawableRepresentation;
 
         public readonly Catcher MovableCatcher;
+        private readonly CatchComboDisplay comboDisplay;
 
         public Container ExplodingFruitTarget
         {
@@ -34,10 +35,22 @@ namespace osu.Game.Rulesets.Catch.UI
         public CatcherArea(BeatmapDifficulty difficulty = null)
         {
             Size = new Vector2(CatchPlayfield.WIDTH, CATCHER_SIZE);
-            Child = MovableCatcher = new Catcher(this, difficulty) { X = CatchPlayfield.CENTER_X };
+            Children = new Drawable[]
+            {
+                comboDisplay = new CatchComboDisplay
+                {
+                    RelativeSizeAxes = Axes.None,
+                    AutoSizeAxes = Axes.Both,
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.Centre,
+                    Margin = new MarginPadding { Bottom = 350f },
+                    X = CatchPlayfield.CENTER_X
+                },
+                MovableCatcher = new Catcher(this, difficulty) { X = CatchPlayfield.CENTER_X },
+            };
         }
 
-        public void OnResult(DrawableCatchHitObject fruit, JudgementResult result)
+        public void OnNewResult(DrawableCatchHitObject fruit, JudgementResult result)
         {
             if (result.Judgement is IgnoreJudgement)
                 return;
@@ -86,8 +99,13 @@ namespace osu.Game.Rulesets.Catch.UI
                 else
                     MovableCatcher.Drop();
             }
+
+            comboDisplay.OnNewResult(fruit, result);
         }
 
+        public void OnRevertResult(DrawableCatchHitObject fruit, JudgementResult result)
+            => comboDisplay.OnRevertResult(fruit, result);
+
         public void OnReleased(CatchAction action)
         {
         }
@@ -105,6 +123,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
             if (state?.CatcherX != null)
                 MovableCatcher.X = state.CatcherX.Value;
+
+            comboDisplay.X = MovableCatcher.X;
         }
     }
 }

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

@@ -0,0 +1,24 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    /// <summary>
+    /// An interface providing a set of methods to update the combo counter.
+    /// </summary>
+    public interface ICatchComboCounter : IDrawable
+    {
+        /// <summary>
+        /// Updates the counter to animate a transition from the old combo value it had to the current provided one.
+        /// </summary>
+        /// <remarks>
+        /// This is called regardless of whether the clock is rewinding.
+        /// </remarks>
+        /// <param name="combo">The new combo value.</param>
+        /// <param name="hitObjectColour">The colour of the object if hit, null on miss.</param>
+        void UpdateCombo(int combo, Color4? hitObjectColour = null);
+    }
+}

osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs

@@ -16,7 +16,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public abstract class ManiaPlacementBlueprintTestScene : PlacementBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/ManiaSelectionBlueprintTestScene.cs

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Tests.Visual;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public abstract class ManiaSelectionBlueprintTestScene : SelectionBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneEditor.cs

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     [TestFixture]
     public class TestSceneEditor : EditorTestScene

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNotePlacementBlueprint.cs

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneHoldNotePlacementBlueprint : ManiaPlacementBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNoteSelectionBlueprint.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneHoldNoteSelectionBlueprint : ManiaSelectionBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaBeatSnapGrid.cs

@@ -20,7 +20,7 @@ using osu.Game.Screens.Edit;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneManiaBeatSnapGrid : EditorClockTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs

@@ -23,7 +23,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneManiaHitObjectComposer : EditorClockTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs

@@ -18,7 +18,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneNotePlacementBlueprint : ManiaPlacementBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNoteSelectionBlueprint.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneNoteSelectionBlueprint : ManiaSelectionBlueprintTestScene
     {

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

@@ -5,6 +5,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using System;
 using System.Linq;
 using System.Collections.Generic;
+using System.Threading;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
@@ -68,14 +69,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
 
-        protected override Beatmap<ManiaHitObject> ConvertBeatmap(IBeatmap original)
+        protected override Beatmap<ManiaHitObject> ConvertBeatmap(IBeatmap original, CancellationToken cancellationToken)
         {
             BeatmapDifficulty difficulty = original.BeatmapInfo.BaseDifficulty;
 
             int seed = (int)MathF.Round(difficulty.DrainRate + difficulty.CircleSize) * 20 + (int)(difficulty.OverallDifficulty * 41.2) + (int)MathF.Round(difficulty.ApproachRate);
             Random = new FastRandom(seed);
 
-            return base.ConvertBeatmap(original);
+            return base.ConvertBeatmap(original, cancellationToken);
         }
 
         protected override Beatmap<ManiaHitObject> CreateBeatmap()
@@ -88,7 +89,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             return beatmap;
         }
 
-        protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap)
+        protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
         {
             if (original is ManiaHitObject maniaOriginal)
             {

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
         {
             base.InitialiseDefaults();
 
-            Set(ManiaRulesetSetting.ScrollTime, 1500.0, DrawableManiaRuleset.MIN_TIME_RANGE, DrawableManiaRuleset.MAX_TIME_RANGE, 1);
+            Set(ManiaRulesetSetting.ScrollTime, 1500.0, DrawableManiaRuleset.MIN_TIME_RANGE, DrawableManiaRuleset.MAX_TIME_RANGE, 5);
             Set(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
         }
 

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -34,7 +34,8 @@ namespace osu.Game.Rulesets.Mania
                 new SettingsSlider<double, TimeSlider>
                 {
                     LabelText = "Scroll speed",
-                    Bindable = config.GetBindable<double>(ManiaRulesetSetting.ScrollTime)
+                    Bindable = config.GetBindable<double>(ManiaRulesetSetting.ScrollTime),
+                    KeyboardStep = 5
                 },
             };
         }

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneHitCirclePlacementBlueprint : PlacementBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCircleSelectionBlueprint.cs

@@ -11,7 +11,7 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneHitCircleSelectionBlueprint : SelectionBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneObjectObjectSnap.cs

@@ -0,0 +1,90 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    [TestFixture]
+    public class TestSceneObjectObjectSnap : TestSceneOsuEditor
+    {
+        private OsuPlayfield playfield;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(Ruleset.Value, false);
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+            AddStep("get playfield", () => playfield = Editor.ChildrenOfType<OsuPlayfield>().First());
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestHitCircleSnapsToOtherHitCircle(bool distanceSnapEnabled)
+        {
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre));
+
+            if (!distanceSnapEnabled)
+                AddStep("disable distance snap", () => InputManager.Key(Key.Q));
+
+            AddStep("enter placement mode", () => InputManager.Key(Key.Number2));
+
+            AddStep("place first object", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.02f, 0)));
+
+            AddStep("place second object", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("both objects at same location", () =>
+            {
+                var objects = EditorBeatmap.HitObjects;
+
+                var first = (OsuHitObject)objects.First();
+                var second = (OsuHitObject)objects.Last();
+
+                return first.Position == second.Position;
+            });
+        }
+
+        [Test]
+        public void TestHitCircleSnapsToSliderEnd()
+        {
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre));
+
+            AddStep("disable distance snap", () => InputManager.Key(Key.Q));
+
+            AddStep("enter slider placement mode", () => InputManager.Key(Key.Number3));
+
+            AddStep("start slider placement", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move to place end", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.185f, 0)));
+
+            AddStep("end slider placement", () => InputManager.Click(MouseButton.Right));
+
+            AddStep("enter circle placement mode", () => InputManager.Key(Key.Number2));
+
+            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.20f, 0)));
+
+            AddStep("place second object", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("circle is at slider's end", () =>
+            {
+                var objects = EditorBeatmap.HitObjects;
+
+                var first = (Slider)objects.First();
+                var second = (OsuHitObject)objects.Last();
+
+                return Precision.AlmostEquals(first.EndPosition, second.Position);
+            });
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuDistanceSnapGrid.cs

@@ -19,7 +19,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneOsuDistanceSnapGrid : OsuManualInputManagerTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditor.cs

@@ -4,10 +4,10 @@
 using NUnit.Framework;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     [TestFixture]
-    public class TestSceneEditor : EditorTestScene
+    public class TestSceneOsuEditor : EditorTestScene
     {
         protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
     }

osu.Game.Rulesets.Osu.Tests/Editor/TestScenePathControlPointVisualiser.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestScenePathControlPointVisualiser : OsuTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs

@@ -14,7 +14,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneSliderPlacementBlueprint : PlacementBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs

@@ -16,7 +16,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneSliderSelectionBlueprint : SelectionBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneSpinnerPlacementBlueprint : PlacementBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerSelectionBlueprint.cs

@@ -11,7 +11,7 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneSpinnerSelectionBlueprint : SelectionBlueprintTestScene
     {

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

@@ -8,6 +8,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using System.Collections.Generic;
 using osu.Game.Rulesets.Objects.Types;
 using System.Linq;
+using System.Threading;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Framework.Extensions.IEnumerableExtensions;
 
@@ -22,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 
         public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasPosition);
 
-        protected override IEnumerable<OsuHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap)
+        protected override IEnumerable<OsuHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
         {
             var positionData = original as IHasPosition;
             var comboData = original as IHasCombo;

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/Components/SpinnerPiece.cs

@@ -34,11 +34,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
                     Alpha = 0.5f,
                     Child = new Box { RelativeSizeAxes = Axes.Both }
                 },
-                ring = new RingPiece
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre
-                }
+                ring = new RingPiece()
             };
         }
 

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

@@ -9,7 +9,9 @@ using osu.Framework.Bindables;
 using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
@@ -17,6 +19,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
@@ -39,21 +42,31 @@ namespace osu.Game.Rulesets.Osu.Edit
             new SpinnerCompositionTool()
         };
 
-        private readonly BindableBool distanceSnapToggle = new BindableBool(true) { Description = "Distance Snap" };
+        private readonly Bindable<TernaryState> distanceSnapToggle = new Bindable<TernaryState>();
 
-        protected override IEnumerable<BindableBool> Toggles => new[]
+        protected override IEnumerable<TernaryButton> CreateTernaryButtons() => base.CreateTernaryButtons().Concat(new[]
         {
-            distanceSnapToggle
-        };
+            new TernaryButton(distanceSnapToggle, "Distance Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Ruler })
+        });
+
+        private BindableList<HitObject> selectedHitObjects;
+
+        private Bindable<HitObject> placementObject;
 
         [BackgroundDependencyLoader]
         private void load()
         {
             LayerBelowRuleset.Add(distanceSnapGridContainer = new Container { RelativeSizeAxes = Axes.Both });
 
-            EditorBeatmap.SelectedHitObjects.CollectionChanged += (_, __) => updateDistanceSnapGrid();
-            EditorBeatmap.PlacementObject.ValueChanged += _ => updateDistanceSnapGrid();
+            selectedHitObjects = EditorBeatmap.SelectedHitObjects.GetBoundCopy();
+            selectedHitObjects.CollectionChanged += (_, __) => updateDistanceSnapGrid();
+
+            placementObject = EditorBeatmap.PlacementObject.GetBoundCopy();
+            placementObject.ValueChanged += _ => updateDistanceSnapGrid();
             distanceSnapToggle.ValueChanged += _ => updateDistanceSnapGrid();
+
+            // we may be entering the screen with a selection already active
+            updateDistanceSnapGrid();
         }
 
         protected override ComposeBlueprintContainer CreateBlueprintContainer(IEnumerable<DrawableHitObject> hitObjects)
@@ -84,6 +97,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition)
         {
+            if (snapToVisibleBlueprints(screenSpacePosition, out var snapResult))
+                return snapResult;
+
+            // will be null if distance snap is disabled or not feasible for the current time value.
             if (distanceSnapGrid == null)
                 return base.SnapScreenSpacePositionToValidTime(screenSpacePosition);
 
@@ -92,13 +109,57 @@ namespace osu.Game.Rulesets.Osu.Edit
             return new SnapResult(distanceSnapGrid.ToScreenSpace(pos), time, PlayfieldAtScreenSpacePosition(screenSpacePosition));
         }
 
+        private bool snapToVisibleBlueprints(Vector2 screenSpacePosition, out SnapResult snapResult)
+        {
+            // check other on-screen objects for snapping/stacking
+            var blueprints = BlueprintContainer.SelectionBlueprints.AliveChildren;
+
+            var playfield = PlayfieldAtScreenSpacePosition(screenSpacePosition);
+
+            float snapRadius =
+                playfield.GamefieldToScreenSpace(new Vector2(OsuHitObject.OBJECT_RADIUS / 5)).X -
+                playfield.GamefieldToScreenSpace(Vector2.Zero).X;
+
+            foreach (var b in blueprints)
+            {
+                if (b.IsSelected)
+                    continue;
+
+                var hitObject = (OsuHitObject)b.HitObject;
+
+                Vector2? snap = checkSnap(hitObject.Position);
+                if (snap == null && hitObject.Position != hitObject.EndPosition)
+                    snap = checkSnap(hitObject.EndPosition);
+
+                if (snap != null)
+                {
+                    // only return distance portion, since time is not really valid
+                    snapResult = new SnapResult(snap.Value, null, playfield);
+                    return true;
+                }
+
+                Vector2? checkSnap(Vector2 checkPos)
+                {
+                    Vector2 checkScreenPos = playfield.GamefieldToScreenSpace(checkPos);
+
+                    if (Vector2.Distance(checkScreenPos, screenSpacePosition) < snapRadius)
+                        return checkScreenPos;
+
+                    return null;
+                }
+            }
+
+            snapResult = null;
+            return false;
+        }
+
         private void updateDistanceSnapGrid()
         {
             distanceSnapGridContainer.Clear();
             distanceSnapGridCache.Invalidate();
             distanceSnapGrid = null;
 
-            if (!distanceSnapToggle.Value)
+            if (distanceSnapToggle.Value != TernaryState.True)
                 return;
 
             switch (BlueprintContainer.CurrentTool)

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

@@ -46,7 +46,20 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
         private void addConnection(FollowPointConnection connection)
         {
             // Groups are sorted by their start time when added such that the index can be used to post-process other surrounding connections
-            int index = connections.AddInPlace(connection, Comparer<FollowPointConnection>.Create((g1, g2) => g1.StartTime.Value.CompareTo(g2.StartTime.Value)));
+            int index = connections.AddInPlace(connection, Comparer<FollowPointConnection>.Create((g1, g2) =>
+            {
+                int comp = g1.StartTime.Value.CompareTo(g2.StartTime.Value);
+
+                if (comp != 0)
+                    return comp;
+
+                // we always want to insert the new item after equal ones.
+                // this is important for beatmaps with multiple hitobjects at the same point in time.
+                // if we use standard comparison insert order, there will be a churn of connections getting re-updated to
+                // the next object at the point-in-time, adding a construction/disposal overhead (see FollowPointConnection.End implementation's ClearInternal).
+                // this is easily visible on https://osu.ppy.sh/beatmapsets/150945#osu/372245
+                return -1;
+            }));
 
             if (index < connections.Count - 1)
             {

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

@@ -9,7 +9,7 @@ using osu.Framework.Graphics.Shapes;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class RingPiece : Container
+    public class RingPiece : CircularContainer
     {
         public RingPiece()
         {
@@ -18,21 +18,15 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            InternalChild = new CircularContainer
+            Masking = true;
+            BorderThickness = 10;
+            BorderColour = Color4.White;
+
+            Child = new Box
             {
-                Masking = true,
-                BorderThickness = 10,
-                BorderColour = Color4.White,
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        AlwaysPresent = true,
-                        Alpha = 0,
-                        RelativeSizeAxes = Axes.Both
-                    }
-                }
+                AlwaysPresent = true,
+                Alpha = 0,
+                RelativeSizeAxes = Axes.Both
             };
         }
     }

osu.Game.Rulesets.Osu/Objects/Slider.cs

@@ -7,6 +7,7 @@ using System.Collections.Generic;
 using osu.Game.Rulesets.Objects;
 using System.Linq;
 using System.Threading;
+using Newtonsoft.Json;
 using osu.Framework.Caching;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
@@ -21,6 +22,7 @@ namespace osu.Game.Rulesets.Osu.Objects
     {
         public double EndTime => StartTime + this.SpanCount() * Path.Distance / Velocity;
 
+        [JsonIgnore]
         public double Duration
         {
             get => EndTime - StartTime;
@@ -112,8 +114,11 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public double TickDistanceMultiplier = 1;
 
-        public HitCircle HeadCircle;
-        public SliderTailCircle TailCircle;
+        [JsonIgnore]
+        public HitCircle HeadCircle { get; protected set; }
+
+        [JsonIgnore]
+        public SliderTailCircle TailCircle { get; protected set; }
 
         public Slider()
         {

osu.Game.Rulesets.Osu/Objects/Spinner.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 osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
@@ -48,14 +49,16 @@ namespace osu.Game.Rulesets.Osu.Objects
             MaximumBonusSpins = (int)((maximum_rotations_per_second - minimumRotationsPerSecond) * secondsDuration);
         }
 
-        protected override void CreateNestedHitObjects()
+        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
         {
-            base.CreateNestedHitObjects();
+            base.CreateNestedHitObjects(cancellationToken);
 
             int totalSpins = MaximumBonusSpins + SpinsRequired;
 
             for (int i = 0; i < totalSpins; i++)
             {
+                cancellationToken.ThrowIfCancellationRequested();
+
                 double startTime = StartTime + (float)(i + 1) / totalSpins * Duration;
 
                 AddNested(i < SpinsRequired

osu.Game.Rulesets.Osu/Skinning/OsuLegacySkinTransformer.cs

@@ -94,7 +94,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
                     var font = GetConfig<OsuSkinConfiguration, string>(OsuSkinConfiguration.HitCirclePrefix)?.Value ?? "default";
                     var overlap = GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.HitCircleOverlap)?.Value ?? -2;
 
-                    return !hasFont(font)
+                    return !this.HasFont(font)
                         ? null
                         : new LegacySpriteText(Source, font)
                         {
@@ -145,7 +145,5 @@ namespace osu.Game.Rulesets.Osu.Skinning
 
             return Source.GetConfig<TLookup, TValue>(lookup);
         }
-
-        private bool hasFont(string fontName) => Source.GetTexture($"{fontName}-0") != null;
     }
 }

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

@@ -2,26 +2,30 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
-    internal class DrawableTestHit : DrawableTaikoHitObject
+    public class DrawableTestHit : DrawableHit
     {
-        private readonly HitResult type;
+        public readonly HitResult Type;
 
         public DrawableTestHit(Hit hit, HitResult type = HitResult.Great)
             : base(hit)
         {
-            this.type = type;
+            Type = type;
+
+            HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            Result.Type = type;
+            Result.Type = Type;
         }
 
         public override bool OnPressed(TaikoAction action) => false;

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

@@ -0,0 +1,35 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    public class DrawableTestStrongHit : DrawableTestHit
+    {
+        private readonly bool hitBoth;
+
+        public DrawableTestStrongHit(double startTime, HitResult type = HitResult.Great, bool hitBoth = true)
+            : base(new Hit
+            {
+                IsStrong = true,
+                StartTime = startTime,
+            }, type)
+        {
+            this.hitBoth = hitBoth;
+        }
+
+        protected override void LoadAsyncComplete()
+        {
+            base.LoadAsyncComplete();
+
+            var nestedStrongHit = (DrawableStrongNestedHit)NestedHitObjects.Single();
+            nestedStrongHit.Result.Type = hitBoth ? Type : HitResult.Miss;
+        }
+
+        public override bool OnPressed(TaikoAction action) => false;
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneEditor.cs

@@ -4,7 +4,7 @@
 using NUnit.Framework;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Taiko.Tests
+namespace osu.Game.Rulesets.Taiko.Tests.Editor
 {
     [TestFixture]
     public class TestSceneEditor : EditorTestScene

osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneTaikoHitObjectComposer.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Screens.Edit;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Taiko.Tests
+namespace osu.Game.Rulesets.Taiko.Tests.Editor
 {
     public class TestSceneTaikoHitObjectComposer : EditorClockTestScene
     {

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

@@ -2,12 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
-using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.UI;
 
 namespace osu.Game.Rulesets.Taiko.Tests.Skinning
@@ -15,25 +13,30 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
     [TestFixture]
     public class TestSceneHitExplosion : TaikoSkinnableTestScene
     {
-        [BackgroundDependencyLoader]
-        private void load()
+        [Test]
+        public void TestNormalHit()
         {
-            AddStep("Great", () => SetContents(() => getContentFor(HitResult.Great)));
-            AddStep("Good", () => SetContents(() => getContentFor(HitResult.Good)));
-            AddStep("Miss", () => SetContents(() => getContentFor(HitResult.Miss)));
+            AddStep("Great", () => SetContents(() => getContentFor(createHit(HitResult.Great))));
+            AddStep("Good", () => SetContents(() => getContentFor(createHit(HitResult.Good))));
+            AddStep("Miss", () => SetContents(() => getContentFor(createHit(HitResult.Miss))));
         }
 
-        private Drawable getContentFor(HitResult type)
+        [Test]
+        public void TestStrongHit([Values(false, true)] bool hitBoth)
         {
-            DrawableTaikoHitObject hit;
+            AddStep("Great", () => SetContents(() => getContentFor(createStrongHit(HitResult.Great, hitBoth))));
+            AddStep("Good", () => SetContents(() => getContentFor(createStrongHit(HitResult.Good, hitBoth))));
+        }
 
+        private Drawable getContentFor(DrawableTestHit hit)
+        {
             return new Container
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
                 {
-                    hit = createHit(type),
-                    new HitExplosion(hit)
+                    hit,
+                    new HitExplosion(hit, hit.Type)
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
@@ -42,6 +45,8 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
             };
         }
 
-        private DrawableTaikoHitObject createHit(HitResult type) => new DrawableTestHit(new Hit { StartTime = Time.Current }, type);
+        private DrawableTestHit createHit(HitResult type) => new DrawableTestHit(new Hit { StartTime = Time.Current }, type);
+
+        private DrawableTestHit createStrongHit(HitResult type, bool hitBoth) => new DrawableTestStrongHit(Time.Current, type, hitBoth);
     }
 }

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

@@ -13,8 +13,8 @@ namespace osu.Game.Rulesets.Taiko.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";
 
-        [TestCase(2.9811338051242915d, "diffcalc-test")]
-        [TestCase(2.9811338051242915d, "diffcalc-test-strong")]
+        [TestCase(2.2867022617692685d, "diffcalc-test")]
+        [TestCase(2.2867022617692685d, "diffcalc-test-strong")]
         public void Test(double expected, string name)
             => base.Test(expected, name);
 

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

@@ -174,7 +174,9 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
         private void addMissJudgement()
         {
-            ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(new DrawableTestHit(new Hit()), new JudgementResult(new HitObject(), new TaikoJudgement()) { Type = HitResult.Miss });
+            DrawableTestHit h;
+            Add(h = new DrawableTestHit(new Hit(), HitResult.Miss));
+            ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(h, new JudgementResult(new HitObject(), new TaikoJudgement()) { Type = HitResult.Miss });
         }
 
         private void addBarLine(bool major, double delay = scroll_time)

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

@@ -8,6 +8,8 @@ using osu.Game.Rulesets.Taiko.Objects;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Utils;
+using System.Threading;
 using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Formats;
@@ -48,14 +50,14 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 
         public override bool CanConvert() => true;
 
-        protected override Beatmap<TaikoHitObject> ConvertBeatmap(IBeatmap original)
+        protected override Beatmap<TaikoHitObject> ConvertBeatmap(IBeatmap original, CancellationToken cancellationToken)
         {
             // Rewrite the beatmap info to add the slider velocity multiplier
             original.BeatmapInfo = original.BeatmapInfo.Clone();
             original.BeatmapInfo.BaseDifficulty = original.BeatmapInfo.BaseDifficulty.Clone();
             original.BeatmapInfo.BaseDifficulty.SliderMultiplier *= LEGACY_VELOCITY_MULTIPLIER;
 
-            Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original);
+            Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original, cancellationToken);
 
             if (original.BeatmapInfo.RulesetID == 3)
             {
@@ -72,7 +74,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             return converted;
         }
 
-        protected override IEnumerable<TaikoHitObject> ConvertHitObject(HitObject obj, IBeatmap beatmap)
+        protected override IEnumerable<TaikoHitObject> ConvertHitObject(HitObject obj, IBeatmap beatmap, CancellationToken cancellationToken)
         {
             // Old osu! used hit sounding to determine various hit type information
             IList<HitSampleInfo> samples = obj.Samples;
@@ -104,6 +106,9 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                             };
 
                             i = (i + 1) % allSamples.Count;
+
+                            if (Precision.AlmostEquals(0, tickSpacing))
+                                break;
                         }
                     }
                     else

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/StaminaCheeseDetector.cs

@@ -0,0 +1,145 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
+{
+    /// <summary>
+    /// Detects special hit object patterns which are easier to hit using special techniques
+    /// than normally assumed in the fully-alternating play style.
+    /// </summary>
+    /// <remarks>
+    /// This component detects two basic types of patterns, leveraged by the following techniques:
+    /// <list>
+    /// <item>Rolling allows hitting patterns with quickly and regularly alternating notes with a single hand.</item>
+    /// <item>TL tapping makes hitting longer sequences of consecutive same-colour notes with little to no colour changes in-between.</item>
+    /// </list>
+    /// </remarks>
+    public class StaminaCheeseDetector
+    {
+        /// <summary>
+        /// The minimum number of consecutive objects with repeating patterns that can be classified as hittable using a roll.
+        /// </summary>
+        private const int roll_min_repetitions = 12;
+
+        /// <summary>
+        /// The minimum number of consecutive objects with repeating patterns that can be classified as hittable using a TL tap.
+        /// </summary>
+        private const int tl_min_repetitions = 16;
+
+        /// <summary>
+        /// The list of all <see cref="TaikoDifficultyHitObject"/>s in the map.
+        /// </summary>
+        private readonly List<TaikoDifficultyHitObject> hitObjects;
+
+        public StaminaCheeseDetector(List<TaikoDifficultyHitObject> hitObjects)
+        {
+            this.hitObjects = hitObjects;
+        }
+
+        /// <summary>
+        /// Finds and marks all objects in <see cref="hitObjects"/> that special difficulty-reducing techiques apply to
+        /// with the <see cref="TaikoDifficultyHitObject.StaminaCheese"/> flag.
+        /// </summary>
+        public void FindCheese()
+        {
+            findRolls(3);
+            findRolls(4);
+
+            findTlTap(0, HitType.Rim);
+            findTlTap(1, HitType.Rim);
+            findTlTap(0, HitType.Centre);
+            findTlTap(1, HitType.Centre);
+        }
+
+        /// <summary>
+        /// Finds and marks all sequences hittable using a roll.
+        /// </summary>
+        /// <param name="patternLength">The length of a single repeating pattern to consider (triplets/quadruplets).</param>
+        private void findRolls(int patternLength)
+        {
+            var history = new LimitedCapacityQueue<TaikoDifficultyHitObject>(2 * patternLength);
+
+            // for convenience, we're tracking the index of the item *before* our suspected repeat's start,
+            // as that index can be simply subtracted from the current index to get the number of elements in between
+            // without off-by-one errors
+            int indexBeforeLastRepeat = -1;
+            int lastMarkEnd = 0;
+
+            for (int i = 0; i < hitObjects.Count; i++)
+            {
+                history.Enqueue(hitObjects[i]);
+                if (!history.Full)
+                    continue;
+
+                if (!containsPatternRepeat(history, patternLength))
+                {
+                    // we're setting this up for the next iteration, hence the +1.
+                    // right here this index will point at the queue's front (oldest item),
+                    // but that item is about to be popped next loop with an enqueue.
+                    indexBeforeLastRepeat = i - history.Count + 1;
+                    continue;
+                }
+
+                int repeatedLength = i - indexBeforeLastRepeat;
+                if (repeatedLength < roll_min_repetitions)
+                    continue;
+
+                markObjectsAsCheese(Math.Max(lastMarkEnd, i - repeatedLength + 1), i);
+                lastMarkEnd = i;
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the objects stored in <paramref name="history"/> contain a repetition of a pattern of length <paramref name="patternLength"/>.
+        /// </summary>
+        private static bool containsPatternRepeat(LimitedCapacityQueue<TaikoDifficultyHitObject> history, int patternLength)
+        {
+            for (int j = 0; j < patternLength; j++)
+            {
+                if (history[j].HitType != history[j + patternLength].HitType)
+                    return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Finds and marks all sequences hittable using a TL tap.
+        /// </summary>
+        /// <param name="parity">Whether sequences starting with an odd- (1) or even-indexed (0) hit object should be checked.</param>
+        /// <param name="type">The type of hit to check for TL taps.</param>
+        private void findTlTap(int parity, HitType type)
+        {
+            int tlLength = -2;
+            int lastMarkEnd = 0;
+
+            for (int i = parity; i < hitObjects.Count; i += 2)
+            {
+                if (hitObjects[i].HitType == type)
+                    tlLength += 2;
+                else
+                    tlLength = -2;
+
+                if (tlLength < tl_min_repetitions)
+                    continue;
+
+                markObjectsAsCheese(Math.Max(lastMarkEnd, i - tlLength + 1), i);
+                lastMarkEnd = i;
+            }
+        }
+
+        /// <summary>
+        /// Marks all objects from <paramref name="start"/> to <paramref name="end"/> (inclusive) as <see cref="TaikoDifficultyHitObject.StaminaCheese"/>.
+        /// </summary>
+        private void markObjectsAsCheese(int start, int end)
+        {
+            for (int i = start; i <= end; i++)
+                hitObjects[i].StaminaCheese = true;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/TaikoDifficultyHitObject.cs

@@ -1,20 +1,94 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
 {
+    /// <summary>
+    /// Represents a single hit object in taiko difficulty calculation.
+    /// </summary>
     public class TaikoDifficultyHitObject : DifficultyHitObject
     {
-        public readonly bool HasTypeChange;
+        /// <summary>
+        /// The rhythm required to hit this hit object.
+        /// </summary>
+        public readonly TaikoDifficultyHitObjectRhythm Rhythm;
 
-        public TaikoDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate)
+        /// <summary>
+        /// The hit type of this hit object.
+        /// </summary>
+        public readonly HitType? HitType;
+
+        /// <summary>
+        /// The index of the object in the beatmap.
+        /// </summary>
+        public readonly int ObjectIndex;
+
+        /// <summary>
+        /// Whether the object should carry a penalty due to being hittable using special techniques
+        /// making it easier to do so.
+        /// </summary>
+        public bool StaminaCheese;
+
+        /// <summary>
+        /// Creates a new difficulty hit object.
+        /// </summary>
+        /// <param name="hitObject">The gameplay <see cref="HitObject"/> associated with this difficulty object.</param>
+        /// <param name="lastObject">The gameplay <see cref="HitObject"/> preceding <paramref name="hitObject"/>.</param>
+        /// <param name="lastLastObject">The gameplay <see cref="HitObject"/> preceding <paramref name="lastObject"/>.</param>
+        /// <param name="clockRate">The rate of the gameplay clock. Modified by speed-changing mods.</param>
+        /// <param name="objectIndex">The index of the object in the beatmap.</param>
+        public TaikoDifficultyHitObject(HitObject hitObject, HitObject lastObject, HitObject lastLastObject, double clockRate, int objectIndex)
             : base(hitObject, lastObject, clockRate)
         {
-            HasTypeChange = (lastObject as Hit)?.Type != (hitObject as Hit)?.Type;
+            var currentHit = hitObject as Hit;
+
+            Rhythm = getClosestRhythm(lastObject, lastLastObject, clockRate);
+            HitType = currentHit?.Type;
+
+            ObjectIndex = objectIndex;
+        }
+
+        /// <summary>
+        /// List of most common rhythm changes in taiko maps.
+        /// </summary>
+        /// <remarks>
+        /// The general guidelines for the values are:
+        /// <list type="bullet">
+        /// <item>rhythm changes with ratio closer to 1 (that are <i>not</i> 1) are harder to play,</item>
+        /// <item>speeding up is <i>generally</i> harder than slowing down (with exceptions of rhythm changes requiring a hand switch).</item>
+        /// </list>
+        /// </remarks>
+        private static readonly TaikoDifficultyHitObjectRhythm[] common_rhythms =
+        {
+            new TaikoDifficultyHitObjectRhythm(1, 1, 0.0),
+            new TaikoDifficultyHitObjectRhythm(2, 1, 0.3),
+            new TaikoDifficultyHitObjectRhythm(1, 2, 0.5),
+            new TaikoDifficultyHitObjectRhythm(3, 1, 0.3),
+            new TaikoDifficultyHitObjectRhythm(1, 3, 0.35),
+            new TaikoDifficultyHitObjectRhythm(3, 2, 0.6), // purposefully higher (requires hand switch in full alternating gameplay style)
+            new TaikoDifficultyHitObjectRhythm(2, 3, 0.4),
+            new TaikoDifficultyHitObjectRhythm(5, 4, 0.5),
+            new TaikoDifficultyHitObjectRhythm(4, 5, 0.7)
+        };
+
+        /// <summary>
+        /// Returns the closest rhythm change from <see cref="common_rhythms"/> required to hit this object.
+        /// </summary>
+        /// <param name="lastObject">The gameplay <see cref="HitObject"/> preceding this one.</param>
+        /// <param name="lastLastObject">The gameplay <see cref="HitObject"/> preceding <paramref name="lastObject"/>.</param>
+        /// <param name="clockRate">The rate of the gameplay clock.</param>
+        private TaikoDifficultyHitObjectRhythm getClosestRhythm(HitObject lastObject, HitObject lastLastObject, double clockRate)
+        {
+            double prevLength = (lastObject.StartTime - lastLastObject.StartTime) / clockRate;
+            double ratio = DeltaTime / prevLength;
+
+            return common_rhythms.OrderBy(x => Math.Abs(x.Ratio - ratio)).First();
         }
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/TaikoDifficultyHitObjectRhythm.cs

@@ -0,0 +1,35 @@
+// 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.
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
+{
+    /// <summary>
+    /// Represents a rhythm change in a taiko map.
+    /// </summary>
+    public class TaikoDifficultyHitObjectRhythm
+    {
+        /// <summary>
+        /// The difficulty multiplier associated with this rhythm change.
+        /// </summary>
+        public readonly double Difficulty;
+
+        /// <summary>
+        /// The ratio of current <see cref="osu.Game.Rulesets.Difficulty.Preprocessing.DifficultyHitObject.DeltaTime"/>
+        /// to previous <see cref="osu.Game.Rulesets.Difficulty.Preprocessing.DifficultyHitObject.DeltaTime"/> for the rhythm change.
+        /// A <see cref="Ratio"/> above 1 indicates a slow-down; a <see cref="Ratio"/> below 1 indicates a speed-up.
+        /// </summary>
+        public readonly double Ratio;
+
+        /// <summary>
+        /// Creates an object representing a rhythm change.
+        /// </summary>
+        /// <param name="numerator">The numerator for <see cref="Ratio"/>.</param>
+        /// <param name="denominator">The denominator for <see cref="Ratio"/></param>
+        /// <param name="difficulty">The difficulty multiplier associated with this rhythm change.</param>
+        public TaikoDifficultyHitObjectRhythm(int numerator, int denominator, double difficulty)
+        {
+            Ratio = numerator / (double)denominator;
+            Difficulty = difficulty;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Skills/Colour.cs

@@ -0,0 +1,135 @@
+// 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.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
+{
+    /// <summary>
+    /// Calculates the colour coefficient of taiko difficulty.
+    /// </summary>
+    public class Colour : Skill
+    {
+        protected override double SkillMultiplier => 1;
+        protected override double StrainDecayBase => 0.4;
+
+        /// <summary>
+        /// Maximum number of entries to keep in <see cref="monoHistory"/>.
+        /// </summary>
+        private const int mono_history_max_length = 5;
+
+        /// <summary>
+        /// Queue with the lengths of the last <see cref="mono_history_max_length"/> most recent mono (single-colour) patterns,
+        /// with the most recent value at the end of the queue.
+        /// </summary>
+        private readonly LimitedCapacityQueue<int> monoHistory = new LimitedCapacityQueue<int>(mono_history_max_length);
+
+        /// <summary>
+        /// The <see cref="HitType"/> of the last object hit before the one being considered.
+        /// </summary>
+        private HitType? previousHitType;
+
+        /// <summary>
+        /// Length of the current mono pattern.
+        /// </summary>
+        private int currentMonoLength;
+
+        protected override double StrainValueOf(DifficultyHitObject current)
+        {
+            // changing from/to a drum roll or a swell does not constitute a colour change.
+            // hits spaced more than a second apart are also exempt from colour strain.
+            if (!(current.LastObject is Hit && current.BaseObject is Hit && current.DeltaTime < 1000))
+            {
+                monoHistory.Clear();
+
+                var currentHit = current.BaseObject as Hit;
+                currentMonoLength = currentHit != null ? 1 : 0;
+                previousHitType = currentHit?.Type;
+
+                return 0.0;
+            }
+
+            var taikoCurrent = (TaikoDifficultyHitObject)current;
+
+            double objectStrain = 0.0;
+
+            if (previousHitType != null && taikoCurrent.HitType != previousHitType)
+            {
+                // The colour has changed.
+                objectStrain = 1.0;
+
+                if (monoHistory.Count < 2)
+                {
+                    // There needs to be at least two streaks to determine a strain.
+                    objectStrain = 0.0;
+                }
+                else if ((monoHistory[^1] + currentMonoLength) % 2 == 0)
+                {
+                    // The last streak in the history is guaranteed to be a different type to the current streak.
+                    // If the total number of notes in the two streaks is even, nullify this object's strain.
+                    objectStrain = 0.0;
+                }
+
+                objectStrain *= repetitionPenalties();
+                currentMonoLength = 1;
+            }
+            else
+            {
+                currentMonoLength += 1;
+            }
+
+            previousHitType = taikoCurrent.HitType;
+            return objectStrain;
+        }
+
+        /// <summary>
+        /// The penalty to apply due to the length of repetition in colour streaks.
+        /// </summary>
+        private double repetitionPenalties()
+        {
+            const int most_recent_patterns_to_compare = 2;
+            double penalty = 1.0;
+
+            monoHistory.Enqueue(currentMonoLength);
+
+            for (int start = monoHistory.Count - most_recent_patterns_to_compare - 1; start >= 0; start--)
+            {
+                if (!isSamePattern(start, most_recent_patterns_to_compare))
+                    continue;
+
+                int notesSince = 0;
+                for (int i = start; i < monoHistory.Count; i++) notesSince += monoHistory[i];
+                penalty *= repetitionPenalty(notesSince);
+                break;
+            }
+
+            return penalty;
+        }
+
+        /// <summary>
+        /// Determines whether the last <paramref name="mostRecentPatternsToCompare"/> patterns have repeated in the history
+        /// of single-colour note sequences, starting from <paramref name="start"/>.
+        /// </summary>
+        private bool isSamePattern(int start, int mostRecentPatternsToCompare)
+        {
+            for (int i = 0; i < mostRecentPatternsToCompare; i++)
+            {
+                if (monoHistory[start + i] != monoHistory[monoHistory.Count - mostRecentPatternsToCompare + i])
+                    return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Calculates the strain penalty for a colour pattern repetition.
+        /// </summary>
+        /// <param name="notesSince">The number of notes since the last repetition of the pattern.</param>
+        private double repetitionPenalty(int notesSince) => Math.Min(1.0, 0.032 * notesSince);
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Skills/Rhythm.cs

@@ -0,0 +1,167 @@
+// 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.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
+{
+    /// <summary>
+    /// Calculates the rhythm coefficient of taiko difficulty.
+    /// </summary>
+    public class Rhythm : Skill
+    {
+        protected override double SkillMultiplier => 10;
+        protected override double StrainDecayBase => 0;
+
+        /// <summary>
+        /// The note-based decay for rhythm strain.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="StrainDecayBase"/> is not used here, as it's time- and not note-based.
+        /// </remarks>
+        private const double strain_decay = 0.96;
+
+        /// <summary>
+        /// Maximum number of entries in <see cref="rhythmHistory"/>.
+        /// </summary>
+        private const int rhythm_history_max_length = 8;
+
+        /// <summary>
+        /// Contains the last <see cref="rhythm_history_max_length"/> changes in note sequence rhythms.
+        /// </summary>
+        private readonly LimitedCapacityQueue<TaikoDifficultyHitObject> rhythmHistory = new LimitedCapacityQueue<TaikoDifficultyHitObject>(rhythm_history_max_length);
+
+        /// <summary>
+        /// Contains the rolling rhythm strain.
+        /// Used to apply per-note decay.
+        /// </summary>
+        private double currentStrain;
+
+        /// <summary>
+        /// Number of notes since the last rhythm change has taken place.
+        /// </summary>
+        private int notesSinceRhythmChange;
+
+        protected override double StrainValueOf(DifficultyHitObject current)
+        {
+            // drum rolls and swells are exempt.
+            if (!(current.BaseObject is Hit))
+            {
+                resetRhythmAndStrain();
+                return 0.0;
+            }
+
+            currentStrain *= strain_decay;
+
+            TaikoDifficultyHitObject hitObject = (TaikoDifficultyHitObject)current;
+            notesSinceRhythmChange += 1;
+
+            // rhythm difficulty zero (due to rhythm not changing) => no rhythm strain.
+            if (hitObject.Rhythm.Difficulty == 0.0)
+            {
+                return 0.0;
+            }
+
+            double objectStrain = hitObject.Rhythm.Difficulty;
+
+            objectStrain *= repetitionPenalties(hitObject);
+            objectStrain *= patternLengthPenalty(notesSinceRhythmChange);
+            objectStrain *= speedPenalty(hitObject.DeltaTime);
+
+            // careful - needs to be done here since calls above read this value
+            notesSinceRhythmChange = 0;
+
+            currentStrain += objectStrain;
+            return currentStrain;
+        }
+
+        /// <summary>
+        /// Returns a penalty to apply to the current hit object caused by repeating rhythm changes.
+        /// </summary>
+        /// <remarks>
+        /// Repetitions of more recent patterns are associated with a higher penalty.
+        /// </remarks>
+        /// <param name="hitObject">The current hit object being considered.</param>
+        private double repetitionPenalties(TaikoDifficultyHitObject hitObject)
+        {
+            double penalty = 1;
+
+            rhythmHistory.Enqueue(hitObject);
+
+            for (int mostRecentPatternsToCompare = 2; mostRecentPatternsToCompare <= rhythm_history_max_length / 2; mostRecentPatternsToCompare++)
+            {
+                for (int start = rhythmHistory.Count - mostRecentPatternsToCompare - 1; start >= 0; start--)
+                {
+                    if (!samePattern(start, mostRecentPatternsToCompare))
+                        continue;
+
+                    int notesSince = hitObject.ObjectIndex - rhythmHistory[start].ObjectIndex;
+                    penalty *= repetitionPenalty(notesSince);
+                    break;
+                }
+            }
+
+            return penalty;
+        }
+
+        /// <summary>
+        /// Determines whether the rhythm change pattern starting at <paramref name="start"/> is a repeat of any of the
+        /// <paramref name="mostRecentPatternsToCompare"/>.
+        /// </summary>
+        private bool samePattern(int start, int mostRecentPatternsToCompare)
+        {
+            for (int i = 0; i < mostRecentPatternsToCompare; i++)
+            {
+                if (rhythmHistory[start + i].Rhythm != rhythmHistory[rhythmHistory.Count - mostRecentPatternsToCompare + i].Rhythm)
+                    return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Calculates a single rhythm repetition penalty.
+        /// </summary>
+        /// <param name="notesSince">Number of notes since the last repetition of a rhythm change.</param>
+        private static double repetitionPenalty(int notesSince) => Math.Min(1.0, 0.032 * notesSince);
+
+        /// <summary>
+        /// Calculates a penalty based on the number of notes since the last rhythm change.
+        /// Both rare and frequent rhythm changes are penalised.
+        /// </summary>
+        /// <param name="patternLength">Number of notes since the last rhythm change.</param>
+        private static double patternLengthPenalty(int patternLength)
+        {
+            double shortPatternPenalty = Math.Min(0.15 * patternLength, 1.0);
+            double longPatternPenalty = Math.Clamp(2.5 - 0.15 * patternLength, 0.0, 1.0);
+            return Math.Min(shortPatternPenalty, longPatternPenalty);
+        }
+
+        /// <summary>
+        /// Calculates a penalty for objects that do not require alternating hands.
+        /// </summary>
+        /// <param name="deltaTime">Time (in milliseconds) since the last hit object.</param>
+        private double speedPenalty(double deltaTime)
+        {
+            if (deltaTime < 80) return 1;
+            if (deltaTime < 210) return Math.Max(0, 1.4 - 0.005 * deltaTime);
+
+            resetRhythmAndStrain();
+            return 0.0;
+        }
+
+        /// <summary>
+        /// Resets the rolling strain value and <see cref="notesSinceRhythmChange"/> counter.
+        /// </summary>
+        private void resetRhythmAndStrain()
+        {
+            currentStrain = 0.0;
+            notesSinceRhythmChange = 0;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Skills/Stamina.cs

@@ -0,0 +1,113 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
+{
+    /// <summary>
+    /// Calculates the stamina coefficient of taiko difficulty.
+    /// </summary>
+    /// <remarks>
+    /// The reference play style chosen uses two hands, with full alternating (the hand changes after every hit).
+    /// </remarks>
+    public class Stamina : Skill
+    {
+        protected override double SkillMultiplier => 1;
+        protected override double StrainDecayBase => 0.4;
+
+        /// <summary>
+        /// Maximum number of entries to keep in <see cref="notePairDurationHistory"/>.
+        /// </summary>
+        private const int max_history_length = 2;
+
+        /// <summary>
+        /// The index of the hand this <see cref="Stamina"/> instance is associated with.
+        /// </summary>
+        /// <remarks>
+        /// The value of 0 indicates the left hand (full alternating gameplay starting with left hand is assumed).
+        /// This naturally translates onto index offsets of the objects in the map.
+        /// </remarks>
+        private readonly int hand;
+
+        /// <summary>
+        /// Stores the last <see cref="max_history_length"/> durations between notes hit with the hand indicated by <see cref="hand"/>.
+        /// </summary>
+        private readonly LimitedCapacityQueue<double> notePairDurationHistory = new LimitedCapacityQueue<double>(max_history_length);
+
+        /// <summary>
+        /// Stores the <see cref="DifficultyHitObject.DeltaTime"/> of the last object that was hit by the <i>other</i> hand.
+        /// </summary>
+        private double offhandObjectDuration = double.MaxValue;
+
+        /// <summary>
+        /// Creates a <see cref="Stamina"/> skill.
+        /// </summary>
+        /// <param name="rightHand">Whether this instance is performing calculations for the right hand.</param>
+        public Stamina(bool rightHand)
+        {
+            hand = rightHand ? 1 : 0;
+        }
+
+        protected override double StrainValueOf(DifficultyHitObject current)
+        {
+            if (!(current.BaseObject is Hit))
+            {
+                return 0.0;
+            }
+
+            TaikoDifficultyHitObject hitObject = (TaikoDifficultyHitObject)current;
+
+            if (hitObject.ObjectIndex % 2 == hand)
+            {
+                double objectStrain = 1;
+
+                if (hitObject.ObjectIndex == 1)
+                    return 1;
+
+                notePairDurationHistory.Enqueue(hitObject.DeltaTime + offhandObjectDuration);
+
+                double shortestRecentNote = notePairDurationHistory.Min();
+                objectStrain += speedBonus(shortestRecentNote);
+
+                if (hitObject.StaminaCheese)
+                    objectStrain *= cheesePenalty(hitObject.DeltaTime + offhandObjectDuration);
+
+                return objectStrain;
+            }
+
+            offhandObjectDuration = hitObject.DeltaTime;
+            return 0;
+        }
+
+        /// <summary>
+        /// Applies a penalty for hit objects marked with <see cref="TaikoDifficultyHitObject.StaminaCheese"/>.
+        /// </summary>
+        /// <param name="notePairDuration">The duration between the current and previous note hit using the hand indicated by <see cref="hand"/>.</param>
+        private double cheesePenalty(double notePairDuration)
+        {
+            if (notePairDuration > 125) return 1;
+            if (notePairDuration < 100) return 0.6;
+
+            return 0.6 + (notePairDuration - 100) * 0.016;
+        }
+
+        /// <summary>
+        /// Applies a speed bonus dependent on the time since the last hit performed using this hand.
+        /// </summary>
+        /// <param name="notePairDuration">The duration between the current and previous note hit using the hand indicated by <see cref="hand"/>.</param>
+        private double speedBonus(double notePairDuration)
+        {
+            if (notePairDuration >= 200) return 0;
+
+            double bonus = 200 - notePairDuration;
+            bonus *= bonus;
+            return bonus / 100000;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/Skills/Strain.cs

@@ -1,95 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Game.Rulesets.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Difficulty.Skills;
-using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Taiko.Objects;
-
-namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
-{
-    public class Strain : Skill
-    {
-        private const double rhythm_change_base_threshold = 0.2;
-        private const double rhythm_change_base = 2.0;
-
-        protected override double SkillMultiplier => 1;
-        protected override double StrainDecayBase => 0.3;
-
-        private ColourSwitch lastColourSwitch = ColourSwitch.None;
-
-        private int sameColourCount = 1;
-
-        protected override double StrainValueOf(DifficultyHitObject current)
-        {
-            double addition = 1;
-
-            // We get an extra addition if we are not a slider or spinner
-            if (current.LastObject is Hit && current.BaseObject is Hit && current.BaseObject.StartTime - current.LastObject.StartTime < 1000)
-            {
-                if (hasColourChange(current))
-                    addition += 0.75;
-
-                if (hasRhythmChange(current))
-                    addition += 1;
-            }
-            else
-            {
-                lastColourSwitch = ColourSwitch.None;
-                sameColourCount = 1;
-            }
-
-            double additionFactor = 1;
-
-            // Scale the addition factor linearly from 0.4 to 1 for DeltaTime from 0 to 50
-            if (current.DeltaTime < 50)
-                additionFactor = 0.4 + 0.6 * current.DeltaTime / 50;
-
-            return additionFactor * addition;
-        }
-
-        private bool hasRhythmChange(DifficultyHitObject current)
-        {
-            // We don't want a division by zero if some random mapper decides to put two HitObjects at the same time.
-            if (current.DeltaTime == 0 || Previous.Count == 0 || Previous[0].DeltaTime == 0)
-                return false;
-
-            double timeElapsedRatio = Math.Max(Previous[0].DeltaTime / current.DeltaTime, current.DeltaTime / Previous[0].DeltaTime);
-
-            if (timeElapsedRatio >= 8)
-                return false;
-
-            double difference = Math.Log(timeElapsedRatio, rhythm_change_base) % 1.0;
-
-            return difference > rhythm_change_base_threshold && difference < 1 - rhythm_change_base_threshold;
-        }
-
-        private bool hasColourChange(DifficultyHitObject current)
-        {
-            var taikoCurrent = (TaikoDifficultyHitObject)current;
-
-            if (!taikoCurrent.HasTypeChange)
-            {
-                sameColourCount++;
-                return false;
-            }
-
-            var oldColourSwitch = lastColourSwitch;
-            var newColourSwitch = sameColourCount % 2 == 0 ? ColourSwitch.Even : ColourSwitch.Odd;
-
-            lastColourSwitch = newColourSwitch;
-            sameColourCount = 1;
-
-            // We only want a bonus if the parity of the color switch changes
-            return oldColourSwitch != ColourSwitch.None && oldColourSwitch != newColourSwitch;
-        }
-
-        private enum ColourSwitch
-        {
-            None,
-            Even,
-            Odd
-        }
-    }
-}

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs

@@ -7,6 +7,10 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 {
     public class TaikoDifficultyAttributes : DifficultyAttributes
     {
+        public double StaminaStrain;
+        public double RhythmStrain;
+        public double ColourStrain;
+        public double ApproachRate;
         public double GreatHitWindow;
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
@@ -19,39 +20,22 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 {
     public class TaikoDifficultyCalculator : DifficultyCalculator
     {
-        private const double star_scaling_factor = 0.04125;
+        private const double rhythm_skill_multiplier = 0.014;
+        private const double colour_skill_multiplier = 0.01;
+        private const double stamina_skill_multiplier = 0.02;
 
         public TaikoDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }
 
-        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
+        protected override Skill[] CreateSkills(IBeatmap beatmap) => new Skill[]
         {
-            if (beatmap.HitObjects.Count == 0)
-                return new TaikoDifficultyAttributes { Mods = mods, Skills = skills };
-
-            HitWindows hitWindows = new TaikoHitWindows();
-            hitWindows.SetDifficulty(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
-
-            return new TaikoDifficultyAttributes
-            {
-                StarRating = skills.Single().DifficultyValue() * star_scaling_factor,
-                Mods = mods,
-                // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be removed in the future
-                GreatHitWindow = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate,
-                MaxCombo = beatmap.HitObjects.Count(h => h is Hit),
-                Skills = skills
-            };
-        }
-
-        protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
-        {
-            for (int i = 1; i < beatmap.HitObjects.Count; i++)
-                yield return new TaikoDifficultyHitObject(beatmap.HitObjects[i], beatmap.HitObjects[i - 1], clockRate);
-        }
-
-        protected override Skill[] CreateSkills(IBeatmap beatmap) => new Skill[] { new Strain() };
+            new Colour(),
+            new Rhythm(),
+            new Stamina(true),
+            new Stamina(false),
+        };
 
         protected override Mod[] DifficultyAdjustmentMods => new Mod[]
         {
@@ -60,5 +44,124 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             new TaikoModEasy(),
             new TaikoModHardRock(),
         };
+
+        protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
+        {
+            List<TaikoDifficultyHitObject> taikoDifficultyHitObjects = new List<TaikoDifficultyHitObject>();
+
+            for (int i = 2; i < beatmap.HitObjects.Count; i++)
+            {
+                taikoDifficultyHitObjects.Add(
+                    new TaikoDifficultyHitObject(
+                        beatmap.HitObjects[i], beatmap.HitObjects[i - 1], beatmap.HitObjects[i - 2], clockRate, i
+                    )
+                );
+            }
+
+            new StaminaCheeseDetector(taikoDifficultyHitObjects).FindCheese();
+            return taikoDifficultyHitObjects;
+        }
+
+        protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
+        {
+            if (beatmap.HitObjects.Count == 0)
+                return new TaikoDifficultyAttributes { Mods = mods, Skills = skills };
+
+            var colour = (Colour)skills[0];
+            var rhythm = (Rhythm)skills[1];
+            var staminaRight = (Stamina)skills[2];
+            var staminaLeft = (Stamina)skills[3];
+
+            double colourRating = colour.DifficultyValue() * colour_skill_multiplier;
+            double rhythmRating = rhythm.DifficultyValue() * rhythm_skill_multiplier;
+            double staminaRating = (staminaRight.DifficultyValue() + staminaLeft.DifficultyValue()) * stamina_skill_multiplier;
+
+            double staminaPenalty = simpleColourPenalty(staminaRating, colourRating);
+            staminaRating *= staminaPenalty;
+
+            double combinedRating = locallyCombinedDifficulty(colour, rhythm, staminaRight, staminaLeft, staminaPenalty);
+            double separatedRating = norm(1.5, colourRating, rhythmRating, staminaRating);
+            double starRating = 1.4 * separatedRating + 0.5 * combinedRating;
+            starRating = rescale(starRating);
+
+            HitWindows hitWindows = new TaikoHitWindows();
+            hitWindows.SetDifficulty(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
+
+            return new TaikoDifficultyAttributes
+            {
+                StarRating = starRating,
+                Mods = mods,
+                StaminaStrain = staminaRating,
+                RhythmStrain = rhythmRating,
+                ColourStrain = colourRating,
+                // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be removed in the future
+                GreatHitWindow = (int)hitWindows.WindowFor(HitResult.Great) / clockRate,
+                MaxCombo = beatmap.HitObjects.Count(h => h is Hit),
+                Skills = skills
+            };
+        }
+
+        /// <summary>
+        /// Calculates the penalty for the stamina skill for maps with low colour difficulty.
+        /// </summary>
+        /// <remarks>
+        /// Some maps (especially converts) can be easy to read despite a high note density.
+        /// This penalty aims to reduce the star rating of such maps by factoring in colour difficulty to the stamina skill.
+        /// </remarks>
+        private double simpleColourPenalty(double staminaDifficulty, double colorDifficulty)
+        {
+            if (colorDifficulty <= 0) return 0.79 - 0.25;
+
+            return 0.79 - Math.Atan(staminaDifficulty / colorDifficulty - 12) / Math.PI / 2;
+        }
+
+        /// <summary>
+        /// Returns the <i>p</i>-norm of an <i>n</i>-dimensional vector.
+        /// </summary>
+        /// <param name="p">The value of <i>p</i> to calculate the norm for.</param>
+        /// <param name="values">The coefficients of the vector.</param>
+        private double norm(double p, params double[] values) => Math.Pow(values.Sum(x => Math.Pow(x, p)), 1 / p);
+
+        /// <summary>
+        /// Returns the partial star rating of the beatmap, calculated using peak strains from all sections of the map.
+        /// </summary>
+        /// <remarks>
+        /// For each section, the peak strains of all separate skills are combined into a single peak strain for the section.
+        /// The resulting partial rating of the beatmap is a weighted sum of the combined peaks (higher peaks are weighted more).
+        /// </remarks>
+        private double locallyCombinedDifficulty(Colour colour, Rhythm rhythm, Stamina staminaRight, Stamina staminaLeft, double staminaPenalty)
+        {
+            List<double> peaks = new List<double>();
+
+            for (int i = 0; i < colour.StrainPeaks.Count; i++)
+            {
+                double colourPeak = colour.StrainPeaks[i] * colour_skill_multiplier;
+                double rhythmPeak = rhythm.StrainPeaks[i] * rhythm_skill_multiplier;
+                double staminaPeak = (staminaRight.StrainPeaks[i] + staminaLeft.StrainPeaks[i]) * stamina_skill_multiplier * staminaPenalty;
+                peaks.Add(norm(2, colourPeak, rhythmPeak, staminaPeak));
+            }
+
+            double difficulty = 0;
+            double weight = 1;
+
+            foreach (double strain in peaks.OrderByDescending(d => d))
+            {
+                difficulty += strain * weight;
+                weight *= 0.9;
+            }
+
+            return difficulty;
+        }
+
+        /// <summary>
+        /// Applies a final re-scaling of the star rating to bring maps with recorded full combos below 9.5 stars.
+        /// </summary>
+        /// <param name="sr">The raw star rating value before re-scaling.</param>
+        private double rescale(double sr)
+        {
+            if (sr < 0) return sr;
+
+            return 10.43 * Math.Log(sr / 8 + 1);
+        }
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs

@@ -78,10 +78,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
             strainValue *= Math.Pow(0.985, countMiss);
 
-            // Combo scaling
-            if (Attributes.MaxCombo > 0)
-                strainValue *= Math.Min(Math.Pow(Score.MaxCombo, 0.5) / Math.Pow(Attributes.MaxCombo, 0.5), 1.0);
-
             if (mods.Any(m => m is ModHidden))
                 strainValue *= 1.025;
 

osu.Game.Rulesets.Taiko/Edit/TaikoSelectionHandler.cs

@@ -1,9 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
@@ -14,67 +15,80 @@ namespace osu.Game.Rulesets.Taiko.Edit
 {
     public class TaikoSelectionHandler : SelectionHandler
     {
+        private readonly Bindable<TernaryState> selectionRimState = new Bindable<TernaryState>();
+        private readonly Bindable<TernaryState> selectionStrongState = new Bindable<TernaryState>();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            selectionStrongState.ValueChanged += state =>
+            {
+                switch (state.NewValue)
+                {
+                    case TernaryState.False:
+                        SetStrongState(false);
+                        break;
+
+                    case TernaryState.True:
+                        SetStrongState(true);
+                        break;
+                }
+            };
+
+            selectionRimState.ValueChanged += state =>
+            {
+                switch (state.NewValue)
+                {
+                    case TernaryState.False:
+                        SetRimState(false);
+                        break;
+
+                    case TernaryState.True:
+                        SetRimState(true);
+                        break;
+                }
+            };
+        }
+
+        public void SetStrongState(bool state)
+        {
+            var hits = SelectedHitObjects.OfType<Hit>();
+
+            ChangeHandler.BeginChange();
+
+            foreach (var h in hits)
+                h.IsStrong = state;
+
+            ChangeHandler.EndChange();
+        }
+
+        public void SetRimState(bool state)
+        {
+            var hits = SelectedHitObjects.OfType<Hit>();
+
+            ChangeHandler.BeginChange();
+
+            foreach (var h in hits)
+                h.Type = state ? HitType.Rim : HitType.Centre;
+
+            ChangeHandler.EndChange();
+        }
+
         protected override IEnumerable<MenuItem> GetContextMenuItemsForSelection(IEnumerable<SelectionBlueprint> selection)
         {
             if (selection.All(s => s.HitObject is Hit))
-            {
-                var hits = selection.Select(s => s.HitObject).OfType<Hit>();
-
-                yield return new TernaryStateMenuItem("Rim", action: state =>
-                {
-                    foreach (var h in hits)
-                    {
-                        switch (state)
-                        {
-                            case TernaryState.True:
-                                h.Type = HitType.Rim;
-                                break;
-
-                            case TernaryState.False:
-                                h.Type = HitType.Centre;
-                                break;
-                        }
-                    }
-                })
-                {
-                    State = { Value = getTernaryState(hits, h => h.Type == HitType.Rim) }
-                };
-            }
+                yield return new TernaryStateMenuItem("Rim") { State = { BindTarget = selectionRimState } };
 
             if (selection.All(s => s.HitObject is TaikoHitObject))
-            {
-                var hits = selection.Select(s => s.HitObject).OfType<TaikoHitObject>();
-
-                yield return new TernaryStateMenuItem("Strong", action: state =>
-                {
-                    foreach (var h in hits)
-                    {
-                        switch (state)
-                        {
-                            case TernaryState.True:
-                                h.IsStrong = true;
-                                break;
-
-                            case TernaryState.False:
-                                h.IsStrong = false;
-                                break;
-                        }
-
-                        EditorBeatmap?.UpdateHitObject(h);
-                    }
-                })
-                {
-                    State = { Value = getTernaryState(hits, h => h.IsStrong) }
-                };
-            }
+                yield return new TernaryStateMenuItem("Strong") { State = { BindTarget = selectionStrongState } };
         }
 
-        private TernaryState getTernaryState<T>(IEnumerable<T> selection, Func<T, bool> func)
+        protected override void UpdateTernaryStates()
         {
-            if (selection.Any(func))
-                return selection.All(func) ? TernaryState.True : TernaryState.Indeterminate;
+            base.UpdateTernaryStates();
 
-            return TernaryState.False;
+            selectionRimState.Value = GetStateFromSelection(SelectedHitObjects.OfType<Hit>(), h => h.Type == HitType.Rim);
+            selectionStrongState.Value = GetStateFromSelection(SelectedHitObjects.OfType<TaikoHitObject>(), h => h.IsStrong);
         }
     }
 }

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

@@ -36,35 +36,64 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         private bool pressHandledThisFrame;
 
-        private Bindable<HitType> type;
+        private readonly Bindable<HitType> type;
 
         public DrawableHit(Hit hit)
             : base(hit)
         {
+            type = HitObject.TypeBindable.GetBoundCopy();
             FillMode = FillMode.Fit;
+
+            updateActionsFromType();
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            type = HitObject.TypeBindable.GetBoundCopy();
             type.BindValueChanged(_ =>
             {
-                updateType();
+                updateActionsFromType();
+
+                // will overwrite samples, should only be called on change.
+                updateSamplesFromTypeChange();
+
                 RecreatePieces();
             });
-
-            updateType();
         }
 
-        private void updateType()
+        private HitSampleInfo[] getRimSamples() => HitObject.Samples.Where(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE).ToArray();
+
+        protected override void LoadSamples()
+        {
+            base.LoadSamples();
+
+            type.Value = getRimSamples().Any() ? HitType.Rim : HitType.Centre;
+        }
+
+        private void updateSamplesFromTypeChange()
+        {
+            var rimSamples = getRimSamples();
+
+            bool isRimType = HitObject.Type == HitType.Rim;
+
+            if (isRimType != rimSamples.Any())
+            {
+                if (isRimType)
+                    HitObject.Samples.Add(new HitSampleInfo { Name = HitSampleInfo.HIT_CLAP });
+                else
+                {
+                    foreach (var sample in rimSamples)
+                        HitObject.Samples.Remove(sample);
+                }
+            }
+        }
+
+        private void updateActionsFromType()
         {
             HitActions =
                 HitObject.Type == HitType.Centre
                     ? new[] { TaikoAction.LeftCentre, TaikoAction.RightCentre }
                     : new[] { TaikoAction.LeftRim, TaikoAction.RightRim };
-
-            RecreatePieces();
         }
 
         protected override SkinnableDrawable CreateMainPiece() => HitObject.Type == HitType.Centre

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

@@ -1,19 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics;
-using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
-using System.Linq;
-using osu.Game.Audio;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
+using osu.Framework.Input.Bindings;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
@@ -120,7 +120,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         protected Vector2 BaseSize;
         protected SkinnableDrawable MainPiece;
 
-        private Bindable<bool> isStrong;
+        private readonly Bindable<bool> isStrong;
 
         private readonly Container<DrawableStrongNestedHit> strongHitContainer;
 
@@ -128,6 +128,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             : base(hitObject)
         {
             HitObject = hitObject;
+            isStrong = HitObject.IsStrongBindable.GetBoundCopy();
 
             Anchor = Anchor.CentreLeft;
             Origin = Anchor.Custom;
@@ -140,8 +141,40 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
-            isStrong = HitObject.IsStrongBindable.GetBoundCopy();
-            isStrong.BindValueChanged(_ => RecreatePieces(), true);
+            isStrong.BindValueChanged(_ =>
+            {
+                // will overwrite samples, should only be called on change.
+                updateSamplesFromStrong();
+
+                RecreatePieces();
+            });
+
+            RecreatePieces();
+        }
+
+        private HitSampleInfo[] getStrongSamples() => HitObject.Samples.Where(s => s.Name == HitSampleInfo.HIT_FINISH).ToArray();
+
+        protected override void LoadSamples()
+        {
+            base.LoadSamples();
+
+            isStrong.Value = getStrongSamples().Any();
+        }
+
+        private void updateSamplesFromStrong()
+        {
+            var strongSamples = getStrongSamples();
+
+            if (isStrong.Value != strongSamples.Any())
+            {
+                if (isStrong.Value)
+                    HitObject.Samples.Add(new HitSampleInfo { Name = HitSampleInfo.HIT_FINISH });
+                else
+                {
+                    foreach (var sample in strongSamples)
+                        HitObject.Samples.Remove(sample);
+                }
+            }
         }
 
         protected virtual void RecreatePieces()

osu.Game.Rulesets.Taiko/Skinning/TaikoLegacySkinTransformer.cs

@@ -75,7 +75,9 @@ namespace osu.Game.Rulesets.Taiko.Skinning
                     return null;
 
                 case TaikoSkinComponents.TaikoExplosionGood:
+                case TaikoSkinComponents.TaikoExplosionGoodStrong:
                 case TaikoSkinComponents.TaikoExplosionGreat:
+                case TaikoSkinComponents.TaikoExplosionGreatStrong:
                 case TaikoSkinComponents.TaikoExplosionMiss:
 
                     var sprite = this.GetAnimation(getHitName(taikoComponent.Component), true, false);
@@ -107,8 +109,14 @@ namespace osu.Game.Rulesets.Taiko.Skinning
                 case TaikoSkinComponents.TaikoExplosionGood:
                     return "taiko-hit100";
 
+                case TaikoSkinComponents.TaikoExplosionGoodStrong:
+                    return "taiko-hit100k";
+
                 case TaikoSkinComponents.TaikoExplosionGreat:
                     return "taiko-hit300";
+
+                case TaikoSkinComponents.TaikoExplosionGreatStrong:
+                    return "taiko-hit300k";
             }
 
             throw new ArgumentOutOfRangeException(nameof(component), "Invalid result type");

osu.Game.Rulesets.Taiko/TaikoSkinComponents.cs

@@ -17,7 +17,9 @@ namespace osu.Game.Rulesets.Taiko
         BarLine,
         TaikoExplosionMiss,
         TaikoExplosionGood,
+        TaikoExplosionGoodStrong,
         TaikoExplosionGreat,
+        TaikoExplosionGreatStrong,
         Scroller,
         Mascot,
     }

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

@@ -15,8 +15,14 @@ namespace osu.Game.Rulesets.Taiko.UI
 {
     internal class DefaultHitExplosion : CircularContainer
     {
-        [Resolved]
-        private DrawableHitObject judgedObject { get; set; }
+        private readonly DrawableHitObject judgedObject;
+        private readonly HitResult result;
+
+        public DefaultHitExplosion(DrawableHitObject judgedObject, HitResult result)
+        {
+            this.judgedObject = judgedObject;
+            this.result = result;
+        }
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
@@ -31,7 +37,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             Alpha = 0.15f;
             Masking = true;
 
-            if (judgedObject.Result.Type == HitResult.Miss)
+            if (result == HitResult.Miss)
                 return;
 
             bool isRim = (judgedObject.HitObject as Hit)?.Type == HitType.Rim;

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using osuTK;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -9,6 +10,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.UI
@@ -23,15 +25,18 @@ namespace osu.Game.Rulesets.Taiko.UI
         [Cached(typeof(DrawableHitObject))]
         public readonly DrawableHitObject JudgedObject;
 
+        private readonly HitResult result;
+
         private SkinnableDrawable skinnable;
 
         public override double LifetimeStart => skinnable.Drawable.LifetimeStart;
 
         public override double LifetimeEnd => skinnable.Drawable.LifetimeEnd;
 
-        public HitExplosion(DrawableHitObject judgedObject)
+        public HitExplosion(DrawableHitObject judgedObject, HitResult result)
         {
             JudgedObject = judgedObject;
+            this.result = result;
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
@@ -45,24 +50,39 @@ namespace osu.Game.Rulesets.Taiko.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            Child = skinnable = new SkinnableDrawable(new TaikoSkinComponent(getComponentName(JudgedObject.Result?.Type ?? HitResult.Great)), _ => new DefaultHitExplosion());
+            Child = skinnable = new SkinnableDrawable(new TaikoSkinComponent(getComponentName(JudgedObject)), _ => new DefaultHitExplosion(JudgedObject, result));
         }
 
-        private TaikoSkinComponents getComponentName(HitResult resultType)
+        private TaikoSkinComponents getComponentName(DrawableHitObject judgedObject)
         {
-            switch (resultType)
+            switch (result)
             {
                 case HitResult.Miss:
                     return TaikoSkinComponents.TaikoExplosionMiss;
 
                 case HitResult.Good:
-                    return TaikoSkinComponents.TaikoExplosionGood;
+                    return useStrongExplosion(judgedObject)
+                        ? TaikoSkinComponents.TaikoExplosionGoodStrong
+                        : TaikoSkinComponents.TaikoExplosionGood;
 
                 case HitResult.Great:
-                    return TaikoSkinComponents.TaikoExplosionGreat;
+                    return useStrongExplosion(judgedObject)
+                        ? TaikoSkinComponents.TaikoExplosionGreatStrong
+                        : TaikoSkinComponents.TaikoExplosionGreat;
             }
 
-            throw new ArgumentOutOfRangeException(nameof(resultType), "Invalid result type");
+            throw new ArgumentOutOfRangeException(nameof(judgedObject), "Invalid result type");
+        }
+
+        private bool useStrongExplosion(DrawableHitObject judgedObject)
+        {
+            if (!(judgedObject.HitObject is Hit))
+                return false;
+
+            if (!(judgedObject.NestedHitObjects.SingleOrDefault() is DrawableStrongNestedHit nestedHit))
+                return false;
+
+            return judgedObject.Result.Type == nestedHit.Result.Type;
         }
 
         /// <summary>

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

@@ -9,6 +9,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Rulesets.Taiko.Objects.Drawables;
@@ -205,12 +206,8 @@ namespace osu.Game.Rulesets.Taiko.UI
                         X = result.IsHit ? judgedObject.Position.X : 0,
                     });
 
-                    if (!result.IsHit)
-                        break;
-
                     var type = (judgedObject.HitObject as Hit)?.Type ?? HitType.Centre;
-
-                    addExplosion(judgedObject, type);
+                    addExplosion(judgedObject, result.Type, type);
                     break;
             }
         }
@@ -218,12 +215,16 @@ namespace osu.Game.Rulesets.Taiko.UI
         private void addDrumRollHit(DrawableDrumRollTick drawableTick) =>
             drumRollHitContainer.Add(new DrawableFlyingHit(drawableTick));
 
-        private void addExplosion(DrawableHitObject drawableObject, HitType type)
+        /// <remarks>
+        /// As legacy skins have different explosions for singular and double strong hits,
+        /// explosion addition is scheduled to ensure that both hits are processed if they occur on the same frame.
+        /// </remarks>
+        private void addExplosion(DrawableHitObject drawableObject, HitResult result, HitType type) => Schedule(() =>
         {
-            hitExplosionContainer.Add(new HitExplosion(drawableObject));
+            hitExplosionContainer.Add(new HitExplosion(drawableObject, result));
             if (drawableObject.HitObject.Kiai)
                 kiaiExplosionContainer.Add(new KiaiHitExplosion(drawableObject, type));
-        }
+        });
 
         private class ProxyContainer : LifetimeManagementContainer
         {

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

@@ -11,6 +11,8 @@ using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
 using osu.Game.IO.Serialization;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Tests.Resources;
 using osuTK;
@@ -90,6 +92,38 @@ namespace osu.Game.Tests.Beatmaps.Formats
             Assert.AreEqual(2, difficulty.SliderTickRate);
         }
 
+        [Test]
+        public void TestDecodePostConverted()
+        {
+            var converted = new OsuBeatmapConverter(decodeAsJson(normal), new OsuRuleset()).Convert();
+
+            var processor = new OsuBeatmapProcessor(converted);
+
+            processor.PreProcess();
+            foreach (var o in converted.HitObjects)
+                o.ApplyDefaults(converted.ControlPointInfo, converted.BeatmapInfo.BaseDifficulty);
+            processor.PostProcess();
+
+            var beatmap = converted.Serialize().Deserialize<Beatmap>();
+
+            var curveData = beatmap.HitObjects[0] as IHasPathWithRepeats;
+            var positionData = beatmap.HitObjects[0] as IHasPosition;
+
+            Assert.IsNotNull(positionData);
+            Assert.IsNotNull(curveData);
+            Assert.AreEqual(90, curveData.Path.Distance);
+            Assert.AreEqual(new Vector2(192, 168), positionData.Position);
+            Assert.AreEqual(956, beatmap.HitObjects[0].StartTime);
+            Assert.IsTrue(beatmap.HitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));
+
+            positionData = beatmap.HitObjects[1] as IHasPosition;
+
+            Assert.IsNotNull(positionData);
+            Assert.AreEqual(new Vector2(304, 56), positionData.Position);
+            Assert.AreEqual(1285, beatmap.HitObjects[1].StartTime);
+            Assert.IsTrue(beatmap.HitObjects[1].Samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP));
+        }
+
         [Test]
         public void TestDecodeHitObjects()
         {
@@ -100,6 +134,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
             Assert.IsNotNull(positionData);
             Assert.IsNotNull(curveData);
+            Assert.AreEqual(90, curveData.Path.Distance);
             Assert.AreEqual(new Vector2(192, 168), positionData.Position);
             Assert.AreEqual(956, beatmap.HitObjects[0].StartTime);
             Assert.IsTrue(beatmap.HitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));

osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs

@@ -28,17 +28,17 @@ using FileInfo = System.IO.FileInfo;
 namespace osu.Game.Tests.Beatmaps.IO
 {
     [TestFixture]
-    public class ImportBeatmapTest
+    public class ImportBeatmapTest : ImportTest
     {
         [Test]
         public async Task TestImportWhenClosed()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    await LoadOszIntoOsu(loadOsu(host));
+                    await LoadOszIntoOsu(LoadOsuIntoHost(host));
                 }
                 finally
                 {
@@ -51,11 +51,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportThenDelete()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
 
@@ -72,11 +72,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportThenImport()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
                     var importedSecondTime = await LoadOszIntoOsu(osu);
@@ -98,11 +98,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportThenImportWithReZip()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -156,11 +156,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportThenImportWithChangedFile()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -207,11 +207,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportThenImportWithDifferentFilename()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -259,11 +259,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportCorruptThenImport()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
 
@@ -301,7 +301,7 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestRollbackOnFailure()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
@@ -314,7 +314,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                             Interlocked.Increment(ref loggedExceptionCount);
                     };
 
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
                     // ReSharper disable once AccessToModifiedClosure
@@ -378,11 +378,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportThenDeleteThenImport()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
 
@@ -406,11 +406,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportThenDeleteThenImportWithOnlineIDMismatch(bool set)
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(set.ToString()))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost($"{nameof(ImportBeatmapTest)}-{set}"))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
 
@@ -440,11 +440,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportWithDuplicateBeatmapIDs()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var metadata = new BeatmapMetadata
                     {
@@ -496,15 +496,15 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Ignore("Binding IPC on Appveyor isn't working (port in use). Need to figure out why")]
         public void TestImportOverIPC()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost("host", true))
-            using (HeadlessGameHost client = new CleanRunHeadlessGameHost("client", true))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost($"{nameof(ImportBeatmapTest)}-host", true))
+            using (HeadlessGameHost client = new CleanRunHeadlessGameHost($"{nameof(ImportBeatmapTest)}-client", true))
             {
                 try
                 {
                     Assert.IsTrue(host.IsPrimaryInstance);
                     Assert.IsFalse(client.IsPrimaryInstance);
 
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -526,11 +526,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportWhenFileOpen()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var temp = TestResources.GetTestBeatmapForImport();
                     using (File.OpenRead(temp))
                         await osu.Dependencies.Get<BeatmapManager>().Import(temp);
@@ -548,11 +548,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportWithDuplicateHashes()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -590,11 +590,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportNestedStructure()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -635,11 +635,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportWithIgnoredDirectoryInArchive()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -689,11 +689,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestUpdateBeatmapInfo()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
                     var temp = TestResources.GetTestBeatmapForImport();
@@ -719,11 +719,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestUpdateBeatmapFile()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
                     var temp = TestResources.GetTestBeatmapForImport();
@@ -761,11 +761,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public void TestCreateNewEmptyBeatmap()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
                     var working = manager.CreateNew(new OsuRuleset().RulesetInfo, User.SYSTEM_USER);
@@ -788,11 +788,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public void TestCreateNewBeatmapWithObject()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
                     var working = manager.CreateNew(new OsuRuleset().RulesetInfo, User.SYSTEM_USER);
@@ -863,14 +863,6 @@ namespace osu.Game.Tests.Beatmaps.IO
             Assert.AreEqual(expected, osu.Dependencies.Get<FileStore>().QueryFiles(f => f.ReferenceCount == 1).Count());
         }
 
-        private OsuGameBase loadOsu(GameHost host)
-        {
-            var osu = new OsuGameBase();
-            Task.Run(() => host.Run(osu));
-            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
-            return osu;
-        }
-
         private static void ensureLoaded(OsuGameBase osu, int timeout = 60000)
         {
             IEnumerable<BeatmapSetInfo> resultSets = null;

osu.Game.Tests/Beatmaps/TestSceneEditorBeatmap.cs

@@ -23,15 +23,19 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestHitObjectAddEvent()
         {
-            var editorBeatmap = new EditorBeatmap(new OsuBeatmap());
-
-            HitObject addedObject = null;
-            editorBeatmap.HitObjectAdded += h => addedObject = h;
-
             var hitCircle = new HitCircle();
 
-            editorBeatmap.Add(hitCircle);
-            Assert.That(addedObject, Is.EqualTo(hitCircle));
+            HitObject addedObject = null;
+            EditorBeatmap editorBeatmap = null;
+
+            AddStep("add beatmap", () =>
+            {
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+                editorBeatmap.HitObjectAdded += h => addedObject = h;
+            });
+
+            AddStep("add hitobject", () => editorBeatmap.Add(hitCircle));
+            AddAssert("received add event", () => addedObject == hitCircle);
         }
 
         /// <summary>
@@ -41,13 +45,15 @@ namespace osu.Game.Tests.Beatmaps
         public void HitObjectRemoveEvent()
         {
             var hitCircle = new HitCircle();
-            var editorBeatmap = new EditorBeatmap(new OsuBeatmap { HitObjects = { hitCircle } });
-
             HitObject removedObject = null;
-            editorBeatmap.HitObjectRemoved += h => removedObject = h;
-
-            editorBeatmap.Remove(hitCircle);
-            Assert.That(removedObject, Is.EqualTo(hitCircle));
+            EditorBeatmap editorBeatmap = null;
+            AddStep("add beatmap", () =>
+            {
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap { HitObjects = { hitCircle } });
+                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+            });
+            AddStep("remove hitobject", () => editorBeatmap.Remove(editorBeatmap.HitObjects.First()));
+            AddAssert("received remove event", () => removedObject == hitCircle);
         }
 
         /// <summary>
@@ -147,6 +153,7 @@ namespace osu.Game.Tests.Beatmaps
         public void TestResortWhenStartTimeChanged()
         {
             var hitCircle = new HitCircle { StartTime = 1000 };
+
             var editorBeatmap = new EditorBeatmap(new OsuBeatmap
             {
                 HitObjects =

osu.Game.Tests/Collections/IO/ImportCollectionsTest.cs

@@ -4,18 +4,15 @@
 using System;
 using System.IO;
 using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Platform;
-using osu.Game.Collections;
 using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Collections.IO
 {
     [TestFixture]
-    public class ImportCollectionsTest
+    public class ImportCollectionsTest : ImportTest
     {
         [Test]
         public async Task TestImportEmptyDatabase()
@@ -24,7 +21,7 @@ namespace osu.Game.Tests.Collections.IO
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     await osu.CollectionManager.Import(new MemoryStream());
 
@@ -44,7 +41,7 @@ namespace osu.Game.Tests.Collections.IO
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     await osu.CollectionManager.Import(TestResources.OpenResource("Collections/collections.db"));
 
@@ -70,7 +67,7 @@ namespace osu.Game.Tests.Collections.IO
             {
                 try
                 {
-                    var osu = loadOsu(host, true);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     await osu.CollectionManager.Import(TestResources.OpenResource("Collections/collections.db"));
 
@@ -101,7 +98,7 @@ namespace osu.Game.Tests.Collections.IO
                 {
                     AppDomain.CurrentDomain.UnhandledException += setException;
 
-                    var osu = loadOsu(host, true);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     using (var ms = new MemoryStream())
                     {
@@ -135,7 +132,7 @@ namespace osu.Game.Tests.Collections.IO
             {
                 try
                 {
-                    var osu = loadOsu(host, true);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     await osu.CollectionManager.Import(TestResources.OpenResource("Collections/collections.db"));
 
@@ -156,7 +153,7 @@ namespace osu.Game.Tests.Collections.IO
             {
                 try
                 {
-                    var osu = loadOsu(host, true);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
 
@@ -172,50 +169,5 @@ namespace osu.Game.Tests.Collections.IO
                 }
             }
         }
-
-        private TestOsuGameBase loadOsu(GameHost host, bool withBeatmap = false)
-        {
-            var osu = new TestOsuGameBase(withBeatmap);
-
-#pragma warning disable 4014
-            Task.Run(() => host.Run(osu));
-#pragma warning restore 4014
-
-            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
-
-            return osu;
-        }
-
-        private void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
-        {
-            Task task = Task.Run(() =>
-            {
-                while (!result()) Thread.Sleep(200);
-            });
-
-            Assert.IsTrue(task.Wait(timeout), failureMessage);
-        }
-
-        private class TestOsuGameBase : OsuGameBase
-        {
-            public CollectionManager CollectionManager { get; private set; }
-
-            private readonly bool withBeatmap;
-
-            public TestOsuGameBase(bool withBeatmap)
-            {
-                this.withBeatmap = withBeatmap;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                // Beatmap must be imported before the collection manager is loaded.
-                if (withBeatmap)
-                    BeatmapManager.Import(TestResources.GetTestBeatmapForImport()).Wait();
-
-                AddInternal(CollectionManager = new CollectionManager(Storage));
-            }
-        }
     }
 }

osu.Game.Tests/Gameplay/TestSceneHitObjectAccentColour.cs

@@ -81,7 +81,7 @@ namespace osu.Game.Tests.Gameplay
 
         private class TestHitObjectWithCombo : ConvertHitObject, IHasComboInformation
         {
-            public bool NewCombo { get; } = false;
+            public bool NewCombo { get; set; } = false;
             public int ComboOffset { get; } = 0;
 
             public Bindable<int> IndexInCurrentComboBindable { get; } = new Bindable<int>();

osu.Game.Tests/Gameplay/TestSceneScoreProcessor.cs

@@ -28,6 +28,20 @@ namespace osu.Game.Tests.Gameplay
             Assert.That(scoreProcessor.TotalScore.Value, Is.EqualTo(0.0));
         }
 
+        [Test]
+        public void TestOnlyBonusScore()
+        {
+            var beatmap = new Beatmap<TestBonusHitObject> { HitObjects = { new TestBonusHitObject() } };
+
+            var scoreProcessor = new ScoreProcessor();
+            scoreProcessor.ApplyBeatmap(beatmap);
+
+            // Apply a judgement
+            scoreProcessor.ApplyResult(new JudgementResult(new TestBonusHitObject(), new TestBonusJudgement()) { Type = HitResult.Perfect });
+
+            Assert.That(scoreProcessor.TotalScore.Value, Is.EqualTo(100));
+        }
+
         private class TestHitObject : HitObject
         {
             public override Judgement CreateJudgement() => new TestJudgement();
@@ -37,5 +51,17 @@ namespace osu.Game.Tests.Gameplay
         {
             protected override int NumericResultFor(HitResult result) => 100;
         }
+
+        private class TestBonusHitObject : HitObject
+        {
+            public override Judgement CreateJudgement() => new TestBonusJudgement();
+        }
+
+        private class TestBonusJudgement : Judgement
+        {
+            public override bool AffectsCombo => false;
+
+            protected override int NumericResultFor(HitResult result) => 100;
+        }
     }
 }

osu.Game.Tests/ImportTest.cs

@@ -0,0 +1,66 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Platform;
+using osu.Game.Collections;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests
+{
+    public abstract class ImportTest
+    {
+        protected virtual TestOsuGameBase LoadOsuIntoHost(GameHost host, bool withBeatmap = false)
+        {
+            var osu = new TestOsuGameBase(withBeatmap);
+            Task.Run(() => host.Run(osu));
+
+            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
+
+            bool ready = false;
+            // wait for two update frames to be executed. this ensures that all components have had a change to run LoadComplete and hopefully avoid
+            // database access (GlobalActionContainer is one to do this).
+            host.UpdateThread.Scheduler.Add(() => host.UpdateThread.Scheduler.Add(() => ready = true));
+
+            waitForOrAssert(() => ready, @"osu! failed to start in a reasonable amount of time");
+
+            return osu;
+        }
+
+        private void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
+        {
+            Task task = Task.Run(() =>
+            {
+                while (!result()) Thread.Sleep(200);
+            });
+
+            Assert.IsTrue(task.Wait(timeout), failureMessage);
+        }
+
+        public class TestOsuGameBase : OsuGameBase
+        {
+            public CollectionManager CollectionManager { get; private set; }
+
+            private readonly bool withBeatmap;
+
+            public TestOsuGameBase(bool withBeatmap)
+            {
+                this.withBeatmap = withBeatmap;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                // Beatmap must be imported before the collection manager is loaded.
+                if (withBeatmap)
+                    BeatmapManager.Import(TestResources.GetTestBeatmapForImport()).Wait();
+
+                AddInternal(CollectionManager = new CollectionManager(Storage));
+            }
+        }
+    }
+}

osu.Game.Tests/NonVisual/CustomDataDirectoryTest.cs

@@ -4,8 +4,7 @@
 using System;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Runtime.CompilerServices;
 using NUnit.Framework;
 using osu.Framework;
 using osu.Framework.Allocation;
@@ -17,18 +16,18 @@ using osu.Game.IO;
 namespace osu.Game.Tests.NonVisual
 {
     [TestFixture]
-    public class CustomDataDirectoryTest
+    public class CustomDataDirectoryTest : ImportTest
     {
         [Test]
         public void TestDefaultDirectory()
         {
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestDefaultDirectory)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
                     string defaultStorageLocation = getDefaultLocationFor(nameof(TestDefaultDirectory));
 
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var storage = osu.Dependencies.Get<Storage>();
 
                     Assert.That(storage.GetFullPath("."), Is.EqualTo(defaultStorageLocation));
@@ -45,14 +44,14 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (var host = new CustomTestHeadlessGameHost(nameof(TestCustomDirectory)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 using (var storageConfig = new StorageConfigManager(host.InitialStorage))
                     storageConfig.Set(StorageConfig.FullPath, customPath);
 
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     // switch to DI'd storage
                     var storage = osu.Dependencies.Get<Storage>();
@@ -71,14 +70,14 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (var host = new CustomTestHeadlessGameHost(nameof(TestSubDirectoryLookup)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 using (var storageConfig = new StorageConfigManager(host.InitialStorage))
                     storageConfig.Set(StorageConfig.FullPath, customPath);
 
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     // switch to DI'd storage
                     var storage = osu.Dependencies.Get<Storage>();
@@ -104,13 +103,13 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigration)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
                     string defaultStorageLocation = getDefaultLocationFor(nameof(TestMigration));
 
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var storage = osu.Dependencies.Get<Storage>();
 
                     // Store the current storage's path. We'll need to refer to this for assertions in the original directory after the migration completes.
@@ -165,11 +164,11 @@ namespace osu.Game.Tests.NonVisual
             string customPath = prepareCustomPath();
             string customPath2 = prepareCustomPath("-2");
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigrationBetweenTwoTargets)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     const string database_filename = "client.db";
 
@@ -194,11 +193,11 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigrationToSameTargetFails)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     Assert.DoesNotThrow(() => osu.Migrate(customPath));
                     Assert.Throws<ArgumentException>(() => osu.Migrate(customPath));
@@ -215,11 +214,11 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigrationToNestedTargetFails)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     Assert.DoesNotThrow(() => osu.Migrate(customPath));
 
@@ -244,11 +243,11 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigrationToSeeminglyNestedTarget)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     Assert.DoesNotThrow(() => osu.Migrate(customPath));
 
@@ -268,25 +267,6 @@ namespace osu.Game.Tests.NonVisual
             }
         }
 
-        private OsuGameBase loadOsu(GameHost host)
-        {
-            var osu = new OsuGameBase();
-            Task.Run(() => host.Run(osu));
-            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
-
-            return osu;
-        }
-
-        private static void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
-        {
-            Task task = Task.Run(() =>
-            {
-                while (!result()) Thread.Sleep(200);
-            });
-
-            Assert.IsTrue(task.Wait(timeout), failureMessage);
-        }
-
         private static string getDefaultLocationFor(string testTypeName)
         {
             string path = Path.Combine(RuntimeInfo.StartupDirectory, "headless", testTypeName);
@@ -307,14 +287,14 @@ namespace osu.Game.Tests.NonVisual
             return path;
         }
 
-        public class CustomTestHeadlessGameHost : HeadlessGameHost
+        public class CustomTestHeadlessGameHost : CleanRunHeadlessGameHost
         {
             public Storage InitialStorage { get; }
 
-            public CustomTestHeadlessGameHost(string name)
-                : base(name)
+            public CustomTestHeadlessGameHost([CallerMemberName] string callingMethodName = @"")
+                : base(callingMethodName: callingMethodName)
             {
-                string defaultStorageLocation = getDefaultLocationFor(name);
+                string defaultStorageLocation = getDefaultLocationFor(callingMethodName);
 
                 InitialStorage = new DesktopStorage(defaultStorageLocation, this);
                 InitialStorage.DeleteDirectory(string.Empty);

osu.Game.Tests/NonVisual/LimitedCapacityQueueTest.cs

@@ -0,0 +1,119 @@
+// 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.Rulesets.Difficulty.Utils;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class LimitedCapacityQueueTest
+    {
+        private const int capacity = 3;
+
+        private LimitedCapacityQueue<int> queue;
+
+        [SetUp]
+        public void SetUp()
+        {
+            queue = new LimitedCapacityQueue<int>(capacity);
+        }
+
+        [Test]
+        public void TestEmptyQueue()
+        {
+            Assert.AreEqual(0, queue.Count);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[0]);
+
+            Assert.Throws<InvalidOperationException>(() => _ = queue.Dequeue());
+
+            int count = 0;
+            foreach (var _ in queue)
+                count++;
+
+            Assert.AreEqual(0, count);
+        }
+
+        [TestCase(1)]
+        [TestCase(2)]
+        [TestCase(3)]
+        public void TestBelowCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            Assert.AreEqual(count, queue.Count);
+
+            for (int i = 0; i < count; ++i)
+                Assert.AreEqual(i, queue[i]);
+
+            int j = 0;
+            foreach (var item in queue)
+                Assert.AreEqual(j++, item);
+
+            for (int i = queue.Count; i < queue.Count + capacity; i++)
+                Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[i]);
+        }
+
+        [TestCase(4)]
+        [TestCase(5)]
+        [TestCase(6)]
+        public void TestEnqueueAtFullCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            Assert.AreEqual(capacity, queue.Count);
+
+            for (int i = 0; i < queue.Count; ++i)
+                Assert.AreEqual(count - capacity + i, queue[i]);
+
+            int j = count - capacity;
+            foreach (var item in queue)
+                Assert.AreEqual(j++, item);
+
+            for (int i = queue.Count; i < queue.Count + capacity; i++)
+                Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[i]);
+        }
+
+        [TestCase(4)]
+        [TestCase(5)]
+        [TestCase(6)]
+        public void TestDequeueAtFullCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            for (int i = 0; i < capacity; ++i)
+            {
+                Assert.AreEqual(count - capacity + i, queue.Dequeue());
+                Assert.AreEqual(2 - i, queue.Count);
+            }
+
+            Assert.Throws<InvalidOperationException>(() => queue.Dequeue());
+        }
+
+        [Test]
+        public void TestClearQueue()
+        {
+            queue.Enqueue(3);
+            queue.Enqueue(5);
+            Assert.AreEqual(2, queue.Count);
+
+            queue.Clear();
+            Assert.AreEqual(0, queue.Count);
+            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[0]);
+
+            queue.Enqueue(7);
+            Assert.AreEqual(1, queue.Count);
+            Assert.AreEqual(7, queue[0]);
+            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[1]);
+
+            queue.Enqueue(9);
+            Assert.AreEqual(2, queue.Count);
+            Assert.AreEqual(9, queue[1]);
+        }
+    }
+}

osu.Game.Tests/Rulesets/TestSceneDrawableRulesetDependencies.cs

@@ -0,0 +1,136 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.UI;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.Rulesets
+{
+    [HeadlessTest]
+    public class TestSceneDrawableRulesetDependencies : OsuTestScene
+    {
+        [Test]
+        public void TestDisposalDoesNotDisposeParentStores()
+        {
+            DrawableWithDependencies drawable = null;
+            TestTextureStore textureStore = null;
+            TestSampleStore sampleStore = null;
+
+            AddStep("add dependencies", () =>
+            {
+                Child = drawable = new DrawableWithDependencies();
+                textureStore = drawable.ParentTextureStore;
+                sampleStore = drawable.ParentSampleStore;
+            });
+
+            AddStep("clear children", Clear);
+            AddUntilStep("wait for disposal", () => drawable.IsDisposed);
+
+            AddStep("GC", () =>
+            {
+                drawable = null;
+
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+            });
+
+            AddAssert("parent texture store not disposed", () => !textureStore.IsDisposed);
+            AddAssert("parent sample store not disposed", () => !sampleStore.IsDisposed);
+        }
+
+        private class DrawableWithDependencies : CompositeDrawable
+        {
+            public TestTextureStore ParentTextureStore { get; private set; }
+            public TestSampleStore ParentSampleStore { get; private set; }
+
+            public DrawableWithDependencies()
+            {
+                InternalChild = new Box { RelativeSizeAxes = Axes.Both };
+            }
+
+            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            {
+                var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
+                dependencies.CacheAs<TextureStore>(ParentTextureStore = new TestTextureStore());
+                dependencies.CacheAs<ISampleStore>(ParentSampleStore = new TestSampleStore());
+
+                return new DrawableRulesetDependencies(new OsuRuleset(), dependencies);
+            }
+
+            public new bool IsDisposed { get; private set; }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+                IsDisposed = true;
+            }
+        }
+
+        private class TestTextureStore : TextureStore
+        {
+            public override Texture Get(string name, WrapMode wrapModeS, WrapMode wrapModeT) => null;
+
+            public bool IsDisposed { get; private set; }
+
+            protected override void Dispose(bool disposing)
+            {
+                base.Dispose(disposing);
+                IsDisposed = true;
+            }
+        }
+
+        private class TestSampleStore : ISampleStore
+        {
+            public bool IsDisposed { get; private set; }
+
+            public void Dispose()
+            {
+                IsDisposed = true;
+            }
+
+            public SampleChannel Get(string name) => null;
+
+            public Task<SampleChannel> GetAsync(string name) => null;
+
+            public Stream GetStream(string name) => null;
+
+            public IEnumerable<string> GetAvailableResources() => throw new NotImplementedException();
+
+            public BindableNumber<double> Volume => throw new NotImplementedException();
+            public BindableNumber<double> Balance => throw new NotImplementedException();
+            public BindableNumber<double> Frequency => throw new NotImplementedException();
+            public BindableNumber<double> Tempo => throw new NotImplementedException();
+
+            public void AddAdjustment(AdjustableProperty type, BindableNumber<double> adjustBindable) => throw new NotImplementedException();
+
+            public void RemoveAdjustment(AdjustableProperty type, BindableNumber<double> adjustBindable) => throw new NotImplementedException();
+
+            public void RemoveAllAdjustments(AdjustableProperty type) => throw new NotImplementedException();
+
+            public IBindable<double> AggregateVolume => throw new NotImplementedException();
+            public IBindable<double> AggregateBalance => throw new NotImplementedException();
+            public IBindable<double> AggregateFrequency => throw new NotImplementedException();
+            public IBindable<double> AggregateTempo => throw new NotImplementedException();
+
+            public int PlaybackConcurrency { get; set; }
+        }
+    }
+}

osu.Game.Tests/Scores/IO/ImportScoreTest.cs

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -17,12 +16,11 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
-using osu.Game.Tests.Resources;
 using osu.Game.Users;
 
 namespace osu.Game.Tests.Scores.IO
 {
-    public class ImportScoreTest
+    public class ImportScoreTest : ImportTest
     {
         [Test]
         public async Task TestBasicImport()
@@ -31,7 +29,7 @@ namespace osu.Game.Tests.Scores.IO
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     var toImport = new ScoreInfo
                     {
@@ -45,7 +43,7 @@ namespace osu.Game.Tests.Scores.IO
                         OnlineScoreID = 12345,
                     };
 
-                    var imported = await loadIntoOsu(osu, toImport);
+                    var imported = await loadScoreIntoOsu(osu, toImport);
 
                     Assert.AreEqual(toImport.Rank, imported.Rank);
                     Assert.AreEqual(toImport.TotalScore, imported.TotalScore);
@@ -70,14 +68,14 @@ namespace osu.Game.Tests.Scores.IO
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     var toImport = new ScoreInfo
                     {
                         Mods = new Mod[] { new OsuModHardRock(), new OsuModDoubleTime() },
                     };
 
-                    var imported = await loadIntoOsu(osu, toImport);
+                    var imported = await loadScoreIntoOsu(osu, toImport);
 
                     Assert.IsTrue(imported.Mods.Any(m => m is OsuModHardRock));
                     Assert.IsTrue(imported.Mods.Any(m => m is OsuModDoubleTime));
@@ -96,7 +94,7 @@ namespace osu.Game.Tests.Scores.IO
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     var toImport = new ScoreInfo
                     {
@@ -107,7 +105,7 @@ namespace osu.Game.Tests.Scores.IO
                         }
                     };
 
-                    var imported = await loadIntoOsu(osu, toImport);
+                    var imported = await loadScoreIntoOsu(osu, toImport);
 
                     Assert.AreEqual(toImport.Statistics[HitResult.Perfect], imported.Statistics[HitResult.Perfect]);
                     Assert.AreEqual(toImport.Statistics[HitResult.Miss], imported.Statistics[HitResult.Miss]);
@@ -126,7 +124,7 @@ namespace osu.Game.Tests.Scores.IO
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     var toImport = new ScoreInfo
                     {
@@ -138,7 +136,7 @@ namespace osu.Game.Tests.Scores.IO
                         }
                     };
 
-                    var imported = await loadIntoOsu(osu, toImport);
+                    var imported = await loadScoreIntoOsu(osu, toImport);
 
                     var beatmapManager = osu.Dependencies.Get<BeatmapManager>();
                     var scoreManager = osu.Dependencies.Get<ScoreManager>();
@@ -146,7 +144,7 @@ namespace osu.Game.Tests.Scores.IO
                     beatmapManager.Delete(beatmapManager.QueryBeatmapSet(s => s.Beatmaps.Any(b => b.ID == imported.Beatmap.ID)));
                     Assert.That(scoreManager.Query(s => s.ID == imported.ID).DeletePending, Is.EqualTo(true));
 
-                    var secondImport = await loadIntoOsu(osu, imported);
+                    var secondImport = await loadScoreIntoOsu(osu, imported);
                     Assert.That(secondImport, Is.Null);
                 }
                 finally
@@ -163,9 +161,9 @@ namespace osu.Game.Tests.Scores.IO
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
-                    await loadIntoOsu(osu, new ScoreInfo { OnlineScoreID = 2 }, new TestArchiveReader());
+                    await loadScoreIntoOsu(osu, new ScoreInfo { OnlineScoreID = 2 }, new TestArchiveReader());
 
                     var scoreManager = osu.Dependencies.Get<ScoreManager>();
 
@@ -179,7 +177,7 @@ namespace osu.Game.Tests.Scores.IO
             }
         }
 
-        private async Task<ScoreInfo> loadIntoOsu(OsuGameBase osu, ScoreInfo score, ArchiveReader archive = null)
+        private async Task<ScoreInfo> loadScoreIntoOsu(OsuGameBase osu, ScoreInfo score, ArchiveReader archive = null)
         {
             var beatmapManager = osu.Dependencies.Get<BeatmapManager>();
 
@@ -192,33 +190,6 @@ namespace osu.Game.Tests.Scores.IO
             return scoreManager.GetAllUsableScores().FirstOrDefault();
         }
 
-        private async Task<OsuGameBase> loadOsu(GameHost host)
-        {
-            var osu = new OsuGameBase();
-
-#pragma warning disable 4014
-            Task.Run(() => host.Run(osu));
-#pragma warning restore 4014
-
-            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
-
-            var beatmapFile = TestResources.GetTestBeatmapForImport();
-            var beatmapManager = osu.Dependencies.Get<BeatmapManager>();
-            await beatmapManager.Import(beatmapFile);
-
-            return osu;
-        }
-
-        private void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
-        {
-            Task task = Task.Run(() =>
-            {
-                while (!result()) Thread.Sleep(200);
-            });
-
-            Assert.IsTrue(task.Wait(timeout), failureMessage);
-        }
-
         private class TestArchiveReader : ArchiveReader
         {
             public TestArchiveReader()

osu.Game.Tests/Skins/IO/ImportSkinTest.cs

@@ -0,0 +1,147 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Platform;
+using osu.Game.IO.Archives;
+using osu.Game.Skinning;
+using SharpCompress.Archives.Zip;
+
+namespace osu.Game.Tests.Skins.IO
+{
+    public class ImportSkinTest : ImportTest
+    {
+        [Test]
+        public async Task TestBasicImport()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin.osk"));
+
+                    Assert.That(imported.Name, Is.EqualTo("test skin"));
+                    Assert.That(imported.Creator, Is.EqualTo("skinner"));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportTwiceWithSameMetadata()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin.osk"));
+                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin2.osk"));
+
+                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Count, Is.EqualTo(1));
+
+                    // the first should be overwritten by the second import.
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().First().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportTwiceWithNoMetadata()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    // if a user downloads two skins that do have skin.ini files but don't have any creator metadata in the skin.ini, they should both import separately just for safety.
+                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk(string.Empty, string.Empty), "download.osk"));
+                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk(string.Empty, string.Empty), "download.osk"));
+
+                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Count, Is.EqualTo(2));
+
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().First().Files.First().FileInfoID, Is.EqualTo(imported.Files.First().FileInfoID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Last().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportTwiceWithDifferentMetadata()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin v2", "skinner"), "skin.osk"));
+                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin v2.1", "skinner"), "skin2.osk"));
+
+                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Count, Is.EqualTo(2));
+
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().First().Files.First().FileInfoID, Is.EqualTo(imported.Files.First().FileInfoID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Last().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        private MemoryStream createOsk(string name, string author)
+        {
+            var zipStream = new MemoryStream();
+            using var zip = ZipArchive.Create();
+            zip.AddEntry("skin.ini", generateSkinIni(name, author));
+            zip.SaveTo(zipStream);
+            return zipStream;
+        }
+
+        private MemoryStream generateSkinIni(string name, string author)
+        {
+            var stream = new MemoryStream();
+            var writer = new StreamWriter(stream);
+
+            writer.WriteLine("[General]");
+            writer.WriteLine($"Name: {name}");
+            writer.WriteLine($"Author: {author}");
+            writer.WriteLine();
+            writer.WriteLine($"# unique {Guid.NewGuid()}");
+
+            writer.Flush();
+
+            return stream;
+        }
+
+        private async Task<SkinInfo> loadSkinIntoOsu(OsuGameBase osu, ArchiveReader archive = null)
+        {
+            var skinManager = osu.Dependencies.Get<SkinManager>();
+            return await skinManager.Import(archive);
+        }
+    }
+}