Merge pull request #8893 from peppy/reduce-initial-channel-load-overhead

Reduce initial channel load overhead by only loading history on active channel

CodeAnalysis/BannedSymbols.txt

@@ -4,3 +4,5 @@ M:System.ValueType.Equals(System.Object)~System.Boolean;Don't use object.Equals(
 M:System.Nullable`1.Equals(System.Object)~System.Boolean;Use == instead.
 T:System.IComparable;Don't use non-generic IComparable. Use generic version instead.
 M:osu.Framework.Graphics.Sprites.SpriteText.#ctor;Use OsuSpriteText.
+T:Microsoft.EntityFrameworkCore.Internal.EnumerableExtensions;Don't use internal extension methods.
+T:Microsoft.EntityFrameworkCore.Internal.TypeExtensions;Don't use internal extension methods.

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.412.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.427.0" />
     <PackageReference Include="ppy.osu.Framework.Android" Version="2020.421.0" />
   </ItemGroup>
 </Project>

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -71,8 +71,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         protected override Skill[] CreateSkills(IBeatmap beatmap)
         {
-            using (var catcher = new Catcher(beatmap.BeatmapInfo.BaseDifficulty))
-                halfCatcherWidth = catcher.CatchWidth * 0.5f;
+            halfCatcherWidth = Catcher.CalculateCatchWidth(beatmap.BeatmapInfo.BaseDifficulty) * 0.5f;
 
             return new Skill[]
             {

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

@@ -44,11 +44,6 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private const float allowed_catch_range = 0.8f;
 
-        /// <summary>
-        /// Width of the area that can be used to attempt catches during gameplay.
-        /// </summary>
-        internal float CatchWidth => CatcherArea.CATCHER_SIZE * Math.Abs(Scale.X) * allowed_catch_range;
-
         protected bool Dashing
         {
             get => dashing;
@@ -79,6 +74,11 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
+        /// <summary>
+        /// Width of the area that can be used to attempt catches during gameplay.
+        /// </summary>
+        private readonly float catchWidth;
+
         private Container<DrawableHitObject> caughtFruit;
 
         private CatcherSprite catcherIdle;
@@ -106,7 +106,9 @@ namespace osu.Game.Rulesets.Catch.UI
 
             Size = new Vector2(CatcherArea.CATCHER_SIZE);
             if (difficulty != null)
-                Scale = new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+                Scale = calculateScale(difficulty);
+
+            catchWidth = CalculateCatchWidth(Scale);
         }
 
         [BackgroundDependencyLoader]
@@ -139,6 +141,26 @@ namespace osu.Game.Rulesets.Catch.UI
             updateCatcher();
         }
 
+        /// <summary>
+        /// Calculates the scale of the catcher based off the provided beatmap difficulty.
+        /// </summary>
+        private static Vector2 calculateScale(BeatmapDifficulty difficulty)
+            => new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+
+        /// <summary>
+        /// Calculates the width of the area used for attempting catches in gameplay.
+        /// </summary>
+        /// <param name="scale">The scale of the catcher.</param>
+        internal static float CalculateCatchWidth(Vector2 scale)
+            => CatcherArea.CATCHER_SIZE * Math.Abs(scale.X) * allowed_catch_range;
+
+        /// <summary>
+        /// Calculates the width of the area used for attempting catches in gameplay.
+        /// </summary>
+        /// <param name="difficulty">The beatmap difficulty.</param>
+        internal static float CalculateCatchWidth(BeatmapDifficulty difficulty)
+            => CalculateCatchWidth(calculateScale(difficulty));
+
         /// <summary>
         /// Add a caught fruit to the catcher's stack.
         /// </summary>
@@ -177,7 +199,7 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <returns>Whether the catch is possible.</returns>
         public bool AttemptCatch(CatchHitObject fruit)
         {
-            var halfCatchWidth = CatchWidth * 0.5f;
+            var halfCatchWidth = catchWidth * 0.5f;
 
             // this stuff wil disappear once we move fruit to non-relative coordinate space in the future.
             var catchObjectPosition = fruit.X * CatchPlayfield.BASE_WIDTH;

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

@@ -41,8 +41,6 @@ namespace osu.Game.Rulesets.Mania.Tests
                 AccentColour = Color4.OrangeRed,
                 Clock = new FramedClock(new StopwatchClock()), // No scroll
             });
-
-            AddStep("change direction", () => ((ScrollingTestContainer)HitObjectContainer).Flip());
         }
 
         protected override Container CreateHitObjectContainer() => new ScrollingTestContainer(ScrollingDirection.Down) { RelativeSizeAxes = Axes.Both };

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

@@ -0,0 +1,174 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Edit;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Edit;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestSceneManiaHitObjectComposer : EditorClockTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ManiaBlueprintContainer)
+        };
+
+        private TestComposer composer;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            BeatDivisor.Value = 8;
+            Clock.Seek(0);
+
+            Child = composer = new TestComposer { RelativeSizeAxes = Axes.Both };
+        });
+
+        [Test]
+        public void TestDragOffscreenSelectionVerticallyUpScroll()
+        {
+            DrawableHitObject lastObject = null;
+            Vector2 originalPosition = Vector2.Zero;
+
+            AddStep("seek to last object", () =>
+            {
+                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
+                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+            });
+
+            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
+
+            AddStep("click last object", () =>
+            {
+                originalPosition = lastObject.DrawPosition;
+
+                InputManager.MoveMouseTo(lastObject);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("move mouse downwards", () =>
+            {
+                InputManager.MoveMouseTo(lastObject, new Vector2(0, 20));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("hitobjects not moved columns", () => composer.EditorBeatmap.HitObjects.All(h => ((ManiaHitObject)h).Column == 0));
+            AddAssert("hitobjects moved downwards", () => lastObject.DrawPosition.Y - originalPosition.Y > 0);
+            AddAssert("hitobjects not moved too far", () => lastObject.DrawPosition.Y - originalPosition.Y < 50);
+        }
+
+        [Test]
+        public void TestDragOffscreenSelectionVerticallyDownScroll()
+        {
+            DrawableHitObject lastObject = null;
+            Vector2 originalPosition = Vector2.Zero;
+
+            AddStep("set down scroll", () => ((Bindable<ScrollingDirection>)composer.Composer.ScrollingInfo.Direction).Value = ScrollingDirection.Down);
+
+            AddStep("seek to last object", () =>
+            {
+                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
+                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+            });
+
+            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
+
+            AddStep("click last object", () =>
+            {
+                originalPosition = lastObject.DrawPosition;
+
+                InputManager.MoveMouseTo(lastObject);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("move mouse upwards", () =>
+            {
+                InputManager.MoveMouseTo(lastObject, new Vector2(0, -20));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("hitobjects not moved columns", () => composer.EditorBeatmap.HitObjects.All(h => ((ManiaHitObject)h).Column == 0));
+            AddAssert("hitobjects moved upwards", () => originalPosition.Y - lastObject.DrawPosition.Y > 0);
+            AddAssert("hitobjects not moved too far", () => originalPosition.Y - lastObject.DrawPosition.Y < 50);
+        }
+
+        [Test]
+        public void TestDragOffscreenSelectionHorizontally()
+        {
+            DrawableHitObject lastObject = null;
+            Vector2 originalPosition = Vector2.Zero;
+
+            AddStep("seek to last object", () =>
+            {
+                lastObject = this.ChildrenOfType<DrawableHitObject>().Single(d => d.HitObject == composer.EditorBeatmap.HitObjects.Last());
+                Clock.Seek(composer.EditorBeatmap.HitObjects.Last().StartTime);
+            });
+
+            AddStep("select all objects", () => composer.EditorBeatmap.SelectedHitObjects.AddRange(composer.EditorBeatmap.HitObjects));
+
+            AddStep("click last object", () =>
+            {
+                originalPosition = lastObject.DrawPosition;
+
+                InputManager.MoveMouseTo(lastObject);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("move mouse right", () =>
+            {
+                var firstColumn = composer.Composer.Playfield.GetColumn(0);
+                var secondColumn = composer.Composer.Playfield.GetColumn(1);
+
+                InputManager.MoveMouseTo(lastObject, new Vector2(secondColumn.ScreenSpaceDrawQuad.Centre.X - firstColumn.ScreenSpaceDrawQuad.Centre.X + 1, 0));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("hitobjects moved columns", () => composer.EditorBeatmap.HitObjects.All(h => ((ManiaHitObject)h).Column == 1));
+
+            // Todo: They'll move vertically by the height of a note since there's no snapping and the selection point is the middle of the note.
+            AddAssert("hitobjects not moved vertically", () => lastObject.DrawPosition.Y - originalPosition.Y <= DefaultNotePiece.NOTE_HEIGHT);
+        }
+
+        private class TestComposer : CompositeDrawable
+        {
+            [Cached(typeof(EditorBeatmap))]
+            [Cached(typeof(IBeatSnapProvider))]
+            public readonly EditorBeatmap EditorBeatmap;
+
+            public readonly ManiaHitObjectComposer Composer;
+
+            public TestComposer()
+            {
+                InternalChildren = new Drawable[]
+                {
+                    EditorBeatmap = new EditorBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 }))
+                    {
+                        BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo }
+                    },
+                    Composer = new ManiaHitObjectComposer(new ManiaRuleset())
+                };
+
+                for (int i = 0; i < 10; i++)
+                    EditorBeatmap.Add(new Note { StartTime = 100 * i });
+            }
+        }
+    }
+}

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

@@ -1,17 +1,59 @@
 // 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.Extensions.IEnumerableExtensions;
+using osu.Framework.Testing;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
     public class TestSceneNotePlacementBlueprint : ManiaPlacementBlueprintTestScene
     {
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            this.ChildrenOfType<HitObjectContainer>().ForEach(c => c.Clear());
+
+            ResetPlacement();
+
+            ((ScrollingTestContainer)HitObjectContainer).Direction = ScrollingDirection.Down;
+        });
+
+        [Test]
+        public void TestPlaceBeforeCurrentTimeDownwards()
+        {
+            AddStep("move mouse before current time", () => InputManager.MoveMouseTo(this.ChildrenOfType<Column>().Single().ScreenSpaceDrawQuad.BottomLeft - new Vector2(0, 10)));
+
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("note start time < 0", () => getNote().StartTime < 0);
+        }
+
+        [Test]
+        public void TestPlaceAfterCurrentTimeDownwards()
+        {
+            AddStep("move mouse after current time", () => InputManager.MoveMouseTo(this.ChildrenOfType<Column>().Single()));
+
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("note start time > 0", () => getNote().StartTime > 0);
+        }
+
+        private Note getNote() => this.ChildrenOfType<DrawableNote>().FirstOrDefault()?.HitObject;
+
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableNote((Note)hitObject);
         protected override PlacementBlueprint CreateBlueprint() => new NotePlacementBlueprint();
     }

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -13,7 +13,6 @@ using osu.Game.Rulesets.Mania.Beatmaps.Patterns;
 using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy;
 using osuTK;
-using osu.Game.Audio;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps
 {
@@ -67,7 +66,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             }
         }
 
-        public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition || h is ManiaHitObject);
+        public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
 
         protected override Beatmap<ManiaHitObject> ConvertBeatmap(IBeatmap original)
         {
@@ -239,8 +238,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                         StartTime = HitObject.StartTime,
                         Duration = endTimeData.Duration,
                         Column = column,
-                        Head = { Samples = sampleInfoListAt(HitObject.StartTime) },
-                        Tail = { Samples = sampleInfoListAt(endTimeData.EndTime) },
+                        Samples = HitObject.Samples,
+                        NodeSamples = (HitObject as IHasRepeats)?.NodeSamples
                     });
                 }
                 else if (HitObject is IHasXPosition)
@@ -255,22 +254,6 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
                 return pattern;
             }
-
-            /// <summary>
-            /// Retrieves the sample info list at a point in time.
-            /// </summary>
-            /// <param name="time">The time to retrieve the sample info list from.</param>
-            /// <returns></returns>
-            private IList<HitSampleInfo> sampleInfoListAt(double time)
-            {
-                if (!(HitObject is IHasCurve curveData))
-                    return HitObject.Samples;
-
-                double segmentTime = (curveData.EndTime - HitObject.StartTime) / curveData.SpanCount();
-
-                int index = (int)(segmentTime == 0 ? 0 : (time - HitObject.StartTime) / segmentTime);
-                return curveData.NodeSamples[index];
-            }
         }
     }
 }

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs

@@ -505,16 +505,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             }
             else
             {
-                var holdNote = new HoldNote
+                newObject = new HoldNote
                 {
                     StartTime = startTime,
-                    Column = column,
                     Duration = endTime - startTime,
-                    Head = { Samples = sampleInfoListAt(startTime) },
-                    Tail = { Samples = sampleInfoListAt(endTime) }
+                    Column = column,
+                    Samples = HitObject.Samples,
+                    NodeSamples = (HitObject as IHasRepeats)?.NodeSamples
                 };
-
-                newObject = holdNote;
             }
 
             pattern.Add(newObject);

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs

@@ -64,21 +64,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             if (holdNote)
             {
-                var hold = new HoldNote
+                newObject = new HoldNote
                 {
                     StartTime = HitObject.StartTime,
+                    Duration = endTime - HitObject.StartTime,
                     Column = column,
-                    Duration = endTime - HitObject.StartTime
+                    Samples = HitObject.Samples,
+                    NodeSamples = (HitObject as IHasRepeats)?.NodeSamples
                 };
-
-                if (hold.Head.Samples == null)
-                    hold.Head.Samples = new List<HitSampleInfo>();
-
-                hold.Head.Samples.Add(new HitSampleInfo { Name = HitSampleInfo.HIT_NORMAL });
-
-                hold.Tail.Samples = HitObject.Samples;
-
-                newObject = hold;
             }
             else
             {

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNotePlacementBlueprint.cs

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 using osuTK;
@@ -46,6 +47,12 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             bodyPiece.Height = (bottomPosition - topPosition).Y;
         }
 
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            base.OnMouseUp(e);
+            EndPlacement(true);
+        }
+
         private double originalStartTime;
 
         public override void UpdatePosition(Vector2 screenSpacePosition)

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs

@@ -76,5 +76,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         }
 
         public override Quad SelectionQuad => ScreenSpaceDrawQuad;
+
+        public override Vector2 SelectionPoint => DrawableObject.Head.ScreenSpaceDrawQuad.Centre;
     }
 }

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs

@@ -50,16 +50,10 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 return base.OnMouseDown(e);
 
             HitObject.Column = Column.Index;
-            BeginPlacement(TimeAt(e.ScreenSpaceMousePosition));
+            BeginPlacement(TimeAt(e.ScreenSpaceMousePosition), true);
             return true;
         }
 
-        protected override void OnMouseUp(MouseUpEvent e)
-        {
-            EndPlacement(true);
-            base.OnMouseUp(e);
-        }
-
         public override void UpdatePosition(Vector2 screenSpacePosition)
         {
             if (!PlacementActive)

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaSelectionBlueprint.cs

@@ -3,8 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Input.Events;
-using osu.Framework.Timing;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -15,13 +13,8 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
     public class ManiaSelectionBlueprint : OverlaySelectionBlueprint
     {
-        public Vector2 ScreenSpaceDragPosition { get; private set; }
-        public Vector2 DragPosition { get; private set; }
-
         public new DrawableManiaHitObject DrawableObject => (DrawableManiaHitObject)base.DrawableObject;
 
-        protected IClock EditorClock { get; private set; }
-
         [Resolved]
         private IScrollingInfo scrollingInfo { get; set; }
 
@@ -34,12 +27,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             RelativeSizeAxes = Axes.None;
         }
 
-        [BackgroundDependencyLoader]
-        private void load(IAdjustableClock clock)
-        {
-            EditorClock = clock;
-        }
-
         protected override void Update()
         {
             base.Update();
@@ -47,22 +34,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             Position = Parent.ToLocalSpace(DrawableObject.ToScreenSpace(Vector2.Zero));
         }
 
-        protected override bool OnMouseDown(MouseDownEvent e)
-        {
-            ScreenSpaceDragPosition = e.ScreenSpaceMousePosition;
-            DragPosition = DrawableObject.ToLocalSpace(e.ScreenSpaceMousePosition);
-
-            return base.OnMouseDown(e);
-        }
-
-        protected override void OnDrag(DragEvent e)
-        {
-            base.OnDrag(e);
-
-            ScreenSpaceDragPosition = e.ScreenSpaceMousePosition;
-            DragPosition = DrawableObject.ToLocalSpace(e.ScreenSpaceMousePosition);
-        }
-
         public override void Show()
         {
             DrawableObject.AlwaysAlive = true;

osu.Game.Rulesets.Mania/Edit/Blueprints/NotePlacementBlueprint.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
 
@@ -26,5 +27,15 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             Width = SnappedWidth;
             Position = SnappedMousePosition;
         }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            base.OnMouseDown(e);
+
+            // Place the note immediately.
+            EndPlacement(true);
+
+            return true;
+        }
     }
 }

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

@@ -30,5 +30,7 @@ namespace osu.Game.Rulesets.Mania.Edit
 
             return base.CreateBlueprintFor(hitObject);
         }
+
+        protected override SelectionHandler CreateSelectionHandler() => new ManiaSelectionHandler();
     }
 }

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

@@ -10,6 +10,7 @@ using osu.Framework.Allocation;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
@@ -37,7 +38,33 @@ namespace osu.Game.Rulesets.Mania.Edit
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
-        public int TotalColumns => ((ManiaPlayfield)drawableRuleset.Playfield).TotalColumns;
+        public ManiaPlayfield Playfield => ((ManiaPlayfield)drawableRuleset.Playfield);
+
+        public IScrollingInfo ScrollingInfo => drawableRuleset.ScrollingInfo;
+
+        public int TotalColumns => Playfield.TotalColumns;
+
+        public override (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time)
+        {
+            var hoc = Playfield.GetColumn(0).HitObjectContainer;
+
+            float targetPosition = hoc.ToLocalSpace(ToScreenSpace(position)).Y;
+
+            if (drawableRuleset.ScrollingInfo.Direction.Value == ScrollingDirection.Down)
+            {
+                // We're dealing with screen coordinates in which the position decreases towards the centre of the screen resulting in an increase in start time.
+                // The scrolling algorithm instead assumes a top anchor meaning an increase in time corresponds to an increase in position,
+                // so when scrolling downwards the coordinates need to be flipped.
+                targetPosition = hoc.DrawHeight - targetPosition;
+            }
+
+            double targetTime = drawableRuleset.ScrollingInfo.Algorithm.TimeAt(targetPosition,
+                EditorClock.CurrentTime,
+                drawableRuleset.ScrollingInfo.TimeRange.Value,
+                hoc.DrawHeight);
+
+            return base.GetSnappedPosition(position, targetTime);
+        }
 
         protected override DrawableRuleset<ManiaHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
         {

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

@@ -4,11 +4,8 @@
 using System;
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Timing;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 
@@ -22,85 +19,16 @@ namespace osu.Game.Rulesets.Mania.Edit
         [Resolved]
         private IManiaHitObjectComposer composer { get; set; }
 
-        private IClock editorClock;
-
-        [BackgroundDependencyLoader]
-        private void load(IAdjustableClock clock)
-        {
-            editorClock = clock;
-        }
-
         public override bool HandleMovement(MoveSelectionEvent moveEvent)
         {
             var maniaBlueprint = (ManiaSelectionBlueprint)moveEvent.Blueprint;
             int lastColumn = maniaBlueprint.DrawableObject.HitObject.Column;
 
-            adjustOrigins(maniaBlueprint);
-            performDragMovement(moveEvent);
             performColumnMovement(lastColumn, moveEvent);
 
             return true;
         }
 
-        /// <summary>
-        /// Ensures that the position of hitobjects remains centred to the mouse position.
-        /// E.g. The hitobject position will change if the editor scrolls while a hitobject is dragged.
-        /// </summary>
-        /// <param name="reference">The <see cref="ManiaSelectionBlueprint"/> that received the drag event.</param>
-        private void adjustOrigins(ManiaSelectionBlueprint reference)
-        {
-            var referenceParent = (HitObjectContainer)reference.DrawableObject.Parent;
-
-            float offsetFromReferenceOrigin = reference.DragPosition.Y - reference.DrawableObject.OriginPosition.Y;
-            float targetPosition = referenceParent.ToLocalSpace(reference.ScreenSpaceDragPosition).Y - offsetFromReferenceOrigin;
-
-            // Flip the vertical coordinate space when scrolling downwards
-            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                targetPosition -= referenceParent.DrawHeight;
-
-            float movementDelta = targetPosition - reference.DrawableObject.Position.Y;
-
-            foreach (var b in SelectedBlueprints.OfType<ManiaSelectionBlueprint>())
-                b.DrawableObject.Y += movementDelta;
-        }
-
-        private void performDragMovement(MoveSelectionEvent moveEvent)
-        {
-            float delta = moveEvent.InstantDelta.Y;
-
-            // When scrolling downwards the anchor position is at the bottom of the screen, however the movement event assumes the anchor is at the top of the screen.
-            // This causes the delta to assume a positive hitobject position, and which can be corrected for by subtracting the parent height.
-            if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                delta -= moveEvent.Blueprint.Parent.DrawHeight; // todo: probably wrong
-
-            foreach (var selectionBlueprint in SelectedBlueprints)
-            {
-                var b = (OverlaySelectionBlueprint)selectionBlueprint;
-
-                var hitObject = b.DrawableObject;
-                var objectParent = (HitObjectContainer)hitObject.Parent;
-
-                // StartTime could be used to adjust the position if only one movement event was received per frame.
-                // However this is not the case and ScrollingHitObjectContainer performs movement in UpdateAfterChildren() so the position must also be updated to be valid for further movement events
-                hitObject.Y += delta;
-
-                float targetPosition = hitObject.Position.Y;
-
-                // The scrolling algorithm always assumes an anchor at the top of the screen, so the position must be flipped when scrolling downwards to reflect a top anchor
-                if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
-                    targetPosition = -targetPosition;
-
-                objectParent.Remove(hitObject);
-
-                hitObject.HitObject.StartTime = scrollingInfo.Algorithm.TimeAt(targetPosition,
-                    editorClock.CurrentTime,
-                    scrollingInfo.TimeRange.Value,
-                    objectParent.DrawHeight);
-
-                objectParent.Add(hitObject);
-            }
-        }
-
         private void performColumnMovement(int lastColumn, MoveSelectionEvent moveEvent)
         {
             var currentColumn = composer.ColumnAt(moveEvent.ScreenSpacePosition);

osu.Game.Rulesets.Mania/Edit/Masks/ManiaSelectionBlueprint.cs

@@ -1,18 +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 osu.Framework.Graphics;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Objects.Drawables;
-
-namespace osu.Game.Rulesets.Mania.Edit.Masks
-{
-    public abstract class ManiaSelectionBlueprint : OverlaySelectionBlueprint
-    {
-        protected ManiaSelectionBlueprint(DrawableHitObject drawableObject)
-            : base(drawableObject)
-        {
-            RelativeSizeAxes = Axes.None;
-        }
-    }
-}

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

@@ -51,7 +51,10 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
             AddRangeInternal(new[]
             {
-                bodyPiece = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HoldNoteBody, hitObject.Column), _ => new DefaultBodyPiece())
+                bodyPiece = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HoldNoteBody, hitObject.Column), _ => new DefaultBodyPiece
+                {
+                    RelativeSizeAxes = Axes.Both
+                })
                 {
                     RelativeSizeAxes = Axes.X
                 },
@@ -127,6 +130,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             bodyPiece.Anchor = bodyPiece.Origin = e.NewValue == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
         }
 
+        public override void PlaySamples()
+        {
+            // Samples are played by the head/tail notes.
+        }
+
         protected override void Update()
         {
             base.Update();

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

@@ -13,11 +13,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
     public abstract class DrawableManiaHitObject : DrawableHitObject<ManiaHitObject>
     {
-        /// <summary>
-        /// Whether this <see cref="DrawableManiaHitObject"/> should always remain alive.
-        /// </summary>
-        internal bool AlwaysAlive;
-
         /// <summary>
         /// The <see cref="ManiaAction"/> which causes this <see cref="DrawableManiaHitObject{TObject}"/> to be hit.
         /// </summary>
@@ -54,7 +49,62 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             Direction.BindValueChanged(OnDirectionChanged, true);
         }
 
-        protected override bool ShouldBeAlive => AlwaysAlive || base.ShouldBeAlive;
+        private double computedLifetimeStart;
+
+        public override double LifetimeStart
+        {
+            get => base.LifetimeStart;
+            set
+            {
+                computedLifetimeStart = value;
+
+                if (!AlwaysAlive)
+                    base.LifetimeStart = value;
+            }
+        }
+
+        private double computedLifetimeEnd;
+
+        public override double LifetimeEnd
+        {
+            get => base.LifetimeEnd;
+            set
+            {
+                computedLifetimeEnd = value;
+
+                if (!AlwaysAlive)
+                    base.LifetimeEnd = value;
+            }
+        }
+
+        private bool alwaysAlive;
+
+        /// <summary>
+        /// Whether this <see cref="DrawableManiaHitObject"/> should always remain alive.
+        /// </summary>
+        internal bool AlwaysAlive
+        {
+            get => alwaysAlive;
+            set
+            {
+                if (alwaysAlive == value)
+                    return;
+
+                alwaysAlive = value;
+
+                if (value)
+                {
+                    // Set the base lifetimes directly, to avoid mangling the computed lifetimes
+                    base.LifetimeStart = double.MinValue;
+                    base.LifetimeEnd = double.MaxValue;
+                }
+                else
+                {
+                    LifetimeStart = computedLifetimeStart;
+                    LifetimeEnd = computedLifetimeEnd;
+                }
+            }
+        }
 
         protected virtual void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> e)
         {

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

@@ -34,7 +34,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
 
         public DefaultBodyPiece()
         {
-            RelativeSizeAxes = Axes.Both;
             Blending = BlendingParameters.Additive;
 
             AddLayout(subtractionCache);

osu.Game.Rulesets.Mania/Objects/HoldNote.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
@@ -28,7 +30,9 @@ namespace osu.Game.Rulesets.Mania.Objects
             set
             {
                 duration = value;
-                Tail.StartTime = EndTime;
+
+                if (Tail != null)
+                    Tail.StartTime = EndTime;
             }
         }
 
@@ -38,8 +42,12 @@ namespace osu.Game.Rulesets.Mania.Objects
             set
             {
                 base.StartTime = value;
-                Head.StartTime = value;
-                Tail.StartTime = EndTime;
+
+                if (Head != null)
+                    Head.StartTime = value;
+
+                if (Tail != null)
+                    Tail.StartTime = EndTime;
             }
         }
 
@@ -49,20 +57,26 @@ namespace osu.Game.Rulesets.Mania.Objects
             set
             {
                 base.Column = value;
-                Head.Column = value;
-                Tail.Column = value;
+
+                if (Head != null)
+                    Head.Column = value;
+
+                if (Tail != null)
+                    Tail.Column = value;
             }
         }
 
+        public List<IList<HitSampleInfo>> NodeSamples { get; set; }
+
         /// <summary>
         /// The head note of the hold.
         /// </summary>
-        public readonly Note Head = new Note();
+        public Note Head { get; private set; }
 
         /// <summary>
         /// The tail note of the hold.
         /// </summary>
-        public readonly TailNote Tail = new TailNote();
+        public TailNote Tail { get; private set; }
 
         /// <summary>
         /// The time between ticks of this hold.
@@ -83,8 +97,19 @@ namespace osu.Game.Rulesets.Mania.Objects
 
             createTicks();
 
-            AddNested(Head);
-            AddNested(Tail);
+            AddNested(Head = new Note
+            {
+                StartTime = StartTime,
+                Column = Column,
+                Samples = getNodeSamples(0),
+            });
+
+            AddNested(Tail = new TailNote
+            {
+                StartTime = EndTime,
+                Column = Column,
+                Samples = getNodeSamples((NodeSamples?.Count - 1) ?? 1),
+            });
         }
 
         private void createTicks()
@@ -105,5 +130,8 @@ namespace osu.Game.Rulesets.Mania.Objects
         public override Judgement CreateJudgement() => new IgnoreJudgement();
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+
+        private IList<HitSampleInfo> getNodeSamples(int nodeIndex) =>
+            nodeIndex < NodeSamples?.Count ? NodeSamples[nodeIndex] : Samples;
     }
 }

osu.Game.Rulesets.Mania/Objects/ManiaHitObject.cs

@@ -5,11 +5,12 @@ using osu.Framework.Bindables;
 using osu.Game.Rulesets.Mania.Objects.Types;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {
-    public abstract class ManiaHitObject : HitObject, IHasColumn
+    public abstract class ManiaHitObject : HitObject, IHasColumn, IHasXPosition
     {
         public readonly Bindable<int> ColumnBindable = new Bindable<int>();
 
@@ -20,5 +21,11 @@ namespace osu.Game.Rulesets.Mania.Objects
         }
 
         protected override HitWindows CreateHitWindows() => new ManiaHitWindows();
+
+        #region LegacyBeatmapEncoder
+
+        float IHasXPosition.X => Column;
+
+        #endregion
     }
 }

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

@@ -2,7 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
@@ -48,6 +50,10 @@ namespace osu.Game.Rulesets.Mania.UI
         protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;
 
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
+        private readonly Bindable<double> configTimeRange = new BindableDouble();
+
+        // Stores the current speed adjustment active in gameplay.
+        private readonly Track speedAdjustmentTrack = new TrackVirtual(0);
 
         public DrawableManiaRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
             : base(ruleset, beatmap, mods)
@@ -58,6 +64,9 @@ namespace osu.Game.Rulesets.Mania.UI
         [BackgroundDependencyLoader]
         private void load()
         {
+            foreach (var mod in Mods.OfType<IApplicableToTrack>())
+                mod.ApplyToTrack(speedAdjustmentTrack);
+
             bool isForCurrentRuleset = Beatmap.BeatmapInfo.Ruleset.Equals(Ruleset.RulesetInfo);
 
             foreach (var p in ControlPoints)
@@ -76,7 +85,7 @@ namespace osu.Game.Rulesets.Mania.UI
             Config.BindWith(ManiaRulesetSetting.ScrollDirection, configDirection);
             configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);
 
-            Config.BindWith(ManiaRulesetSetting.ScrollTime, TimeRange);
+            Config.BindWith(ManiaRulesetSetting.ScrollTime, configTimeRange);
         }
 
         protected override void AdjustScrollSpeed(int amount)
@@ -86,10 +95,19 @@ namespace osu.Game.Rulesets.Mania.UI
 
         private double relativeTimeRange
         {
-            get => MAX_TIME_RANGE / TimeRange.Value;
-            set => TimeRange.Value = MAX_TIME_RANGE / value;
+            get => MAX_TIME_RANGE / configTimeRange.Value;
+            set => configTimeRange.Value = MAX_TIME_RANGE / value;
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            updateTimeRange();
+        }
+
+        private void updateTimeRange() => TimeRange.Value = configTimeRange.Value * speedAdjustmentTrack.AggregateTempo.Value * speedAdjustmentTrack.AggregateFrequency.Value;
+
         /// <summary>
         /// Retrieves the column that intersects a screen-space position.
         /// </summary>

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

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Mania.UI
             {
                 foreach (var column in stage.Columns)
                 {
-                    if (column.ReceivePositionalInputAt(screenSpacePosition))
+                    if (column.ReceivePositionalInputAt(new Vector2(screenSpacePosition.X, column.ScreenSpaceDrawQuad.Centre.Y)))
                     {
                         found = column;
                         break;
@@ -87,6 +87,31 @@ namespace osu.Game.Rulesets.Mania.UI
             return found;
         }
 
+        /// <summary>
+        /// Retrieves a <see cref="Column"/> by index.
+        /// </summary>
+        /// <param name="index">The index of the column.</param>
+        /// <returns>The <see cref="Column"/> corresponding to the given index.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="index"/> is less than 0 or greater than <see cref="TotalColumns"/>.</exception>
+        public Column GetColumn(int index)
+        {
+            if (index < 0 || index > TotalColumns - 1)
+                throw new ArgumentOutOfRangeException(nameof(index));
+
+            foreach (var stage in stages)
+            {
+                if (index >= stage.Columns.Count)
+                {
+                    index -= stage.Columns.Count;
+                    continue;
+                }
+
+                return stage.Columns[index];
+            }
+
+            throw new ArgumentOutOfRangeException(nameof(index));
+        }
+
         /// <summary>
         /// Retrieves the total amount of columns across all stages in this playfield.
         /// </summary>

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

@@ -259,6 +259,23 @@ namespace osu.Game.Rulesets.Osu.Tests
             assertControlPointType(2, PathType.PerfectCurve);
         }
 
+        [Test]
+        public void TestBeginPlacementWithoutReleasingMouse()
+        {
+            addMovementStep(new Vector2(200));
+            AddStep("press left button", () => InputManager.PressButton(MouseButton.Left));
+
+            addMovementStep(new Vector2(400, 200));
+            AddStep("release left button", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            addClickStep(MouseButton.Right);
+
+            assertPlaced(true);
+            assertLength(200);
+            assertControlPointCount(2);
+            assertControlPointType(0, PathType.Linear);
+        }
+
         private void addMovementStep(Vector2 position) => AddStep($"move mouse to {position}", () => InputManager.MoveMouseTo(InputManager.ToScreenSpace(position)));
 
         private void addClickStep(MouseButton button)

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs

@@ -6,6 +6,7 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 {
@@ -28,16 +29,17 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
             circlePiece.UpdateFrom(HitObject);
         }
 
-        protected override bool OnClick(ClickEvent e)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
-            EndPlacement(true);
-            return true;
+            if (e.Button == MouseButton.Left)
+            {
+                EndPlacement(true);
+                return true;
+            }
+
+            return base.OnMouseDown(e);
         }
 
-        public override void UpdatePosition(Vector2 screenSpacePosition)
-        {
-            BeginPlacement();
-            HitObject.Position = ToLocalSpace(screenSpacePosition);
-        }
+        public override void UpdatePosition(Vector2 screenSpacePosition) => HitObject.Position = ToLocalSpace(screenSpacePosition);
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs

@@ -28,7 +28,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         public Action<PathControlPointPiece, MouseButtonEvent> RequestSelection;
 
         public readonly BindableBool IsSelected = new BindableBool();
-
         public readonly PathControlPoint ControlPoint;
 
         private readonly Slider slider;
@@ -146,6 +145,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
         protected override bool OnDragStart(DragStartEvent e)
         {
+            if (RequestSelection == null)
+                return false;
+
             if (e.Button == MouseButton.Left)
             {
                 changeHandler?.BeginChange();

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs

@@ -82,8 +82,11 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             }
         }
 
-        protected override bool OnClick(ClickEvent e)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
+            if (e.Button != MouseButton.Left)
+                return base.OnMouseDown(e);
+
             switch (state)
             {
                 case PlacementState.Initial:
@@ -91,9 +94,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                     break;
 
                 case PlacementState.Body:
-                    if (e.Button != MouseButton.Left)
-                        break;
-
                     if (canPlaceNewControlPoint(out var lastPoint))
                     {
                         // Place a new point by detatching the current cursor.
@@ -111,7 +111,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                         currentSegmentLength = 1;
                     }
 
-                    return true;
+                    break;
             }
 
             return true;

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

@@ -0,0 +1,29 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.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
+    {
+        private readonly HitResult type;
+
+        public DrawableTestHit(Hit hit, HitResult type = HitResult.Great)
+            : base(hit)
+        {
+            this.type = type;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Result.Type = type;
+        }
+
+        public override bool OnPressed(TaikoAction action) => false;
+    }
+}

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

@@ -0,0 +1,111 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.Skinning;
+using osu.Game.Rulesets.Taiko.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Skinning
+{
+    [TestFixture]
+    public class TestSceneDrawableBarLine : TaikoSkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
+        {
+            typeof(DrawableBarLine),
+            typeof(LegacyBarLine),
+            typeof(BarLine),
+        }).ToList();
+
+        [Cached(typeof(IScrollingInfo))]
+        private ScrollingTestContainer.TestScrollingInfo info = new ScrollingTestContainer.TestScrollingInfo
+        {
+            Direction = { Value = ScrollingDirection.Left },
+            TimeRange = { Value = 5000 },
+        };
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddStep("Bar line", () => SetContents(() =>
+            {
+                ScrollingHitObjectContainer hoc;
+
+                var cont = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.8f,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        new TaikoPlayfield(new ControlPointInfo()),
+                        hoc = new ScrollingHitObjectContainer()
+                    }
+                };
+
+                hoc.Add(new DrawableBarLine(createBarLineAtCurrentTime())
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                });
+
+                return cont;
+            }));
+
+            AddStep("Bar line (major)", () => SetContents(() =>
+            {
+                ScrollingHitObjectContainer hoc;
+
+                var cont = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.8f,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        new TaikoPlayfield(new ControlPointInfo()),
+                        hoc = new ScrollingHitObjectContainer()
+                    }
+                };
+
+                hoc.Add(new DrawableBarLineMajor(createBarLineAtCurrentTime(true))
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                });
+
+                return cont;
+            }));
+        }
+
+        private BarLine createBarLineAtCurrentTime(bool major = false)
+        {
+            var barline = new BarLine
+            {
+                Major = major,
+                StartTime = Time.Current + 2000,
+            };
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 500 });
+
+            barline.ApplyDefaults(cpi, new BeatmapDifficulty());
+
+            return barline;
+        }
+    }
+}

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

@@ -21,8 +21,6 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
         {
             typeof(DrawableHit),
-            typeof(DrawableCentreHit),
-            typeof(DrawableRimHit),
             typeof(LegacyHit),
             typeof(LegacyCirclePiece),
         }).ToList();
@@ -30,25 +28,25 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         [BackgroundDependencyLoader]
         private void load()
         {
-            AddStep("Centre hit", () => SetContents(() => new DrawableCentreHit(createHitAtCurrentTime())
+            AddStep("Centre hit", () => SetContents(() => new DrawableHit(createHitAtCurrentTime())
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             }));
 
-            AddStep("Centre hit (strong)", () => SetContents(() => new DrawableCentreHit(createHitAtCurrentTime(true))
+            AddStep("Centre hit (strong)", () => SetContents(() => new DrawableHit(createHitAtCurrentTime(true))
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             }));
 
-            AddStep("Rim hit", () => SetContents(() => new DrawableRimHit(createHitAtCurrentTime())
+            AddStep("Rim hit", () => SetContents(() => new DrawableHit(createHitAtCurrentTime())
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             }));
 
-            AddStep("Rim hit (strong)", () => SetContents(() => new DrawableRimHit(createHitAtCurrentTime(true))
+            AddStep("Rim hit (strong)", () => SetContents(() => new DrawableHit(createHitAtCurrentTime(true))
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,

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

@@ -0,0 +1,58 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.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.Skinning;
+using osu.Game.Rulesets.Taiko.UI;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Skinning
+{
+    [TestFixture]
+    public class TestSceneHitExplosion : TaikoSkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
+        {
+            typeof(HitExplosion),
+            typeof(LegacyHitExplosion),
+            typeof(DefaultHitExplosion),
+        }).ToList();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddStep("Great", () => SetContents(() => getContentFor(HitResult.Great)));
+            AddStep("Good", () => SetContents(() => getContentFor(HitResult.Good)));
+            AddStep("Miss", () => SetContents(() => getContentFor(HitResult.Miss)));
+        }
+
+        private Drawable getContentFor(HitResult type)
+        {
+            DrawableTaikoHitObject hit;
+
+            return new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    hit = createHit(type),
+                    new HitExplosion(hit)
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                }
+            };
+        }
+
+        private DrawableTaikoHitObject createHit(HitResult type) => new DrawableTestHit(new Hit { StartTime = Time.Current }, type);
+    }
+}

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

@@ -5,7 +5,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Taiko.Skinning;
 using osu.Game.Rulesets.Taiko.UI;
@@ -18,8 +20,9 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
     {
         public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
         {
-            typeof(HitTarget),
-            typeof(LegacyHitTarget),
+            typeof(TaikoHitTarget),
+            typeof(TaikoLegacyHitTarget),
+            typeof(PlayfieldBackgroundRight),
         }).ToList();
 
         [Cached(typeof(IScrollingInfo))]
@@ -33,10 +36,11 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         {
             AddStep("Load playfield", () => SetContents(() => new TaikoPlayfield(new ControlPointInfo())
             {
-                Height = 0.4f,
                 Anchor = Anchor.CentreLeft,
                 Origin = Anchor.CentreLeft,
             }));
+
+            AddRepeatStep("change height", () => this.ChildrenOfType<TaikoPlayfield>().ForEach(p => p.Height = Math.Max(0.2f, (p.Height + 0.2f) % 1f)), 50);
         }
     }
 }

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
     [TestFixture]
     public class TestSceneHits : OsuTestScene
     {
-        private const double default_duration = 1000;
+        private const double default_duration = 3000;
         private const float scroll_time = 1000;
 
         protected override double TimePerAction => default_duration * 2;
@@ -45,6 +45,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             AddStep("Miss :(", addMissJudgement);
             AddStep("DrumRoll", () => addDrumRoll(false));
             AddStep("Strong DrumRoll", () => addDrumRoll(true));
+            AddStep("Kiai DrumRoll", () => addDrumRoll(true, kiai: true));
             AddStep("Swell", () => addSwell());
             AddStep("Centre", () => addCentreHit(false));
             AddStep("Strong Centre", () => addCentreHit(true));
@@ -148,6 +149,8 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             var h = new DrawableTestHit(hit) { X = RNG.NextSingle(hitResult == HitResult.Good ? -0.1f : -0.05f, hitResult == HitResult.Good ? 0.1f : 0.05f) };
 
+            Add(h);
+
             ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(h, new JudgementResult(new HitObject(), new TaikoJudgement()) { Type = hitResult });
         }
 
@@ -163,6 +166,8 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             var h = new DrawableTestHit(hit) { X = RNG.NextSingle(hitResult == HitResult.Good ? -0.1f : -0.05f, hitResult == HitResult.Good ? 0.1f : 0.05f) };
 
+            Add(h);
+
             ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(h, new JudgementResult(new HitObject(), new TaikoJudgement()) { Type = hitResult });
             ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(new TestStrongNestedHit(h), new JudgementResult(new HitObject(), new TaikoStrongJudgement()) { Type = HitResult.Great });
         }
@@ -192,7 +197,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             drawableRuleset.Playfield.Add(new DrawableSwell(swell));
         }
 
-        private void addDrumRoll(bool strong, double duration = default_duration)
+        private void addDrumRoll(bool strong, double duration = default_duration, bool kiai = false)
         {
             addBarLine(true);
             addBarLine(true, scroll_time + duration);
@@ -202,9 +207,13 @@ namespace osu.Game.Rulesets.Taiko.Tests
                 StartTime = drawableRuleset.Playfield.Time.Current + scroll_time,
                 IsStrong = strong,
                 Duration = duration,
+                TickRate = 8,
             };
 
-            d.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+            var cpi = new ControlPointInfo();
+            cpi.Add(-10000, new EffectControlPoint { KiaiMode = kiai });
+
+            d.ApplyDefaults(cpi, new BeatmapDifficulty());
 
             drawableRuleset.Playfield.Add(new DrawableDrumRoll(d));
         }
@@ -219,7 +228,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             h.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-            drawableRuleset.Playfield.Add(new DrawableCentreHit(h));
+            drawableRuleset.Playfield.Add(new DrawableHit(h));
         }
 
         private void addRimHit(bool strong)
@@ -232,7 +241,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             h.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-            drawableRuleset.Playfield.Add(new DrawableRimHit(h));
+            drawableRuleset.Playfield.Add(new DrawableHit(h));
         }
 
         private class TestStrongNestedHit : DrawableStrongNestedHit
@@ -244,13 +253,5 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             public override bool OnPressed(TaikoAction action) => false;
         }
-
-        private class DrawableTestHit : DrawableHitObject<TaikoHitObject>
-        {
-            public DrawableTestHit(TaikoHitObject hitObject)
-                : base(hitObject)
-            {
-            }
-        }
     }
 }

osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
         /// osu! is generally slower than taiko, so a factor is added to increase
         /// speed. This must be used everywhere slider length or beat length is used.
         /// </summary>
-        private const float legacy_velocity_multiplier = 1.4f;
+        public const float LEGACY_VELOCITY_MULTIPLIER = 1.4f;
 
         /// <summary>
         /// Because swells are easier in taiko than spinners are in osu!,
@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             // 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;
+            original.BeatmapInfo.BaseDifficulty.SliderMultiplier *= LEGACY_VELOCITY_MULTIPLIER;
 
             Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original);
 
@@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                     double speedAdjustedBeatLength = timingPoint.BeatLength / speedAdjustment;
 
                     // The true distance, accounting for any repeats. This ends up being the drum roll distance later
-                    double distance = distanceData.Distance * spans * legacy_velocity_multiplier;
+                    double distance = distanceData.Distance * spans * LEGACY_VELOCITY_MULTIPLIER;
 
                     // The velocity of the taiko hit object - calculated as the velocity of a drum roll
                     double taikoVelocity = taiko_base_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier / speedAdjustedBeatLength;

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

@@ -6,6 +6,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Objects;
 using osuTK;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
@@ -27,7 +28,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         /// <summary>
         /// The visual line tracker.
         /// </summary>
-        protected Box Tracker;
+        protected SkinnableDrawable Line;
 
         /// <summary>
         /// The bar line.
@@ -45,13 +46,15 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             RelativeSizeAxes = Axes.Y;
             Width = tracker_width;
 
-            AddInternal(Tracker = new Box
+            AddInternal(Line = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.BarLine), _ => new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                EdgeSmoothness = new Vector2(0.5f, 0),
+            })
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                RelativeSizeAxes = Axes.Both,
-                EdgeSmoothness = new Vector2(0.5f, 0),
-                Alpha = 0.75f
+                Alpha = 0.75f,
             });
         }
 

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

@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 }
             });
 
-            Tracker.Alpha = 1f;
+            Line.Alpha = 1f;
         }
 
         protected override void LoadComplete()

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

@@ -1,21 +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 osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-using osu.Game.Skinning;
-
-namespace osu.Game.Rulesets.Taiko.Objects.Drawables
-{
-    public class DrawableCentreHit : DrawableHit
-    {
-        public override TaikoAction[] HitActions { get; } = { TaikoAction.LeftCentre, TaikoAction.RightCentre };
-
-        public DrawableCentreHit(Hit hit)
-            : base(hit)
-        {
-        }
-
-        protected override SkinnableDrawable CreateMainPiece() => new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.CentreHit),
-            _ => new CentreHitCirclePiece(), confineMode: ConfineMode.ScaleToFit);
-    }
-}

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

@@ -121,8 +121,11 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 return;
 
             int countHit = NestedHitObjects.Count(o => o.IsHit);
+
             if (countHit >= HitObject.RequiredGoodHits)
+            {
                 ApplyResult(r => r.Type = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Good);
+            }
             else
                 ApplyResult(r => r.Type = HitResult.Miss);
         }

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

@@ -12,14 +12,17 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
     public class DrawableDrumRollTick : DrawableTaikoHitObject<DrumRollTick>
     {
+        /// <summary>
+        /// The hit type corresponding to the <see cref="TaikoAction"/> that the user pressed to hit this <see cref="DrawableDrumRollTick"/>.
+        /// </summary>
+        public HitType JudgementType;
+
         public DrawableDrumRollTick(DrumRollTick tick)
             : base(tick)
         {
             FillMode = FillMode.Fit;
         }
 
-        public override bool DisplayResult => false;
-
         protected override SkinnableDrawable CreateMainPiece() => new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.DrumRollTick),
             _ => new TickPiece
             {
@@ -51,7 +54,11 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             }
         }
 
-        public override bool OnPressed(TaikoAction action) => UpdateResult(true);
+        public override bool OnPressed(TaikoAction action)
+        {
+            JudgementType = action == TaikoAction.LeftRim || action == TaikoAction.RightRim ? HitType.Rim : HitType.Centre;
+            return UpdateResult(true);
+        }
 
         protected override DrawableStrongNestedHit CreateStrongHit(StrongHitObject hitObject) => new StrongNestedHit(hitObject, this);
 

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

@@ -0,0 +1,31 @@
+// 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.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+
+namespace osu.Game.Rulesets.Taiko.Objects.Drawables
+{
+    /// <summary>
+    /// A hit used specifically for drum rolls, where spawning flying hits is required.
+    /// </summary>
+    public class DrawableFlyingHit : DrawableHit
+    {
+        public DrawableFlyingHit(DrawableDrumRollTick drumRollTick)
+            : base(new IgnoreHit
+            {
+                StartTime = drumRollTick.HitObject.StartTime + drumRollTick.Result.TimeOffset,
+                IsStrong = drumRollTick.HitObject.IsStrong,
+                Type = drumRollTick.JudgementType
+            })
+        {
+            HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            ApplyResult(r => r.Type = r.Judgement.MaxResult);
+        }
+    }
+}

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

@@ -8,31 +8,45 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
-    public abstract class DrawableHit : DrawableTaikoHitObject<Hit>
+    public class DrawableHit : DrawableTaikoHitObject<Hit>
     {
         /// <summary>
         /// A list of keys which can result in hits for this HitObject.
         /// </summary>
-        public abstract TaikoAction[] HitActions { get; }
+        public TaikoAction[] HitActions { get; }
 
         /// <summary>
         /// The action that caused this <see cref="DrawableHit"/> to be hit.
         /// </summary>
-        public TaikoAction? HitAction { get; private set; }
+        public TaikoAction? HitAction
+        {
+            get;
+            private set;
+        }
 
         private bool validActionPressed;
 
         private bool pressHandledThisFrame;
 
-        protected DrawableHit(Hit hit)
+        public DrawableHit(Hit hit)
             : base(hit)
         {
             FillMode = FillMode.Fit;
+
+            HitActions =
+                HitObject.Type == HitType.Centre
+                    ? new[] { TaikoAction.LeftCentre, TaikoAction.RightCentre }
+                    : new[] { TaikoAction.LeftRim, TaikoAction.RightRim };
         }
 
+        protected override SkinnableDrawable CreateMainPiece() => HitObject.Type == HitType.Centre
+            ? new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.CentreHit), _ => new CentreHitCirclePiece(), confineMode: ConfineMode.ScaleToFit)
+            : new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.RimHit), _ => new RimHitCirclePiece(), confineMode: ConfineMode.ScaleToFit);
+
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             Debug.Assert(HitObject.HitWindows != null);
@@ -58,7 +72,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
             if (pressHandledThisFrame)
                 return true;
-
             if (Judged)
                 return false;
 
@@ -66,14 +79,12 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
             // Only count this as handled if the new judgement is a hit
             var result = UpdateResult(true);
-
             if (IsHit)
                 HitAction = action;
 
             // Regardless of whether we've hit or not, any secondary key presses in the same frame should be discarded
             // E.g. hitting a non-strong centre as a strong should not fall through and perform a hit on the next note
             pressHandledThisFrame = true;
-
             return result;
         }
 
@@ -81,7 +92,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
             if (action == HitAction)
                 HitAction = null;
-
             base.OnReleased(action);
         }
 
@@ -92,8 +102,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             // The input manager processes all input prior to us updating, so this is the perfect time
             // for us to remove the extra press blocking, before input is handled in the next frame
             pressHandledThisFrame = false;
-
-            Size = BaseSize * Parent.RelativeChildSize;
         }
 
         protected override void UpdateStateTransforms(ArmedState state)

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

@@ -1,21 +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 osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-using osu.Game.Skinning;
-
-namespace osu.Game.Rulesets.Taiko.Objects.Drawables
-{
-    public class DrawableRimHit : DrawableHit
-    {
-        public override TaikoAction[] HitActions { get; } = { TaikoAction.LeftRim, TaikoAction.RightRim };
-
-        public DrawableRimHit(Hit hit)
-            : base(hit)
-        {
-        }
-
-        protected override SkinnableDrawable CreateMainPiece() => new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.RimHit),
-            _ => new RimHitCirclePiece(), confineMode: ConfineMode.ScaleToFit);
-    }
-}

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

@@ -3,15 +3,20 @@
 
 using osu.Game.Rulesets.Objects.Types;
 using System;
+using System.Collections.Generic;
+using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Beatmaps;
 using osu.Game.Rulesets.Taiko.Judgements;
+using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.Objects
 {
-    public class DrumRoll : TaikoHitObject, IHasEndTime
+    public class DrumRoll : TaikoHitObject, IHasCurve
     {
         /// <summary>
         /// Drum roll distance that results in a duration of 1 speed-adjusted beat length.
@@ -26,6 +31,11 @@ namespace osu.Game.Rulesets.Taiko.Objects
 
         public double Duration { get; set; }
 
+        /// <summary>
+        /// Velocity of this <see cref="DrumRoll"/>.
+        /// </summary>
+        public double Velocity { get; private set; }
+
         /// <summary>
         /// Numer of ticks per beat length.
         /// </summary>
@@ -54,6 +64,10 @@ namespace osu.Game.Rulesets.Taiko.Objects
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
+            DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
+
+            double scoringDistance = base_distance * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
+            Velocity = scoringDistance / timingPoint.BeatLength;
 
             tickSpacing = timingPoint.BeatLength / TickRate;
             overallDifficulty = difficulty.OverallDifficulty;
@@ -93,5 +107,18 @@ namespace osu.Game.Rulesets.Taiko.Objects
         public override Judgement CreateJudgement() => new TaikoDrumRollJudgement();
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+
+        #region LegacyBeatmapEncoder
+
+        double IHasDistance.Distance => Duration * Velocity;
+
+        int IHasRepeats.RepeatCount { get => 0; set { } }
+
+        List<IList<HitSampleInfo>> IHasRepeats.NodeSamples => new List<IList<HitSampleInfo>>();
+
+        SliderPath IHasCurve.Path
+            => new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(1) }, ((IHasDistance)this).Distance / TaikoBeatmapConverter.LEGACY_VELOCITY_MULTIPLIER);
+
+        #endregion
     }
 }

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

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Judgements;
+
+namespace osu.Game.Rulesets.Taiko.Objects
+{
+    public class IgnoreHit : Hit
+    {
+        public override Judgement CreateJudgement() => new IgnoreJudgement();
+    }
+}

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

@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Taiko.Skinning
+{
+    public class LegacyBarLine : Sprite
+    {
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            Texture = skin.GetTexture("taiko-barline");
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            RelativeSizeAxes = Axes.Both;
+            Size = new Vector2(1, 0.88f);
+            FillMode = FillMode.Fill;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Skinning/LegacyHitExplosion.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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+
+namespace osu.Game.Rulesets.Taiko.Skinning
+{
+    public class LegacyHitExplosion : CompositeDrawable
+    {
+        public LegacyHitExplosion(Drawable sprite)
+        {
+            InternalChild = sprite;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            AutoSizeAxes = Axes.Both;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            const double animation_time = 120;
+
+            this.FadeInFromZero(animation_time).Then().FadeOut(animation_time * 1.5);
+
+            this.ScaleTo(0.6f)
+                .Then().ScaleTo(1.1f, animation_time * 0.8)
+                .Then().ScaleTo(0.9f, animation_time * 0.4)
+                .Then().ScaleTo(1f, animation_time * 0.2);
+        }
+    }
+}

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

@@ -1,41 +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 osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Game.Skinning;
-using osuTK;
-
-namespace osu.Game.Rulesets.Taiko.Skinning
-{
-    public class LegacyHitTarget : CompositeDrawable
-    {
-        [BackgroundDependencyLoader]
-        private void load(ISkinSource skin)
-        {
-            RelativeSizeAxes = Axes.Both;
-
-            InternalChildren = new Drawable[]
-            {
-                new Sprite
-                {
-                    Texture = skin.GetTexture("approachcircle"),
-                    Scale = new Vector2(0.73f),
-                    Alpha = 0.7f,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                },
-                new Sprite
-                {
-                    Texture = skin.GetTexture("taikobigcircle"),
-                    Scale = new Vector2(0.7f),
-                    Alpha = 0.5f,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                },
-            };
-        }
-    }
-}

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

@@ -20,36 +20,41 @@ namespace osu.Game.Rulesets.Taiko.Skinning
     {
         private LegacyHalfDrum left;
         private LegacyHalfDrum right;
+        private Container content;
 
         public LegacyInputDrum()
         {
-            Size = new Vector2(180, 200);
+            RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin)
         {
-            Children = new Drawable[]
+            Child = content = new Container
             {
-                new Sprite
+                Size = new Vector2(180, 200),
+                Children = new Drawable[]
                 {
-                    Texture = skin.GetTexture("taiko-bar-left")
-                },
-                left = new LegacyHalfDrum(false)
-                {
-                    Name = "Left Half",
-                    RelativeSizeAxes = Axes.Both,
-                    RimAction = TaikoAction.LeftRim,
-                    CentreAction = TaikoAction.LeftCentre
-                },
-                right = new LegacyHalfDrum(true)
-                {
-                    Name = "Right Half",
-                    RelativeSizeAxes = Axes.Both,
-                    Origin = Anchor.TopRight,
-                    Scale = new Vector2(-1, 1),
-                    RimAction = TaikoAction.RightRim,
-                    CentreAction = TaikoAction.RightCentre
+                    new Sprite
+                    {
+                        Texture = skin.GetTexture("taiko-bar-left")
+                    },
+                    left = new LegacyHalfDrum(false)
+                    {
+                        Name = "Left Half",
+                        RelativeSizeAxes = Axes.Both,
+                        RimAction = TaikoAction.LeftRim,
+                        CentreAction = TaikoAction.LeftCentre
+                    },
+                    right = new LegacyHalfDrum(true)
+                    {
+                        Name = "Right Half",
+                        RelativeSizeAxes = Axes.Both,
+                        Origin = Anchor.TopRight,
+                        Scale = new Vector2(-1, 1),
+                        RimAction = TaikoAction.RightRim,
+                        CentreAction = TaikoAction.RightCentre
+                    }
                 }
             };
 
@@ -60,7 +65,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning
             const float ratio = 1.6f;
 
             // because the right half is flipped, we need to position using width - position to get the true "topleft" origin position
-            float negativeScaleAdjust = Width / ratio;
+            float negativeScaleAdjust = content.Width / ratio;
 
             if (skin.GetConfig<LegacySkinConfiguration.LegacySetting, decimal>(LegacySkinConfiguration.LegacySetting.Version)?.Value >= 2.1m)
             {
@@ -78,6 +83,15 @@ namespace osu.Game.Rulesets.Taiko.Skinning
             }
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            // Relying on RelativeSizeAxes.Both + FillMode.Fit doesn't work due to the precise pixel layout requirements.
+            // This is a bit ugly but makes the non-legacy implementations a lot cleaner to implement.
+            content.Scale = new Vector2(DrawHeight / content.Size.Y);
+        }
+
         /// <summary>
         /// A half-drum. Contains one centre and one rim hit.
         /// </summary>

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

@@ -0,0 +1,59 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Taiko.UI;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Taiko.Skinning
+{
+    public class TaikoLegacyHitTarget : CompositeDrawable
+    {
+        private Container content;
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChild = content = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Children = new Drawable[]
+                {
+                    new Sprite
+                    {
+                        Texture = skin.GetTexture("approachcircle"),
+                        Scale = new Vector2(0.73f),
+                        Alpha = 0.47f, // eyeballed to match stable
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                    new Sprite
+                    {
+                        Texture = skin.GetTexture("taikobigcircle"),
+                        Scale = new Vector2(0.7f),
+                        Alpha = 0.22f, // eyeballed to match stable
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // Relying on RelativeSizeAxes.Both + FillMode.Fit doesn't work due to the precise pixel layout requirements.
+            // This is a bit ugly but makes the non-legacy implementations a lot cleaner to implement.
+            content.Scale = new Vector2(DrawHeight / TaikoPlayfield.DEFAULT_HEIGHT);
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Skinning/TaikoLegacySkinTransformer.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 osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
@@ -8,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.Skinning
 {
@@ -52,7 +54,42 @@ namespace osu.Game.Rulesets.Taiko.Skinning
 
                 case TaikoSkinComponents.HitTarget:
                     if (GetTexture("taikobigcircle") != null)
-                        return new LegacyHitTarget();
+                        return new TaikoLegacyHitTarget();
+
+                    return null;
+
+                case TaikoSkinComponents.PlayfieldBackgroundRight:
+                    if (GetTexture("taiko-bar-right") != null)
+                    {
+                        return this.GetAnimation("taiko-bar-right", false, false).With(d =>
+                        {
+                            d.RelativeSizeAxes = Axes.Both;
+                            d.Size = Vector2.One;
+                        });
+                    }
+
+                    return null;
+
+                case TaikoSkinComponents.PlayfieldBackgroundLeft:
+                    // This is displayed inside LegacyInputDrum. It is required to be there for layout purposes (can be seen on legacy skins).
+                    if (GetTexture("taiko-bar-right") != null)
+                        return Drawable.Empty();
+
+                    return null;
+
+                case TaikoSkinComponents.BarLine:
+                    if (GetTexture("taiko-barline") != null)
+                        return new LegacyBarLine();
+
+                    return null;
+
+                case TaikoSkinComponents.TaikoExplosionGood:
+                case TaikoSkinComponents.TaikoExplosionGreat:
+                case TaikoSkinComponents.TaikoExplosionMiss:
+
+                    var sprite = this.GetAnimation(getHitName(taikoComponent.Component), true, false);
+                    if (sprite != null)
+                        return new LegacyHitExplosion(sprite);
 
                     return null;
             }
@@ -60,6 +97,23 @@ namespace osu.Game.Rulesets.Taiko.Skinning
             return source.GetDrawableComponent(component);
         }
 
+        private string getHitName(TaikoSkinComponents component)
+        {
+            switch (component)
+            {
+                case TaikoSkinComponents.TaikoExplosionMiss:
+                    return "taiko-hit0";
+
+                case TaikoSkinComponents.TaikoExplosionGood:
+                    return "taiko-hit100";
+
+                case TaikoSkinComponents.TaikoExplosionGreat:
+                    return "taiko-hit300";
+            }
+
+            throw new ArgumentOutOfRangeException(nameof(component), "Invalid result type");
+        }
+
         public Texture GetTexture(string componentName) => source.GetTexture(componentName);
 
         public SampleChannel GetSample(ISampleInfo sampleInfo) => source.GetSample(new LegacyTaikoSampleInfo(sampleInfo));

osu.Game.Rulesets.Taiko/TaikoSkinComponents.cs

@@ -11,6 +11,12 @@ namespace osu.Game.Rulesets.Taiko
         DrumRollBody,
         DrumRollTick,
         Swell,
-        HitTarget
+        HitTarget,
+        PlayfieldBackgroundLeft,
+        PlayfieldBackgroundRight,
+        BarLine,
+        TaikoExplosionMiss,
+        TaikoExplosionGood,
+        TaikoExplosionGreat,
     }
 }

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

@@ -0,0 +1,57 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Taiko.UI
+{
+    internal class DefaultHitExplosion : CircularContainer
+    {
+        [Resolved]
+        private DrawableHitObject judgedObject { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            BorderColour = Color4.White;
+            BorderThickness = 1;
+
+            Alpha = 0.15f;
+            Masking = true;
+
+            if (judgedObject.Result.Type == HitResult.Miss)
+                return;
+
+            bool isRim = (judgedObject.HitObject as Hit)?.Type == HitType.Rim;
+
+            InternalChildren = new[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = isRim ? colours.BlueDarker : colours.PinkDarker,
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            this.ScaleTo(3f, 1000, Easing.OutQuint);
+            this.FadeOut(500);
+
+            Expire(true);
+        }
+    }
+}

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

@@ -49,10 +49,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             switch (h)
             {
                 case Hit hit:
-                    if (hit.Type == HitType.Centre)
-                        return new DrawableCentreHit(hit);
-                    else
-                        return new DrawableRimHit(hit);
+                    return new DrawableHit(hit);
 
                 case DrumRoll drumRoll:
                     return new DrawableDrumRoll(drumRoll);

osu.Game.Rulesets.Taiko/UI/DrumRollHitContainer.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 osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Taiko.UI
+{
+    internal class DrumRollHitContainer : ScrollingHitObjectContainer
+    {
+        protected override void Update()
+        {
+            base.Update();
+
+            // Remove any auxiliary hit notes that were spawned during a drum roll but subsequently rewound.
+            for (var i = AliveInternalChildren.Count - 1; i >= 0; i--)
+            {
+                var flyingHit = (DrawableFlyingHit)AliveInternalChildren[i];
+                if (Time.Current <= flyingHit.HitObject.StartTime)
+                    Remove(flyingHit);
+            }
+        }
+
+        protected override void OnChildLifetimeBoundaryCrossed(LifetimeBoundaryCrossedEvent e)
+        {
+            base.OnChildLifetimeBoundaryCrossed(e);
+
+            // ensure all old hits are removed on becoming alive (may miss being in the AliveInternalChildren list above).
+            if (e.Kind == LifetimeBoundaryKind.Start && e.Direction == LifetimeBoundaryCrossingDirection.Backward)
+                Remove((DrawableHitObject)e.Child);
+        }
+    }
+}

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

@@ -1,15 +1,15 @@
 // 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 osuTK;
-using osuTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
@@ -20,55 +20,49 @@ namespace osu.Game.Rulesets.Taiko.UI
     {
         public override bool RemoveWhenNotAlive => true;
 
+        [Cached(typeof(DrawableHitObject))]
         public readonly DrawableHitObject JudgedObject;
 
-        private readonly Box innerFill;
+        private SkinnableDrawable skinnable;
 
-        private readonly bool isRim;
+        public override double LifetimeStart => skinnable.Drawable.LifetimeStart;
 
-        public HitExplosion(DrawableHitObject judgedObject, bool isRim)
+        public override double LifetimeEnd => skinnable.Drawable.LifetimeEnd;
+
+        public HitExplosion(DrawableHitObject judgedObject)
         {
-            this.isRim = isRim;
-
             JudgedObject = judgedObject;
 
-            Anchor = Anchor.CentreLeft;
+            Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
             RelativeSizeAxes = Axes.Both;
             Size = new Vector2(TaikoHitObject.DEFAULT_SIZE);
 
             RelativePositionAxes = Axes.Both;
-
-            BorderColour = Color4.White;
-            BorderThickness = 1;
-
-            Alpha = 0.15f;
-            Masking = true;
-
-            Children = new[]
-            {
-                innerFill = new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                }
-            };
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load()
         {
-            innerFill.Colour = isRim ? colours.BlueDarker : colours.PinkDarker;
+            Child = skinnable = new SkinnableDrawable(new TaikoSkinComponent(getComponentName(JudgedObject.Result?.Type ?? HitResult.Great)), _ => new DefaultHitExplosion());
         }
 
-        protected override void LoadComplete()
+        private TaikoSkinComponents getComponentName(HitResult resultType)
         {
-            base.LoadComplete();
+            switch (resultType)
+            {
+                case HitResult.Miss:
+                    return TaikoSkinComponents.TaikoExplosionMiss;
 
-            this.ScaleTo(3f, 1000, Easing.OutQuint);
-            this.FadeOut(500);
+                case HitResult.Good:
+                    return TaikoSkinComponents.TaikoExplosionGood;
 
-            Expire(true);
+                case HitResult.Great:
+                    return TaikoSkinComponents.TaikoExplosionGreat;
+            }
+
+            throw new ArgumentOutOfRangeException(nameof(resultType), "Invalid result type");
         }
 
         /// <summary>

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

@@ -31,7 +31,6 @@ namespace osu.Game.Rulesets.Taiko.UI
             sampleMapping = new DrumSampleMapping(controlPoints);
 
             RelativeSizeAxes = Axes.Both;
-            FillMode = FillMode.Fit;
         }
 
         [BackgroundDependencyLoader]
@@ -40,6 +39,8 @@ namespace osu.Game.Rulesets.Taiko.UI
             Child = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.InputDrum), _ => new Container
             {
                 RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit,
+                Scale = new Vector2(0.9f),
                 Children = new Drawable[]
                 {
                     new TaikoHalfDrum(false)

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

@@ -18,14 +18,12 @@ namespace osu.Game.Rulesets.Taiko.UI
         public override bool RemoveWhenNotAlive => true;
 
         public readonly DrawableHitObject JudgedObject;
+        private readonly HitType type;
 
-        private readonly bool isRim;
-
-        public KiaiHitExplosion(DrawableHitObject judgedObject, bool isRim)
+        public KiaiHitExplosion(DrawableHitObject judgedObject, HitType type)
         {
-            this.isRim = isRim;
-
             JudgedObject = judgedObject;
+            this.type = type;
 
             Anchor = Anchor.CentreLeft;
             Origin = Anchor.Centre;
@@ -53,7 +51,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             EdgeEffect = new EdgeEffectParameters
             {
                 Type = EdgeEffectType.Glow,
-                Colour = isRim ? colours.BlueDarker : colours.PinkDarker,
+                Colour = type == HitType.Rim ? colours.BlueDarker : colours.PinkDarker,
                 Radius = 60,
             };
         }

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

@@ -0,0 +1,37 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Taiko.UI
+{
+    internal class PlayfieldBackgroundLeft : CompositeDrawable
+    {
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            RelativeSizeAxes = Axes.Both;
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    Colour = colours.Gray1,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new Box
+                {
+                    Anchor = Anchor.TopRight,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = 10,
+                    Colour = Framework.Graphics.Colour.ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.6f), Color4.Black.Opacity(0)),
+                },
+            };
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Taiko.UI
+{
+    public class PlayfieldBackgroundRight : CompositeDrawable
+    {
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Name = "Transparent playfield background";
+            RelativeSizeAxes = Axes.Both;
+            Masking = true;
+            BorderColour = colours.Gray1;
+
+            EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Shadow,
+                Colour = Color4.Black.Opacity(0.2f),
+                Radius = 5,
+            };
+
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colours.Gray0,
+                    Alpha = 0.6f
+                },
+                new Container
+                {
+                    Name = "Border",
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    MaskingSmoothness = 0,
+                    BorderThickness = 2,
+                    AlwaysPresent = true,
+                    Children = new[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true
+                        }
+                    }
+                }
+            };
+        }
+    }
+}

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

@@ -13,14 +13,14 @@ namespace osu.Game.Rulesets.Taiko.UI
     /// <summary>
     /// A component that is displayed at the hit position in the taiko playfield.
     /// </summary>
-    internal class HitTarget : Container
+    internal class TaikoHitTarget : Container
     {
         /// <summary>
         /// Thickness of all drawn line pieces.
         /// </summary>
         private const float border_thickness = 2.5f;
 
-        public HitTarget()
+        public TaikoHitTarget()
         {
             RelativeSizeAxes = Axes.Both;
 
@@ -41,7 +41,6 @@ namespace osu.Game.Rulesets.Taiko.UI
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
-                    FillMode = FillMode.Fit,
                     Scale = new Vector2(TaikoHitObject.DEFAULT_STRONG_SIZE),
                     Masking = true,
                     BorderColour = Color4.White,
@@ -63,7 +62,6 @@ namespace osu.Game.Rulesets.Taiko.UI
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
-                    FillMode = FillMode.Fit,
                     Scale = new Vector2(TaikoHitObject.DEFAULT_SIZE),
                     Masking = true,
                     BorderColour = Color4.White,

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

@@ -3,11 +3,8 @@
 
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Effects;
-using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -18,193 +15,141 @@ using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Skinning;
-using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
     public class TaikoPlayfield : ScrollingPlayfield
     {
+        private readonly ControlPointInfo controlPoints;
+
         /// <summary>
         /// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="DrawableTaikoRuleset"/>.
         /// </summary>
         public const float DEFAULT_HEIGHT = 178;
 
-        /// <summary>
-        /// The offset from <see cref="left_area_size"/> which the center of the hit target lies at.
-        /// </summary>
-        public const float HIT_TARGET_OFFSET = 100;
+        private Container<HitExplosion> hitExplosionContainer;
+        private Container<KiaiHitExplosion> kiaiExplosionContainer;
+        private JudgementContainer<DrawableTaikoJudgement> judgementContainer;
+        private ScrollingHitObjectContainer drumRollHitContainer;
+        internal Drawable HitTarget;
 
-        /// <summary>
-        /// The size of the left area of the playfield. This area contains the input drum.
-        /// </summary>
-        private const float left_area_size = 240;
+        private ProxyContainer topLevelHitContainer;
+        private ProxyContainer barlineContainer;
+        private Container rightArea;
+        private Container leftArea;
 
-        private readonly Container<HitExplosion> hitExplosionContainer;
-        private readonly Container<KiaiHitExplosion> kiaiExplosionContainer;
-        private readonly JudgementContainer<DrawableTaikoJudgement> judgementContainer;
-        internal readonly Drawable HitTarget;
-
-        private readonly ProxyContainer topLevelHitContainer;
-        private readonly ProxyContainer barlineContainer;
-
-        private readonly Container overlayBackgroundContainer;
-        private readonly Container backgroundContainer;
-
-        private readonly Box overlayBackground;
-        private readonly Box background;
+        private Container hitTargetOffsetContent;
 
         public TaikoPlayfield(ControlPointInfo controlPoints)
         {
-            InternalChildren = new Drawable[]
+            this.controlPoints = controlPoints;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            InternalChildren = new[]
             {
-                backgroundContainer = new Container
-                {
-                    Name = "Transparent playfield background",
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Shadow,
-                        Colour = Color4.Black.Opacity(0.2f),
-                        Radius = 5,
-                    },
-                    Children = new Drawable[]
-                    {
-                        background = new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0.6f
-                        },
-                    }
-                },
-                new Container
+                new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.PlayfieldBackgroundRight), _ => new PlayfieldBackgroundRight()),
+                rightArea = new Container
                 {
                     Name = "Right area",
                     RelativeSizeAxes = Axes.Both,
-                    Padding = new MarginPadding { Left = left_area_size },
+                    RelativePositionAxes = Axes.Both,
                     Children = new Drawable[]
                     {
                         new Container
                         {
                             Name = "Masked elements before hit objects",
                             RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                            Masking = true,
+                            FillMode = FillMode.Fit,
                             Children = new[]
                             {
                                 hitExplosionContainer = new Container<HitExplosion>
                                 {
                                     RelativeSizeAxes = Axes.Both,
-                                    FillMode = FillMode.Fit,
                                     Blending = BlendingParameters.Additive,
                                 },
-                                HitTarget = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.HitTarget), _ => new HitTarget())
+                                HitTarget = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.HitTarget), _ => new TaikoHitTarget())
                                 {
-                                    Anchor = Anchor.CentreLeft,
-                                    Origin = Anchor.Centre,
                                     RelativeSizeAxes = Axes.Both,
-                                    FillMode = FillMode.Fit
                                 }
                             }
                         },
-                        barlineContainer = new ProxyContainer
+                        hitTargetOffsetContent = new Container
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET }
-                        },
-                        new Container
-                        {
-                            Name = "Hit objects",
-                            RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                            Masking = true,
-                            Child = HitObjectContainer
-                        },
-                        kiaiExplosionContainer = new Container<KiaiHitExplosion>
-                        {
-                            Name = "Kiai hit explosions",
-                            RelativeSizeAxes = Axes.Both,
-                            FillMode = FillMode.Fit,
-                            Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                            Blending = BlendingParameters.Additive
-                        },
-                        judgementContainer = new JudgementContainer<DrawableTaikoJudgement>
-                        {
-                            Name = "Judgements",
-                            RelativeSizeAxes = Axes.Y,
-                            Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                            Blending = BlendingParameters.Additive
+                            Children = new Drawable[]
+                            {
+                                barlineContainer = new ProxyContainer
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                },
+                                new Container
+                                {
+                                    Name = "Hit objects",
+                                    RelativeSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
+                                    {
+                                        HitObjectContainer,
+                                        drumRollHitContainer = new DrumRollHitContainer()
+                                    }
+                                },
+                                kiaiExplosionContainer = new Container<KiaiHitExplosion>
+                                {
+                                    Name = "Kiai hit explosions",
+                                    RelativeSizeAxes = Axes.Both,
+                                    FillMode = FillMode.Fit,
+                                    Blending = BlendingParameters.Additive
+                                },
+                                judgementContainer = new JudgementContainer<DrawableTaikoJudgement>
+                                {
+                                    Name = "Judgements",
+                                    RelativeSizeAxes = Axes.Y,
+                                    Blending = BlendingParameters.Additive
+                                },
+                            }
                         },
                     }
                 },
-                overlayBackgroundContainer = new Container
+                leftArea = new Container
                 {
                     Name = "Left overlay",
-                    RelativeSizeAxes = Axes.Y,
-                    Size = new Vector2(left_area_size, 1),
+                    RelativeSizeAxes = Axes.Both,
+                    FillMode = FillMode.Fit,
+                    BorderColour = colours.Gray0,
                     Children = new Drawable[]
                     {
-                        overlayBackground = new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                        },
+                        new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.PlayfieldBackgroundLeft), _ => new PlayfieldBackgroundLeft()),
                         new InputDrum(controlPoints)
                         {
-                            Anchor = Anchor.CentreRight,
-                            Origin = Anchor.CentreRight,
-                            Scale = new Vector2(0.9f),
-                            Margin = new MarginPadding { Right = 20 }
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
                         },
-                        new Box
-                        {
-                            Anchor = Anchor.TopRight,
-                            RelativeSizeAxes = Axes.Y,
-                            Width = 10,
-                            Colour = Framework.Graphics.Colour.ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.6f), Color4.Black.Opacity(0)),
-                        },
-                    }
-                },
-                new Container
-                {
-                    Name = "Border",
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    MaskingSmoothness = 0,
-                    BorderThickness = 2,
-                    AlwaysPresent = true,
-                    Children = new[]
-                    {
-                        new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0,
-                            AlwaysPresent = true
-                        }
                     }
                 },
                 topLevelHitContainer = new ProxyContainer
                 {
                     Name = "Top level hit objects",
                     RelativeSizeAxes = Axes.Both,
-                }
+                },
+                drumRollHitContainer.CreateProxy()
             };
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        protected override void Update()
         {
-            overlayBackgroundContainer.BorderColour = colours.Gray0;
-            overlayBackground.Colour = colours.Gray1;
+            base.Update();
 
-            backgroundContainer.BorderColour = colours.Gray1;
-            background.Colour = colours.Gray0;
+            // Padding is required to be updated for elements which are based on "absolute" X sized elements.
+            // This is basically allowing for correct alignment as relative pieces move around them.
+            rightArea.Padding = new MarginPadding { Left = leftArea.DrawWidth };
+            hitTargetOffsetContent.Padding = new MarginPadding { Left = HitTarget.DrawWidth / 2 };
         }
 
         public override void Add(DrawableHitObject h)
         {
             h.OnNewResult += OnNewResult;
-
             base.Add(h);
 
             switch (h)
@@ -223,7 +168,6 @@ namespace osu.Game.Rulesets.Taiko.UI
         {
             if (!DisplayJudgements.Value)
                 return;
-
             if (!judgedObject.DisplayResult)
                 return;
 
@@ -234,6 +178,15 @@ namespace osu.Game.Rulesets.Taiko.UI
                         hitExplosionContainer.Children.FirstOrDefault(e => e.JudgedObject == ((DrawableStrongNestedHit)judgedObject).MainObject)?.VisualiseSecondHit();
                     break;
 
+                case TaikoDrumRollTickJudgement _:
+                    if (!result.IsHit)
+                        break;
+
+                    var drawableTick = (DrawableDrumRollTick)judgedObject;
+
+                    addDrumRollHit(drawableTick);
+                    break;
+
                 default:
                     judgementContainer.Add(new DrawableTaikoJudgement(result, judgedObject)
                     {
@@ -246,17 +199,23 @@ namespace osu.Game.Rulesets.Taiko.UI
                     if (!result.IsHit)
                         break;
 
-                    bool isRim = (judgedObject.HitObject as Hit)?.Type == HitType.Rim;
-
-                    hitExplosionContainer.Add(new HitExplosion(judgedObject, isRim));
-
-                    if (judgedObject.HitObject.Kiai)
-                        kiaiExplosionContainer.Add(new KiaiHitExplosion(judgedObject, isRim));
+                    var type = (judgedObject.HitObject as Hit)?.Type ?? HitType.Centre;
 
+                    addExplosion(judgedObject, type);
                     break;
             }
         }
 
+        private void addDrumRollHit(DrawableDrumRollTick drawableTick) =>
+            drumRollHitContainer.Add(new DrawableFlyingHit(drawableTick));
+
+        private void addExplosion(DrawableHitObject drawableObject, HitType type)
+        {
+            hitExplosionContainer.Add(new HitExplosion(drawableObject));
+            if (drawableObject.HitObject.Kiai)
+                kiaiExplosionContainer.Add(new KiaiHitExplosion(drawableObject, type));
+        }
+
         private class ProxyContainer : LifetimeManagementContainer
         {
             public new MarginPadding Padding

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

@@ -1,14 +1,23 @@
 // 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;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
 using osu.Game.IO.Serialization;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Taiko;
 using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Beatmaps.Formats
@@ -16,39 +25,91 @@ namespace osu.Game.Tests.Beatmaps.Formats
     [TestFixture]
     public class LegacyBeatmapEncoderTest
     {
-        private const string normal = "Soleily - Renatus (Gamu) [Insane].osu";
-
         private static IEnumerable<string> allBeatmaps => TestResources.GetStore().GetAvailableResources().Where(res => res.EndsWith(".osu"));
 
         [TestCaseSource(nameof(allBeatmaps))]
-        public void TestDecodeEncodedBeatmap(string name)
+        public void TestBeatmap(string name)
         {
-            var decoded = decode(normal, out var encoded);
+            var decoded = decode(name, out var encoded);
+
+            sort(decoded);
+            sort(encoded);
 
-            Assert.That(decoded.HitObjects.Count, Is.EqualTo(encoded.HitObjects.Count));
             Assert.That(encoded.Serialize(), Is.EqualTo(decoded.Serialize()));
         }
 
-        private Beatmap decode(string filename, out Beatmap encoded)
+        private void sort(IBeatmap beatmap)
         {
-            using (var stream = TestResources.OpenResource(filename))
+            // Sort control points to ensure a sane ordering, as they may be parsed in different orders. This works because each group contains only uniquely-typed control points.
+            foreach (var g in beatmap.ControlPointInfo.Groups)
+            {
+                ArrayList.Adapter((IList)g.ControlPoints).Sort(
+                    Comparer<ControlPoint>.Create((c1, c2) => string.Compare(c1.GetType().ToString(), c2.GetType().ToString(), StringComparison.Ordinal)));
+            }
+        }
+
+        private IBeatmap decode(string filename, out IBeatmap encoded)
+        {
+            using (var stream = TestResources.GetStore().GetStream(filename))
             using (var sr = new LineBufferedReader(stream))
             {
-                var legacyDecoded = new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(sr);
+                var legacyDecoded = convert(new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(sr));
 
                 using (var ms = new MemoryStream())
                 using (var sw = new StreamWriter(ms))
-                using (var sr2 = new LineBufferedReader(ms))
+                using (var sr2 = new LineBufferedReader(ms, true))
                 {
                     new LegacyBeatmapEncoder(legacyDecoded).Encode(sw);
-                    sw.Flush();
 
+                    sw.Flush();
                     ms.Position = 0;
 
-                    encoded = new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(sr2);
+                    encoded = convert(new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(sr2));
+
                     return legacyDecoded;
                 }
             }
         }
+
+        private IBeatmap convert(IBeatmap beatmap)
+        {
+            switch (beatmap.BeatmapInfo.RulesetID)
+            {
+                case 0:
+                    beatmap.BeatmapInfo.Ruleset = new OsuRuleset().RulesetInfo;
+                    break;
+
+                case 1:
+                    beatmap.BeatmapInfo.Ruleset = new TaikoRuleset().RulesetInfo;
+                    break;
+
+                case 2:
+                    beatmap.BeatmapInfo.Ruleset = new CatchRuleset().RulesetInfo;
+                    break;
+
+                case 3:
+                    beatmap.BeatmapInfo.Ruleset = new ManiaRuleset().RulesetInfo;
+                    break;
+            }
+
+            return new TestWorkingBeatmap(beatmap).GetPlayableBeatmap(beatmap.BeatmapInfo.Ruleset);
+        }
+
+        private class TestWorkingBeatmap : WorkingBeatmap
+        {
+            private readonly IBeatmap beatmap;
+
+            public TestWorkingBeatmap(IBeatmap beatmap)
+                : base(beatmap.BeatmapInfo, null)
+            {
+                this.beatmap = beatmap;
+            }
+
+            protected override IBeatmap GetBeatmap() => beatmap;
+
+            protected override Texture GetBackground() => throw new NotImplementedException();
+
+            protected override Track GetTrack() => throw new NotImplementedException();
+        }
     }
 }

osu.Game.Tests/Beatmaps/TestSceneEditorBeatmap.cs

@@ -1,9 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.EntityFrameworkCore.Internal;
 using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Game.Rulesets.Objects;
@@ -137,7 +137,7 @@ namespace osu.Game.Tests.Beatmaps
             var hitCircle = new HitCircle { StartTime = 1000 };
             editorBeatmap.Add(hitCircle);
             Assert.That(editorBeatmap.HitObjects.Count(h => h == hitCircle), Is.EqualTo(1));
-            Assert.That(editorBeatmap.HitObjects.IndexOf(hitCircle), Is.EqualTo(3));
+            Assert.That(Array.IndexOf(editorBeatmap.HitObjects.ToArray(), hitCircle), Is.EqualTo(3));
         }
 
         /// <summary>
@@ -161,7 +161,7 @@ namespace osu.Game.Tests.Beatmaps
 
             hitCircle.StartTime = 0;
             Assert.That(editorBeatmap.HitObjects.Count(h => h == hitCircle), Is.EqualTo(1));
-            Assert.That(editorBeatmap.HitObjects.IndexOf(hitCircle), Is.EqualTo(1));
+            Assert.That(Array.IndexOf(editorBeatmap.HitObjects.ToArray(), hitCircle), Is.EqualTo(1));
         }
 
         /// <summary>

osu.Game.Tests/Beatmaps/ToStringFormattingTest.cs

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Beatmaps
+{
+    [TestFixture]
+    public class ToStringFormattingTest
+    {
+        [Test]
+        public void TestArtistTitle()
+        {
+            var beatmap = new BeatmapInfo
+            {
+                Metadata = new BeatmapMetadata
+                {
+                    Artist = "artist",
+                    Title = "title"
+                }
+            };
+
+            Assert.That(beatmap.ToString(), Is.EqualTo("artist - title"));
+        }
+
+        [Test]
+        public void TestArtistTitleCreator()
+        {
+            var beatmap = new BeatmapInfo
+            {
+                Metadata = new BeatmapMetadata
+                {
+                    Artist = "artist",
+                    Title = "title",
+                    Author = new User { Username = "creator" }
+                }
+            };
+
+            Assert.That(beatmap.ToString(), Is.EqualTo("artist - title (creator)"));
+        }
+
+        [Test]
+        public void TestArtistTitleCreatorDifficulty()
+        {
+            var beatmap = new BeatmapInfo
+            {
+                Metadata = new BeatmapMetadata
+                {
+                    Artist = "artist",
+                    Title = "title",
+                    Author = new User { Username = "creator" }
+                },
+                Version = "difficulty"
+            };
+
+            Assert.That(beatmap.ToString(), Is.EqualTo("artist - title (creator) [difficulty]"));
+        }
+    }
+}

osu.Game.Tests/Editing/EditorChangeHandlerTest.cs

@@ -5,7 +5,7 @@ using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Screens.Edit;
 
-namespace osu.Game.Tests.Editor
+namespace osu.Game.Tests.Editing
 {
     [TestFixture]
     public class EditorChangeHandlerTest

osu.Game.Tests/Editing/LegacyEditorBeatmapPatcherTest.cs

@@ -17,7 +17,7 @@ using osu.Game.Screens.Edit;
 using osuTK;
 using Decoder = osu.Game.Beatmaps.Formats.Decoder;
 
-namespace osu.Game.Tests.Editor
+namespace osu.Game.Tests.Editing
 {
     [TestFixture]
     public class LegacyEditorBeatmapPatcherTest

osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs

@@ -14,7 +14,7 @@ using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Screens.Edit;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Tests.Editor
+namespace osu.Game.Tests.Editing
 {
     [HeadlessTest]
     public class TestSceneHitObjectComposerDistanceSnapping : EditorClockTestScene

osu.Game.Tests/Resources/hitobject-combo-offset.osu

@@ -5,27 +5,27 @@ osu file format v14
 255,193,1000,49,0,0:0:0:0:
 // Combo index = 4
 
-// Slider with new combo followed by circle with no new combo
+// Spinner with new combo followed by circle with no new combo
 256,192,2000,12,0,2000,0:0:0:0:
 255,193,3000,1,0,0:0:0:0:
 // Combo index = 5
 
-// Slider without new combo followed by circle with no new combo
+// Spinner without new combo followed by circle with no new combo
 256,192,4000,8,0,5000,0:0:0:0:
 255,193,6000,1,0,0:0:0:0:
 // Combo index = 5
 
-// Slider without new combo followed by circle with new combo
+// Spinner without new combo followed by circle with new combo
 256,192,7000,8,0,8000,0:0:0:0:
 255,193,9000,5,0,0:0:0:0:
 // Combo index = 6
 
-// Slider with new combo and offset (1) followed by circle with new combo and offset (3)
+// Spinner with new combo and offset (1) followed by circle with new combo and offset (3)
 256,192,10000,28,0,11000,0:0:0:0:
 255,193,12000,53,0,0:0:0:0:
 // Combo index = 11
 
-// Slider with new combo and offset (2) followed by slider with no new combo followed by circle with no new combo
+// Spinner with new combo and offset (2) followed by slider with no new combo followed by circle with no new combo
 256,192,13000,44,0,14000,0:0:0:0:
 256,192,15000,8,0,16000,0:0:0:0:
 255,193,17000,1,0,0:0:0:0:

osu.Game.Tests/Resources/sample-beatmap-catch.osu

@@ -0,0 +1,30 @@
+osu file format v14
+
+[General]
+SampleSet: Normal
+StackLeniency: 0.7
+Mode: 2
+
+[Difficulty]
+HPDrainRate:3
+CircleSize:5
+OverallDifficulty:8
+ApproachRate:8
+SliderMultiplier:3.59999990463257
+SliderTickRate:2
+
+[TimingPoints]
+24,352.941176470588,4,1,1,100,1,0
+6376,-50,4,1,1,100,0,0
+
+[HitObjects]
+32,183,24,5,0,0:0:0:0:
+106,123,200,1,10,0:0:0:0:
+199,108,376,1,2,0:0:0:0:
+305,105,553,5,4,0:0:0:0:
+386,112,729,1,14,0:0:0:0:
+486,197,906,5,12,0:0:0:0:
+14,199,1082,2,0,L|473:198,1,449.999988079071
+14,199,1700,6,6,P|248:33|490:222,1,629.9999833107,0|8,0:0|0:0,0:0:0:0:
+10,190,2494,2,8,B|252:29|254:335|468:167,1,449.999988079071,10|12,0:0|0:0,0:0:0:0:
+256,192,3112,12,0,3906,0:0:0:0:

osu.Game.Tests/Resources/sample-beatmap-mania.osu

@@ -0,0 +1,39 @@
+osu file format v14
+
+[General]
+SampleSet: Normal
+StackLeniency: 0.7
+Mode: 3
+
+[Difficulty]
+HPDrainRate:3
+CircleSize:5
+OverallDifficulty:8
+ApproachRate:8
+SliderMultiplier:3.59999990463257
+SliderTickRate:2
+
+[TimingPoints]
+24,352.941176470588,4,1,1,100,1,0
+6376,-50,4,1,1,100,0,0
+
+[HitObjects]
+51,192,24,1,0,0:0:0:0:
+153,192,200,1,0,0:0:0:0:
+358,192,376,1,0,0:0:0:0:
+460,192,553,1,0,0:0:0:0:
+460,192,729,128,0,1435:0:0:0:0:
+358,192,906,128,0,1612:0:0:0:0:
+256,192,1082,128,0,1788:0:0:0:0:
+153,192,1259,128,0,1965:0:0:0:0:
+51,192,1435,128,0,2141:0:0:0:0:
+51,192,2318,1,12,0:0:0:0:
+153,192,2318,1,4,0:0:0:0:
+256,192,2318,1,6,0:0:0:0:
+358,192,2318,1,14,0:0:0:0:
+460,192,2318,1,0,0:0:0:0:
+51,192,2494,128,0,2582:0:0:0:0:
+153,192,2494,128,14,2582:0:0:0:0:
+256,192,2494,128,6,2582:0:0:0:0:
+358,192,2494,128,4,2582:0:0:0:0:
+460,192,2494,128,12,2582:0:0:0:0:

osu.Game.Tests/Resources/sample-beatmap-osu.osu

@@ -0,0 +1,32 @@
+osu file format v14
+
+[General]
+SampleSet: Normal
+StackLeniency: 0.7
+Mode: 0
+
+[Difficulty]
+HPDrainRate:3
+CircleSize:5
+OverallDifficulty:8
+ApproachRate:8
+SliderMultiplier:3.59999990463257
+SliderTickRate:2
+
+[TimingPoints]
+24,352.941176470588,4,1,1,100,1,0
+6376,-50,4,1,1,100,0,0
+
+[HitObjects]
+98,69,24,1,0,0:0:0:0:
+419,72,200,1,2,0:0:0:0:
+81,314,376,1,6,0:0:0:0:
+423,321,553,1,12,0:0:0:0:
+86,192,729,2,0,P|459:193|460:193,1,359.999990463257
+86,192,1259,2,0,P|246:82|453:203,1,449.999988079071
+86,192,1876,2,0,B|256:30|257:313|464:177,1,359.999990463257
+86,55,2406,2,12,B|447:51|447:51|452:348|452:348|78:344,1,989.999973773957,14|2,0:0|0:0,0:0:0:0:
+256,192,3553,12,0,4259,0:0:0:0:
+67,57,4435,5,0,0:0:0:0:
+440,52,4612,5,0,0:0:0:0:
+86,181,4788,6,0,L|492:183,1,359.999990463257

osu.Game.Tests/Resources/sample-beatmap-taiko.osu

@@ -0,0 +1,42 @@
+osu file format v14
+
+[General]
+SampleSet: Normal
+StackLeniency: 0.7
+Mode: 1
+
+[Difficulty]
+HPDrainRate:3
+CircleSize:5
+OverallDifficulty:8
+ApproachRate:8
+SliderMultiplier:3.59999990463257
+SliderTickRate:2
+
+[TimingPoints]
+24,352.941176470588,4,1,1,100,1,0
+6376,-50,4,1,1,100,0,0
+
+[HitObjects]
+231,129,24,1,0,0:0:0:0:
+231,129,200,1,0,0:0:0:0:
+231,129,376,1,0,0:0:0:0:
+231,129,553,1,0,0:0:0:0:
+231,129,729,1,0,0:0:0:0:
+373,132,906,1,4,0:0:0:0:
+373,132,1082,1,4,0:0:0:0:
+373,132,1259,1,4,0:0:0:0:
+373,132,1435,1,4,0:0:0:0:
+231,129,1788,1,8,0:0:0:0:
+231,129,1964,1,8,0:0:0:0:
+231,129,2140,1,8,0:0:0:0:
+231,129,2317,1,8,0:0:0:0:
+231,129,2493,1,8,0:0:0:0:
+373,132,2670,1,12,0:0:0:0:
+373,132,2846,1,12,0:0:0:0:
+373,132,3023,1,12,0:0:0:0:
+373,132,3199,1,12,0:0:0:0:
+51,189,3553,2,0,L|150:188,1,89.9999976158143
+52,191,3906,2,0,L|512:189,1,449.999988079071
+26,196,4612,2,4,L|501:195,1,449.999988079071
+17,242,5318,2,10,P|250:69|495:243,1,629.9999833107,0|8,0:0|0:0,0:0:0:0:

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

@@ -14,7 +14,7 @@ using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     public class TestSceneBeatDivisorControl : OsuManualInputManagerTestScene
     {

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

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneComposeScreen : EditorClockTestScene

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

@@ -13,7 +13,7 @@ using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     public class TestSceneDistanceSnapGrid : EditorClockTestScene
     {

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

@@ -4,35 +4,27 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
-using osu.Game.Screens.Edit.Compose.Components.Timeline;
-using osuTK.Input;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
-    public class TestSceneEditorChangeStates : ScreenTestScene
+    public class TestSceneEditorChangeStates : EditorTestScene
     {
+        public TestSceneEditorChangeStates()
+            : base(new OsuRuleset())
+        {
+        }
+
         private EditorBeatmap editorBeatmap;
 
         public override void SetUpSteps()
         {
             base.SetUpSteps();
 
-            Screens.Edit.Editor editor = null;
-
-            AddStep("load editor", () =>
-            {
-                Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
-                LoadScreen(editor = new Screens.Edit.Editor());
-            });
-
-            AddUntilStep("wait for editor to load", () => editor.ChildrenOfType<HitObjectComposer>().FirstOrDefault()?.IsLoaded == true
-                                                          && editor.ChildrenOfType<TimelineArea>().FirstOrDefault()?.IsLoaded == true);
-            AddStep("get beatmap", () => editorBeatmap = editor.ChildrenOfType<EditorBeatmap>().Single());
+            AddStep("get beatmap", () => editorBeatmap = Editor.ChildrenOfType<EditorBeatmap>().Single());
         }
 
         [Test]
@@ -160,36 +152,17 @@ namespace osu.Game.Tests.Visual.Editor
             AddAssert("no hitobject added", () => addedObject == null);
         }
 
-        private void addUndoSteps()
+        private void addUndoSteps() => AddStep("undo", () => ((TestEditor)Editor).Undo());
+
+        private void addRedoSteps() => AddStep("redo", () => ((TestEditor)Editor).Redo());
+
+        protected override Editor CreateEditor() => new TestEditor();
+
+        private class TestEditor : Editor
         {
-            AddStep("press undo", () =>
-            {
-                InputManager.PressKey(Key.LControl);
-                InputManager.PressKey(Key.Z);
-            });
+            public new void Undo() => base.Undo();
 
-            AddStep("release keys", () =>
-            {
-                InputManager.ReleaseKey(Key.LControl);
-                InputManager.ReleaseKey(Key.Z);
-            });
-        }
-
-        private void addRedoSteps()
-        {
-            AddStep("press redo", () =>
-            {
-                InputManager.PressKey(Key.LControl);
-                InputManager.PressKey(Key.LShift);
-                InputManager.PressKey(Key.Z);
-            });
-
-            AddStep("release keys", () =>
-            {
-                InputManager.ReleaseKey(Key.LControl);
-                InputManager.ReleaseKey(Key.LShift);
-                InputManager.ReleaseKey(Key.Z);
-            });
+            public new void Redo() => base.Redo();
         }
     }
 }

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

@@ -7,7 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Game.Screens.Edit.Components.RadioButtons;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneEditorComposeRadioButtons : OsuTestScene

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

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Edit.Components.Menus;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneEditorMenuBar : OsuTestScene

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

@@ -13,7 +13,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneEditorSeekSnapping : EditorClockTestScene

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

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osuTK;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneEditorSummaryTimeline : EditorClockTestScene

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

@@ -20,7 +20,7 @@ using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneHitObjectComposer : EditorClockTestScene

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

@@ -9,7 +9,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Screens.Edit.Components;
 using osuTK;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestScenePlaybackControl : OsuTestScene

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

@@ -7,7 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneTimelineBlueprintContainer : TimelineTestScene

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

@@ -8,7 +8,7 @@ using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneTimelineTickDisplay : TimelineTestScene

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

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Timing;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneTimingScreen : EditorClockTestScene

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

@@ -14,7 +14,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Osu;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     [TestFixture]
     public class TestSceneWaveform : OsuTestScene

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

@@ -15,7 +15,7 @@ using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     public class TestSceneZoomableScrollContainer : OsuManualInputManagerTestScene
     {

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

@@ -18,7 +18,7 @@ using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual.Editor
+namespace osu.Game.Tests.Visual.Editing
 {
     public abstract class TimelineTestScene : EditorClockTestScene
     {

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

@@ -5,13 +5,17 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
 using osu.Game.Overlays.Toolbar;
+using osu.Game.Rulesets;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Menus
 {
     [TestFixture]
-    public class TestSceneToolbar : OsuTestScene
+    public class TestSceneToolbar : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -21,24 +25,62 @@ namespace osu.Game.Tests.Visual.Menus
             typeof(ToolbarNotificationButton),
         };
 
-        public TestSceneToolbar()
+        private Toolbar toolbar;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            Child = toolbar = new Toolbar { State = { Value = Visibility.Visible } };
+        });
+
+        [Test]
+        public void TestNotificationCounter()
         {
-            var toolbar = new Toolbar { State = { Value = Visibility.Visible } };
             ToolbarNotificationButton notificationButton = null;
 
-            AddStep("create toolbar", () =>
-            {
-                Add(toolbar);
-                notificationButton = toolbar.Children.OfType<FillFlowContainer>().Last().Children.OfType<ToolbarNotificationButton>().First();
-            });
-
-            void setNotifications(int count) => AddStep($"set notification count to {count}", () => notificationButton.NotificationCount.Value = count);
+            AddStep("retrieve notification button", () => notificationButton = toolbar.ChildrenOfType<ToolbarNotificationButton>().Single());
 
             setNotifications(1);
             setNotifications(2);
             setNotifications(3);
             setNotifications(0);
             setNotifications(144);
+
+            void setNotifications(int count)
+                => AddStep($"set notification count to {count}",
+                    () => notificationButton.NotificationCount.Value = count);
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestRulesetSwitchingShortcut(bool toolbarHidden)
+        {
+            ToolbarRulesetSelector rulesetSelector = null;
+
+            if (toolbarHidden)
+                AddStep("hide toolbar", () => toolbar.Hide());
+
+            AddStep("retrieve ruleset selector", () => rulesetSelector = toolbar.ChildrenOfType<ToolbarRulesetSelector>().Single());
+
+            for (int i = 0; i < 4; i++)
+            {
+                var expected = rulesets.AvailableRulesets.ElementAt(i);
+                var numberKey = Key.Number1 + i;
+
+                AddStep($"switch to ruleset {i} via shortcut", () =>
+                {
+                    InputManager.PressKey(Key.ControlLeft);
+                    InputManager.PressKey(numberKey);
+
+                    InputManager.ReleaseKey(Key.ControlLeft);
+                    InputManager.ReleaseKey(numberKey);
+                });
+
+                AddUntilStep("ruleset switched", () => rulesetSelector.Current.Value.Equals(expected));
+            }
         }
     }
 }

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

@@ -14,8 +14,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Mods.Sections;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mania;
-using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
@@ -117,8 +115,6 @@ namespace osu.Game.Tests.Visual.UserInterface
         public void TestManiaMods()
         {
             changeRuleset(3);
-
-            testRankedText(new ManiaRuleset().GetModsFor(ModType.Conversion).First(m => m is ManiaModRandom));
         }
 
         [Test]
@@ -217,15 +213,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             checkLabelColor(() => Color4.White);
         }
 
-        private void testRankedText(Mod mod)
-        {
-            AddUntilStep("check for ranked", () => modSelect.UnrankedLabel.Alpha == 0);
-            selectNext(mod);
-            AddUntilStep("check for unranked", () => modSelect.UnrankedLabel.Alpha != 0);
-            selectPrevious(mod);
-            AddUntilStep("check for ranked", () => modSelect.UnrankedLabel.Alpha == 0);
-        }
-
         private void selectNext(Mod mod) => AddStep($"left click {mod.Name}", () => modSelect.GetModButton(mod)?.SelectNext(1));
 
         private void selectPrevious(Mod mod) => AddStep($"right click {mod.Name}", () => modSelect.GetModButton(mod)?.SelectNext(-1));
@@ -272,7 +259,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             }
 
             public new OsuSpriteText MultiplierLabel => base.MultiplierLabel;
-            public new OsuSpriteText UnrankedLabel => base.UnrankedLabel;
             public new TriangleButton DeselectAllButton => base.DeselectAllButton;
 
             public new Color4 LowMultiplierColour => base.LowMultiplierColour;

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

@@ -1,12 +1,15 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
 using osu.Framework.Graphics;
-using osu.Framework.Utils;
+using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -21,9 +24,14 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private NowPlayingOverlay nowPlayingOverlay;
 
+        private RulesetStore rulesets;
+
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(AudioManager audio, GameHost host)
         {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
 
             nowPlayingOverlay = new NowPlayingOverlay
@@ -44,21 +52,43 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddStep(@"hide", () => nowPlayingOverlay.Hide());
         }
 
+        private BeatmapManager manager { get; set; }
+
+        private int importId;
+
         [Test]
         public void TestPrevTrackBehavior()
         {
-            AddStep(@"Play track", () =>
+            // ensure we have at least two beatmaps available.
+            AddRepeatStep("import beatmap", () => manager.Import(new BeatmapSetInfo
             {
-                musicController.NextTrack();
-                currentBeatmap = Beatmap.Value;
-            });
+                Beatmaps = new List<BeatmapInfo>
+                {
+                    new BeatmapInfo
+                    {
+                        BaseDifficulty = new BeatmapDifficulty(),
+                    }
+                },
+                Metadata = new BeatmapMetadata
+                {
+                    Artist = $"a test map {importId++}",
+                    Title = "title",
+                }
+            }).Wait(), 5);
+
+            AddStep(@"Next track", () => musicController.NextTrack());
+            AddStep("Store track", () => currentBeatmap = Beatmap.Value);
 
             AddStep(@"Seek track to 6 second", () => musicController.SeekTo(6000));
             AddUntilStep(@"Wait for current time to update", () => currentBeatmap.Track.CurrentTime > 5000);
-            AddAssert(@"Check action is restart track", () => musicController.PreviousTrack() == PreviousTrackResult.Restart);
-            AddUntilStep("Wait for current time to update", () => Precision.AlmostEquals(currentBeatmap.Track.CurrentTime, 0));
-            AddAssert(@"Check track didn't change", () => currentBeatmap == Beatmap.Value);
-            AddAssert(@"Check action is not restart", () => musicController.PreviousTrack() != PreviousTrackResult.Restart);
+
+            AddStep(@"Set previous", () => musicController.PreviousTrack());
+
+            AddAssert(@"Check beatmap didn't change", () => currentBeatmap == Beatmap.Value);
+            AddUntilStep("Wait for current time to update", () => currentBeatmap.Track.CurrentTime < 5000);
+
+            AddStep(@"Set previous", () => musicController.PreviousTrack());
+            AddAssert(@"Check beatmap did change", () => currentBeatmap != Beatmap.Value);
         }
     }
 }