Merge branch 'master' into argon-spinner-sides

Gemfile.lock

@@ -3,25 +3,25 @@ GEM
   specs:
     CFPropertyList (3.0.5)
       rexml
-    addressable (2.8.0)
+    addressable (2.8.1)
-      public_suffix (>= 2.0.2, < 5.0)
+      public_suffix (>= 2.0.2, < 6.0)
     artifactory (3.0.15)
     atomos (0.1.3)
     aws-eventstream (1.2.0)
-    aws-partitions (1.601.0)
+    aws-partitions (1.653.0)
-    aws-sdk-core (3.131.2)
+    aws-sdk-core (3.166.0)
       aws-eventstream (~> 1, >= 1.0.2)
-      aws-partitions (~> 1, >= 1.525.0)
+      aws-partitions (~> 1, >= 1.651.0)
-      aws-sigv4 (~> 1.1)
+      aws-sigv4 (~> 1.5)
       jmespath (~> 1, >= 1.6.1)
-    aws-sdk-kms (1.57.0)
+    aws-sdk-kms (1.59.0)
-      aws-sdk-core (~> 3, >= 3.127.0)
+      aws-sdk-core (~> 3, >= 3.165.0)
       aws-sigv4 (~> 1.1)
-    aws-sdk-s3 (1.114.0)
+    aws-sdk-s3 (1.117.1)
-      aws-sdk-core (~> 3, >= 3.127.0)
+      aws-sdk-core (~> 3, >= 3.165.0)
       aws-sdk-kms (~> 1)
       aws-sigv4 (~> 1.4)
-    aws-sigv4 (1.5.0)
+    aws-sigv4 (1.5.2)
       aws-eventstream (~> 1, >= 1.0.2)
     babosa (1.0.4)
     claide (1.1.0)
@@ -34,10 +34,10 @@ GEM
       rake (>= 12.0.0, < 14.0.0)
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
-    dotenv (2.7.6)
+    dotenv (2.8.1)
     emoji_regex (3.2.3)
-    excon (0.92.3)
+    excon (0.93.1)
-    faraday (1.10.0)
+    faraday (1.10.2)
       faraday-em_http (~> 1.0)
       faraday-em_synchrony (~> 1.0)
       faraday-excon (~> 1.1)
@@ -66,7 +66,7 @@ GEM
     faraday_middleware (1.2.0)
       faraday (~> 1.0)
     fastimage (2.2.6)
-    fastlane (2.206.2)
+    fastlane (2.210.1)
       CFPropertyList (>= 2.3, < 4.0.0)
       addressable (>= 2.8, < 3.0.0)
       artifactory (~> 3.0)
@@ -110,9 +110,9 @@ GEM
       souyuz (= 0.11.1)
     fastlane-plugin-xamarin (0.6.3)
     gh_inspector (1.1.3)
-    google-apis-androidpublisher_v3 (0.23.0)
+    google-apis-androidpublisher_v3 (0.29.0)
-      google-apis-core (>= 0.6, < 2.a)
+      google-apis-core (>= 0.9.0, < 2.a)
-    google-apis-core (0.6.0)
+    google-apis-core (0.9.1)
       addressable (~> 2.5, >= 2.5.1)
       googleauth (>= 0.16.2, < 2.a)
       httpclient (>= 2.8.1, < 3.a)
@@ -121,27 +121,27 @@ GEM
       retriable (>= 2.0, < 4.a)
       rexml
       webrick
-    google-apis-iamcredentials_v1 (0.12.0)
+    google-apis-iamcredentials_v1 (0.15.0)
-      google-apis-core (>= 0.6, < 2.a)
+      google-apis-core (>= 0.9.0, < 2.a)
-    google-apis-playcustomapp_v1 (0.9.0)
+    google-apis-playcustomapp_v1 (0.12.0)
-      google-apis-core (>= 0.6, < 2.a)
+      google-apis-core (>= 0.9.1, < 2.a)
-    google-apis-storage_v1 (0.16.0)
+    google-apis-storage_v1 (0.19.0)
-      google-apis-core (>= 0.6, < 2.a)
+      google-apis-core (>= 0.9.0, < 2.a)
     google-cloud-core (1.6.0)
       google-cloud-env (~> 1.0)
       google-cloud-errors (~> 1.0)
     google-cloud-env (1.6.0)
       faraday (>= 0.17.3, < 3.0)
-    google-cloud-errors (1.2.0)
+    google-cloud-errors (1.3.0)
-    google-cloud-storage (1.36.2)
+    google-cloud-storage (1.43.0)
       addressable (~> 2.8)
       digest-crc (~> 0.4)
       google-apis-iamcredentials_v1 (~> 0.1)
-      google-apis-storage_v1 (~> 0.1)
+      google-apis-storage_v1 (~> 0.19.0)
       google-cloud-core (~> 1.6)
       googleauth (>= 0.16.2, < 2.a)
       mini_mime (~> 1.0)
-    googleauth (1.2.0)
+    googleauth (1.3.0)
       faraday (>= 0.17.3, < 3.a)
       jwt (>= 1.4, < 3.0)
       memoist (~> 0.16)
@@ -154,22 +154,22 @@ GEM
     httpclient (2.8.3)
     jmespath (1.6.1)
     json (2.6.2)
-    jwt (2.4.1)
+    jwt (2.5.0)
     memoist (0.16.2)
     mini_magick (4.11.0)
     mini_mime (1.1.2)
-    mini_portile2 (2.7.1)
+    mini_portile2 (2.8.0)
     multi_json (1.15.0)
     multipart-post (2.0.0)
     nanaimo (0.3.0)
     naturally (2.2.1)
-    nokogiri (1.13.1)
+    nokogiri (1.13.9)
-      mini_portile2 (~> 2.7.0)
+      mini_portile2 (~> 2.8.0)
       racc (~> 1.4)
     optparse (0.1.1)
     os (1.1.4)
     plist (3.6.0)
-    public_suffix (4.0.7)
+    public_suffix (5.0.0)
     racc (1.6.0)
     rake (13.0.6)
     representable (3.2.0)

fastlane/Fastfile

@@ -138,10 +138,10 @@ platform :ios do
   end
 
   lane :testflight_prune_dry do
-    clean_testflight_testers(days_of_inactivity:45, dry_run: true)
+    clean_testflight_testers(days_of_inactivity:30, dry_run: true)
   end
 
   lane :testflight_prune do
-    clean_testflight_testers(days_of_inactivity: 45)
+    clean_testflight_testers(days_of_inactivity: 30)
   end
 end

osu.Android.props

@@ -52,7 +52,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2022.1021.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.1022.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2022.1101.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
     <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->

osu.Desktop/OsuGameDesktop.cs

@@ -18,17 +18,9 @@ using osu.Framework;
 using osu.Framework.Logging;
 using osu.Game.Updater;
 using osu.Desktop.Windows;
-using osu.Framework.Input.Handlers;
-using osu.Framework.Input.Handlers.Joystick;
-using osu.Framework.Input.Handlers.Mouse;
-using osu.Framework.Input.Handlers.Tablet;
-using osu.Framework.Input.Handlers.Touch;
 using osu.Framework.Threading;
 using osu.Game.IO;
 using osu.Game.IPC;
-using osu.Game.Overlays.Settings;
-using osu.Game.Overlays.Settings.Sections;
-using osu.Game.Overlays.Settings.Sections.Input;
 using osu.Game.Utils;
 using SDL2;
 
@@ -148,27 +140,6 @@ namespace osu.Desktop
             desktopWindow.DragDrop += f => fileDrop(new[] { f });
         }
 
-        public override SettingsSubsection CreateSettingsSubsectionFor(InputHandler handler)
-        {
-            switch (handler)
-            {
-                case ITabletHandler th:
-                    return new TabletSettings(th);
-
-                case MouseHandler mh:
-                    return new MouseSettings(mh);
-
-                case JoystickHandler jh:
-                    return new JoystickSettings(jh);
-
-                case TouchHandler th:
-                    return new InputSection.HandlerSection(th);
-
-                default:
-                    return base.CreateSettingsSubsectionFor(handler);
-            }
-        }
-
         protected override BatteryInfo CreateBatteryInfo() => new SDL2BatteryInfo();
 
         private readonly List<string> importableFiles = new List<string>();

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -17,6 +17,7 @@ using osu.Game.Rulesets.Catch.Edit;
 using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Catch.Scoring;
+using osu.Game.Rulesets.Catch.Skinning.Argon;
 using osu.Game.Rulesets.Catch.Skinning.Legacy;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Difficulty;
@@ -188,6 +189,9 @@ namespace osu.Game.Rulesets.Catch
             {
                 case LegacySkin:
                     return new CatchLegacySkinTransformer(skin);
+
+                case ArgonSkin:
+                    return new CatchArgonSkinTransformer(skin);
             }
 
             return null;

osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs

@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
@@ -10,7 +11,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
@@ -23,7 +23,6 @@ using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
@@ -35,8 +34,6 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         private CatchDistanceSnapGrid distanceSnapGrid;
 
-        private readonly Bindable<TernaryState> distanceSnapToggle = new Bindable<TernaryState>();
-
         private InputManager inputManager;
 
         private readonly BindableDouble timeRangeMultiplier = new BindableDouble(1)
@@ -81,6 +78,19 @@ namespace osu.Game.Rulesets.Catch.Edit
             inputManager = GetContainingInputManager();
         }
 
+        protected override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
+        {
+            // osu!catch's distance snap implementation is limited, in that a custom spacing cannot be specified.
+            // Therefore this functionality is not currently used.
+            //
+            // The implementation below is probably correct but should be checked if/when exposed via controls.
+
+            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
+            float actualDistance = Math.Abs(((CatchHitObject)before).EffectiveX - ((CatchHitObject)after).EffectiveX);
+
+            return actualDistance / expectedDistance;
+        }
+
         protected override void Update()
         {
             base.Update();
@@ -120,11 +130,6 @@ namespace osu.Game.Rulesets.Catch.Edit
             new BananaShowerCompositionTool()
         };
 
-        protected override IEnumerable<TernaryButton> CreateTernaryButtons() => base.CreateTernaryButtons().Concat(new[]
-        {
-            new TernaryButton(distanceSnapToggle, "Distance Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Ruler })
-        });
-
         public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
         {
             var result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
@@ -196,7 +201,7 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         private void updateDistanceSnapGrid()
         {
-            if (distanceSnapToggle.Value != TernaryState.True)
+            if (DistanceSnapToggle.Value != TernaryState.True)
             {
                 distanceSnapGrid.Hide();
                 return;

osu.Game.Rulesets.Catch/Objects/Drawables/CaughtObject.cs

@@ -28,6 +28,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
 
         public float DisplayRotation => Rotation;
 
+        public double DisplayStartTime => HitObject.StartTime;
+
         /// <summary>
         /// Whether this hit object should stay on the catcher plate when the object is caught by the catcher.
         /// </summary>

osu.Game.Rulesets.Catch/Objects/Drawables/DrawablePalpableCatchHitObject.cs

@@ -18,6 +18,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
     {
         public new PalpableCatchHitObject HitObject => (PalpableCatchHitObject)base.HitObject;
 
+        public double DisplayStartTime => LifetimeStart;
+
         Bindable<Color4> IHasCatchObjectState.AccentColour => AccentColour;
 
         public Bindable<bool> HyperDash { get; } = new Bindable<bool>();

osu.Game.Rulesets.Catch/Objects/Drawables/IHasCatchObjectState.cs

@@ -16,6 +16,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
     {
         PalpableCatchHitObject HitObject { get; }
 
+        double DisplayStartTime { get; }
+
         Bindable<Color4> AccentColour { get; }
 
         Bindable<bool> HyperDash { get; }

osu.Game.Rulesets.Catch/Skinning/Argon/ArgonBananaPiece.cs

@@ -0,0 +1,122 @@
+// 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.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Objects;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Argon
+{
+    internal class ArgonBananaPiece : ArgonFruitPiece
+    {
+        private Container stabilisedPieceContainer = null!;
+
+        private Drawable fadeContent = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddInternal(fadeContent = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    stabilisedPieceContainer = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Children = new Drawable[]
+                        {
+                            new Circle
+                            {
+                                Colour = Color4.White.Opacity(0.4f),
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Blending = BlendingParameters.Additive,
+                                Size = new Vector2(8),
+                                Scale = new Vector2(25, 1),
+                            },
+                            new Box
+                            {
+                                Colour = ColourInfo.GradientHorizontal(Color4.White.Opacity(0), Color4.White.Opacity(0.8f)),
+                                RelativeSizeAxes = Axes.X,
+                                Blending = BlendingParameters.Additive,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.CentreRight,
+                                Width = 1.6f,
+                                Height = 2,
+                            },
+                            new Circle
+                            {
+                                Colour = ColourInfo.GradientHorizontal(Color4.White.Opacity(0.8f), Color4.White.Opacity(0)),
+                                RelativeSizeAxes = Axes.X,
+                                Blending = BlendingParameters.Additive,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.CentreLeft,
+                                Width = 1.6f,
+                                Height = 2,
+                            },
+                        }
+                    },
+                    new Circle
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Size = new Vector2(1.2f),
+                        EdgeEffect = new EdgeEffectParameters
+                        {
+                            Type = EdgeEffectType.Glow,
+                            Hollow = false,
+                            Colour = Color4.White.Opacity(0.1f),
+                            Radius = 50,
+                        },
+                        Child =
+                        {
+                            Alpha = 0,
+                            AlwaysPresent = true,
+                        },
+                        BorderColour = Color4.White.Opacity(0.1f),
+                        BorderThickness = 3,
+                    },
+                }
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            const float parent_scale_application = 0.4f;
+
+            // relative to time on screen
+            const float lens_flare_start = 0.3f;
+            const float lens_flare_end = 0.8f;
+
+            // Undo some of the parent scale being applied to make the lens flare feel a bit better..
+            float scale = parent_scale_application + (1 - parent_scale_application) * (1 / (ObjectState.DisplaySize.X / (CatchHitObject.OBJECT_RADIUS * 2)));
+
+            stabilisedPieceContainer.Rotation = -ObjectState.DisplayRotation;
+            stabilisedPieceContainer.Scale = new Vector2(scale, 1);
+
+            double duration = ObjectState.HitObject.StartTime - ObjectState.DisplayStartTime;
+
+            fadeContent.Alpha = MathHelper.Clamp(
+                Interpolation.ValueAt(
+                    Time.Current, 1f, 0f,
+                    ObjectState.DisplayStartTime + duration * lens_flare_start,
+                    ObjectState.DisplayStartTime + duration * lens_flare_end,
+                    Easing.OutQuint
+                ), 0, 1);
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/Argon/ArgonCatcher.cs

@@ -0,0 +1,85 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Catch.UI;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Argon
+{
+    public class ArgonCatcher : CompositeDrawable
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = 10,
+                    Children = new Drawable[]
+                    {
+                        new Circle
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Colour = Color4.White,
+                            Width = Catcher.ALLOWED_CATCH_RANGE,
+                        },
+                        new Box
+                        {
+                            Name = "long line left",
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreRight,
+                            Colour = Color4.White,
+                            Alpha = 0.25f,
+                            RelativeSizeAxes = Axes.X,
+                            Width = 20,
+                            Height = 1.8f,
+                        },
+                        new Circle
+                        {
+                            Name = "bumper left",
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Colour = Color4.White,
+                            RelativeSizeAxes = Axes.X,
+                            Width = (1 - Catcher.ALLOWED_CATCH_RANGE) / 2,
+                            Height = 4,
+                        },
+                        new Box
+                        {
+                            Name = "long line right",
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreLeft,
+                            Colour = Color4.White,
+                            Alpha = 0.25f,
+                            RelativeSizeAxes = Axes.X,
+                            Width = 20,
+                            Height = 1.8f,
+                        },
+                        new Circle
+                        {
+                            Name = "bumper right",
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                            Colour = Color4.White,
+                            RelativeSizeAxes = Axes.X,
+                            Width = (1 - Catcher.ALLOWED_CATCH_RANGE) / 2,
+                            Height = 4,
+                        },
+                    }
+                },
+            };
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/Argon/ArgonDropletPiece.cs

@@ -0,0 +1,121 @@
+// 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.Framework.Graphics.UserInterface;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Skinning.Default;
+using osu.Game.Rulesets.Catch.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Argon
+{
+    internal class ArgonDropletPiece : CatchHitObjectPiece
+    {
+        protected override Drawable HyperBorderPiece => hyperBorderPiece;
+
+        private Drawable hyperBorderPiece = null!;
+
+        private Container layers = null!;
+
+        private float rotationRandomness;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            const float droplet_scale_down = 0.7f;
+
+            int largeBlobSeed = RNG.Next();
+
+            InternalChildren = new[]
+            {
+                new Circle
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(20),
+                },
+                layers = new Container
+                {
+                    Scale = new Vector2(droplet_scale_down),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new CircularBlob
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Blending = BlendingParameters.Additive,
+                            InnerRadius = 0.5f,
+                            Alpha = 0.15f,
+                            Seed = largeBlobSeed
+                        },
+                        new CircularBlob
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Blending = BlendingParameters.Additive,
+                            InnerRadius = 0.4f,
+                            Alpha = 0.5f,
+                            Scale = new Vector2(0.7f),
+                            Seed = RNG.Next()
+                        },
+                    }
+                },
+                hyperBorderPiece = new CircularBlob
+                {
+                    Scale = new Vector2(droplet_scale_down),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
+                    RelativeSizeAxes = Axes.Both,
+                    Blending = BlendingParameters.Additive,
+                    InnerRadius = 0.5f,
+                    Alpha = 0.15f,
+                    Seed = largeBlobSeed
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AccentColour.BindValueChanged(colour =>
+            {
+                foreach (var sprite in layers)
+                    sprite.Colour = colour.NewValue;
+            }, true);
+
+            rotationRandomness = RNG.NextSingle(0.2f, 1);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // Note that droplets are rotated at a higher level, so this is mostly just to create more
+            // random arrangements of the multiple layers than actually rotate.
+            //
+            // Because underlying rotation is always clockwise, we apply anti-clockwise resistance to avoid
+            // making things spin too fast.
+            for (int i = 0; i < layers.Count; i++)
+            {
+                layers[i].Rotation -=
+                    (float)Clock.ElapsedFrameTime
+                    * 0.4f * rotationRandomness
+                    // Each layer should alternate rotation speed.
+                    * (i % 2 == 1 ? 0.5f : 1);
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/Argon/ArgonFruitPiece.cs

@@ -0,0 +1,121 @@
+// 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.Framework.Graphics.UserInterface;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Skinning.Default;
+using osu.Game.Rulesets.Catch.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Argon
+{
+    internal class ArgonFruitPiece : CatchHitObjectPiece
+    {
+        protected override Drawable HyperBorderPiece => hyperBorderPiece;
+
+        private Drawable hyperBorderPiece = null!;
+
+        private Container layers = null!;
+
+        private float rotationRandomness;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            int largeBlobSeed = RNG.Next();
+
+            InternalChildren = new[]
+            {
+                new Circle
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(20),
+                },
+                layers = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new CircularBlob
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Blending = BlendingParameters.Additive,
+                            Alpha = 0.15f,
+                            InnerRadius = 0.5f,
+                            Size = new Vector2(1.1f),
+                            Seed = largeBlobSeed,
+                        },
+                        new CircularBlob
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Blending = BlendingParameters.Additive,
+                            InnerRadius = 0.2f,
+                            Alpha = 0.5f,
+                            Seed = RNG.Next(),
+                        },
+                        new CircularBlob
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Blending = BlendingParameters.Additive,
+                            InnerRadius = 0.05f,
+                            Seed = RNG.Next(),
+                        },
+                    }
+                },
+                hyperBorderPiece = new CircularBlob
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
+                    RelativeSizeAxes = Axes.Both,
+                    Blending = BlendingParameters.Additive,
+                    InnerRadius = 0.08f,
+                    Size = new Vector2(1.15f),
+                    Seed = largeBlobSeed
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AccentColour.BindValueChanged(colour =>
+            {
+                foreach (var sprite in layers)
+                    sprite.Colour = colour.NewValue;
+            }, true);
+
+            rotationRandomness = RNG.NextSingle(0.2f, 1) * (RNG.NextBool() ? -1 : 1);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            for (int i = 0; i < layers.Count; i++)
+            {
+                layers[i].Rotation +=
+                    // Layers are ordered from largest to smallest. Smaller layers should rotate more.
+                    (i * 2)
+                    * (float)Clock.ElapsedFrameTime
+                    * 0.02f * rotationRandomness
+                    // Each layer should alternate rotation direction.
+                    * (i % 2 == 1 ? 1 : -1);
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/Argon/ArgonHitExplosion.cs

@@ -0,0 +1,112 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Argon
+{
+    public class ArgonHitExplosion : CompositeDrawable, IHitExplosion
+    {
+        public override bool RemoveWhenNotAlive => true;
+
+        private Container tallExplosion = null!;
+        private Container largeFaint = null!;
+
+        private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+
+        public ArgonHitExplosion()
+        {
+            Size = new Vector2(20);
+            Anchor = Anchor.BottomCentre;
+            Origin = Anchor.BottomCentre;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                tallExplosion = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Width = 0.1f,
+                    Child = new Box
+                    {
+                        AlwaysPresent = true,
+                        Alpha = 0,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                },
+                largeFaint = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Child = new Box
+                    {
+                        AlwaysPresent = true,
+                        Alpha = 0,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                },
+            };
+
+            accentColour.BindValueChanged(colour =>
+            {
+                tallExplosion.EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Glow,
+                    Colour = colour.NewValue,
+                    Hollow = false,
+                    Roundness = 15,
+                    Radius = 15,
+                };
+
+                largeFaint.EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Glow,
+                    Colour = Interpolation.ValueAt(0.2f, colour.NewValue, Color4.White, 0, 1),
+                    Hollow = false,
+                    Radius = 50,
+                };
+            }, true);
+        }
+
+        public void Animate(HitExplosionEntry entry)
+        {
+            X = entry.Position;
+            Scale = new Vector2(entry.HitObject.Scale);
+            accentColour.Value = entry.ObjectColour;
+
+            using (BeginAbsoluteSequence(entry.LifetimeStart))
+            {
+                this.FadeOutFromOne(400);
+
+                if (!(entry.HitObject is Droplet))
+                {
+                    float scale = Math.Clamp(entry.JudgementResult.ComboAtJudgement / 200f, 0.35f, 1.125f);
+
+                    tallExplosion
+                        .ScaleTo(new Vector2(1.1f, 20 * scale), 200, Easing.OutQuint)
+                        .Then()
+                        .ScaleTo(new Vector2(1.1f, 1), 600, Easing.In);
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/Argon/ArgonJudgementPiece.cs

@@ -0,0 +1,193 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Argon
+{
+    public class ArgonJudgementPiece : CompositeDrawable, IAnimatableJudgement
+    {
+        protected readonly HitResult Result;
+
+        protected SpriteText JudgementText { get; private set; } = null!;
+
+        private RingExplosion? ringExplosion;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        public ArgonJudgementPiece(HitResult result)
+        {
+            Result = result;
+            Origin = Anchor.Centre;
+            Y = 160;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AutoSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                JudgementText = new OsuSpriteText
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Text = Result.GetDescription().ToUpperInvariant(),
+                    Colour = colours.ForHitResult(Result),
+                    Blending = BlendingParameters.Additive,
+                    Spacing = new Vector2(10, 0),
+                    Font = OsuFont.Default.With(size: 28, weight: FontWeight.Regular),
+                },
+            };
+
+            if (Result.IsHit())
+            {
+                AddInternal(ringExplosion = new RingExplosion(Result)
+                {
+                    Colour = colours.ForHitResult(Result),
+                });
+            }
+        }
+
+        /// <summary>
+        /// Plays the default animation for this judgement piece.
+        /// </summary>
+        /// <remarks>
+        /// The base implementation only handles fade (for all result types) and misses.
+        /// Individual rulesets are recommended to implement their appropriate hit animations.
+        /// </remarks>
+        public virtual void PlayAnimation()
+        {
+            switch (Result)
+            {
+                default:
+                    JudgementText
+                        .ScaleTo(Vector2.One)
+                        .ScaleTo(new Vector2(1.4f), 1800, Easing.OutQuint);
+                    break;
+
+                case HitResult.Miss:
+                    this.ScaleTo(1.6f);
+                    this.ScaleTo(1, 100, Easing.In);
+
+                    this.MoveTo(Vector2.Zero);
+                    this.MoveToOffset(new Vector2(0, 100), 800, Easing.InQuint);
+
+                    this.RotateTo(0);
+                    this.RotateTo(40, 800, Easing.InQuint);
+                    break;
+            }
+
+            this.FadeOutFromOne(800);
+
+            ringExplosion?.PlayAnimation();
+        }
+
+        public Drawable? GetAboveHitObjectsProxiedContent() => null;
+
+        private class RingExplosion : CompositeDrawable
+        {
+            private readonly float travel = 52;
+
+            public RingExplosion(HitResult result)
+            {
+                const float thickness = 4;
+
+                const float small_size = 9;
+                const float large_size = 14;
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                Blending = BlendingParameters.Additive;
+
+                int countSmall = 0;
+                int countLarge = 0;
+
+                switch (result)
+                {
+                    case HitResult.Meh:
+                        countSmall = 3;
+                        travel *= 0.3f;
+                        break;
+
+                    case HitResult.Ok:
+                    case HitResult.Good:
+                        countSmall = 4;
+                        travel *= 0.6f;
+                        break;
+
+                    case HitResult.Great:
+                    case HitResult.Perfect:
+                        countSmall = 4;
+                        countLarge = 4;
+                        break;
+                }
+
+                for (int i = 0; i < countSmall; i++)
+                    AddInternal(new RingPiece(thickness) { Size = new Vector2(small_size) });
+
+                for (int i = 0; i < countLarge; i++)
+                    AddInternal(new RingPiece(thickness) { Size = new Vector2(large_size) });
+            }
+
+            public void PlayAnimation()
+            {
+                foreach (var c in InternalChildren)
+                {
+                    const float start_position_ratio = 0.3f;
+
+                    float direction = RNG.NextSingle(0, 360);
+                    float distance = RNG.NextSingle(travel / 2, travel);
+
+                    c.MoveTo(new Vector2(
+                        MathF.Cos(direction) * distance * start_position_ratio,
+                        MathF.Sin(direction) * distance * start_position_ratio
+                    ));
+
+                    c.MoveTo(new Vector2(
+                        MathF.Cos(direction) * distance,
+                        MathF.Sin(direction) * distance
+                    ), 600, Easing.OutQuint);
+                }
+
+                this.FadeOutFromOne(1000, Easing.OutQuint);
+            }
+
+            public class RingPiece : CircularContainer
+            {
+                public RingPiece(float thickness = 9)
+                {
+                    Anchor = Anchor.Centre;
+                    Origin = Anchor.Centre;
+
+                    Masking = true;
+                    BorderThickness = thickness;
+                    BorderColour = Color4.White;
+
+                    Child = new Box
+                    {
+                        AlwaysPresent = true,
+                        Alpha = 0,
+                        RelativeSizeAxes = Axes.Both
+                    };
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/Argon/CatchArgonSkinTransformer.cs

@@ -0,0 +1,46 @@
+// 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.Skinning;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Argon
+{
+    public class CatchArgonSkinTransformer : SkinTransformer
+    {
+        public CatchArgonSkinTransformer(ISkin skin)
+            : base(skin)
+        {
+        }
+
+        public override Drawable? GetDrawableComponent(ISkinComponent component)
+        {
+            switch (component)
+            {
+                case CatchSkinComponent catchComponent:
+                    // TODO: Once everything is finalised, consider throwing UnsupportedSkinComponentException on missing entries.
+                    switch (catchComponent.Component)
+                    {
+                        case CatchSkinComponents.HitExplosion:
+                            return new ArgonHitExplosion();
+
+                        case CatchSkinComponents.Catcher:
+                            return new ArgonCatcher();
+
+                        case CatchSkinComponents.Fruit:
+                            return new ArgonFruitPiece();
+
+                        case CatchSkinComponents.Banana:
+                            return new ArgonBananaPiece();
+
+                        case CatchSkinComponents.Droplet:
+                            return new ArgonDropletPiece();
+                    }
+
+                    break;
+            }
+
+            return base.GetDrawableComponent(component);
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/Default/BananaPiece.cs

@@ -1,21 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Default
 {
     public class BananaPiece : CatchHitObjectPiece
     {
-        protected override BorderPiece BorderPiece { get; }
+        protected override Drawable BorderPiece { get; }
 
         public BananaPiece()
         {
             RelativeSizeAxes = Axes.Both;
 
-            InternalChildren = new Drawable[]
+            InternalChildren = new[]
             {
                 new BananaPulpFormation
                 {

osu.Game.Rulesets.Catch/Skinning/Default/CatchHitObjectPiece.cs

@@ -7,6 +7,7 @@ using System;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osuTK.Graphics;
@@ -26,13 +27,13 @@ namespace osu.Game.Rulesets.Catch.Skinning.Default
         /// A part of this piece that will be faded out while falling in the playfield.
         /// </summary>
         [CanBeNull]
-        protected virtual BorderPiece BorderPiece => null;
+        protected virtual Drawable BorderPiece => null;
 
         /// <summary>
         /// A part of this piece that will be only visible when <see cref="HyperDash"/> is true.
         /// </summary>
         [CanBeNull]
-        protected virtual HyperBorderPiece HyperBorderPiece => null;
+        protected virtual Drawable HyperBorderPiece => null;
 
         protected override void LoadComplete()
         {

osu.Game.Rulesets.Catch/Skinning/Default/DropletPiece.cs

@@ -11,13 +11,13 @@ namespace osu.Game.Rulesets.Catch.Skinning.Default
 {
     public class DropletPiece : CatchHitObjectPiece
     {
-        protected override HyperBorderPiece HyperBorderPiece { get; }
+        protected override Drawable HyperBorderPiece { get; }
 
         public DropletPiece()
         {
             Size = new Vector2(CatchHitObject.OBJECT_RADIUS / 2);
 
-            InternalChildren = new Drawable[]
+            InternalChildren = new[]
             {
                 new Pulp
                 {

osu.Game.Rulesets.Catch/Skinning/Default/FruitPiece.cs

@@ -18,14 +18,14 @@ namespace osu.Game.Rulesets.Catch.Skinning.Default
 
         public readonly Bindable<FruitVisualRepresentation> VisualRepresentation = new Bindable<FruitVisualRepresentation>();
 
-        protected override BorderPiece BorderPiece { get; }
+        protected override Drawable BorderPiece { get; }
-        protected override HyperBorderPiece HyperBorderPiece { get; }
+        protected override Drawable HyperBorderPiece { get; }
 
         public FruitPiece()
         {
             RelativeSizeAxes = Axes.Both;
 
-            InternalChildren = new Drawable[]
+            InternalChildren = new[]
             {
                 new FruitPulpFormation
                 {

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

@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             assertHeadJudgement(HitResult.Miss);
             assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
-            assertNoteJudgement(HitResult.IgnoreHit);
+            assertNoteJudgement(HitResult.IgnoreMiss);
         }
 
         /// <summary>

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

@@ -76,8 +76,8 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             performTest(objects, new List<ReplayFrame>());
 
-            addJudgementAssert(objects[0], HitResult.IgnoreHit);
+            addJudgementAssert(objects[0], HitResult.IgnoreMiss);
-            addJudgementAssert(objects[1], HitResult.IgnoreHit);
+            addJudgementAssert(objects[1], HitResult.IgnoreMiss);
         }
 
         [Test]

osu.Game.Rulesets.Mania/Mods/ManiaModHoldOff.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override string Acronym => "HO";
 
-        public override double ScoreMultiplier => 1;
+        public override double ScoreMultiplier => 0.9;
 
         public override LocalisableString Description => @"Replaces all hold notes with normal notes.";
 

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

@@ -69,6 +69,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// </summary>
         private double? releaseTime;
 
+        public override double MaximumJudgementOffset => Tail.MaximumJudgementOffset;
+
         public DrawableHoldNote()
             : this(null)
         {
@@ -260,7 +262,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                         tick.MissForcefully();
                 }
 
-                ApplyResult(r => r.Type = r.Judgement.MaxResult);
+                ApplyResult(r => r.Type = Tail.IsHit ? r.Judgement.MaxResult : r.Judgement.MinResult);
                 endHold();
             }
 

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

@@ -4,12 +4,15 @@
 #nullable disable
 
 using System;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Overlays;
@@ -52,6 +55,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         };
 
         private OsuDistanceSnapGrid grid;
+        private SnappingCursorContainer cursor;
 
         public TestSceneOsuDistanceSnapGrid()
         {
@@ -88,8 +92,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                     RelativeSizeAxes = Axes.Both,
                     Colour = Color4.SlateGray
                 },
+                cursor = new SnappingCursorContainer { GetSnapPosition = v => grid.GetSnappedPosition(grid.ToLocalSpace(v)).position },
                 grid = new OsuDistanceSnapGrid(new HitCircle { Position = grid_position }),
-                new SnappingCursorContainer { GetSnapPosition = v => grid.GetSnappedPosition(grid.ToLocalSpace(v)).position }
             };
         });
 
@@ -154,6 +158,37 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             assertSnappedDistance(expectedDistance);
         }
 
+        [Test]
+        public void TestReferenceObjectNotOnSnapGrid()
+        {
+            AddStep("create grid", () =>
+            {
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.SlateGray
+                    },
+                    cursor = new SnappingCursorContainer { GetSnapPosition = v => grid.GetSnappedPosition(grid.ToLocalSpace(v)).position },
+                    grid = new OsuDistanceSnapGrid(new HitCircle
+                    {
+                        Position = grid_position,
+                        // This is important. It sets the reference object to a point in time that isn't on the current snap divisor's grid.
+                        // We are testing that the grid's display is offset correctly.
+                        StartTime = 40,
+                    }),
+                };
+            });
+
+            AddStep("move mouse to point", () => InputManager.MoveMouseTo(grid.ToScreenSpace(grid_position + new Vector2(beat_length, 0) * 2)));
+
+            AddAssert("Ensure cursor is on a grid line", () =>
+            {
+                return grid.ChildrenOfType<CircularProgress>().Any(p => Precision.AlmostEquals(p.ScreenSpaceDrawQuad.TopRight.X, grid.ToScreenSpace(cursor.LastSnappedPosition).X));
+            });
+        }
+
         [Test]
         public void TestLimitedDistance()
         {
@@ -166,8 +201,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                         RelativeSizeAxes = Axes.Both,
                         Colour = Color4.SlateGray
                     },
+                    cursor = new SnappingCursorContainer { GetSnapPosition = v => grid.GetSnappedPosition(grid.ToLocalSpace(v)).position },
                     grid = new OsuDistanceSnapGrid(new HitCircle { Position = grid_position }, new HitCircle { StartTime = 200 }),
-                    new SnappingCursorContainer { GetSnapPosition = v => grid.GetSnappedPosition(grid.ToLocalSpace(v)).position }
                 };
             });
 
@@ -186,6 +221,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         {
             public Func<Vector2, Vector2> GetSnapPosition;
 
+            public Vector2 LastSnappedPosition { get; private set; }
+
             private readonly Drawable cursor;
 
             private InputManager inputManager;
@@ -214,7 +251,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             protected override void Update()
             {
                 base.Update();
-                cursor.Position = GetSnapPosition.Invoke(inputManager.CurrentState.Mouse.Position);
+                cursor.Position = LastSnappedPosition = GetSnapPosition.Invoke(inputManager.CurrentState.Mouse.Position);
             }
         }
     }

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

@@ -20,20 +20,49 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
 
         [Test]
-        public void TestGridExclusivity()
+        public void TestGridToggles()
         {
             AddStep("enable distance snap grid", () => InputManager.Key(Key.T));
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
+
             AddUntilStep("distance snap grid visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             rectangularGridActive(false);
 
             AddStep("enable rectangular grid", () => InputManager.Key(Key.Y));
-            AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
+
+            AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
+            AddUntilStep("distance snap grid still visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             rectangularGridActive(true);
 
-            AddStep("enable distance snap grid", () => InputManager.Key(Key.T));
+            AddStep("disable distance snap grid", () => InputManager.Key(Key.T));
+            AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
+            rectangularGridActive(true);
+
+            AddStep("disable rectangular grid", () => InputManager.Key(Key.Y));
+            AddUntilStep("distance snap grid still hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
+            rectangularGridActive(false);
+        }
+
+        [Test]
+        public void TestDistanceSnapMomentaryToggle()
+        {
+            AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
+
+            AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
+            AddStep("hold alt", () => InputManager.PressKey(Key.AltLeft));
             AddUntilStep("distance snap grid visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
+            AddStep("release alt", () => InputManager.ReleaseKey(Key.AltLeft));
+            AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
+        }
+
+        [Test]
+        public void TestGridSnapMomentaryToggle()
+        {
+            rectangularGridActive(false);
+            AddStep("hold shift", () => InputManager.PressKey(Key.ShiftLeft));
+            rectangularGridActive(true);
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
             rectangularGridActive(false);
         }
 
@@ -50,8 +79,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 AddAssert("placement blueprint at (0, 0)", () => Precision.AlmostEquals(Editor.ChildrenOfType<HitCirclePlacementBlueprint>().Single().HitObject.Position, new Vector2(0, 0)));
             else
                 AddAssert("placement blueprint at (1, 1)", () => Precision.AlmostEquals(Editor.ChildrenOfType<HitCirclePlacementBlueprint>().Single().HitObject.Position, new Vector2(1, 1)));
-
-            AddStep("choose selection tool", () => InputManager.Key(Key.Number1));
         }
 
         [Test]

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFreezeFrame.cs

@@ -0,0 +1,22 @@
+// 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.Rulesets.Osu.Mods;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModFreezeFrame : OsuModTestScene
+    {
+        [Test]
+        public void TestFreezeFrame()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new OsuModFreezeFrame(),
+                PassCondition = () => true,
+                Autoplay = false,
+            });
+        }
+    }
+}

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

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             new object[] { LegacyMods.Autoplay, new[] { typeof(OsuModAutoplay) } },
             new object[] { LegacyMods.SpunOut, new[] { typeof(OsuModSpunOut) } },
             new object[] { LegacyMods.Autopilot, new[] { typeof(OsuModAutopilot) } },
-            new object[] { LegacyMods.Target, new[] { typeof(OsuModTarget) } },
+            new object[] { LegacyMods.Target, new[] { typeof(OsuModTargetPractice) } },
             new object[] { LegacyMods.HardRock | LegacyMods.DoubleTime, new[] { typeof(OsuModHardRock), typeof(OsuModDoubleTime) } }
         };
 

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

@@ -377,7 +377,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private void addJudgementAssert(OsuHitObject hitObject, HitResult result)
         {
             AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judgement is {result}",
-                () => judgementResults.Single(r => r.HitObject == hitObject).Type == result);
+                () => judgementResults.Single(r => r.HitObject == hitObject).Type, () => Is.EqualTo(result));
         }
 
         private void addJudgementAssert(string name, Func<OsuHitObject> hitObject, HitResult result)

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

@@ -40,16 +40,23 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             body.BorderColour = colours.Yellow;
         }
 
+        private int? lastVersion;
+
         public override void UpdateFrom(Slider hitObject)
         {
             base.UpdateFrom(hitObject);
 
             body.PathRadius = hitObject.Scale * OsuHitObject.OBJECT_RADIUS;
 
+            if (lastVersion != hitObject.Path.Version.Value)
+            {
+                lastVersion = hitObject.Path.Version.Value;
+
                 var vertices = new List<Vector2>();
                 hitObject.Path.GetPathToProgress(vertices, 0, 1);
 
                 body.SetVertices(vertices);
+            }
 
             Size = body.Size;
             OriginPosition = body.PathOffset;

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

@@ -59,6 +59,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private readonly BindableList<PathControlPoint> controlPoints = new BindableList<PathControlPoint>();
         private readonly IBindable<int> pathVersion = new Bindable<int>();
+        private readonly BindableList<HitObject> selectedObjects = new BindableList<HitObject>();
 
         public SliderSelectionBlueprint(Slider slider)
             : base(slider)
@@ -86,6 +87,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             pathVersion.BindValueChanged(_ => editorBeatmap?.Update(HitObject));
 
             BodyPiece.UpdateFrom(HitObject);
+
+            if (editorBeatmap != null)
+                selectedObjects.BindTo(editorBeatmap.SelectedHitObjects);
+            selectedObjects.BindCollectionChanged((_, _) => updateVisualDefinition(), true);
         }
 
         public override bool HandleQuickDeletion()
@@ -100,6 +105,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             return true;
         }
 
+        private bool hasSingleObjectSelected => selectedObjects.Count == 1;
+
         protected override void Update()
         {
             base.Update();
@@ -108,14 +115,25 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 BodyPiece.UpdateFrom(HitObject);
         }
 
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateVisualDefinition();
+
+            // In the case more than a single object is selected, block hover from arriving at sliders behind this one.
+            // Without doing this, the path visualisers of potentially hundreds of sliders will render, which is not only
+            // visually noisy but also functionally useless.
+            return !hasSingleObjectSelected;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            updateVisualDefinition();
+            base.OnHoverLost(e);
+        }
+
         protected override void OnSelected()
         {
-            AddInternal(ControlPointVisualiser = new PathControlPointVisualiser(HitObject, true)
+            updateVisualDefinition();
-            {
-                RemoveControlPointsRequested = removeControlPoints,
-                SplitControlPointsRequested = splitControlPoints
-            });
-
             base.OnSelected();
         }
 
@@ -123,11 +141,29 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         {
             base.OnDeselected();
 
-            // throw away frame buffers on deselection.
+            updateVisualDefinition();
+            BodyPiece.RecyclePath();
+        }
+
+        private void updateVisualDefinition()
+        {
+            // To reduce overhead of drawing these blueprints, only add extra detail when hovered or when only this slider is selected.
+            if (IsSelected && (hasSingleObjectSelected || IsHovered))
+            {
+                if (ControlPointVisualiser == null)
+                {
+                    AddInternal(ControlPointVisualiser = new PathControlPointVisualiser(HitObject, true)
+                    {
+                        RemoveControlPointsRequested = removeControlPoints,
+                        SplitControlPointsRequested = splitControlPoints
+                    });
+                }
+            }
+            else
+            {
                 ControlPointVisualiser?.Expire();
                 ControlPointVisualiser = null;
-
+            }
-            BodyPiece.RecyclePath();
         }
 
         private Vector2 rightClickPosition;

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

@@ -5,19 +5,17 @@
 
 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.Osu.Objects;
-using osu.Game.Rulesets.Osu.Skinning.Default;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
 {
     public class SpinnerPiece : BlueprintPiece<Spinner>
     {
-        private readonly CircularContainer circle;
+        private readonly Circle circle;
-        private readonly RingPiece ring;
+        private readonly Circle ring;
 
         public SpinnerPiece()
         {
@@ -25,18 +23,21 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
 
             RelativeSizeAxes = Axes.Both;
             FillMode = FillMode.Fit;
-            Size = new Vector2(1.3f);
+            Size = new Vector2(1);
 
             InternalChildren = new Drawable[]
             {
-                circle = new CircularContainer
+                circle = new Circle
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Masking = true,
                     Alpha = 0.5f,
-                    Child = new Box { RelativeSizeAxes = Axes.Both }
                 },
-                ring = new RingPiece()
+                ring = new Circle
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(OsuHitObject.OBJECT_RADIUS),
+                },
             };
         }
 

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

@@ -13,8 +13,11 @@ using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
+using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
@@ -44,12 +47,10 @@ namespace osu.Game.Rulesets.Osu.Edit
             new SpinnerCompositionTool()
         };
 
-        private readonly Bindable<TernaryState> distanceSnapToggle = new Bindable<TernaryState>();
         private readonly Bindable<TernaryState> rectangularGridSnapToggle = new Bindable<TernaryState>();
 
         protected override IEnumerable<TernaryButton> CreateTernaryButtons() => base.CreateTernaryButtons().Concat(new[]
         {
-            new TernaryButton(distanceSnapToggle, "Distance Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Ruler }),
             new TernaryButton(rectangularGridSnapToggle, "Grid Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Th })
         });
 
@@ -80,19 +81,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             placementObject = EditorBeatmap.PlacementObject.GetBoundCopy();
             placementObject.ValueChanged += _ => updateDistanceSnapGrid();
-            distanceSnapToggle.ValueChanged += _ =>
+            DistanceSnapToggle.ValueChanged += _ => updateDistanceSnapGrid();
-            {
-                updateDistanceSnapGrid();
-
-                if (distanceSnapToggle.Value == TernaryState.True)
-                    rectangularGridSnapToggle.Value = TernaryState.False;
-            };
-
-            rectangularGridSnapToggle.ValueChanged += _ =>
-            {
-                if (rectangularGridSnapToggle.Value == TernaryState.True)
-                    distanceSnapToggle.Value = TernaryState.False;
-            };
 
             // we may be entering the screen with a selection already active
             updateDistanceSnapGrid();
@@ -112,6 +101,14 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private RectangularPositionSnapGrid rectangularPositionSnapGrid;
 
+        protected override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
+        {
+            float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
+            float actualDistance = Vector2.Distance(((OsuHitObject)before).EndPosition, ((OsuHitObject)after).Position);
+
+            return actualDistance / expectedDistance;
+        }
+
         protected override void Update()
         {
             base.Update();
@@ -132,24 +129,46 @@ namespace osu.Game.Rulesets.Osu.Edit
         public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
         {
             if (snapType.HasFlagFast(SnapType.NearbyObjects) && snapToVisibleBlueprints(screenSpacePosition, out var snapResult))
+            {
+                // In the case of snapping to nearby objects, a time value is not provided.
+                // This matches the stable editor (which also uses current time), but with the introduction of time-snapping distance snap
+                // this could result in unexpected behaviour when distance snapping is turned on and a user attempts to place an object that is
+                // BOTH on a valid distance snap ring, and also at the same position as a previous object.
+                //
+                // We want to ensure that in this particular case, the time-snapping component of distance snap is still applied.
+                // The easiest way to ensure this is to attempt application of distance snap after a nearby object is found, and copy over
+                // the time value if the proposed positions are roughly the same.
+                if (snapType.HasFlagFast(SnapType.Grids) && DistanceSnapToggle.Value == TernaryState.True && distanceSnapGrid != null)
+                {
+                    (Vector2 distanceSnappedPosition, double distanceSnappedTime) = distanceSnapGrid.GetSnappedPosition(distanceSnapGrid.ToLocalSpace(snapResult.ScreenSpacePosition));
+                    if (Precision.AlmostEquals(distanceSnapGrid.ToScreenSpace(distanceSnappedPosition), snapResult.ScreenSpacePosition, 1))
+                        snapResult.Time = distanceSnappedTime;
+                }
+
                 return snapResult;
+            }
+
+            SnapResult result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
 
             if (snapType.HasFlagFast(SnapType.Grids))
             {
-                if (distanceSnapToggle.Value == TernaryState.True && distanceSnapGrid != null)
+                if (DistanceSnapToggle.Value == TernaryState.True && distanceSnapGrid != null)
                 {
                     (Vector2 pos, double time) = distanceSnapGrid.GetSnappedPosition(distanceSnapGrid.ToLocalSpace(screenSpacePosition));
-                    return new SnapResult(distanceSnapGrid.ToScreenSpace(pos), time, PlayfieldAtScreenSpacePosition(screenSpacePosition));
+
+                    result.ScreenSpacePosition = distanceSnapGrid.ToScreenSpace(pos);
+                    result.Time = time;
                 }
 
                 if (rectangularGridSnapToggle.Value == TernaryState.True)
                 {
-                    Vector2 pos = rectangularPositionSnapGrid.GetSnappedPosition(rectangularPositionSnapGrid.ToLocalSpace(screenSpacePosition));
+                    Vector2 pos = rectangularPositionSnapGrid.GetSnappedPosition(rectangularPositionSnapGrid.ToLocalSpace(result.ScreenSpacePosition));
-                    return new SnapResult(rectangularPositionSnapGrid.ToScreenSpace(pos), null, PlayfieldAtScreenSpacePosition(screenSpacePosition));
+
+                    result.ScreenSpacePosition = rectangularPositionSnapGrid.ToScreenSpace(pos);
                 }
             }
 
-            return base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
+            return result;
         }
 
         private bool snapToVisibleBlueprints(Vector2 screenSpacePosition, out SnapResult snapResult)
@@ -202,7 +221,7 @@ namespace osu.Game.Rulesets.Osu.Edit
             distanceSnapGridCache.Invalidate();
             distanceSnapGrid = null;
 
-            if (distanceSnapToggle.Value != TernaryState.True)
+            if (DistanceSnapToggle.Value != TernaryState.True)
                 return;
 
             switch (BlueprintContainer.CurrentTool)
@@ -229,6 +248,42 @@ namespace osu.Game.Rulesets.Osu.Edit
             }
         }
 
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.Repeat)
+                return false;
+
+            handleToggleViaKey(e);
+            return base.OnKeyDown(e);
+        }
+
+        protected override void OnKeyUp(KeyUpEvent e)
+        {
+            handleToggleViaKey(e);
+            base.OnKeyUp(e);
+        }
+
+        protected override bool AdjustDistanceSpacing(GlobalAction action, float amount)
+        {
+            // To allow better visualisation, ensure that the spacing grid is visible before adjusting.
+            DistanceSnapToggle.Value = TernaryState.True;
+
+            return base.AdjustDistanceSpacing(action, amount);
+        }
+
+        private bool gridSnapMomentary;
+
+        private void handleToggleViaKey(KeyboardEvent key)
+        {
+            bool shiftPressed = key.ShiftPressed;
+
+            if (shiftPressed != gridSnapMomentary)
+            {
+                gridSnapMomentary = shiftPressed;
+                rectangularGridSnapToggle.Value = rectangularGridSnapToggle.Value == TernaryState.False ? TernaryState.True : TernaryState.False;
+            }
+        }
+
         private DistanceSnapGrid createDistanceSnapGrid(IEnumerable<HitObject> selectedHitObjects)
         {
             if (BlueprintContainer.CurrentTool is SpinnerCompositionTool)

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

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override double ScoreMultiplier => 1;
         public override IconUsage? Icon { get; } = FontAwesome.Regular.Circle;
 
-        public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles) };
+        public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles), typeof(OsuModFreezeFrame) };
 
         [SettingSource("Initial size", "Change the initial size of the approach circle, relative to hit circles.", 0)]
         public BindableFloat Scale { get; } = new BindableFloat(4)

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

@@ -0,0 +1,89 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModFreezeFrame : Mod, IApplicableToDrawableHitObject, IApplicableToBeatmap
+    {
+        public override string Name => "Freeze Frame";
+
+        public override string Acronym => "FR";
+
+        public override double ScoreMultiplier => 1;
+
+        public override LocalisableString Description => "Burn the notes into your memory.";
+
+        //Alters the transforms of the approach circles, breaking the effects of these mods.
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModApproachDifferent) };
+
+        public override ModType Type => ModType.Fun;
+
+        //mod breaks normal approach circle preempt
+        private double originalPreempt;
+
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            var firstHitObject = beatmap.HitObjects.OfType<OsuHitObject>().FirstOrDefault();
+            if (firstHitObject == null)
+                return;
+
+            double lastNewComboTime = 0;
+
+            originalPreempt = firstHitObject.TimePreempt;
+
+            foreach (var obj in beatmap.HitObjects.OfType<OsuHitObject>())
+            {
+                if (obj.NewCombo) { lastNewComboTime = obj.StartTime; }
+
+                applyFadeInAdjustment(obj);
+            }
+
+            void applyFadeInAdjustment(OsuHitObject osuObject)
+            {
+                osuObject.TimePreempt += osuObject.StartTime - lastNewComboTime;
+
+                foreach (var nested in osuObject.NestedHitObjects.OfType<OsuHitObject>())
+                {
+                    switch (nested)
+                    {
+                        //SliderRepeat wont layer correctly if preempt is changed.
+                        case SliderRepeat:
+                            break;
+
+                        default:
+                            applyFadeInAdjustment(nested);
+                            break;
+                    }
+                }
+            }
+        }
+
+        public void ApplyToDrawableHitObject(DrawableHitObject drawableObject)
+        {
+            drawableObject.ApplyCustomUpdateState += (drawableHitObject, _) =>
+            {
+                if (drawableHitObject is not DrawableHitCircle drawableHitCircle) return;
+
+                var hitCircle = drawableHitCircle.HitObject;
+                var approachCircle = drawableHitCircle.ApproachCircle;
+
+                // Reapply scale, ensuring the AR isn't changed due to the new preempt.
+                approachCircle.ClearTransforms(targetMember: nameof(approachCircle.Scale));
+                approachCircle.ScaleTo(4 * (float)(hitCircle.TimePreempt / originalPreempt));
+
+                using (drawableHitCircle.ApproachCircle.BeginAbsoluteSequence(hitCircle.StartTime - hitCircle.TimePreempt))
+                    approachCircle.ScaleTo(1, hitCircle.TimePreempt).Then().Expire();
+            };
+        }
+    }
+}

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override LocalisableString Description => "It never gets boring!";
 
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModTarget)).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModTargetPractice)).ToArray();
 
         [SettingSource("Angle sharpness", "How sharp angles should be", SettingControlType = typeof(SettingsSlider<float>))]
         public BindableFloat AngleSharpness { get; } = new BindableFloat(7)

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

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Automation;
         public override LocalisableString Description => @"Spinners will be automatically completed.";
         public override double ScoreMultiplier => 0.9;
-        public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(OsuModAutopilot), typeof(OsuModTarget) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(OsuModAutopilot), typeof(OsuModTargetPractice) };
 
         public void ApplyToDrawableHitObject(DrawableHitObject hitObject)
         {

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.DifficultyIncrease;
         public override LocalisableString Description => @"Once you start a slider, follow precisely or get a miss.";
         public override double ScoreMultiplier => 1.0;
-        public override Type[] IncompatibleMods => new[] { typeof(ModClassic), typeof(OsuModTarget) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModClassic), typeof(OsuModTargetPractice) };
 
         public void ApplyToDrawableHitObject(DrawableHitObject drawable)
         {

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

@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]
         {
             typeof(OsuModAutopilot),
-            typeof(OsuModTarget),
+            typeof(OsuModTargetPractice),
         }).ToArray();
     }
 }

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

@@ -32,16 +32,15 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModTarget : ModWithVisibilityAdjustment, IApplicableToDrawableRuleset<OsuHitObject>,
+    public class OsuModTargetPractice : ModWithVisibilityAdjustment, IApplicableToDrawableRuleset<OsuHitObject>,
-                                IApplicableToHealthProcessor, IApplicableToDifficulty, IApplicableFailOverride,
+                                        IApplicableToHealthProcessor, IApplicableToDifficulty, IApplicableFailOverride, IHasSeed, IHidesApproachCircles
-                                IHasSeed, IHidesApproachCircles
     {
-        public override string Name => "Target";
+        public override string Name => "Target Practice";
         public override string Acronym => "TP";
         public override ModType Type => ModType.Conversion;
         public override IconUsage? Icon => OsuIcon.ModTarget;
         public override LocalisableString Description => @"Practice keeping up with the beat of the song.";
-        public override double ScoreMultiplier => 1;
+        public override double ScoreMultiplier => 0.1;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]
         {

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

@@ -102,8 +102,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             Size = HitArea.DrawSize;
 
-            PositionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            PositionBindable.BindValueChanged(_ => UpdatePosition());
-            StackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            StackHeightBindable.BindValueChanged(_ => UpdatePosition());
             ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue));
         }
 
@@ -134,6 +134,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
+        protected virtual void UpdatePosition()
+        {
+            Position = HitObject.StackedPosition;
+        }
+
         public override void Shake() => shakeContainer.Shake();
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)

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

@@ -79,7 +79,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public override void ApplyTransformsAt(double time, bool propagateChildren = false)
         {
             // For the same reasons as above w.r.t rewinding, we shouldn't propagate to children here either.
-            // ReSharper disable once RedundantArgumentDefaultValue - removing the "redundant" default value triggers BaseMethodCallWithDefaultParameter
+
+            // ReSharper disable once RedundantArgumentDefaultValue
             base.ApplyTransformsAt(time, false);
         }
 

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

@@ -6,7 +6,6 @@
 using System;
 using System.Diagnostics;
 using JetBrains.Annotations;
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -43,13 +42,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            PositionBindable.BindValueChanged(_ => updatePosition());
-            pathVersion.BindValueChanged(_ => updatePosition());
-        }
-
         protected override void OnFree()
         {
             base.OnFree();
@@ -57,6 +49,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             pathVersion.UnbindFrom(DrawableSlider.PathVersion);
         }
 
+        protected override void UpdatePosition()
+        {
+            // Slider head is always drawn at (0,0).
+        }
+
         protected override void OnApply()
         {
             base.OnApply();
@@ -100,11 +97,5 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.Shake();
             DrawableSlider.Shake();
         }
-
-        private void updatePosition()
-        {
-            if (Slider != null)
-                Position = HitObject.Position - Slider.Position;
-        }
     }
 }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -109,7 +109,7 @@ namespace osu.Game.Rulesets.Osu
                 yield return new OsuModSpunOut();
 
             if (mods.HasFlagFast(LegacyMods.Target))
-                yield return new OsuModTarget();
+                yield return new OsuModTargetPractice();
 
             if (mods.HasFlagFast(LegacyMods.TouchDevice))
                 yield return new OsuModTouchDevice();
@@ -131,7 +131,7 @@ namespace osu.Game.Rulesets.Osu
                         value |= LegacyMods.SpunOut;
                         break;
 
-                    case OsuModTarget:
+                    case OsuModTargetPractice:
                         value |= LegacyMods.Target;
                         break;
 
@@ -170,7 +170,7 @@ namespace osu.Game.Rulesets.Osu
                 case ModType.Conversion:
                     return new Mod[]
                     {
-                        new OsuModTarget(),
+                        new OsuModTargetPractice(),
                         new OsuModDifficultyAdjust(),
                         new OsuModClassic(),
                         new OsuModRandom(),
@@ -201,7 +201,8 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModMuted(),
                         new OsuModNoScope(),
                         new MultiMod(new OsuModMagnetised(), new OsuModRepel()),
-                        new ModAdaptiveSpeed()
+                        new ModAdaptiveSpeed(),
+                        new OsuModFreezeFrame()
                     };
 
                 case ModType.System:

osu.Game.Rulesets.Osu/Skinning/Argon/ArgonMainCirclePiece.cs

@@ -121,12 +121,16 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
                 innerGradient.Colour = ColourInfo.GradientVertical(colour.NewValue.Darken(0.5f), colour.NewValue.Darken(0.6f));
                 flash.Colour = colour.NewValue;
 
-                updateStateTransforms(drawableObject, drawableObject.State.Value);
+                // Accent colour may be changed many times during a paused gameplay state.
+                // Schedule the change to avoid transforms piling up.
+                Scheduler.AddOnce(updateStateTransforms);
             }, true);
 
             drawableObject.ApplyCustomUpdateState += updateStateTransforms;
         }
 
+        private void updateStateTransforms() => updateStateTransforms(drawableObject, drawableObject.State.Value);
+
         private void updateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state)
         {
             using (BeginAbsoluteSequence(drawableObject.HitStateUpdateTime))
@@ -171,7 +175,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
                         // This is to give it a bomb-like effect, with the border "triggering" its animation when getting close.
                         using (BeginDelayedSequence(flash_in_duration / 12))
                         {
-                            outerGradient.ResizeTo(outerGradient.Size * shrink_size, resize_duration, Easing.OutElasticHalf);
+                            outerGradient.ResizeTo(OUTER_GRADIENT_SIZE * shrink_size, resize_duration, Easing.OutElasticHalf);
                             outerGradient
                                 .FadeColour(Color4.White, 80)
                                 .Then()

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyMainCirclePiece.cs

@@ -68,7 +68,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
             InternalChildren = new[]
             {
-                CircleSprite = new KiaiFlashingDrawable(() => new Sprite { Texture = skin.GetTexture(circleName) })
+                CircleSprite = new LegacyKiaiFlashingDrawable(() => new Sprite { Texture = skin.GetTexture(circleName) })
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Child = OverlaySprite = new KiaiFlashingDrawable(() => skin.GetAnimation(@$"{circleName}overlay", true, true, frameLength: 1000 / 2d))
+                    Child = OverlaySprite = new LegacyKiaiFlashingDrawable(() => skin.GetAnimation(@$"{circleName}overlay", true, true, frameLength: 1000 / 2d))
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,

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

@@ -1,8 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Game.Rulesets.Taiko.Mods;
+using osu.Game.Rulesets.Taiko.UI;
+using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.Tests.Mods
 {
@@ -16,5 +20,37 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods
 
         [Test]
         public void TestComboBasedSize([Values] bool comboBasedSize) => CreateModTest(new ModTestData { Mod = new TaikoModFlashlight { ComboBasedSize = { Value = comboBasedSize } }, PassCondition = () => true });
+
+        [Test]
+        public void TestFlashlightAlwaysHasNonZeroSize()
+        {
+            bool failed = false;
+
+            CreateModTest(new ModTestData
+            {
+                Mod = new TestTaikoModFlashlight { ComboBasedSize = { Value = true } },
+                Autoplay = false,
+                PassCondition = () =>
+                {
+                    failed |= this.ChildrenOfType<TestTaikoModFlashlight.TestTaikoFlashlight>().SingleOrDefault()?.FlashlightSize.Y == 0;
+                    return !failed;
+                }
+            });
+        }
+
+        private class TestTaikoModFlashlight : TaikoModFlashlight
+        {
+            protected override Flashlight CreateFlashlight() => new TestTaikoFlashlight(this, Playfield);
+
+            public class TestTaikoFlashlight : TaikoFlashlight
+            {
+                public TestTaikoFlashlight(TaikoModFlashlight modFlashlight, TaikoPlayfield taikoPlayfield)
+                    : base(modFlashlight, taikoPlayfield)
+                {
+                }
+
+                public new Vector2 FlashlightSize => base.FlashlightSize;
+            }
+        }
     }
 }

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

@@ -25,8 +25,8 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
             TimeRange = { Value = 5000 },
         };
 
-        [BackgroundDependencyLoader]
+        [Test]
-        private void load()
+        public void DrumrollTest()
         {
             AddStep("Drum roll", () => SetContents(_ =>
             {

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

@@ -0,0 +1,30 @@
+// 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.ControlPoints;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Skinning
+{
+    [TestFixture]
+    public class TestSceneDrawableDrumRollKiai : TestSceneDrawableDrumRoll
+    {
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            var controlPointInfo = new ControlPointInfo();
+
+            controlPointInfo.Add(0, new TimingControlPoint { BeatLength = 500 });
+            controlPointInfo.Add(0, new EffectControlPoint { KiaiMode = true });
+
+            Beatmap.Value = CreateWorkingBeatmap(new Beatmap
+            {
+                ControlPointInfo = controlPointInfo
+            });
+
+            // track needs to be playing for BeatSyncedContainer to work.
+            Beatmap.Value.Track.Start();
+        });
+    }
+}

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

@@ -4,7 +4,6 @@
 #nullable disable
 
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -16,8 +15,8 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
     [TestFixture]
     public class TestSceneDrawableHit : TaikoSkinnableTestScene
     {
-        [BackgroundDependencyLoader]
+        [Test]
-        private void load()
+        public void TestHits()
         {
             AddStep("Centre hit", () => SetContents(_ => new DrawableHit(createHitAtCurrentTime())
             {
@@ -31,23 +30,24 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
                 Origin = Anchor.Centre,
             }));
 
-            AddStep("Rim hit", () => SetContents(_ => new DrawableHit(createHitAtCurrentTime())
+            AddStep("Rim hit", () => SetContents(_ => new DrawableHit(createHitAtCurrentTime(rim: true))
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             }));
 
-            AddStep("Rim hit (strong)", () => SetContents(_ => new DrawableHit(createHitAtCurrentTime(true))
+            AddStep("Rim hit (strong)", () => SetContents(_ => new DrawableHit(createHitAtCurrentTime(true, true))
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             }));
         }
 
-        private Hit createHitAtCurrentTime(bool strong = false)
+        private Hit createHitAtCurrentTime(bool strong = false, bool rim = false)
         {
             var hit = new Hit
             {
+                Type = rim ? HitType.Rim : HitType.Centre,
                 IsStrong = strong,
                 StartTime = Time.Current + 3000,
             };

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

@@ -0,0 +1,30 @@
+// 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.Beatmaps.ControlPoints;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Skinning
+{
+    [TestFixture]
+    public class TestSceneDrawableHitKiai : TestSceneDrawableHit
+    {
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            var controlPointInfo = new ControlPointInfo();
+
+            controlPointInfo.Add(0, new TimingControlPoint { BeatLength = 500 });
+            controlPointInfo.Add(0, new EffectControlPoint { KiaiMode = true });
+
+            Beatmap.Value = CreateWorkingBeatmap(new Beatmap
+            {
+                ControlPointInfo = controlPointInfo
+            });
+
+            // track needs to be playing for BeatSyncedContainer to work.
+            Beatmap.Value.Track.Start();
+        });
+    }
+}

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

@@ -13,6 +13,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.UI;
+using osu.Game.Screens.Ranking;
 
 namespace osu.Game.Rulesets.Taiko.Tests.Skinning
 {
@@ -49,12 +50,20 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
                     // the hit needs to be added to hierarchy in order for nested objects to be created correctly.
                     // setting zero alpha is supposed to prevent the test from looking broken.
                     hit.With(h => h.Alpha = 0),
+
+                    new AspectContainer
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Child =
                             new HitExplosion(hit.Type)
                             {
                                 Anchor = Anchor.Centre,
                                 Origin = Anchor.Centre,
                             }.With(explosion => explosion.Apply(hit))
                     }
+                }
             };
         }
 

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

@@ -57,6 +57,28 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
 
             Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original, cancellationToken);
 
+            if (original.BeatmapInfo.Ruleset.OnlineID == 0)
+            {
+                // Post processing step to transform standard slider velocity changes into scroll speed changes
+                double lastScrollSpeed = 1;
+
+                foreach (HitObject hitObject in original.HitObjects)
+                {
+                    double nextScrollSpeed = hitObject.DifficultyControlPoint.SliderVelocity;
+                    EffectControlPoint currentEffectPoint = converted.ControlPointInfo.EffectPointAt(hitObject.StartTime);
+
+                    if (!Precision.AlmostEquals(lastScrollSpeed, nextScrollSpeed, acceptableDifference: currentEffectPoint.ScrollSpeedBindable.Precision))
+                    {
+                        converted.ControlPointInfo.Add(hitObject.StartTime, new EffectControlPoint
+                        {
+                            KiaiMode = currentEffectPoint.KiaiMode,
+                            OmitFirstBarLine = currentEffectPoint.OmitFirstBarLine,
+                            ScrollSpeed = lastScrollSpeed = nextScrollSpeed,
+                        });
+                    }
+                }
+            }
+
             if (original.BeatmapInfo.Ruleset.OnlineID == 3)
             {
                 // Post processing step to transform mania hit objects with the same start time into strong hits

osu.Game.Rulesets.Taiko/Edit/Blueprints/HitPlacementBlueprint.cs

@@ -27,6 +27,12 @@ namespace osu.Game.Rulesets.Taiko.Edit.Blueprints
             };
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            BeginPlacement();
+        }
+
         protected override bool OnMouseDown(MouseDownEvent e)
         {
             switch (e.Button)

osu.Game.Rulesets.Taiko/Edit/Blueprints/TaikoSpanPlacementBlueprint.cs

@@ -52,6 +52,12 @@ namespace osu.Game.Rulesets.Taiko.Edit.Blueprints
         private double originalStartTime;
         private Vector2 originalPosition;
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            BeginPlacement();
+        }
+
         protected override bool OnMouseDown(MouseDownEvent e)
         {
             if (e.Button != MouseButton.Left)

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Collections.Generic;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;

osu.Game.Rulesets.Taiko/Mods/TaikoModFlashlight.cs

@@ -27,17 +27,17 @@ namespace osu.Game.Rulesets.Taiko.Mods
 
         public override float DefaultFlashlightSize => 200;
 
-        protected override Flashlight CreateFlashlight() => new TaikoFlashlight(this, playfield);
+        protected override Flashlight CreateFlashlight() => new TaikoFlashlight(this, Playfield);
 
-        private TaikoPlayfield playfield = null!;
+        protected TaikoPlayfield Playfield { get; private set; } = null!;
 
         public override void ApplyToDrawableRuleset(DrawableRuleset<TaikoHitObject> drawableRuleset)
         {
-            playfield = (TaikoPlayfield)drawableRuleset.Playfield;
+            Playfield = (TaikoPlayfield)drawableRuleset.Playfield;
             base.ApplyToDrawableRuleset(drawableRuleset);
         }
 
-        private class TaikoFlashlight : Flashlight
+        public class TaikoFlashlight : Flashlight
         {
             private readonly LayoutValue flashlightProperties = new LayoutValue(Invalidation.RequiredParentSizeToFit | Invalidation.DrawInfo);
             private readonly TaikoPlayfield taikoPlayfield;
@@ -47,21 +47,28 @@ namespace osu.Game.Rulesets.Taiko.Mods
             {
                 this.taikoPlayfield = taikoPlayfield;
 
-                FlashlightSize = adjustSize(GetSize());
+                FlashlightSize = adjustSizeForPlayfieldAspectRatio(GetSize());
                 FlashlightSmoothness = 1.4f;
 
                 AddLayout(flashlightProperties);
             }
 
-            private Vector2 adjustSize(float size)
+            /// <summary>
+            /// Returns the aspect ratio-adjusted size of the flashlight.
+            /// This ensures that the size of the flashlight remains independent of taiko-specific aspect ratio adjustments.
+            /// </summary>
+            /// <param name="size">
+            /// The size of the flashlight.
+            /// The value provided here should always come from <see cref="ModFlashlight{T}.Flashlight.GetSize"/>.
+            /// </param>
+            private Vector2 adjustSizeForPlayfieldAspectRatio(float size)
             {
-                // Preserve flashlight size through the playfield's aspect adjustment.
                 return new Vector2(0, size * taikoPlayfield.DrawHeight / TaikoPlayfield.DEFAULT_HEIGHT);
             }
 
             protected override void UpdateFlashlightSize(float size)
             {
-                this.TransformTo(nameof(FlashlightSize), adjustSize(size), FLASHLIGHT_FADE_DURATION);
+                this.TransformTo(nameof(FlashlightSize), adjustSizeForPlayfieldAspectRatio(size), FLASHLIGHT_FADE_DURATION);
             }
 
             protected override string FragmentShader => "CircularFlashlight";
@@ -75,7 +82,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
                     FlashlightPosition = ToLocalSpace(taikoPlayfield.HitTarget.ScreenSpaceDrawQuad.Centre);
 
                     ClearTransforms(targetMember: nameof(FlashlightSize));
-                    FlashlightSize = adjustSize(Combo.Value);
+                    FlashlightSize = adjustSizeForPlayfieldAspectRatio(GetSize());
 
                     flashlightProperties.Validate();
                 }

osu.Game.Rulesets.Taiko/Skinning/Default/CentreHitCirclePiece.cs

@@ -41,12 +41,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Default
 
                 Children = new[]
                 {
-                    new CircularContainer
+                    new Circle { RelativeSizeAxes = Axes.Both }
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Masking = true,
-                        Children = new[] { new Box { RelativeSizeAxes = Axes.Both } }
-                    }
                 };
             }
         }

osu.Game.Rulesets.Taiko/Skinning/Default/CirclePiece.cs

@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -13,6 +14,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Objects;
 using osuTK.Graphics;
 
@@ -32,6 +34,8 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Default
 
         private const double pre_beat_transition_time = 80;
 
+        private const float flash_opacity = 0.3f;
+
         private Color4 accentColour;
 
         /// <summary>
@@ -152,11 +156,22 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Default
             };
         }
 
+        [Resolved]
+        private DrawableHitObject drawableHitObject { get; set; }
+
         protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
         {
             if (!effectPoint.KiaiMode)
                 return;
 
+            if (drawableHitObject.State.Value == ArmedState.Idle)
+            {
+                FlashBox
+                    .FadeTo(flash_opacity)
+                    .Then()
+                    .FadeOut(timingPoint.BeatLength * 0.75, Easing.OutSine);
+            }
+
             if (beatIndex % timingPoint.TimeSignature.Numerator != 0)
                 return;
 

osu.Game.Rulesets.Taiko/Skinning/Default/DefaultHitExplosion.cs

@@ -1,9 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
-using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -12,19 +9,19 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.UI;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Taiko.UI
+namespace osu.Game.Rulesets.Taiko.Skinning.Default
 {
     internal class DefaultHitExplosion : CircularContainer, IAnimatableHitExplosion
     {
         private readonly HitResult result;
 
-        [CanBeNull]
+        private Box? body;
-        private Box body;
 
         [Resolved]
-        private OsuColour colours { get; set; }
+        private OsuColour colours { get; set; } = null!;
 
         public DefaultHitExplosion(HitResult result)
         {
@@ -58,7 +55,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             updateColour();
         }
 
-        private void updateColour([CanBeNull] DrawableHitObject judgedObject = null)
+        private void updateColour(DrawableHitObject? judgedObject = null)
         {
             if (body == null)
                 return;

osu.Game.Rulesets.Taiko/Skinning/Default/DefaultInputDrum.cs

@@ -0,0 +1,181 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable disable
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Screens.Ranking;
+using osuTK;
+
+namespace osu.Game.Rulesets.Taiko.Skinning.Default
+{
+    public class DefaultInputDrum : AspectContainer
+    {
+        public DefaultInputDrum()
+        {
+            RelativeSizeAxes = Axes.Y;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            const float middle_split = 0.025f;
+
+            InternalChild = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Scale = new Vector2(0.9f),
+                Children = new[]
+                {
+                    new TaikoHalfDrum(false)
+                    {
+                        Name = "Left Half",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.CentreRight,
+                        RelativeSizeAxes = Axes.Both,
+                        RelativePositionAxes = Axes.X,
+                        X = -middle_split / 2,
+                        RimAction = TaikoAction.LeftRim,
+                        CentreAction = TaikoAction.LeftCentre
+                    },
+                    new TaikoHalfDrum(true)
+                    {
+                        Name = "Right Half",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.CentreLeft,
+                        RelativeSizeAxes = Axes.Both,
+                        RelativePositionAxes = Axes.X,
+                        X = middle_split / 2,
+                        RimAction = TaikoAction.RightRim,
+                        CentreAction = TaikoAction.RightCentre
+                    }
+                }
+            };
+        }
+
+        /// <summary>
+        /// A half-drum. Contains one centre and one rim hit.
+        /// </summary>
+        private class TaikoHalfDrum : Container, IKeyBindingHandler<TaikoAction>
+        {
+            /// <summary>
+            /// The key to be used for the rim of the half-drum.
+            /// </summary>
+            public TaikoAction RimAction;
+
+            /// <summary>
+            /// The key to be used for the centre of the half-drum.
+            /// </summary>
+            public TaikoAction CentreAction;
+
+            private readonly Sprite rim;
+            private readonly Sprite rimHit;
+            private readonly Sprite centre;
+            private readonly Sprite centreHit;
+
+            public TaikoHalfDrum(bool flipped)
+            {
+                Masking = true;
+
+                Children = new Drawable[]
+                {
+                    rim = new Sprite
+                    {
+                        Anchor = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both
+                    },
+                    rimHit = new Sprite
+                    {
+                        Anchor = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0,
+                        Blending = BlendingParameters.Additive,
+                    },
+                    centre = new Sprite
+                    {
+                        Anchor = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
+                        Size = new Vector2(0.7f)
+                    },
+                    centreHit = new Sprite
+                    {
+                        Anchor = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
+                        Size = new Vector2(0.7f),
+                        Alpha = 0,
+                        Blending = BlendingParameters.Additive
+                    }
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures, OsuColour colours)
+            {
+                rim.Texture = textures.Get(@"Gameplay/taiko/taiko-drum-outer");
+                rimHit.Texture = textures.Get(@"Gameplay/taiko/taiko-drum-outer-hit");
+                centre.Texture = textures.Get(@"Gameplay/taiko/taiko-drum-inner");
+                centreHit.Texture = textures.Get(@"Gameplay/taiko/taiko-drum-inner-hit");
+
+                rimHit.Colour = colours.Blue;
+                centreHit.Colour = colours.Pink;
+            }
+
+            public bool OnPressed(KeyBindingPressEvent<TaikoAction> e)
+            {
+                Drawable target = null;
+                Drawable back = null;
+
+                if (e.Action == CentreAction)
+                {
+                    target = centreHit;
+                    back = centre;
+                }
+                else if (e.Action == RimAction)
+                {
+                    target = rimHit;
+                    back = rim;
+                }
+
+                if (target != null)
+                {
+                    const float scale_amount = 0.05f;
+                    const float alpha_amount = 0.5f;
+
+                    const float down_time = 40;
+                    const float up_time = 1000;
+
+                    back.ScaleTo(target.Scale.X - scale_amount, down_time, Easing.OutQuint)
+                        .Then()
+                        .ScaleTo(1, up_time, Easing.OutQuint);
+
+                    target.Animate(
+                        t => t.ScaleTo(target.Scale.X - scale_amount, down_time, Easing.OutQuint),
+                        t => t.FadeTo(Math.Min(target.Alpha + alpha_amount, 1), down_time, Easing.OutQuint)
+                    ).Then(
+                        t => t.ScaleTo(1, up_time, Easing.OutQuint),
+                        t => t.FadeOut(up_time, Easing.OutQuint)
+                    );
+                }
+
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<TaikoAction> e)
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Skinning/Default/DefaultKiaiHitExplosion.cs

@@ -1,9 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
-using osuTK;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -11,8 +8,9 @@ using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Objects;
+using osuTK;
 
-namespace osu.Game.Rulesets.Taiko.UI
+namespace osu.Game.Rulesets.Taiko.Skinning.Default
 {
     public class DefaultKiaiHitExplosion : CircularContainer
     {

osu.Game.Rulesets.Taiko/Skinning/Default/ElongatedCirclePiece.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Graphics;

osu.Game.Rulesets.Taiko/Skinning/Default/RimHitCirclePiece.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;

osu.Game.Rulesets.Taiko/Skinning/Default/SwellSymbolPiece.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;

osu.Game.Rulesets.Taiko/Skinning/Default/TickPiece.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyCirclePiece.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
@@ -19,7 +17,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 {
     public class LegacyCirclePiece : CompositeDrawable, IHasAccentColour
     {
-        private Drawable backgroundLayer;
+        private Drawable backgroundLayer = null!;
 
         // required for editor blueprints (not sure why these circle pieces are zero size).
         public override Quad ScreenSpaceDrawQuad => backgroundLayer.ScreenSpaceDrawQuad;
@@ -32,7 +30,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, DrawableHitObject drawableHitObject)
         {
-            Drawable getDrawableFor(string lookup)
+            Drawable? getDrawableFor(string lookup)
             {
                 const string normal_hit = "taikohit";
                 const string big_hit = "taikobig";
@@ -45,7 +43,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
             }
 
             // backgroundLayer is guaranteed to exist due to the pre-check in TaikoLegacySkinTransformer.
-            AddInternal(backgroundLayer = getDrawableFor("circle"));
+            AddInternal(backgroundLayer = new LegacyKiaiFlashingDrawable(() => getDrawableFor("circle")));
 
             var foregroundLayer = getDrawableFor("circleoverlay");
             if (foregroundLayer != null)

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyDrumRoll.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -28,11 +26,11 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
             }
         }
 
-        private LegacyCirclePiece headCircle;
+        private LegacyCirclePiece headCircle = null!;
 
-        private Sprite body;
+        private Sprite body = null!;
 
-        private Sprite tailCircle;
+        private Sprite tailCircle = null!;
 
         public LegacyDrumRoll()
         {

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyHit.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Game.Skinning;
 using osuTK.Graphics;

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyHitExplosion.cs

@@ -1,9 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
-using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
@@ -17,8 +14,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
     {
         private readonly Drawable sprite;
 
-        [CanBeNull]
+        private readonly Drawable? strongSprite;
-        private readonly Drawable strongSprite;
 
         /// <summary>
         /// Creates a new legacy hit explosion.
@@ -29,7 +25,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
         /// </remarks>
         /// <param name="sprite">The normal legacy explosion sprite.</param>
         /// <param name="strongSprite">The strong legacy explosion sprite.</param>
-        public LegacyHitExplosion(Drawable sprite, [CanBeNull] Drawable strongSprite = null)
+        public LegacyHitExplosion(Drawable sprite, Drawable? strongSprite = null)
         {
             this.sprite = sprite;
             this.strongSprite = strongSprite;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -20,9 +18,9 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
     /// </summary>
     internal class LegacyInputDrum : Container
     {
-        private Container content;
+        private Container content = null!;
-        private LegacyHalfDrum left;
+        private LegacyHalfDrum left = null!;
-        private LegacyHalfDrum right;
+        private LegacyHalfDrum right = null!;
 
         public LegacyInputDrum()
         {
@@ -142,7 +140,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 
             public bool OnPressed(KeyBindingPressEvent<TaikoAction> e)
             {
-                Drawable target = null;
+                Drawable? target = null;
 
                 if (e.Action == CentreAction)
                 {

osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyTaikoScroller.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -27,7 +25,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(GameplayState gameplayState)
+        private void load(GameplayState? gameplayState)
         {
             if (gameplayState != null)
                 ((IBindable<JudgementResult>)LastResult).BindTo(gameplayState.LastJudgementResult);
@@ -91,8 +89,8 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 
         private class ScrollerSprite : CompositeDrawable
         {
-            private Sprite passingSprite;
+            private Sprite passingSprite = null!;
-            private Sprite failingSprite;
+            private Sprite failingSprite = null!;
 
             private bool passing = true;
 

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -15,7 +13,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 {
     public class TaikoLegacyHitTarget : CompositeDrawable
     {
-        private Container content;
+        private Container content = null!;
 
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin)

osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacyPlayfieldBackgroundRight.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics;
@@ -16,7 +14,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 {
     public class TaikoLegacyPlayfieldBackgroundRight : BeatSyncedContainer
     {
-        private Sprite kiai;
+        private Sprite kiai = null!;
 
         private bool kiaiDisplayed;
 

osu.Game.Rulesets.Taiko/TaikoSkinComponent.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko

osu.Game.Rulesets.Taiko/TaikoSkinComponents.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 namespace osu.Game.Rulesets.Taiko
 {
     public enum TaikoSkinComponents

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Objects.Drawables;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
@@ -24,7 +22,8 @@ namespace osu.Game.Rulesets.Taiko.UI
         public readonly Bindable<JudgementResult> LastResult;
 
         private readonly Dictionary<TaikoMascotAnimationState, TaikoMascotAnimation> animations;
-        private TaikoMascotAnimation currentAnimation;
+
+        private TaikoMascotAnimation? currentAnimation;
 
         private bool lastObjectHit = true;
         private bool kiaiMode;
@@ -40,7 +39,7 @@ namespace osu.Game.Rulesets.Taiko.UI
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(GameplayState gameplayState)
+        private void load(GameplayState? gameplayState)
         {
             InternalChildren = new[]
             {

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using osu.Game.Audio;
 using osu.Game.Rulesets.Taiko.Objects;

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

@@ -1,10 +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.
 
-#nullable disable
-
 using System;
-using JetBrains.Annotations;
 using osuTK;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -13,6 +10,7 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.UI
@@ -29,10 +27,9 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         private double? secondHitTime;
 
-        [CanBeNull]
+        public DrawableHitObject? JudgedObject;
-        public DrawableHitObject JudgedObject;
 
-        private SkinnableDrawable skinnable;
+        private SkinnableDrawable skinnable = null!;
 
         /// <summary>
         /// This constructor only exists to meet the <c>new()</c> type constraint of <see cref="DrawablePool{T}"/>.
@@ -62,7 +59,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             skinnable.OnSkinChanged += runAnimation;
         }
 
-        public void Apply([CanBeNull] DrawableHitObject drawableHitObject)
+        public void Apply(DrawableHitObject? drawableHitObject)
         {
             JudgedObject = drawableHitObject;
             secondHitTime = null;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Graphics.Pooling;
 using osu.Game.Rulesets.Scoring;
 

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Taiko.UI

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

@@ -1,20 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
-using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Taiko.Skinning.Default;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.Bindings;
-using osu.Framework.Input.Events;
-using osu.Game.Graphics;
-using osu.Game.Screens.Ranking;
 using osu.Game.Skinning;
-using osuTK;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
@@ -23,8 +14,6 @@ namespace osu.Game.Rulesets.Taiko.UI
     /// </summary>
     internal class InputDrum : Container
     {
-        private const float middle_split = 0.025f;
-
         public InputDrum()
         {
             AutoSizeAxes = Axes.X;
@@ -43,166 +32,5 @@ namespace osu.Game.Rulesets.Taiko.UI
                 },
             };
         }
-
-        private class DefaultInputDrum : AspectContainer
-        {
-            public DefaultInputDrum()
-            {
-                RelativeSizeAxes = Axes.Y;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                InternalChild = new Container
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Scale = new Vector2(0.9f),
-                    Children = new[]
-                    {
-                        new TaikoHalfDrum(false)
-                        {
-                            Name = "Left Half",
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.CentreRight,
-                            RelativeSizeAxes = Axes.Both,
-                            RelativePositionAxes = Axes.X,
-                            X = -middle_split / 2,
-                            RimAction = TaikoAction.LeftRim,
-                            CentreAction = TaikoAction.LeftCentre
-                        },
-                        new TaikoHalfDrum(true)
-                        {
-                            Name = "Right Half",
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.CentreLeft,
-                            RelativeSizeAxes = Axes.Both,
-                            RelativePositionAxes = Axes.X,
-                            X = middle_split / 2,
-                            RimAction = TaikoAction.RightRim,
-                            CentreAction = TaikoAction.RightCentre
-                        }
-                    }
-                };
-            }
-
-            /// <summary>
-            /// A half-drum. Contains one centre and one rim hit.
-            /// </summary>
-            private class TaikoHalfDrum : Container, IKeyBindingHandler<TaikoAction>
-            {
-                /// <summary>
-                /// The key to be used for the rim of the half-drum.
-                /// </summary>
-                public TaikoAction RimAction;
-
-                /// <summary>
-                /// The key to be used for the centre of the half-drum.
-                /// </summary>
-                public TaikoAction CentreAction;
-
-                private readonly Sprite rim;
-                private readonly Sprite rimHit;
-                private readonly Sprite centre;
-                private readonly Sprite centreHit;
-
-                public TaikoHalfDrum(bool flipped)
-                {
-                    Masking = true;
-
-                    Children = new Drawable[]
-                    {
-                        rim = new Sprite
-                        {
-                            Anchor = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
-                            Origin = Anchor.Centre,
-                            RelativeSizeAxes = Axes.Both
-                        },
-                        rimHit = new Sprite
-                        {
-                            Anchor = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
-                            Origin = Anchor.Centre,
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0,
-                            Blending = BlendingParameters.Additive,
-                        },
-                        centre = new Sprite
-                        {
-                            Anchor = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
-                            Origin = Anchor.Centre,
-                            RelativeSizeAxes = Axes.Both,
-                            Size = new Vector2(0.7f)
-                        },
-                        centreHit = new Sprite
-                        {
-                            Anchor = flipped ? Anchor.CentreLeft : Anchor.CentreRight,
-                            Origin = Anchor.Centre,
-                            RelativeSizeAxes = Axes.Both,
-                            Size = new Vector2(0.7f),
-                            Alpha = 0,
-                            Blending = BlendingParameters.Additive
-                        }
-                    };
-                }
-
-                [BackgroundDependencyLoader]
-                private void load(TextureStore textures, OsuColour colours)
-                {
-                    rim.Texture = textures.Get(@"Gameplay/taiko/taiko-drum-outer");
-                    rimHit.Texture = textures.Get(@"Gameplay/taiko/taiko-drum-outer-hit");
-                    centre.Texture = textures.Get(@"Gameplay/taiko/taiko-drum-inner");
-                    centreHit.Texture = textures.Get(@"Gameplay/taiko/taiko-drum-inner-hit");
-
-                    rimHit.Colour = colours.Blue;
-                    centreHit.Colour = colours.Pink;
-                }
-
-                public bool OnPressed(KeyBindingPressEvent<TaikoAction> e)
-                {
-                    Drawable target = null;
-                    Drawable back = null;
-
-                    if (e.Action == CentreAction)
-                    {
-                        target = centreHit;
-                        back = centre;
-                    }
-                    else if (e.Action == RimAction)
-                    {
-                        target = rimHit;
-                        back = rim;
-                    }
-
-                    if (target != null)
-                    {
-                        const float scale_amount = 0.05f;
-                        const float alpha_amount = 0.5f;
-
-                        const float down_time = 40;
-                        const float up_time = 1000;
-
-                        back.ScaleTo(target.Scale.X - scale_amount, down_time, Easing.OutQuint)
-                            .Then()
-                            .ScaleTo(1, up_time, Easing.OutQuint);
-
-                        target.Animate(
-                            t => t.ScaleTo(target.Scale.X - scale_amount, down_time, Easing.OutQuint),
-                            t => t.FadeTo(Math.Min(target.Alpha + alpha_amount, 1), down_time, Easing.OutQuint)
-                        ).Then(
-                            t => t.ScaleTo(1, up_time, Easing.OutQuint),
-                            t => t.FadeOut(up_time, Easing.OutQuint)
-                        );
-                    }
-
-                    return false;
-                }
-
-                public void OnReleased(KeyBindingReleaseEvent<TaikoAction> e)
-                {
-                }
-            }
-        }
     }
 }

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

@@ -1,13 +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.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Skinning;
 using osuTK;
 
@@ -22,7 +21,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         private readonly HitType hitType;
 
-        private SkinnableDrawable skinnable;
+        private SkinnableDrawable skinnable = null!;
 
         public override double LifetimeStart => skinnable.Drawable.LifetimeStart;
 

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Graphics;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
@@ -89,7 +87,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             [BackgroundDependencyLoader]
             private void load(ISkinSource source)
             {
-                ISkin skin = source.FindProvider(s => getAnimationFrame(s, state, 0) != null);
+                ISkin? skin = source.FindProvider(s => getAnimationFrame(s, state, 0) != null);
 
                 if (skin == null) return;
 
@@ -120,7 +118,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             [BackgroundDependencyLoader]
             private void load(ISkinSource source)
             {
-                ISkin skin = source.FindProvider(s => getAnimationFrame(s, TaikoMascotAnimationState.Clear, 0) != null);
+                ISkin? skin = source.FindProvider(s => getAnimationFrame(s, TaikoMascotAnimationState.Clear, 0) != null);
 
                 if (skin == null) return;
 
@@ -137,7 +135,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             }
         }
 
-        private static Texture getAnimationFrame(ISkin skin, TaikoMascotAnimationState state, int frameIndex)
+        private static Texture? getAnimationFrame(ISkin skin, TaikoMascotAnimationState state, int frameIndex)
         {
             var texture = skin.GetTexture($"pippidon{state.ToString().ToLowerInvariant()}{frameIndex}");
 

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 namespace osu.Game.Rulesets.Taiko.UI
 {
     public enum TaikoMascotAnimationState

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Collections.Generic;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Taiko.Replays;

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

@@ -188,7 +188,7 @@ namespace osu.Game.Tests.Collections.IO
             }
 
             // Name matches the automatically chosen name from `CleanRunHeadlessGameHost` above, so we end up using the same storage location.
-            using (HeadlessGameHost host = new TestRunHeadlessGameHost(firstRunName, null))
+            using (HeadlessGameHost host = new TestRunHeadlessGameHost(firstRunName))
             {
                 try
                 {

osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs

@@ -7,6 +7,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
@@ -66,12 +67,25 @@ namespace osu.Game.Tests.Editing
         {
             AddStep($"set slider multiplier = {multiplier}", () => composer.EditorBeatmap.Difficulty.SliderMultiplier = multiplier);
 
-            assertSnapDistance(100 * multiplier);
+            assertSnapDistance(100 * multiplier, null, true);
         }
 
         [TestCase(1)]
         [TestCase(2)]
-        public void TestSpeedMultiplier(float multiplier)
+        public void TestSpeedMultiplierDoesNotChangeDistanceSnap(float multiplier)
+        {
+            assertSnapDistance(100, new HitObject
+            {
+                DifficultyControlPoint = new DifficultyControlPoint
+                {
+                    SliderVelocity = multiplier
+                }
+            }, false);
+        }
+
+        [TestCase(1)]
+        [TestCase(2)]
+        public void TestSpeedMultiplierDoesChangeDistanceSnap(float multiplier)
         {
             assertSnapDistance(100 * multiplier, new HitObject
             {
@@ -79,7 +93,7 @@ namespace osu.Game.Tests.Editing
                 {
                     SliderVelocity = multiplier
                 }
-            });
+            }, true);
         }
 
         [TestCase(1)]
@@ -88,7 +102,32 @@ namespace osu.Game.Tests.Editing
         {
             AddStep($"set divisor = {divisor}", () => BeatDivisor.Value = divisor);
 
-            assertSnapDistance(100f / divisor);
+            assertSnapDistance(100f / divisor, null, true);
+        }
+
+        /// <summary>
+        /// The basic distance-duration functions should always include slider velocity of the reference object.
+        /// </summary>
+        [Test]
+        public void TestConversionsWithSliderVelocity()
+        {
+            const float base_distance = 100;
+            const float slider_velocity = 1.2f;
+
+            var referenceObject = new HitObject
+            {
+                DifficultyControlPoint = new DifficultyControlPoint
+                {
+                    SliderVelocity = slider_velocity
+                }
+            };
+
+            assertSnapDistance(base_distance * slider_velocity, referenceObject, true);
+            assertSnappedDistance(base_distance * slider_velocity + 10, base_distance * slider_velocity, referenceObject);
+            assertSnappedDuration(base_distance * slider_velocity + 10, 1000, referenceObject);
+
+            assertDistanceToDuration(base_distance * slider_velocity, 1000, referenceObject);
+            assertDurationToDistance(1000, base_distance * slider_velocity, referenceObject);
         }
 
         [Test]
@@ -197,20 +236,20 @@ namespace osu.Game.Tests.Editing
             assertSnappedDistance(400, 400);
         }
 
-        private void assertSnapDistance(float expectedDistance, HitObject? hitObject = null)
+        private void assertSnapDistance(float expectedDistance, HitObject? referenceObject, bool includeSliderVelocity)
-            => AddAssert($"distance is {expectedDistance}", () => composer.GetBeatSnapDistanceAt(hitObject ?? new HitObject()), () => Is.EqualTo(expectedDistance));
+            => AddAssert($"distance is {expectedDistance}", () => composer.GetBeatSnapDistanceAt(referenceObject ?? new HitObject(), includeSliderVelocity), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
-        private void assertDurationToDistance(double duration, float expectedDistance)
+        private void assertDurationToDistance(double duration, float expectedDistance, HitObject? referenceObject = null)
-            => AddAssert($"duration = {duration} -> distance = {expectedDistance}", () => composer.DurationToDistance(new HitObject(), duration) == expectedDistance);
+            => AddAssert($"duration = {duration} -> distance = {expectedDistance}", () => composer.DurationToDistance(referenceObject ?? new HitObject(), duration), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
-        private void assertDistanceToDuration(float distance, double expectedDuration)
+        private void assertDistanceToDuration(float distance, double expectedDuration, HitObject? referenceObject = null)
-            => AddAssert($"distance = {distance} -> duration = {expectedDuration}", () => composer.DistanceToDuration(new HitObject(), distance) == expectedDuration);
+            => AddAssert($"distance = {distance} -> duration = {expectedDuration}", () => composer.DistanceToDuration(referenceObject ?? new HitObject(), distance), () => Is.EqualTo(expectedDuration).Within(Precision.FLOAT_EPSILON));
 
-        private void assertSnappedDuration(float distance, double expectedDuration)
+        private void assertSnappedDuration(float distance, double expectedDuration, HitObject? referenceObject = null)
-            => AddAssert($"distance = {distance} -> duration = {expectedDuration} (snapped)", () => composer.FindSnappedDuration(new HitObject(), distance) == expectedDuration);
+            => AddAssert($"distance = {distance} -> duration = {expectedDuration} (snapped)", () => composer.FindSnappedDuration(referenceObject ?? new HitObject(), distance), () => Is.EqualTo(expectedDuration).Within(Precision.FLOAT_EPSILON));
 
-        private void assertSnappedDistance(float distance, float expectedDistance)
+        private void assertSnappedDistance(float distance, float expectedDistance, HitObject? referenceObject = null)
-            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)", () => composer.FindSnappedDistance(new HitObject(), distance) == expectedDistance);
+            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)", () => composer.FindSnappedDistance(referenceObject ?? new HitObject(), distance), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
         private class TestHitObjectComposer : OsuHitObjectComposer
         {

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

@@ -106,6 +106,49 @@ namespace osu.Game.Tests.Visual.Editing
             assertBeatSnap(16);
         }
 
+        [Test]
+        public void TestKeyboardNavigation()
+        {
+            pressKey(1);
+            assertBeatSnap(1);
+            assertPreset(BeatDivisorType.Common);
+
+            pressKey(2);
+            assertBeatSnap(2);
+            assertPreset(BeatDivisorType.Common);
+
+            pressKey(3);
+            assertBeatSnap(3);
+            assertPreset(BeatDivisorType.Triplets);
+
+            pressKey(4);
+            assertBeatSnap(4);
+            assertPreset(BeatDivisorType.Common);
+
+            pressKey(5);
+            assertBeatSnap(5);
+            assertPreset(BeatDivisorType.Custom, 5);
+
+            pressKey(6);
+            assertBeatSnap(6);
+            assertPreset(BeatDivisorType.Triplets);
+
+            pressKey(7);
+            assertBeatSnap(7);
+            assertPreset(BeatDivisorType.Custom, 7);
+
+            pressKey(8);
+            assertBeatSnap(8);
+            assertPreset(BeatDivisorType.Common);
+
+            void pressKey(int key) => AddStep($"press shift+{key}", () =>
+            {
+                InputManager.PressKey(Key.ShiftLeft);
+                InputManager.Key(Key.Number0 + key);
+                InputManager.ReleaseKey(Key.ShiftLeft);
+            });
+        }
+
         [Test]
         public void TestBeatPresetNavigation()
         {

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

@@ -193,7 +193,7 @@ namespace osu.Game.Tests.Visual.Editing
 
             IBindable<double> IDistanceSnapProvider.DistanceSpacingMultiplier => DistanceSpacingMultiplier;
 
-            public float GetBeatSnapDistanceAt(HitObject referenceObject) => beat_snap_distance;
+            public float GetBeatSnapDistanceAt(HitObject referenceObject, bool useReferenceSliderVelocity = true) => beat_snap_distance;
 
             public float DurationToDistance(HitObject referenceObject, double duration) => (float)duration;
 

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

@@ -0,0 +1,32 @@
+// 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.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    /// <summary>
+    /// Test editor hotkeys at a high level to ensure they all work well together.
+    /// </summary>
+    public class TestSceneEditorBindings : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        [Test]
+        public void TestBeatDivisorChangeHotkeys()
+        {
+            AddStep("hold shift", () => InputManager.PressKey(Key.LShift));
+
+            AddStep("press 4", () => InputManager.Key(Key.Number4));
+            AddAssert("snap updated to 4", () => EditorBeatmap.BeatmapInfo.BeatDivisor, () => Is.EqualTo(4));
+
+            AddStep("press 6", () => InputManager.Key(Key.Number6));
+            AddAssert("snap updated to 6", () => EditorBeatmap.BeatmapInfo.BeatDivisor, () => Is.EqualTo(6));
+
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.LShift));
+        }
+    }
+}

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

@@ -155,6 +155,20 @@ namespace osu.Game.Tests.Visual.Editing
             AddUntilStep("composer selection box is visible", () => Editor.ChildrenOfType<HitObjectComposer>().First().ChildrenOfType<EditorSelectionHandler>().First().Alpha > 0);
         }
 
+        [Test]
+        public void TestClone()
+        {
+            var addedObject = new HitCircle { StartTime = 1000 };
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddAssert("is one object", () => EditorBeatmap.HitObjects.Count == 1);
+            AddStep("clone", () => Editor.Clone());
+            AddAssert("is two objects", () => EditorBeatmap.HitObjects.Count == 2);
+            AddStep("clone", () => Editor.Clone());
+            AddAssert("is three objects", () => EditorBeatmap.HitObjects.Count == 3);
+        }
+
         [Test]
         public void TestCutNothing()
         {
@@ -175,5 +189,22 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("paste hitobject", () => Editor.Paste());
             AddAssert("are no objects", () => EditorBeatmap.HitObjects.Count == 0);
         }
+
+        [Test]
+        public void TestCloneNothing()
+        {
+            // Add arbitrary object and copy to clipboard.
+            // This is tested to ensure that clone doesn't incorrectly read from the clipboard when no selection is made.
+            var addedObject = new HitCircle { StartTime = 1000 };
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+            AddStep("copy hitobject", () => Editor.Copy());
+
+            AddStep("deselect all objects", () => EditorBeatmap.SelectedHitObjects.Clear());
+
+            AddAssert("is one object", () => EditorBeatmap.HitObjects.Count == 1);
+            AddStep("clone", () => Editor.Clone());
+            AddAssert("still one object", () => EditorBeatmap.HitObjects.Count == 1);
+        }
     }
 }