Merge branch 'master' into import-screen

global.json

@@ -5,6 +5,6 @@
     "version": "3.1.100"
   },
   "msbuild-sdks": {
-    "Microsoft.Build.Traversal": "2.2.3"
+    "Microsoft.Build.Traversal": "3.0.2"
   }
 }

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1113.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1202.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1203.0" />
   </ItemGroup>
 </Project>

osu.Desktop/OsuGameDesktop.cs

@@ -59,7 +59,7 @@ namespace osu.Desktop
             try
             {
                 using (RegistryKey key = Registry.ClassesRoot.OpenSubKey("osu"))
-                    stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty).ToString()?.Split('"')[1].Replace("osu!.exe", "");
+                    stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty)?.ToString()?.Split('"')[1].Replace("osu!.exe", "");
 
                 if (checkExists(stableInstallPath))
                     return stableInstallPath;
@@ -138,8 +138,8 @@ namespace osu.Desktop
                     break;
 
                 // SDL2 DesktopWindow
-                case DesktopWindow desktopWindow:
-                    desktopWindow.CursorState.Value |= CursorState.Hidden;
+                case SDL2DesktopWindow desktopWindow:
+                    desktopWindow.CursorState |= CursorState.Hidden;
                     desktopWindow.SetIconFromStream(iconStream);
                     desktopWindow.Title = Name;
                     desktopWindow.DragDrop += f => fileDrop(new[] { f });

osu.Desktop/Program.cs

@@ -22,9 +22,9 @@ namespace osu.Desktop
         {
             // Back up the cwd before DesktopGameHost changes it
             var cwd = Environment.CurrentDirectory;
-            bool useSdl = args.Contains("--sdl");
+            bool useOsuTK = args.Contains("--tk");
 
-            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true, useSdl: useSdl))
+            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true, useOsuTK: useOsuTK))
             {
                 host.ExceptionThrown += handleException;
 

osu.Desktop/osu.Desktop.csproj

@@ -24,12 +24,12 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="4.7.0" />
+    <PackageReference Include="System.IO.Packaging" Version="5.0.0" />
     <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.4" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.6" />
-    <PackageReference Include="Microsoft.Win32.Registry" Version="4.7.0" />
-    <PackageReference Include="DiscordRichPresence" Version="1.0.150" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
+    <PackageReference Include="DiscordRichPresence" Version="1.0.166" />
     <!-- .NET 3.1 SDK seems to cause issues with a runtime specification. This will likely be resolved in .NET 5. -->
     <PackageReference Include="System.IO.FileSystem.Primitives" Version="4.3.0" />
     <PackageReference Include="System.Runtime.Handles" Version="4.3.0" />

osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModRelax.cs

@@ -38,17 +38,17 @@ namespace osu.Game.Rulesets.Catch.Tests.Mods
                     new Fruit
                     {
                         X = 0,
-                        StartTime = 250
+                        StartTime = 1000
                     },
                     new Fruit
                     {
                         X = CatchPlayfield.WIDTH,
-                        StartTime = 500
+                        StartTime = 2000
                     },
                     new JuiceStream
                     {
                         X = CatchPlayfield.CENTER_X,
-                        StartTime = 750,
+                        StartTime = 3000,
                         Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, Vector2.UnitY * 200 })
                     }
                 }

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

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                     NewCombo = i % 8 == 0,
                     Samples = new List<HitSampleInfo>(new[]
                     {
-                        new HitSampleInfo { Bank = "normal", Name = "hitnormal", Volume = 100 }
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, "normal", volume: 100)
                     })
                 });
             }

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

@@ -0,0 +1,14 @@
+// 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.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    [TestFixture]
+    public class TestSceneCatchPlayerLegacySkin : LegacySkinPlayerTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+    }
+}

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

@@ -1,26 +1,194 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneCatcher : CatchSkinnableTestScene
+    public class TestSceneCatcher : OsuTestScene
     {
-        [BackgroundDependencyLoader]
-        private void load()
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        private Container droppedObjectContainer;
+
+        private TestCatcher catcher;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
         {
-            SetContents(() => new Catcher(new Container())
+            var difficulty = new BeatmapDifficulty
+            {
+                CircleSize = 0,
+            };
+
+            var trailContainer = new Container();
+            droppedObjectContainer = new Container();
+            catcher = new TestCatcher(trailContainer, droppedObjectContainer, difficulty);
+
+            Child = new Container
             {
-                RelativePositionAxes = Axes.None,
                 Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
+                Children = new Drawable[]
+                {
+                    trailContainer,
+                    droppedObjectContainer,
+                    catcher
+                }
+            };
+        });
+
+        [Test]
+        public void TestCatcherCatchWidth()
+        {
+            var halfWidth = Catcher.CalculateCatchWidth(new BeatmapDifficulty { CircleSize = 0 }) / 2;
+            AddStep("catch fruit", () =>
+            {
+                attemptCatch(new Fruit { X = -halfWidth + 1 });
+                attemptCatch(new Fruit { X = halfWidth - 1 });
             });
+            checkPlate(2);
+            AddStep("miss fruit", () =>
+            {
+                attemptCatch(new Fruit { X = -halfWidth - 1 });
+                attemptCatch(new Fruit { X = halfWidth + 1 });
+            });
+            checkPlate(2);
+        }
+
+        [Test]
+        public void TestFruitChangesCatcherState()
+        {
+            AddStep("miss fruit", () => attemptCatch(new Fruit { X = 100 }));
+            checkState(CatcherAnimationState.Fail);
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            checkState(CatcherAnimationState.Idle);
+            AddStep("catch kiai fruit", () => attemptCatch(new TestKiaiFruit()));
+            checkState(CatcherAnimationState.Kiai);
+        }
+
+        [Test]
+        public void TestNormalFruitResetsHyperDashState()
+        {
+            AddStep("catch hyper fruit", () => attemptCatch(new Fruit
+            {
+                HyperDashTarget = new Fruit { X = 100 }
+            }));
+            checkHyperDash(true);
+            AddStep("catch normal fruit", () => attemptCatch(new Fruit()));
+            checkHyperDash(false);
+        }
+
+        [Test]
+        public void TestTinyDropletMissPreservesCatcherState()
+        {
+            AddStep("catch hyper kiai fruit", () => attemptCatch(new TestKiaiFruit
+            {
+                HyperDashTarget = new Fruit { X = 100 }
+            }));
+            AddStep("catch tiny droplet", () => attemptCatch(new TinyDroplet()));
+            AddStep("miss tiny droplet", () => attemptCatch(new TinyDroplet { X = 100 }));
+            // catcher state and hyper dash state is preserved
+            checkState(CatcherAnimationState.Kiai);
+            checkHyperDash(true);
+        }
+
+        [Test]
+        public void TestBananaMissPreservesCatcherState()
+        {
+            AddStep("catch hyper kiai fruit", () => attemptCatch(new TestKiaiFruit
+            {
+                HyperDashTarget = new Fruit { X = 100 }
+            }));
+            AddStep("miss banana", () => attemptCatch(new Banana { X = 100 }));
+            // catcher state is preserved but hyper dash state is reset
+            checkState(CatcherAnimationState.Kiai);
+            checkHyperDash(false);
+        }
+
+        [Test]
+        public void TestCatcherStacking()
+        {
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            checkPlate(1);
+            AddStep("catch more fruits", () => attemptCatch(new Fruit(), 9));
+            checkPlate(10);
+            AddAssert("caught objects are stacked", () =>
+                catcher.CaughtObjects.All(obj => obj.Y <= 0) &&
+                catcher.CaughtObjects.Any(obj => obj.Y == 0) &&
+                catcher.CaughtObjects.Any(obj => obj.Y < -20));
+        }
+
+        [Test]
+        public void TestCatcherExplosionAndDropping()
+        {
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            AddStep("catch tiny droplet", () => attemptCatch(new TinyDroplet()));
+            AddAssert("tiny droplet is exploded", () => catcher.CaughtObjects.Count() == 1 && droppedObjectContainer.Count == 1);
+            AddUntilStep("wait explosion", () => !droppedObjectContainer.Any());
+            AddStep("catch more fruits", () => attemptCatch(new Fruit(), 9));
+            AddStep("explode", () => catcher.Explode());
+            AddAssert("fruits are exploded", () => !catcher.CaughtObjects.Any() && droppedObjectContainer.Count == 10);
+            AddUntilStep("wait explosion", () => !droppedObjectContainer.Any());
+            AddStep("catch fruits", () => attemptCatch(new Fruit(), 10));
+            AddStep("drop", () => catcher.Drop());
+            AddAssert("fruits are dropped", () => !catcher.CaughtObjects.Any() && droppedObjectContainer.Count == 10);
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestHitLighting(bool enabled)
+        {
+            AddStep($"{(enabled ? "enable" : "disable")} hit lighting", () => config.Set(OsuSetting.HitLighting, enabled));
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            AddAssert("check hit lighting", () => catcher.ChildrenOfType<HitExplosion>().Any() == enabled);
+        }
+
+        private void checkPlate(int count) => AddAssert($"{count} objects on the plate", () => catcher.CaughtObjects.Count() == count);
+
+        private void checkState(CatcherAnimationState state) => AddAssert($"catcher state is {state}", () => catcher.CurrentState == state);
+
+        private void checkHyperDash(bool state) => AddAssert($"catcher is {(state ? "" : "not ")}hyper dashing", () => catcher.HyperDashing == state);
+
+        private void attemptCatch(CatchHitObject hitObject, int count = 1)
+        {
+            hitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            for (var i = 0; i < count; i++)
+                catcher.AttemptCatch(hitObject);
+        }
+
+        public class TestCatcher : Catcher
+        {
+            public IEnumerable<DrawablePalpableCatchHitObject> CaughtObjects => this.ChildrenOfType<DrawablePalpableCatchHitObject>();
+
+            public TestCatcher(Container trailsTarget, Container droppedObjectTarget, BeatmapDifficulty difficulty)
+                : base(trailsTarget, droppedObjectTarget, difficulty)
+            {
+            }
+        }
+
+        public class TestKiaiFruit : Fruit
+        {
+            protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+            {
+                controlPointInfo.Add(0, new EffectControlPoint { KiaiMode = true });
+                base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
+            }
         }
     }
 }

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

@@ -6,18 +6,17 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Configuration;
-using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -29,82 +28,68 @@ namespace osu.Game.Rulesets.Catch.Tests
         [Resolved]
         private OsuConfigManager config { get; set; }
 
-        private Catcher catcher => this.ChildrenOfType<CatcherArea>().First().MovableCatcher;
+        private Catcher catcher => this.ChildrenOfType<Catcher>().First();
+
+        private float circleSize;
 
         public TestSceneCatcherArea()
         {
-            AddSliderStep<float>("CircleSize", 0, 8, 5, createCatcher);
-            AddToggleStep("Hyperdash", t =>
-                CreatedDrawables.OfType<CatchInputManager>().Select(i => i.Child)
-                                .OfType<TestCatcherArea>().ForEach(c => c.ToggleHyperDash(t)));
+            AddSliderStep<float>("circle size", 0, 8, 5, createCatcher);
+            AddToggleStep("hyper dash", t => this.ChildrenOfType<TestCatcherArea>().ForEach(area => area.ToggleHyperDash(t)));
 
-            AddRepeatStep("catch fruit", () => catchFruit(new TestFruit(false)
-            {
-                X = catcher.X
-            }), 20);
-            AddRepeatStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
-            {
-                X = catcher.X,
-                LastInCombo = true,
-            }), 20);
-            AddRepeatStep("catch kiai fruit", () => catchFruit(new TestFruit(true)
-            {
-                X = catcher.X
-            }), 20);
-            AddRepeatStep("miss fruit", () => catchFruit(new Fruit
-            {
-                X = catcher.X + 100,
-                LastInCombo = true,
-            }, true), 20);
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
+            AddStep("catch fruit last in combo", () => attemptCatch(new Fruit { LastInCombo = true }));
+            AddStep("catch kiai fruit", () => attemptCatch(new TestSceneCatcher.TestKiaiFruit()));
+            AddStep("miss last in combo", () => attemptCatch(new Fruit { X = 100, LastInCombo = true }));
         }
 
-        [TestCase(true)]
-        [TestCase(false)]
-        public void TestHitLighting(bool enable)
+        private void attemptCatch(Fruit fruit)
         {
-            AddStep("create catcher", () => createCatcher(5));
-
-            AddStep("toggle hit lighting", () => config.Set(OsuSetting.HitLighting, enable));
-            AddStep("catch fruit", () => catchFruit(new TestFruit(false)
+            fruit.X += catcher.X;
+            fruit.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty
             {
-                X = catcher.X
-            }));
-            AddStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
-            {
-                X = catcher.X,
-                LastInCombo = true
-            }));
-            AddAssert("check hit explosion", () => catcher.ChildrenOfType<HitExplosion>().Any() == enable);
-        }
+                CircleSize = circleSize
+            });
 
-        private void catchFruit(Fruit fruit, bool miss = false)
-        {
-            this.ChildrenOfType<CatcherArea>().ForEach(area =>
+            foreach (var area in this.ChildrenOfType<CatcherArea>())
             {
                 DrawableFruit drawable = new DrawableFruit(fruit);
                 area.Add(drawable);
 
                 Schedule(() =>
                 {
-                    area.AttemptCatch(fruit);
-                    area.OnNewResult(drawable, new JudgementResult(fruit, new CatchJudgement()) { Type = miss ? HitResult.Miss : HitResult.Great });
+                    bool caught = area.AttemptCatch(fruit);
+                    area.OnNewResult(drawable, new JudgementResult(fruit, new CatchJudgement())
+                    {
+                        Type = caught ? HitResult.Great : HitResult.Miss
+                    });
 
                     drawable.Expire();
                 });
-            });
+            }
         }
 
         private void createCatcher(float size)
         {
-            SetContents(() => new CatchInputManager(catchRuleset)
+            circleSize = size;
+
+            SetContents(() =>
             {
-                RelativeSizeAxes = Axes.Both,
-                Child = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
+                var droppedObjectContainer = new Container();
+
+                return new CatchInputManager(catchRuleset)
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.TopCentre,
-                    CreateDrawableRepresentation = ((DrawableRuleset<CatchHitObject>)catchRuleset.CreateInstance().CreateDrawableRulesetWith(new CatchBeatmap())).CreateDrawableRepresentation
-                },
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        droppedObjectContainer,
+                        new TestCatcherArea(droppedObjectContainer, new BeatmapDifficulty { CircleSize = size })
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.TopCentre,
+                        }
+                    }
+                };
             });
         }
 
@@ -114,26 +99,13 @@ namespace osu.Game.Rulesets.Catch.Tests
             catchRuleset = rulesets.GetRuleset(2);
         }
 
-        public class TestFruit : Fruit
-        {
-            public TestFruit(bool kiai)
-            {
-                var kiaiCpi = new ControlPointInfo();
-                kiaiCpi.Add(0, new EffectControlPoint { KiaiMode = kiai });
-
-                ApplyDefaultsToSelf(kiaiCpi, new BeatmapDifficulty());
-            }
-        }
-
         private class TestCatcherArea : CatcherArea
         {
-            public TestCatcherArea(BeatmapDifficulty beatmapDifficulty)
-                : base(beatmapDifficulty)
+            public TestCatcherArea(Container droppedObjectContainer, BeatmapDifficulty beatmapDifficulty)
+                : base(droppedObjectContainer, beatmapDifficulty)
             {
             }
 
-            public new Catcher MovableCatcher => base.MovableCatcher;
-
             public void ToggleHyperDash(bool status) => MovableCatcher.SetHyperDashState(status ? 2 : 1);
         }
     }

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

@@ -136,7 +136,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             if (juice.NestedHitObjects.Last() is CatchHitObject tail)
                 tail.LastInCombo = true; // usually the (Catch)BeatmapProcessor would do this for us when necessary
 
-            addToPlayfield(new DrawableJuiceStream(juice, drawableRuleset.CreateDrawableRepresentation));
+            addToPlayfield(new DrawableJuiceStream(juice));
         }
 
         private void spawnBananas(bool hit = false)

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

@@ -1,12 +1,14 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -17,99 +19,69 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             base.LoadComplete();
 
-            foreach (FruitVisualRepresentation rep in Enum.GetValues(typeof(FruitVisualRepresentation)))
-                AddStep($"show {rep}", () => SetContents(() => createDrawable(rep)));
+            AddStep("show pear", () => SetContents(() => createDrawableFruit(0)));
+            AddStep("show grape", () => SetContents(() => createDrawableFruit(1)));
+            AddStep("show pineapple / apple", () => SetContents(() => createDrawableFruit(2)));
+            AddStep("show raspberry / orange", () => SetContents(() => createDrawableFruit(3)));
+
+            AddStep("show banana", () => SetContents(createDrawableBanana));
 
             AddStep("show droplet", () => SetContents(() => createDrawableDroplet()));
             AddStep("show tiny droplet", () => SetContents(createDrawableTinyDroplet));
 
-            foreach (FruitVisualRepresentation rep in Enum.GetValues(typeof(FruitVisualRepresentation)))
-                AddStep($"show hyperdash {rep}", () => SetContents(() => createDrawable(rep, true)));
+            AddStep("show hyperdash pear", () => SetContents(() => createDrawableFruit(0, true)));
+            AddStep("show hyperdash grape", () => SetContents(() => createDrawableFruit(1, true)));
+            AddStep("show hyperdash pineapple / apple", () => SetContents(() => createDrawableFruit(2, true)));
+            AddStep("show hyperdash raspberry / orange", () => SetContents(() => createDrawableFruit(3, true)));
 
             AddStep("show hyperdash droplet", () => SetContents(() => createDrawableDroplet(true)));
         }
 
-        private Drawable createDrawableTinyDroplet()
-        {
-            var droplet = new TestCatchTinyDroplet
+        private Drawable createDrawableFruit(int indexInBeatmap, bool hyperdash = false) =>
+            new TestDrawableCatchHitObjectSpecimen(new DrawableFruit(new Fruit
             {
-                Scale = 1.5f,
+                IndexInBeatmap = indexInBeatmap,
+                HyperDashBindable = { Value = hyperdash }
+            }));
+
+        private Drawable createDrawableBanana() =>
+            new TestDrawableCatchHitObjectSpecimen(new DrawableBanana(new Banana()));
+
+        private Drawable createDrawableDroplet(bool hyperdash = false) =>
+            new TestDrawableCatchHitObjectSpecimen(new DrawableDroplet(new Droplet
+            {
+                HyperDashBindable = { Value = hyperdash }
+            }));
+
+        private Drawable createDrawableTinyDroplet() => new TestDrawableCatchHitObjectSpecimen(new DrawableTinyDroplet(new TinyDroplet()));
+    }
+
+    public class TestDrawableCatchHitObjectSpecimen : CompositeDrawable
+    {
+        public readonly ManualClock ManualClock;
+
+        public TestDrawableCatchHitObjectSpecimen(DrawableCatchHitObject d)
+        {
+            AutoSizeAxes = Axes.Both;
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            ManualClock = new ManualClock();
+            Clock = new FramedClock(ManualClock);
+
+            var hitObject = d.HitObject;
+            hitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+            hitObject.Scale = 1.5f;
+            hitObject.StartTime = 500;
+
+            d.Anchor = Anchor.Centre;
+            d.HitObjectApplied += _ =>
+            {
+                d.LifetimeStart = double.NegativeInfinity;
+                d.LifetimeEnd = double.PositiveInfinity;
             };
 
-            return new DrawableTinyDroplet(droplet)
-            {
-                Anchor = Anchor.Centre,
-                RelativePositionAxes = Axes.None,
-                Position = Vector2.Zero,
-                Alpha = 1,
-                LifetimeStart = double.NegativeInfinity,
-                LifetimeEnd = double.PositiveInfinity,
-            };
-        }
-
-        private Drawable createDrawableDroplet(bool hyperdash = false)
-        {
-            var droplet = new TestCatchDroplet
-            {
-                Scale = 1.5f,
-                HyperDashTarget = hyperdash ? new Banana() : null
-            };
-
-            return new DrawableDroplet(droplet)
-            {
-                Anchor = Anchor.Centre,
-                RelativePositionAxes = Axes.None,
-                Position = Vector2.Zero,
-                Alpha = 1,
-                LifetimeStart = double.NegativeInfinity,
-                LifetimeEnd = double.PositiveInfinity,
-            };
-        }
-
-        private Drawable createDrawable(FruitVisualRepresentation rep, bool hyperdash = false)
-        {
-            Fruit fruit = new TestCatchFruit(rep)
-            {
-                Scale = 1.5f,
-                HyperDashTarget = hyperdash ? new Banana() : null
-            };
-
-            return new DrawableFruit(fruit)
-            {
-                Anchor = Anchor.Centre,
-                RelativePositionAxes = Axes.None,
-                Position = Vector2.Zero,
-                Alpha = 1,
-                LifetimeStart = double.NegativeInfinity,
-                LifetimeEnd = double.PositiveInfinity,
-            };
-        }
-
-        public class TestCatchFruit : Fruit
-        {
-            public TestCatchFruit(FruitVisualRepresentation rep)
-            {
-                VisualRepresentation = rep;
-                StartTime = 1000000000000;
-            }
-
-            public override FruitVisualRepresentation VisualRepresentation { get; }
-        }
-
-        public class TestCatchDroplet : Droplet
-        {
-            public TestCatchDroplet()
-            {
-                StartTime = 1000000000000;
-            }
-        }
-
-        public class TestCatchTinyDroplet : TinyDroplet
-        {
-            public TestCatchTinyDroplet()
-            {
-                StartTime = 1000000000000;
-            }
+            InternalChild = d;
         }
     }
 }

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

@@ -0,0 +1,96 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Tests.Visual;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneFruitRandomness : OsuTestScene
+    {
+        private readonly TestDrawableFruit drawableFruit;
+        private readonly TestDrawableBanana drawableBanana;
+
+        public TestSceneFruitRandomness()
+        {
+            drawableFruit = new TestDrawableFruit(new Fruit());
+            drawableBanana = new TestDrawableBanana(new Banana());
+
+            Add(new TestDrawableCatchHitObjectSpecimen(drawableFruit) { X = -200 });
+            Add(new TestDrawableCatchHitObjectSpecimen(drawableBanana));
+
+            AddSliderStep("start time", 500, 600, 0, x =>
+            {
+                drawableFruit.HitObject.StartTime = drawableBanana.HitObject.StartTime = x;
+            });
+        }
+
+        [Test]
+        public void TestFruitRandomness()
+        {
+            // Use values such that the banana colour changes (2/3 of the integers are okay)
+            const int initial_start_time = 500;
+            const int another_start_time = 501;
+
+            float fruitRotation = 0;
+            float bananaRotation = 0;
+            float bananaScale = 0;
+            Color4 bananaColour = new Color4();
+
+            AddStep("Initialize start time", () =>
+            {
+                drawableFruit.HitObject.StartTime = drawableBanana.HitObject.StartTime = initial_start_time;
+
+                fruitRotation = drawableFruit.InnerRotation;
+                bananaRotation = drawableBanana.InnerRotation;
+                bananaScale = drawableBanana.InnerScale;
+                bananaColour = drawableBanana.AccentColour.Value;
+            });
+
+            AddStep("change start time", () =>
+            {
+                drawableFruit.HitObject.StartTime = drawableBanana.HitObject.StartTime = another_start_time;
+            });
+
+            AddAssert("fruit rotation is changed", () => drawableFruit.InnerRotation != fruitRotation);
+            AddAssert("banana rotation is changed", () => drawableBanana.InnerRotation != bananaRotation);
+            AddAssert("banana scale is changed", () => drawableBanana.InnerScale != bananaScale);
+            AddAssert("banana colour is changed", () => drawableBanana.AccentColour.Value != bananaColour);
+
+            AddStep("reset start time", () =>
+            {
+                drawableFruit.HitObject.StartTime = drawableBanana.HitObject.StartTime = initial_start_time;
+            });
+
+            AddAssert("rotation and scale restored", () =>
+                drawableFruit.InnerRotation == fruitRotation &&
+                drawableBanana.InnerRotation == bananaRotation &&
+                drawableBanana.InnerScale == bananaScale &&
+                drawableBanana.AccentColour.Value == bananaColour);
+        }
+
+        private class TestDrawableFruit : DrawableFruit
+        {
+            public float InnerRotation => ScaleContainer.Rotation;
+
+            public TestDrawableFruit(Fruit h)
+                : base(h)
+            {
+            }
+        }
+
+        private class TestDrawableBanana : DrawableBanana
+        {
+            public float InnerRotation => ScaleContainer.Rotation;
+            public float InnerScale => ScaleContainer.Scale.X;
+
+            public TestDrawableBanana(Banana h)
+                : base(h)
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch.Tests/TestSceneFruitVisualChange.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 osu.Framework.Bindables;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneFruitVisualChange : TestSceneFruitObjects
+    {
+        private readonly Bindable<int> indexInBeatmap = new Bindable<int>();
+        private readonly Bindable<bool> hyperDash = new Bindable<bool>();
+
+        protected override void LoadComplete()
+        {
+            AddStep("fruit changes visual and hyper", () => SetContents(() => new TestDrawableCatchHitObjectSpecimen(new DrawableFruit(new Fruit
+            {
+                IndexInBeatmapBindable = { BindTarget = indexInBeatmap },
+                HyperDashBindable = { BindTarget = hyperDash },
+            }))));
+
+            AddStep("droplet changes hyper", () => SetContents(() => new TestDrawableCatchHitObjectSpecimen(new DrawableDroplet(new Droplet
+            {
+                HyperDashBindable = { BindTarget = hyperDash },
+            }))));
+
+            Scheduler.AddDelayed(() => indexInBeatmap.Value++, 250, true);
+            Scheduler.AddDelayed(() => hyperDash.Value = !hyperDash.Value, 1000, true);
+        }
+    }
+}

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

@@ -117,7 +117,7 @@ namespace osu.Game.Rulesets.Catch.Tests
 
             AddStep("create hyper-dashing catcher", () =>
             {
-                Child = setupSkinHierarchy(catcherArea = new CatcherArea
+                Child = setupSkinHierarchy(catcherArea = new CatcherArea(new Container())
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,

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

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

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

@@ -5,11 +5,11 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.MathUtils;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Catch.MathUtils;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
@@ -192,24 +192,24 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
         private static void initialiseHyperDash(IBeatmap beatmap)
         {
-            List<CatchHitObject> objectWithDroplets = new List<CatchHitObject>();
+            List<PalpableCatchHitObject> palpableObjects = new List<PalpableCatchHitObject>();
 
             foreach (var currentObject in beatmap.HitObjects)
             {
                 if (currentObject is Fruit fruitObject)
-                    objectWithDroplets.Add(fruitObject);
+                    palpableObjects.Add(fruitObject);
 
                 if (currentObject is JuiceStream)
                 {
-                    foreach (var currentJuiceElement in currentObject.NestedHitObjects)
+                    foreach (var juice in currentObject.NestedHitObjects)
                     {
-                        if (!(currentJuiceElement is TinyDroplet))
-                            objectWithDroplets.Add((CatchHitObject)currentJuiceElement);
+                        if (juice is PalpableCatchHitObject palpableObject && !(juice is TinyDroplet))
+                            palpableObjects.Add(palpableObject);
                     }
                 }
             }
 
-            objectWithDroplets.Sort((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));
+            palpableObjects.Sort((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));
 
             double halfCatcherWidth = Catcher.CalculateCatchWidth(beatmap.BeatmapInfo.BaseDifficulty) / 2;
 
@@ -221,10 +221,10 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             int lastDirection = 0;
             double lastExcess = halfCatcherWidth;
 
-            for (int i = 0; i < objectWithDroplets.Count - 1; i++)
+            for (int i = 0; i < palpableObjects.Count - 1; i++)
             {
-                CatchHitObject currentObject = objectWithDroplets[i];
-                CatchHitObject nextObject = objectWithDroplets[i + 1];
+                var currentObject = palpableObjects[i];
+                var nextObject = palpableObjects[i + 1];
 
                 // Reset variables in-case values have changed (e.g. after applying HR)
                 currentObject.HyperDashTarget = null;

osu.Game.Rulesets.Catch/Difficulty/Preprocessing/CatchDifficultyHitObject.cs

@@ -12,9 +12,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
     {
         private const float normalized_hitobject_radius = 41.0f;
 
-        public new CatchHitObject BaseObject => (CatchHitObject)base.BaseObject;
+        public new PalpableCatchHitObject BaseObject => (PalpableCatchHitObject)base.BaseObject;
 
-        public new CatchHitObject LastObject => (CatchHitObject)base.LastObject;
+        public new PalpableCatchHitObject LastObject => (PalpableCatchHitObject)base.LastObject;
 
         public readonly float NormalizedPosition;
         public readonly float LastNormalizedPosition;

osu.Game.Rulesets.Catch/Mods/CatchModEasy.cs

@@ -5,7 +5,7 @@ using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModEasy : ModEasy
+    public class CatchModEasy : ModEasyWithExtraLives
     {
         public override string Description => @"Larger fruits, more forgiving HP drain, less accuracy required, and three lives!";
     }

osu.Game.Rulesets.Catch/Objects/Banana.cs

@@ -1,22 +1,26 @@
 // 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 enable
+
+using System;
 using System.Collections.Generic;
 using osu.Game.Audio;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Utils;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class Banana : Fruit
+    public class Banana : Fruit, IHasComboInformation
     {
         /// <summary>
         /// Index of banana in current shower.
         /// </summary>
         public int BananaIndex;
 
-        public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
-
         public override Judgement CreateJudgement() => new CatchBananaJudgement();
 
         private static readonly List<HitSampleInfo> samples = new List<HitSampleInfo> { new BananaHitSampleInfo() };
@@ -26,11 +30,45 @@ namespace osu.Game.Rulesets.Catch.Objects
             Samples = samples;
         }
 
-        private class BananaHitSampleInfo : HitSampleInfo
-        {
-            private static string[] lookupNames { get; } = { "metronomelow", "catch-banana" };
+        // override any external colour changes with banananana
+        Color4 IHasComboInformation.GetComboColour(IReadOnlyList<Color4> comboColours) => getBananaColour();
 
-            public override IEnumerable<string> LookupNames => lookupNames;
+        private Color4 getBananaColour()
+        {
+            switch (StatelessRNG.NextInt(3, RandomSeed))
+            {
+                default:
+                    return new Color4(255, 240, 0, 255);
+
+                case 1:
+                    return new Color4(255, 192, 0, 255);
+
+                case 2:
+                    return new Color4(214, 221, 28, 255);
+            }
+        }
+
+        private class BananaHitSampleInfo : HitSampleInfo, IEquatable<BananaHitSampleInfo>
+        {
+            private static readonly string[] lookup_names = { "Gameplay/metronomelow", "Gameplay/catch-banana" };
+
+            public override IEnumerable<string> LookupNames => lookup_names;
+
+            public BananaHitSampleInfo(int volume = 0)
+                : base(string.Empty, volume: volume)
+            {
+            }
+
+            public sealed override HitSampleInfo With(Optional<string> newName = default, Optional<string?> newBank = default, Optional<string?> newSuffix = default, Optional<int> newVolume = default)
+                => new BananaHitSampleInfo(newVolume.GetOr(Volume));
+
+            public bool Equals(BananaHitSampleInfo? other)
+                => other != null;
+
+            public override bool Equals(object? obj)
+                => obj is BananaHitSampleInfo other && Equals(other);
+
+            public override int GetHashCode() => lookup_names.GetHashCode();
         }
     }
 }

osu.Game.Rulesets.Catch/Objects/BananaShower.cs

@@ -9,8 +9,6 @@ namespace osu.Game.Rulesets.Catch.Objects
 {
     public class BananaShower : CatchHitObject, IHasDuration
     {
-        public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
-
         public override bool LastInCombo => true;
 
         public override Judgement CreateJudgement() => new IgnoreJudgement();

osu.Game.Rulesets.Catch/Objects/CatchHitObject.cs

@@ -16,32 +16,47 @@ namespace osu.Game.Rulesets.Catch.Objects
     {
         public const float OBJECT_RADIUS = 64;
 
-        private float x;
+        // This value is after XOffset applied.
+        public readonly Bindable<float> XBindable = new Bindable<float>();
+
+        // This value is before XOffset applied.
+        private float originalX;
 
         /// <summary>
         /// The horizontal position of the fruit between 0 and <see cref="CatchPlayfield.WIDTH"/>.
         /// </summary>
         public float X
         {
-            get => x + XOffset;
-            set => x = value;
+            // TODO: I don't like this asymmetry.
+            get => XBindable.Value;
+            // originalX is set by `XBindable.BindValueChanged`
+            set => XBindable.Value = value + xOffset;
         }
 
-        /// <summary>
-        /// Whether this object can be placed on the catcher's plate.
-        /// </summary>
-        public virtual bool CanBePlated => false;
+        private float xOffset;
 
         /// <summary>
         /// A random offset applied to <see cref="X"/>, set by the <see cref="CatchBeatmapProcessor"/>.
         /// </summary>
-        internal float XOffset { get; set; }
+        internal float XOffset
+        {
+            get => xOffset;
+            set
+            {
+                xOffset = value;
+                XBindable.Value = originalX + xOffset;
+            }
+        }
 
         public double TimePreempt = 1000;
 
-        public int IndexInBeatmap { get; set; }
+        public readonly Bindable<int> IndexInBeatmapBindable = new Bindable<int>();
 
-        public virtual FruitVisualRepresentation VisualRepresentation => (FruitVisualRepresentation)(IndexInBeatmap % 4);
+        public int IndexInBeatmap
+        {
+            get => IndexInBeatmapBindable.Value;
+            set => IndexInBeatmapBindable.Value = value;
+        }
 
         public virtual bool NewCombo { get; set; }
 
@@ -63,13 +78,6 @@ namespace osu.Game.Rulesets.Catch.Objects
             set => ComboIndexBindable.Value = value;
         }
 
-        /// <summary>
-        /// Difference between the distance to the next object
-        /// and the distance that would have triggered a hyper dash.
-        /// A value close to 0 indicates a difficult jump (for difficulty calculation).
-        /// </summary>
-        public float DistanceToHyperDash { get; set; }
-
         public Bindable<bool> LastInComboBindable { get; } = new Bindable<bool>();
 
         /// <summary>
@@ -81,17 +89,19 @@ namespace osu.Game.Rulesets.Catch.Objects
             set => LastInComboBindable.Value = value;
         }
 
-        public float Scale { get; set; } = 1;
+        public readonly Bindable<float> ScaleBindable = new Bindable<float>(1);
+
+        public float Scale
+        {
+            get => ScaleBindable.Value;
+            set => ScaleBindable.Value = value;
+        }
 
         /// <summary>
-        /// Whether this fruit can initiate a hyperdash.
+        /// The seed value used for visual randomness such as fruit rotation.
+        /// The value is <see cref="HitObject.StartTime"/> truncated to an integer.
         /// </summary>
-        public bool HyperDash => HyperDashTarget != null;
-
-        /// <summary>
-        /// The target fruit if we are to initiate a hyperdash.
-        /// </summary>
-        public CatchHitObject HyperDashTarget;
+        public int RandomSeed => (int)StartTime;
 
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
@@ -103,22 +113,10 @@ namespace osu.Game.Rulesets.Catch.Objects
         }
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
-    }
 
-    /// <summary>
-    /// Represents a single object that can be caught by the catcher.
-    /// </summary>
-    public abstract class PalpableCatchHitObject : CatchHitObject
-    {
-        public override bool CanBePlated => true;
-    }
-
-    public enum FruitVisualRepresentation
-    {
-        Pear,
-        Grape,
-        Pineapple,
-        Raspberry,
-        Banana // banananananannaanana
+        protected CatchHitObject()
+        {
+            XBindable.BindValueChanged(x => originalX = x.NewValue - xOffset);
+        }
     }
 }

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

@@ -1,26 +1,31 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
+using JetBrains.Annotations;
 using osu.Framework.Graphics;
-using osu.Framework.Utils;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public class DrawableBanana : DrawableFruit
     {
-        public DrawableBanana(Banana h)
+        protected override FruitVisualRepresentation GetVisualRepresentation(int indexInBeatmap) => FruitVisualRepresentation.Banana;
+
+        public DrawableBanana()
+            : this(null)
+        {
+        }
+
+        public DrawableBanana([CanBeNull] Banana h)
             : base(h)
         {
         }
 
-        private Color4? colour;
-
-        protected override Color4 GetComboColour(IReadOnlyList<Color4> comboColours)
+        protected override void LoadComplete()
         {
-            // override any external colour changes with banananana
-            return colour ??= getBananaColour();
+            base.LoadComplete();
+
+            // start time affects the random seed which is used to determine the banana colour
+            StartTimeBindable.BindValueChanged(_ => UpdateComboColour());
         }
 
         protected override void UpdateInitialTransforms()
@@ -30,14 +35,14 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             const float end_scale = 0.6f;
             const float random_scale_range = 1.6f;
 
-            ScaleContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RNG.NextSingle()))
+            ScaleContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RandomSingle(3)))
                           .Then().ScaleTo(HitObject.Scale * end_scale, HitObject.TimePreempt);
 
-            ScaleContainer.RotateTo(getRandomAngle())
+            ScaleContainer.RotateTo(getRandomAngle(1))
                           .Then()
-                          .RotateTo(getRandomAngle(), HitObject.TimePreempt);
+                          .RotateTo(getRandomAngle(2), HitObject.TimePreempt);
 
-            float getRandomAngle() => 180 * (RNG.NextSingle() * 2 - 1);
+            float getRandomAngle(int series) => 180 * (RandomSingle(series) * 2 - 1);
         }
 
         public override void PlaySamples()
@@ -46,20 +51,5 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             if (Samples != null)
                 Samples.Frequency.Value = 0.77f + ((Banana)HitObject).BananaIndex * 0.006f;
         }
-
-        private Color4 getBananaColour()
-        {
-            switch (RNG.Next(0, 3))
-            {
-                default:
-                    return new Color4(255, 240, 0, 255);
-
-                case 1:
-                    return new Color4(255, 192, 0, 255);
-
-                case 2:
-                    return new Color4(214, 221, 28, 255);
-            }
-        }
     }
 }

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

@@ -1,26 +1,27 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
+using JetBrains.Annotations;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableBananaShower : DrawableCatchHitObject<BananaShower>
+    public class DrawableBananaShower : DrawableCatchHitObject
     {
-        private readonly Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation;
         private readonly Container bananaContainer;
 
-        public DrawableBananaShower(BananaShower s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
+        public DrawableBananaShower()
+            : this(null)
+        {
+        }
+
+        public DrawableBananaShower([CanBeNull] BananaShower s)
             : base(s)
         {
-            this.createDrawableRepresentation = createDrawableRepresentation;
             RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
-            X = 0;
 
             AddInternal(bananaContainer = new Container { RelativeSizeAxes = Axes.Both });
         }
@@ -34,18 +35,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         protected override void ClearNestedHitObjects()
         {
             base.ClearNestedHitObjects();
-            bananaContainer.Clear();
-        }
-
-        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
-        {
-            switch (hitObject)
-            {
-                case Banana banana:
-                    return createDrawableRepresentation?.Invoke(banana)?.With(o => ((DrawableCatchHitObject)o).CheckPosition = p => CheckPosition?.Invoke(p) ?? false);
-            }
-
-            return base.CreateNestedHitObject(hitObject);
+            bananaContainer.Clear(false);
         }
     }
 }

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

@@ -2,77 +2,48 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using osu.Framework.Allocation;
+using JetBrains.Annotations;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
-using osuTK.Graphics;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public abstract class PalpableDrawableCatchHitObject<TObject> : DrawableCatchHitObject<TObject>
-        where TObject : PalpableCatchHitObject
-    {
-        protected Container ScaleContainer { get; private set; }
-
-        protected PalpableDrawableCatchHitObject(TObject hitObject)
-            : base(hitObject)
-        {
-            Origin = Anchor.Centre;
-            Size = new Vector2(CatchHitObject.OBJECT_RADIUS * 2);
-            Masking = false;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            AddRangeInternal(new Drawable[]
-            {
-                ScaleContainer = new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Origin = Anchor.Centre,
-                    Anchor = Anchor.Centre,
-                }
-            });
-
-            ScaleContainer.Scale = new Vector2(HitObject.Scale);
-        }
-
-        protected override Color4 GetComboColour(IReadOnlyList<Color4> comboColours) =>
-            comboColours[(HitObject.IndexInBeatmap + 1) % comboColours.Count];
-    }
-
-    public abstract class DrawableCatchHitObject<TObject> : DrawableCatchHitObject
-        where TObject : CatchHitObject
-    {
-        public new TObject HitObject;
-
-        protected DrawableCatchHitObject(TObject hitObject)
-            : base(hitObject)
-        {
-            HitObject = hitObject;
-            Anchor = Anchor.BottomLeft;
-        }
-    }
-
     public abstract class DrawableCatchHitObject : DrawableHitObject<CatchHitObject>
     {
+        public readonly Bindable<float> XBindable = new Bindable<float>();
+
         protected override double InitialLifetimeOffset => HitObject.TimePreempt;
 
-        public virtual bool StaysOnPlate => HitObject.CanBePlated;
-
-        public float DisplayRadius => DrawSize.X / 2 * Scale.X * HitObject.Scale;
-
         protected override float SamplePlaybackPosition => HitObject.X / CatchPlayfield.WIDTH;
 
-        protected DrawableCatchHitObject(CatchHitObject hitObject)
+        public int RandomSeed => HitObject?.RandomSeed ?? 0;
+
+        protected DrawableCatchHitObject([CanBeNull] CatchHitObject hitObject)
             : base(hitObject)
         {
-            X = hitObject.X;
+            Anchor = Anchor.BottomLeft;
+        }
+
+        /// <summary>
+        /// Get a random number in range [0,1) based on seed <see cref="RandomSeed"/>.
+        /// </summary>
+        public float RandomSingle(int series) => StatelessRNG.NextSingle(RandomSeed, series);
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            XBindable.BindTo(HitObject.XBindable);
+        }
+
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            XBindable.UnbindFrom(HitObject.XBindable);
         }
 
         public Func<CatchHitObject, bool> CheckPosition;

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

@@ -1,18 +1,24 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableDroplet : PalpableDrawableCatchHitObject<Droplet>
+    public class DrawableDroplet : DrawablePalpableCatchHitObject
     {
         public override bool StaysOnPlate => false;
 
-        public DrawableDroplet(Droplet h)
+        public DrawableDroplet()
+            : this(null)
+        {
+        }
+
+        public DrawableDroplet([CanBeNull] CatchHitObject h)
             : base(h)
         {
         }
@@ -20,7 +26,17 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
-            ScaleContainer.Child = new SkinnableDrawable(new CatchSkinComponent(CatchSkinComponents.Droplet), _ => new DropletPiece());
+            HyperDash.BindValueChanged(_ => updatePiece(), true);
+        }
+
+        private void updatePiece()
+        {
+            ScaleContainer.Child = new SkinnableDrawable(
+                new CatchSkinComponent(CatchSkinComponents.Droplet),
+                _ => new DropletPiece
+                {
+                    HyperDash = { BindTarget = HyperDash }
+                });
         }
 
         protected override void UpdateInitialTransforms()
@@ -28,7 +44,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             base.UpdateInitialTransforms();
 
             // roughly matches osu-stable
-            float startRotation = RNG.NextSingle() * 20;
+            float startRotation = RandomSingle(1) * 20;
             double duration = HitObject.TimePreempt + 2000;
 
             ScaleContainer.RotateTo(startRotation).RotateTo(startRotation + 720, duration);

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

@@ -2,15 +2,27 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
-using osu.Framework.Utils;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableFruit : PalpableDrawableCatchHitObject<Fruit>
+    public class DrawableFruit : DrawablePalpableCatchHitObject
     {
-        public DrawableFruit(Fruit h)
+        public readonly Bindable<FruitVisualRepresentation> VisualRepresentation = new Bindable<FruitVisualRepresentation>();
+
+        protected virtual FruitVisualRepresentation GetVisualRepresentation(int indexInBeatmap) => (FruitVisualRepresentation)(indexInBeatmap % 4);
+
+        public DrawableFruit()
+            : this(null)
+        {
+        }
+
+        public DrawableFruit([CanBeNull] Fruit h)
             : base(h)
         {
         }
@@ -18,10 +30,31 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
-            ScaleContainer.Child = new SkinnableDrawable(
-                new CatchSkinComponent(getComponent(HitObject.VisualRepresentation)), _ => new FruitPiece());
+            IndexInBeatmap.BindValueChanged(change =>
+            {
+                VisualRepresentation.Value = GetVisualRepresentation(change.NewValue);
+            }, true);
 
-            ScaleContainer.Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
+            VisualRepresentation.BindValueChanged(_ => updatePiece());
+            HyperDash.BindValueChanged(_ => updatePiece(), true);
+        }
+
+        protected override void UpdateInitialTransforms()
+        {
+            base.UpdateInitialTransforms();
+
+            ScaleContainer.RotateTo((RandomSingle(1) - 0.5f) * 40);
+        }
+
+        private void updatePiece()
+        {
+            ScaleContainer.Child = new SkinnableDrawable(
+                new CatchSkinComponent(getComponent(VisualRepresentation.Value)),
+                _ => new FruitPiece
+                {
+                    VisualRepresentation = { BindTarget = VisualRepresentation },
+                    HyperDash = { BindTarget = HyperDash },
+                });
         }
 
         private CatchSkinComponents getComponent(FruitVisualRepresentation hitObjectVisualRepresentation)
@@ -48,4 +81,13 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             }
         }
     }
+
+    public enum FruitVisualRepresentation
+    {
+        Pear,
+        Grape,
+        Pineapple,
+        Raspberry,
+        Banana // banananananannaanana
+    }
 }

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

@@ -1,37 +1,33 @@
 // 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 JetBrains.Annotations;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableJuiceStream : DrawableCatchHitObject<JuiceStream>
+    public class DrawableJuiceStream : DrawableCatchHitObject
     {
-        private readonly Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation;
         private readonly Container dropletContainer;
 
-        public override Vector2 OriginPosition => base.OriginPosition - new Vector2(0, CatchHitObject.OBJECT_RADIUS);
+        public DrawableJuiceStream()
+            : this(null)
+        {
+        }
 
-        public DrawableJuiceStream(JuiceStream s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
+        public DrawableJuiceStream([CanBeNull] JuiceStream s)
             : base(s)
         {
-            this.createDrawableRepresentation = createDrawableRepresentation;
             RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
-            X = 0;
 
             AddInternal(dropletContainer = new Container { RelativeSizeAxes = Axes.Both, });
         }
 
         protected override void AddNestedHitObject(DrawableHitObject hitObject)
         {
-            hitObject.Origin = Anchor.BottomCentre;
-
             base.AddNestedHitObject(hitObject);
             dropletContainer.Add(hitObject);
         }
@@ -39,19 +35,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         protected override void ClearNestedHitObjects()
         {
             base.ClearNestedHitObjects();
-            dropletContainer.Clear();
-        }
-
-        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
-        {
-            switch (hitObject)
-            {
-                case CatchHitObject catchObject:
-                    return createDrawableRepresentation?.Invoke(catchObject)?.With(o =>
-                        ((DrawableCatchHitObject)o).CheckPosition = p => CheckPosition?.Invoke(p) ?? false);
-            }
-
-            throw new ArgumentException($"{nameof(hitObject)} must be of type {nameof(CatchHitObject)}.");
+            dropletContainer.Clear(false);
         }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawables/DrawablePalpableCatchHitObject.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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public abstract class DrawablePalpableCatchHitObject : DrawableCatchHitObject
+    {
+        public new PalpableCatchHitObject HitObject => (PalpableCatchHitObject)base.HitObject;
+
+        public readonly Bindable<bool> HyperDash = new Bindable<bool>();
+
+        public readonly Bindable<float> ScaleBindable = new Bindable<float>(1);
+
+        public readonly Bindable<int> IndexInBeatmap = new Bindable<int>();
+
+        /// <summary>
+        /// The multiplicative factor applied to <see cref="ScaleContainer"/> scale relative to <see cref="HitObject"/> scale.
+        /// </summary>
+        protected virtual float ScaleFactor => 1;
+
+        /// <summary>
+        /// Whether this hit object should stay on the catcher plate when the object is caught by the catcher.
+        /// </summary>
+        public virtual bool StaysOnPlate => true;
+
+        public float DisplayRadius => CatchHitObject.OBJECT_RADIUS * HitObject.Scale * ScaleFactor;
+
+        protected readonly Container ScaleContainer;
+
+        protected DrawablePalpableCatchHitObject([CanBeNull] CatchHitObject h)
+            : base(h)
+        {
+            Origin = Anchor.Centre;
+            Size = new Vector2(CatchHitObject.OBJECT_RADIUS * 2);
+
+            AddInternal(ScaleContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            XBindable.BindValueChanged(x =>
+            {
+                if (!IsOnPlate) X = x.NewValue;
+            }, true);
+
+            ScaleBindable.BindValueChanged(scale =>
+            {
+                ScaleContainer.Scale = new Vector2(scale.NewValue * ScaleFactor);
+            }, true);
+
+            IndexInBeatmap.BindValueChanged(_ => UpdateComboColour());
+        }
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            HyperDash.BindTo(HitObject.HyperDashBindable);
+            ScaleBindable.BindTo(HitObject.ScaleBindable);
+            IndexInBeatmap.BindTo(HitObject.IndexInBeatmapBindable);
+        }
+
+        protected override void OnFree()
+        {
+            HyperDash.UnbindFrom(HitObject.HyperDashBindable);
+            ScaleBindable.UnbindFrom(HitObject.ScaleBindable);
+            IndexInBeatmap.UnbindFrom(HitObject.IndexInBeatmapBindable);
+
+            base.OnFree();
+        }
+    }
+}

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

@@ -1,21 +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 osu.Framework.Allocation;
+using JetBrains.Annotations;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public class DrawableTinyDroplet : DrawableDroplet
     {
-        public DrawableTinyDroplet(TinyDroplet h)
-            : base(h)
+        protected override float ScaleFactor => base.ScaleFactor / 2;
+
+        public DrawableTinyDroplet()
+            : this(null)
         {
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
+        public DrawableTinyDroplet([CanBeNull] TinyDroplet h)
+            : base(h)
         {
-            ScaleContainer.Scale /= 2;
         }
     }
 }

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

@@ -1,69 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
-{
-    public class DropletPiece : CompositeDrawable
-    {
-        public DropletPiece()
-        {
-            Size = new Vector2(CatchHitObject.OBJECT_RADIUS / 2);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(DrawableHitObject drawableObject)
-        {
-            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
-            var hitObject = drawableCatchObject.HitObject;
-
-            InternalChild = new Pulp
-            {
-                RelativeSizeAxes = Axes.Both,
-                AccentColour = { BindTarget = drawableObject.AccentColour }
-            };
-
-            if (hitObject.HyperDash)
-            {
-                AddInternal(new Container
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Size = new Vector2(2f),
-                    Depth = 1,
-                    Children = new Drawable[]
-                    {
-                        new Circle
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                            BorderColour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                            BorderThickness = 6,
-                            Children = new Drawable[]
-                            {
-                                new Box
-                                {
-                                    AlwaysPresent = true,
-                                    Alpha = 0.3f,
-                                    Blending = BlendingParameters.Additive,
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                                }
-                            }
-                        }
-                    }
-                });
-            }
-        }
-    }
-}

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

@@ -1,111 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Objects.Drawables;
-using osuTK.Graphics;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
-{
-    internal class FruitPiece : CompositeDrawable
-    {
-        /// <summary>
-        /// Because we're adding a border around the fruit, we need to scale down some.
-        /// </summary>
-        public const float RADIUS_ADJUST = 1.1f;
-
-        private Circle border;
-        private CatchHitObject hitObject;
-
-        public FruitPiece()
-        {
-            RelativeSizeAxes = Axes.Both;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(DrawableHitObject drawableObject)
-        {
-            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
-            hitObject = drawableCatchObject.HitObject;
-
-            AddRangeInternal(new[]
-            {
-                getFruitFor(drawableCatchObject.HitObject.VisualRepresentation),
-                border = new Circle
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    BorderColour = Color4.White,
-                    BorderThickness = 6f * RADIUS_ADJUST,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            AlwaysPresent = true,
-                            Alpha = 0,
-                            RelativeSizeAxes = Axes.Both
-                        }
-                    }
-                },
-            });
-
-            if (hitObject.HyperDash)
-            {
-                AddInternal(new Circle
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    BorderColour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                    BorderThickness = 12f * RADIUS_ADJUST,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            AlwaysPresent = true,
-                            Alpha = 0.3f,
-                            Blending = BlendingParameters.Additive,
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                        }
-                    }
-                });
-            }
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-            border.Alpha = (float)Math.Clamp((hitObject.StartTime - Time.Current) / 500, 0, 1);
-        }
-
-        private Drawable getFruitFor(FruitVisualRepresentation representation)
-        {
-            switch (representation)
-            {
-                case FruitVisualRepresentation.Pear:
-                    return new PearPiece();
-
-                case FruitVisualRepresentation.Grape:
-                    return new GrapePiece();
-
-                case FruitVisualRepresentation.Pineapple:
-                    return new PineapplePiece();
-
-                case FruitVisualRepresentation.Banana:
-                    return new BananaPiece();
-
-                case FruitVisualRepresentation.Raspberry:
-                    return new RaspberryPiece();
-            }
-
-            return Empty();
-        }
-    }
-}

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/BananaPiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class BananaPiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/BorderPiece.cs

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    public class BorderPiece : Circle
+    {
+        public BorderPiece()
+        {
+            Size = new Vector2(CatchHitObject.OBJECT_RADIUS * 2);
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            BorderColour = Color4.White;
+            BorderThickness = 6f * FruitPiece.RADIUS_ADJUST;
+
+            // Border is drawn only when there is a child drawable.
+            Child = new Box
+            {
+                AlwaysPresent = true,
+                Alpha = 0,
+                RelativeSizeAxes = Axes.Both,
+            };
+        }
+    }
+}
+

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/DropletPiece.cs

@@ -0,0 +1,37 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    public class DropletPiece : CompositeDrawable
+    {
+        public readonly Bindable<bool> HyperDash = new Bindable<bool>();
+
+        public DropletPiece()
+        {
+            Size = new Vector2(CatchHitObject.OBJECT_RADIUS / 2);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(DrawableHitObject drawableObject)
+        {
+            InternalChild = new Pulp
+            {
+                RelativeSizeAxes = Axes.Both,
+                AccentColour = { BindTarget = drawableObject.AccentColour }
+            };
+
+            if (HyperDash.Value)
+            {
+                AddInternal(new HyperDropletBorderPiece());
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/FruitPiece.cs

@@ -0,0 +1,79 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    internal class FruitPiece : CompositeDrawable
+    {
+        /// <summary>
+        /// Because we're adding a border around the fruit, we need to scale down some.
+        /// </summary>
+        public const float RADIUS_ADJUST = 1.1f;
+
+        public readonly Bindable<FruitVisualRepresentation> VisualRepresentation = new Bindable<FruitVisualRepresentation>();
+        public readonly Bindable<bool> HyperDash = new Bindable<bool>();
+
+        [CanBeNull]
+        private DrawableCatchHitObject drawableHitObject;
+
+        [CanBeNull]
+        private BorderPiece borderPiece;
+
+        public FruitPiece()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader(permitNulls: true)]
+        private void load([CanBeNull] DrawableHitObject drawable)
+        {
+            drawableHitObject = (DrawableCatchHitObject)drawable;
+
+            AddInternal(getFruitFor(VisualRepresentation.Value));
+
+            // if it is not part of a DHO, the border is always invisible.
+            if (drawableHitObject != null)
+                AddInternal(borderPiece = new BorderPiece());
+
+            if (HyperDash.Value)
+                AddInternal(new HyperBorderPiece());
+        }
+
+        protected override void Update()
+        {
+            if (borderPiece != null && drawableHitObject?.HitObject != null)
+                borderPiece.Alpha = (float)Math.Clamp((drawableHitObject.HitObject.StartTime - Time.Current) / 500, 0, 1);
+        }
+
+        private Drawable getFruitFor(FruitVisualRepresentation representation)
+        {
+            switch (representation)
+            {
+                case FruitVisualRepresentation.Pear:
+                    return new PearPiece();
+
+                case FruitVisualRepresentation.Grape:
+                    return new GrapePiece();
+
+                case FruitVisualRepresentation.Pineapple:
+                    return new PineapplePiece();
+
+                case FruitVisualRepresentation.Banana:
+                    return new BananaPiece();
+
+                case FruitVisualRepresentation.Raspberry:
+                    return new RaspberryPiece();
+            }
+
+            return Empty();
+        }
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/GrapePiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class GrapePiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/HyperBorderPiece.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 osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.UI;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    public class HyperBorderPiece : BorderPiece
+    {
+        public HyperBorderPiece()
+        {
+            BorderColour = Catcher.DEFAULT_HYPER_DASH_COLOUR;
+            BorderThickness = 12f * FruitPiece.RADIUS_ADJUST;
+
+            Child.Alpha = 0.3f;
+            Child.Blending = BlendingParameters.Additive;
+            Child.Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR;
+        }
+    }
+}
+

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/HyperDropletBorderPiece.cs

@@ -0,0 +1,14 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+{
+    public class HyperDropletBorderPiece : HyperBorderPiece
+    {
+        public HyperDropletBorderPiece()
+        {
+            Size /= 2;
+            BorderThickness = 6f;
+        }
+    }
+}

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/PearPiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class PearPiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/PineapplePiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class PineapplePiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/PulpFormation.cs

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public abstract class PulpFormation : CompositeDrawable
     {

osu.Game.Rulesets.Catch/Objects/Drawables/Pieces/RaspberryPiece.cs

@@ -2,10 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osuTK;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
     public class RaspberryPiece : PulpFormation
     {

osu.Game.Rulesets.Catch/Objects/JuiceStream.cs

@@ -50,12 +50,7 @@ namespace osu.Game.Rulesets.Catch.Objects
         {
             base.CreateNestedHitObjects(cancellationToken);
 
-            var dropletSamples = Samples.Select(s => new HitSampleInfo
-            {
-                Bank = s.Bank,
-                Name = @"slidertick",
-                Volume = s.Volume
-            }).ToList();
+            var dropletSamples = Samples.Select(s => s.With(@"slidertick")).ToList();
 
             int nodeIndex = 0;
             SliderEventDescriptor? lastEvent = null;

osu.Game.Rulesets.Catch/Objects/PalpableCatchHitObject.cs

@@ -0,0 +1,48 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Bindables;
+using osu.Game.Rulesets.Objects.Types;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Objects
+{
+    /// <summary>
+    /// Represents a single object that can be caught by the catcher.
+    /// This includes normal fruits, droplets, and bananas but excludes objects that act only as a container of nested hit objects.
+    /// </summary>
+    public abstract class PalpableCatchHitObject : CatchHitObject, IHasComboInformation
+    {
+        /// <summary>
+        /// Difference between the distance to the next object
+        /// and the distance that would have triggered a hyper dash.
+        /// A value close to 0 indicates a difficult jump (for difficulty calculation).
+        /// </summary>
+        public float DistanceToHyperDash { get; set; }
+
+        public readonly Bindable<bool> HyperDashBindable = new Bindable<bool>();
+
+        /// <summary>
+        /// Whether this fruit can initiate a hyperdash.
+        /// </summary>
+        public bool HyperDash => HyperDashBindable.Value;
+
+        private CatchHitObject hyperDashTarget;
+
+        /// <summary>
+        /// The target fruit if we are to initiate a hyperdash.
+        /// </summary>
+        public CatchHitObject HyperDashTarget
+        {
+            get => hyperDashTarget;
+            set
+            {
+                hyperDashTarget = value;
+                HyperDashBindable.Value = value != null;
+            }
+        }
+
+        Color4 IHasComboInformation.GetComboColour(IReadOnlyList<Color4> comboColours) => comboColours[(IndexInBeatmap + 1) % comboColours.Count];
+    }
+}

osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs

@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Catch.Replays
             float lastPosition = CatchPlayfield.CENTER_X;
             double lastTime = 0;
 
-            void moveToNext(CatchHitObject h)
+            void moveToNext(PalpableCatchHitObject h)
             {
                 float positionChange = Math.Abs(lastPosition - h.X);
                 double timeAvailable = h.StartTime - lastTime;
@@ -101,23 +101,16 @@ namespace osu.Game.Rulesets.Catch.Replays
 
             foreach (var obj in Beatmap.HitObjects)
             {
-                switch (obj)
+                if (obj is PalpableCatchHitObject palpableObject)
                 {
-                    case Fruit _:
-                        moveToNext(obj);
-                        break;
+                    moveToNext(palpableObject);
                 }
 
                 foreach (var nestedObj in obj.NestedHitObjects.Cast<CatchHitObject>())
                 {
-                    switch (nestedObj)
+                    if (nestedObj is PalpableCatchHitObject palpableNestedObject)
                     {
-                        case Banana _:
-                        case TinyDroplet _:
-                        case Droplet _:
-                        case Fruit _:
-                            moveToNext(nestedObj);
-                            break;
+                        moveToNext(palpableNestedObject);
                     }
                 }
             }

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

@@ -19,7 +19,8 @@ namespace osu.Game.Rulesets.Catch.Skinning
     {
         private readonly string lookupName;
 
-        private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+        private readonly Bindable<bool> hyperDash = new Bindable<bool>();
         private Sprite colouredSprite;
 
         public LegacyFruitPiece(string lookupName)
@@ -31,9 +32,10 @@ namespace osu.Game.Rulesets.Catch.Skinning
         [BackgroundDependencyLoader]
         private void load(DrawableHitObject drawableObject, ISkinSource skin)
         {
-            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
+            var drawableCatchObject = (DrawablePalpableCatchHitObject)drawableObject;
 
             accentColour.BindTo(drawableCatchObject.AccentColour);
+            hyperDash.BindTo(drawableCatchObject.HyperDash);
 
             InternalChildren = new Drawable[]
             {
@@ -51,9 +53,9 @@ namespace osu.Game.Rulesets.Catch.Skinning
                 },
             };
 
-            if (drawableCatchObject.HitObject.HyperDash)
+            if (hyperDash.Value)
             {
-                var hyperDash = new Sprite
+                var hyperDashOverlay = new Sprite
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -67,7 +69,7 @@ namespace osu.Game.Rulesets.Catch.Skinning
                              Catcher.DEFAULT_HYPER_DASH_COLOUR,
                 };
 
-                AddInternal(hyperDash);
+                AddInternal(hyperDashOverlay);
             }
         }
 

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
@@ -35,41 +36,53 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation)
         {
-            var explodingFruitContainer = new Container
+            var droppedObjectContainer = new Container
             {
                 RelativeSizeAxes = Axes.Both,
             };
 
-            CatcherArea = new CatcherArea(difficulty)
+            CatcherArea = new CatcherArea(droppedObjectContainer, difficulty)
             {
-                CreateDrawableRepresentation = createDrawableRepresentation,
-                ExplodingFruitTarget = explodingFruitContainer,
                 Anchor = Anchor.BottomLeft,
                 Origin = Anchor.TopLeft,
             };
 
             InternalChildren = new[]
             {
-                explodingFruitContainer,
+                droppedObjectContainer,
                 CatcherArea.MovableCatcher.CreateProxiedContent(),
                 HitObjectContainer,
                 CatcherArea,
             };
         }
 
-        public bool CheckIfWeCanCatch(CatchHitObject obj) => CatcherArea.AttemptCatch(obj);
-
-        public override void Add(DrawableHitObject h)
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            h.OnNewResult += onNewResult;
-            h.OnRevertResult += onRevertResult;
-
-            base.Add(h);
-
-            var fruit = (DrawableCatchHitObject)h;
-            fruit.CheckPosition = CheckIfWeCanCatch;
+            RegisterPool<Droplet, DrawableDroplet>(50);
+            RegisterPool<TinyDroplet, DrawableTinyDroplet>(50);
+            RegisterPool<Fruit, DrawableFruit>(100);
+            RegisterPool<Banana, DrawableBanana>(100);
+            RegisterPool<JuiceStream, DrawableJuiceStream>(10);
+            RegisterPool<BananaShower, DrawableBananaShower>(2);
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // these subscriptions need to be done post constructor to ensure externally bound components have a chance to populate required fields (ScoreProcessor / ComboAtJudgement in this case).
+            NewResult += onNewResult;
+            RevertResult += onRevertResult;
+        }
+
+        protected override void OnNewDrawableHitObject(DrawableHitObject d)
+        {
+            ((DrawableCatchHitObject)d).CheckPosition = checkIfWeCanCatch;
+        }
+
+        private bool checkIfWeCanCatch(CatchHitObject obj) => CatcherArea.AttemptCatch(obj);
+
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
             => CatcherArea.OnNewResult((DrawableCatchHitObject)judgedObject, result);
 

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

@@ -9,6 +9,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -16,7 +17,6 @@ using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Skinning;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
@@ -46,19 +46,15 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         public const double BASE_SPEED = 1.0;
 
-        public Container ExplodingFruitTarget;
-
-        private Container<DrawableHitObject> caughtFruitContainer { get; } = new Container<DrawableHitObject>
-        {
-            Anchor = Anchor.TopCentre,
-            Origin = Anchor.BottomCentre,
-        };
-
         [NotNull]
         private readonly Container trailsTarget;
 
         private CatcherTrailDisplay trails;
 
+        private readonly Container droppedObjectTarget;
+
+        private readonly Container<DrawablePalpableCatchHitObject> caughtFruitContainer;
+
         public CatcherAnimationState CurrentState { get; private set; }
 
         /// <summary>
@@ -91,9 +87,9 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private readonly float catchWidth;
 
-        private CatcherSprite catcherIdle;
-        private CatcherSprite catcherKiai;
-        private CatcherSprite catcherFail;
+        private readonly CatcherSprite catcherIdle;
+        private readonly CatcherSprite catcherKiai;
+        private readonly CatcherSprite catcherFail;
 
         private CatcherSprite currentCatcher;
 
@@ -107,9 +103,13 @@ namespace osu.Game.Rulesets.Catch.UI
         private float hyperDashTargetPosition;
         private Bindable<bool> hitLighting;
 
-        public Catcher([NotNull] Container trailsTarget, BeatmapDifficulty difficulty = null)
+        private readonly DrawablePool<HitExplosion> hitExplosionPool;
+        private readonly Container<HitExplosion> hitExplosionContainer;
+
+        public Catcher([NotNull] Container trailsTarget, [NotNull] Container droppedObjectTarget, BeatmapDifficulty difficulty = null)
         {
             this.trailsTarget = trailsTarget;
+            this.droppedObjectTarget = droppedObjectTarget;
 
             Origin = Anchor.TopCentre;
 
@@ -118,16 +118,15 @@ namespace osu.Game.Rulesets.Catch.UI
                 Scale = calculateScale(difficulty);
 
             catchWidth = CalculateCatchWidth(Scale);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            hitLighting = config.GetBindable<bool>(OsuSetting.HitLighting);
 
             InternalChildren = new Drawable[]
             {
-                caughtFruitContainer,
+                hitExplosionPool = new DrawablePool<HitExplosion>(10),
+                caughtFruitContainer = new Container<DrawablePalpableCatchHitObject>
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.BottomCentre,
+                },
                 catcherIdle = new CatcherSprite(CatcherAnimationState.Idle)
                 {
                     Anchor = Anchor.TopCentre,
@@ -142,9 +141,19 @@ namespace osu.Game.Rulesets.Catch.UI
                 {
                     Anchor = Anchor.TopCentre,
                     Alpha = 0,
-                }
+                },
+                hitExplosionContainer = new Container<HitExplosion>
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.BottomCentre,
+                },
             };
+        }
 
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            hitLighting = config.GetBindable<bool>(OsuSetting.HitLighting);
             trails = new CatcherTrailDisplay(this);
 
             updateCatcher();
@@ -166,65 +175,28 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <summary>
         /// Calculates the scale of the catcher based off the provided beatmap difficulty.
         /// </summary>
-        private static Vector2 calculateScale(BeatmapDifficulty difficulty)
-            => new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+        private static Vector2 calculateScale(BeatmapDifficulty difficulty) => new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
 
         /// <summary>
         /// Calculates the width of the area used for attempting catches in gameplay.
         /// </summary>
         /// <param name="scale">The scale of the catcher.</param>
-        internal static float CalculateCatchWidth(Vector2 scale)
-            => CatcherArea.CATCHER_SIZE * Math.Abs(scale.X) * ALLOWED_CATCH_RANGE;
+        internal static float CalculateCatchWidth(Vector2 scale) => CatcherArea.CATCHER_SIZE * Math.Abs(scale.X) * ALLOWED_CATCH_RANGE;
 
         /// <summary>
         /// Calculates the width of the area used for attempting catches in gameplay.
         /// </summary>
         /// <param name="difficulty">The beatmap difficulty.</param>
-        internal static float CalculateCatchWidth(BeatmapDifficulty difficulty)
-            => CalculateCatchWidth(calculateScale(difficulty));
-
-        /// <summary>
-        /// Add a caught fruit to the catcher's stack.
-        /// </summary>
-        /// <param name="fruit">The fruit that was caught.</param>
-        public void PlaceOnPlate(DrawableCatchHitObject fruit)
-        {
-            var ourRadius = fruit.DisplayRadius;
-            float theirRadius = 0;
-
-            const float allowance = 10;
-
-            while (caughtFruitContainer.Any(f =>
-                f.LifetimeEnd == double.MaxValue &&
-                Vector2Extensions.Distance(f.Position, fruit.Position) < (ourRadius + (theirRadius = f.DrawSize.X / 2 * f.Scale.X)) / (allowance / 2)))
-            {
-                var diff = (ourRadius + theirRadius) / allowance;
-                fruit.X += (RNG.NextSingle() - 0.5f) * diff * 2;
-                fruit.Y -= RNG.NextSingle() * diff;
-            }
-
-            fruit.X = Math.Clamp(fruit.X, -CatcherArea.CATCHER_SIZE / 2, CatcherArea.CATCHER_SIZE / 2);
-
-            caughtFruitContainer.Add(fruit);
-
-            if (hitLighting.Value)
-            {
-                AddInternal(new HitExplosion(fruit)
-                {
-                    X = fruit.X,
-                    Scale = new Vector2(fruit.HitObject.Scale)
-                });
-            }
-        }
+        internal static float CalculateCatchWidth(BeatmapDifficulty difficulty) => CalculateCatchWidth(calculateScale(difficulty));
 
         /// <summary>
         /// Let the catcher attempt to catch a fruit.
         /// </summary>
-        /// <param name="fruit">The fruit to catch.</param>
+        /// <param name="hitObject">The fruit to catch.</param>
         /// <returns>Whether the catch is possible.</returns>
-        public bool AttemptCatch(CatchHitObject fruit)
+        public bool AttemptCatch(CatchHitObject hitObject)
         {
-            if (!fruit.CanBePlated)
+            if (!(hitObject is PalpableCatchHitObject fruit))
                 return false;
 
             var halfCatchWidth = catchWidth * 0.5f;
@@ -237,7 +209,10 @@ namespace osu.Game.Rulesets.Catch.UI
                 catchObjectPosition >= catcherPosition - halfCatchWidth &&
                 catchObjectPosition <= catcherPosition + halfCatchWidth;
 
-            // only update hyperdash state if we are not catching a tiny droplet.
+            if (validCatch)
+                placeCaughtObject(fruit);
+
+            // droplet doesn't affect the catcher state
             if (fruit is TinyDroplet) return validCatch;
 
             if (validCatch && fruit.HyperDash)
@@ -291,24 +266,17 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
-        private void runHyperDashStateTransition(bool hyperDashing)
+        public void UpdatePosition(float position)
         {
-            updateTrailVisibility();
+            position = Math.Clamp(position, 0, CatchPlayfield.WIDTH);
 
-            if (hyperDashing)
-            {
-                this.FadeColour(hyperDashColour, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-                this.FadeTo(0.2f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-            }
-            else
-            {
-                this.FadeColour(Color4.White, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-                this.FadeTo(1f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-            }
+            if (position == X)
+                return;
+
+            Scale = new Vector2(Math.Abs(Scale.X) * (position > X ? 1 : -1), Scale.Y);
+            X = position;
         }
 
-        private void updateTrailVisibility() => trails.DisplayTrail = Dashing || HyperDashing;
-
         public bool OnPressed(CatchAction action)
         {
             switch (action)
@@ -347,56 +315,34 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
-        public void UpdatePosition(float position)
-        {
-            position = Math.Clamp(position, 0, CatchPlayfield.WIDTH);
-
-            if (position == X)
-                return;
-
-            Scale = new Vector2(Math.Abs(Scale.X) * (position > X ? 1 : -1), Scale.Y);
-            X = position;
-        }
-
         /// <summary>
         /// Drop any fruit off the plate.
         /// </summary>
-        public void Drop()
-        {
-            foreach (var f in caughtFruitContainer.ToArray())
-                Drop(f);
-        }
+        public void Drop() => clearPlate(DroppedObjectAnimation.Drop);
 
         /// <summary>
-        /// Explode any fruit off the plate.
+        /// Explode all fruit off the plate.
         /// </summary>
-        public void Explode()
-        {
-            foreach (var f in caughtFruitContainer.ToArray())
-                Explode(f);
-        }
+        public void Explode() => clearPlate(DroppedObjectAnimation.Explode);
 
-        public void Drop(DrawableHitObject fruit)
+        private void runHyperDashStateTransition(bool hyperDashing)
         {
-            removeFromPlateWithTransform(fruit, f =>
+            updateTrailVisibility();
+
+            if (hyperDashing)
             {
-                f.MoveToY(f.Y + 75, 750, Easing.InSine);
-                f.FadeOut(750);
-            });
-        }
-
-        public void Explode(DrawableHitObject fruit)
-        {
-            var originalX = fruit.X * Scale.X;
-
-            removeFromPlateWithTransform(fruit, f =>
+                this.FadeColour(hyperDashColour, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+                this.FadeTo(0.2f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            }
+            else
             {
-                f.MoveToY(f.Y - 50, 250, Easing.OutSine).Then().MoveToY(f.Y + 50, 500, Easing.InSine);
-                f.MoveToX(f.X + originalX * 6, 1000);
-                f.FadeOut(750);
-            });
+                this.FadeColour(Color4.White, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+                this.FadeTo(1f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            }
         }
 
+        private void updateTrailVisibility() => trails.DisplayTrail = Dashing || HyperDashing;
+
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)
         {
             base.SkinChanged(skin, allowFallback);
@@ -469,33 +415,143 @@ namespace osu.Game.Rulesets.Catch.UI
             updateCatcher();
         }
 
-        private void removeFromPlateWithTransform(DrawableHitObject fruit, Action<DrawableHitObject> action)
+        private void placeCaughtObject(PalpableCatchHitObject source)
         {
-            if (ExplodingFruitTarget != null)
+            var caughtObject = createCaughtObject(source);
+
+            if (caughtObject == null) return;
+
+            caughtObject.RelativePositionAxes = Axes.None;
+            caughtObject.X = source.X - X;
+            caughtObject.IsOnPlate = true;
+
+            caughtObject.Anchor = Anchor.TopCentre;
+            caughtObject.Origin = Anchor.Centre;
+            caughtObject.Scale *= 0.5f;
+            caughtObject.LifetimeStart = source.StartTime;
+            caughtObject.LifetimeEnd = double.MaxValue;
+
+            adjustPositionInStack(caughtObject);
+
+            caughtFruitContainer.Add(caughtObject);
+
+            addLighting(caughtObject);
+
+            if (!caughtObject.StaysOnPlate)
+                removeFromPlate(caughtObject, DroppedObjectAnimation.Explode);
+        }
+
+        private void adjustPositionInStack(DrawablePalpableCatchHitObject caughtObject)
+        {
+            const float radius_div_2 = CatchHitObject.OBJECT_RADIUS / 2;
+            const float allowance = 10;
+
+            float caughtObjectRadius = caughtObject.DisplayRadius;
+
+            while (caughtFruitContainer.Any(f => Vector2Extensions.Distance(f.Position, caughtObject.Position) < (caughtObjectRadius + radius_div_2) / (allowance / 2)))
             {
-                fruit.Anchor = Anchor.TopLeft;
-                fruit.Position = caughtFruitContainer.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
+                float diff = (caughtObjectRadius + radius_div_2) / allowance;
 
-                if (!caughtFruitContainer.Remove(fruit))
-                    // we may have already been removed by a previous operation (due to the weird OnLoadComplete scheduling).
-                    // this avoids a crash on potentially attempting to Add a fruit to ExplodingFruitTarget twice.
-                    return;
-
-                ExplodingFruitTarget.Add(fruit);
+                caughtObject.X += (RNG.NextSingle() - 0.5f) * diff * 2;
+                caughtObject.Y -= RNG.NextSingle() * diff;
             }
 
-            var actionTime = Clock.CurrentTime;
+            caughtObject.X = Math.Clamp(caughtObject.X, -CatcherArea.CATCHER_SIZE / 2, CatcherArea.CATCHER_SIZE / 2);
+        }
 
-            fruit.ApplyCustomUpdateState += onFruitOnApplyCustomUpdateState;
-            onFruitOnApplyCustomUpdateState(fruit, fruit.State.Value);
+        private void addLighting(DrawablePalpableCatchHitObject caughtObject)
+        {
+            if (!hitLighting.Value) return;
 
-            void onFruitOnApplyCustomUpdateState(DrawableHitObject o, ArmedState state)
+            HitExplosion hitExplosion = hitExplosionPool.Get();
+            hitExplosion.X = caughtObject.X;
+            hitExplosion.Scale = new Vector2(caughtObject.HitObject.Scale);
+            hitExplosion.ObjectColour = caughtObject.AccentColour.Value;
+            hitExplosionContainer.Add(hitExplosion);
+        }
+
+        private DrawablePalpableCatchHitObject createCaughtObject(PalpableCatchHitObject source)
+        {
+            switch (source)
             {
-                using (fruit.BeginAbsoluteSequence(actionTime))
-                    action(fruit);
+                case Banana banana:
+                    return new DrawableBanana(banana);
 
-                fruit.Expire();
+                case Fruit fruit:
+                    return new DrawableFruit(fruit);
+
+                case TinyDroplet tiny:
+                    return new DrawableTinyDroplet(tiny);
+
+                case Droplet droplet:
+                    return new DrawableDroplet(droplet);
+
+                default:
+                    return null;
             }
         }
+
+        private void clearPlate(DroppedObjectAnimation animation)
+        {
+            var caughtObjects = caughtFruitContainer.Children.ToArray();
+            caughtFruitContainer.Clear(false);
+
+            droppedObjectTarget.AddRange(caughtObjects);
+
+            foreach (var caughtObject in caughtObjects)
+                drop(caughtObject, animation);
+        }
+
+        private void removeFromPlate(DrawablePalpableCatchHitObject caughtObject, DroppedObjectAnimation animation)
+        {
+            if (!caughtFruitContainer.Remove(caughtObject))
+                throw new InvalidOperationException("Can only drop a caught object on the plate");
+
+            droppedObjectTarget.Add(caughtObject);
+
+            drop(caughtObject, animation);
+        }
+
+        private void drop(DrawablePalpableCatchHitObject d, DroppedObjectAnimation animation)
+        {
+            var originalX = d.X * Scale.X;
+            var startTime = Clock.CurrentTime;
+
+            d.Anchor = Anchor.TopLeft;
+            d.Position = caughtFruitContainer.ToSpaceOfOtherDrawable(d.DrawPosition, droppedObjectTarget);
+
+            // we cannot just apply the transforms because DHO clears transforms when state is updated
+            d.ApplyCustomUpdateState += (o, state) => animate(o, animation, originalX, startTime);
+            if (d.IsLoaded)
+                animate(d, animation, originalX, startTime);
+        }
+
+        private void animate(Drawable d, DroppedObjectAnimation animation, float originalX, double startTime)
+        {
+            using (d.BeginAbsoluteSequence(startTime))
+            {
+                switch (animation)
+                {
+                    case DroppedObjectAnimation.Drop:
+                        d.MoveToY(d.Y + 75, 750, Easing.InSine);
+                        d.FadeOut(750);
+                        break;
+
+                    case DroppedObjectAnimation.Explode:
+                        d.MoveToY(d.Y - 50, 250, Easing.OutSine).Then().MoveToY(d.Y + 50, 500, Easing.InSine);
+                        d.MoveToX(d.X + originalX * 6, 1000);
+                        d.FadeOut(750);
+                        break;
+                }
+
+                d.Expire();
+            }
+        }
+
+        private enum DroppedObjectAnimation
+        {
+            Drop,
+            Explode
+        }
     }
 }

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

@@ -1,7 +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.
 
-using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
@@ -10,7 +9,6 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osuTK;
@@ -21,19 +19,10 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float CATCHER_SIZE = 106.75f;
 
-        public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> CreateDrawableRepresentation;
-
         public readonly Catcher MovableCatcher;
         private readonly CatchComboDisplay comboDisplay;
 
-        public Container ExplodingFruitTarget
-        {
-            set => MovableCatcher.ExplodingFruitTarget = value;
-        }
-
-        private DrawableCatchHitObject lastPlateableFruit;
-
-        public CatcherArea(BeatmapDifficulty difficulty = null)
+        public CatcherArea(Container droppedObjectContainer, BeatmapDifficulty difficulty = null)
         {
             Size = new Vector2(CatchPlayfield.WIDTH, CATCHER_SIZE);
             Children = new Drawable[]
@@ -47,70 +36,29 @@ namespace osu.Game.Rulesets.Catch.UI
                     Margin = new MarginPadding { Bottom = 350f },
                     X = CatchPlayfield.CENTER_X
                 },
-                MovableCatcher = new Catcher(this, difficulty) { X = CatchPlayfield.CENTER_X },
+                MovableCatcher = new Catcher(this, droppedObjectContainer, difficulty) { X = CatchPlayfield.CENTER_X },
             };
         }
 
-        public void OnNewResult(DrawableCatchHitObject fruit, JudgementResult result)
+        public void OnNewResult(DrawableCatchHitObject hitObject, JudgementResult result)
         {
             if (!result.Type.IsScorable())
                 return;
 
-            void runAfterLoaded(Action action)
-            {
-                if (lastPlateableFruit == null)
-                    return;
-
-                // this is required to make this run after the last caught fruit runs updateState() at least once.
-                // TODO: find a better alternative
-                if (lastPlateableFruit.IsLoaded)
-                    action();
-                else
-                    lastPlateableFruit.OnLoadComplete += _ => action();
-            }
-
-            if (result.IsHit && fruit.HitObject.CanBePlated)
-            {
-                // create a new (cloned) fruit to stay on the plate. the original is faded out immediately.
-                var caughtFruit = (DrawableCatchHitObject)CreateDrawableRepresentation?.Invoke(fruit.HitObject);
-
-                if (caughtFruit == null) return;
-
-                caughtFruit.RelativePositionAxes = Axes.None;
-                caughtFruit.Position = new Vector2(MovableCatcher.ToLocalSpace(fruit.ScreenSpaceDrawQuad.Centre).X - MovableCatcher.DrawSize.X / 2, 0);
-                caughtFruit.IsOnPlate = true;
-
-                caughtFruit.Anchor = Anchor.TopCentre;
-                caughtFruit.Origin = Anchor.Centre;
-                caughtFruit.Scale *= 0.5f;
-                caughtFruit.LifetimeStart = caughtFruit.HitObject.StartTime;
-                caughtFruit.LifetimeEnd = double.MaxValue;
-
-                MovableCatcher.PlaceOnPlate(caughtFruit);
-                lastPlateableFruit = caughtFruit;
-
-                if (!fruit.StaysOnPlate)
-                    runAfterLoaded(() => MovableCatcher.Explode(caughtFruit));
-            }
-
-            if (fruit.HitObject.LastInCombo)
+            if (hitObject.HitObject.LastInCombo)
             {
                 if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
-                    runAfterLoaded(() => MovableCatcher.Explode());
+                    MovableCatcher.Explode();
                 else
                     MovableCatcher.Drop();
             }
 
-            comboDisplay.OnNewResult(fruit, result);
+            comboDisplay.OnNewResult(hitObject, result);
         }
 
         public void OnRevertResult(DrawableCatchHitObject fruit, JudgementResult result)
             => comboDisplay.OnRevertResult(fruit, result);
 
-        public void OnReleased(CatchAction action)
-        {
-        }
-
         public bool AttemptCatch(CatchHitObject obj)
         {
             return MovableCatcher.AttemptCatch(obj);

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

@@ -8,7 +8,6 @@ using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -40,30 +39,6 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
 
-        public override DrawableHitObject<CatchHitObject> CreateDrawableRepresentation(CatchHitObject h)
-        {
-            switch (h)
-            {
-                case Banana banana:
-                    return new DrawableBanana(banana);
-
-                case Fruit fruit:
-                    return new DrawableFruit(fruit);
-
-                case JuiceStream stream:
-                    return new DrawableJuiceStream(stream, CreateDrawableRepresentation);
-
-                case BananaShower shower:
-                    return new DrawableBananaShower(shower, CreateDrawableRepresentation);
-
-                case TinyDroplet tiny:
-                    return new DrawableTinyDroplet(tiny);
-
-                case Droplet droplet:
-                    return new DrawableDroplet(droplet);
-            }
-
-            return null;
-        }
+        public override DrawableHitObject<CatchHitObject> CreateDrawableRepresentation(CatchHitObject h) => null;
     }
 }

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

@@ -5,35 +5,43 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Utils;
-using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class HitExplosion : CompositeDrawable
+    public class HitExplosion : PoolableDrawable
     {
-        private readonly CircularContainer largeFaint;
+        private Color4 objectColour;
 
-        public HitExplosion(DrawableCatchHitObject fruit)
+        public Color4 ObjectColour
+        {
+            get => objectColour;
+            set
+            {
+                if (objectColour == value) return;
+
+                objectColour = value;
+                onColourChanged();
+            }
+        }
+
+        private readonly CircularContainer largeFaint;
+        private readonly CircularContainer smallFaint;
+        private readonly CircularContainer directionalGlow1;
+        private readonly CircularContainer directionalGlow2;
+
+        public HitExplosion()
         {
             Size = new Vector2(20);
             Anchor = Anchor.TopCentre;
             Origin = Anchor.BottomCentre;
 
-            Color4 objectColour = fruit.AccentColour.Value;
-
             // scale roughly in-line with visual appearance of notes
-
-            const float angle_variangle = 15; // should be less than 45
-
-            const float roundness = 100;
-
             const float initial_height = 10;
 
-            var colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1);
-
             InternalChildren = new Drawable[]
             {
                 largeFaint = new CircularContainer
@@ -42,33 +50,17 @@ namespace osu.Game.Rulesets.Catch.UI
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,
-                    // we want our size to be very small so the glow dominates it.
-                    Size = new Vector2(0.8f),
                     Blending = BlendingParameters.Additive,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
-                        Roundness = 160,
-                        Radius = 200,
-                    },
                 },
-                new CircularContainer
+                smallFaint = new CircularContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,
                     Blending = BlendingParameters.Additive,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
-                        Roundness = 20,
-                        Radius = 50,
-                    },
                 },
-                new CircularContainer
+                directionalGlow1 = new CircularContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -76,16 +68,8 @@ namespace osu.Game.Rulesets.Catch.UI
                     Masking = true,
                     Size = new Vector2(0.01f, initial_height),
                     Blending = BlendingParameters.Additive,
-                    Rotation = RNG.NextSingle(-angle_variangle, angle_variangle),
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = colour,
-                        Roundness = roundness,
-                        Radius = 40,
-                    },
                 },
-                new CircularContainer
+                directionalGlow2 = new CircularContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -93,30 +77,57 @@ namespace osu.Game.Rulesets.Catch.UI
                     Masking = true,
                     Size = new Vector2(0.01f, initial_height),
                     Blending = BlendingParameters.Additive,
-                    Rotation = RNG.NextSingle(-angle_variangle, angle_variangle),
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = colour,
-                        Roundness = roundness,
-                        Radius = 40,
-                    },
                 }
             };
         }
 
-        protected override void LoadComplete()
+        protected override void PrepareForUse()
         {
-            base.LoadComplete();
+            base.PrepareForUse();
 
             const double duration = 400;
 
+            // we want our size to be very small so the glow dominates it.
+            largeFaint.Size = new Vector2(0.8f);
             largeFaint
                 .ResizeTo(largeFaint.Size * new Vector2(5, 1), duration, Easing.OutQuint)
                 .FadeOut(duration * 2);
 
+            const float angle_variangle = 15; // should be less than 45
+            directionalGlow1.Rotation = RNG.NextSingle(-angle_variangle, angle_variangle);
+            directionalGlow2.Rotation = RNG.NextSingle(-angle_variangle, angle_variangle);
+
             this.FadeInFromZero(50).Then().FadeOut(duration, Easing.Out);
             Expire(true);
         }
+
+        private void onColourChanged()
+        {
+            const float roundness = 100;
+
+            largeFaint.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
+                Roundness = 160,
+                Radius = 200,
+            };
+
+            smallFaint.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
+                Roundness = 20,
+                Radius = 50,
+            };
+
+            directionalGlow1.EdgeEffect = directionalGlow2.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1),
+                Roundness = roundness,
+                Radius = 40,
+            };
+        }
     }
 }

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

@@ -96,6 +96,11 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             throw new System.NotImplementedException();
         }
 
+        public override SnapResult SnapScreenSpacePositionToValidPosition(Vector2 screenSpacePosition)
+        {
+            throw new System.NotImplementedException();
+        }
+
         public override float GetBeatSnapDistanceAt(double referenceTime)
         {
             throw new System.NotImplementedException();

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneDrawableJudgement.cs

@@ -24,7 +24,10 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                 if (hitWindows.IsHitResultAllowed(result))
                 {
                     AddStep("Show " + result.GetDescription(), () => SetContents(() =>
-                        new DrawableManiaJudgement(new JudgementResult(new HitObject(), new Judgement()) { Type = result }, null)
+                        new DrawableManiaJudgement(new JudgementResult(new HitObject { StartTime = Time.Current }, new Judgement())
+                        {
+                            Type = result
+                        }, null)
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,

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

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

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

@@ -78,9 +78,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
         private double originalStartTime;
 
-        public override void UpdatePosition(SnapResult result)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            base.UpdatePosition(result);
+            base.UpdateTimeAndPosition(result);
 
             if (PlacementActive)
             {

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

@@ -48,9 +48,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             return true;
         }
 
-        public override void UpdatePosition(SnapResult result)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            base.UpdatePosition(result);
+            base.UpdateTimeAndPosition(result);
 
             if (!PlacementActive)
                 Column = result.Playfield as Column;

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

@@ -22,9 +22,9 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             InternalChild = piece = new EditNotePiece { Origin = Anchor.Centre };
         }
 
-        public override void UpdatePosition(SnapResult result)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            base.UpdatePosition(result);
+            base.UpdateTimeAndPosition(result);
 
             if (result.Playfield != null)
             {

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

@@ -5,7 +5,7 @@ using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModEasy : ModEasy
+    public class ManiaModEasy : ModEasyWithExtraLives
     {
         public override string Description => @"More forgiving HP drain, less accuracy required, and three lives!";
     }

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

@@ -30,6 +30,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         public void UpdateResult() => base.UpdateResult(true);
 
+        protected override double MaximumJudgementOffset => base.MaximumJudgementOffset * release_window_lenience;
+
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             Debug.Assert(HitObject.HitWindows != null);

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

@@ -16,8 +16,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// </summary>
     public class DrawableHoldNoteTick : DrawableManiaHitObject<HoldNoteTick>
     {
-        public override bool DisplayResult => false;
-
         /// <summary>
         /// References the time at which the user started holding the hold note.
         /// </summary>

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

@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.Mania.UI
             DrawableManiaHitObject maniaObject = (DrawableManiaHitObject)hitObject;
             maniaObject.CheckHittable = hitPolicy.IsHittable;
 
-            HitObjectContainer.Add(hitObject);
+            base.Add(hitObject);
         }
 
         public override bool Remove(DrawableHitObject h)
@@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Mania.UI
             if (result.IsHit)
                 hitPolicy.HandleHit(judgedObject);
 
-            if (!result.IsHit || !DisplayJudgements.Value)
+            if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 
             HitObjectArea.Explosions.Add(hitExplosionPool.Get(e => e.Apply(result)));

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

@@ -1,10 +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.
 
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -19,22 +20,52 @@ namespace osu.Game.Rulesets.Mania.UI
         {
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
+        protected override void ApplyMissAnimations()
         {
-            if (JudgementText != null)
-                JudgementText.Font = JudgementText.Font.With(size: 25);
-        }
+            if (!(JudgementBody.Drawable is DefaultManiaJudgementPiece))
+            {
+                // this is temporary logic until mania's skin transformer returns IAnimatableJudgements
+                JudgementBody.ScaleTo(1.6f);
+                JudgementBody.ScaleTo(1, 100, Easing.In);
 
-        protected override double FadeInDuration => 50;
+                JudgementBody.MoveTo(Vector2.Zero);
+                JudgementBody.MoveToOffset(new Vector2(0, 100), 800, Easing.InQuint);
+
+                JudgementBody.RotateTo(0);
+                JudgementBody.RotateTo(40, 800, Easing.InQuint);
+                JudgementBody.FadeOutFromOne(800);
+
+                LifetimeEnd = JudgementBody.LatestTransformEndTime;
+            }
+
+            base.ApplyMissAnimations();
+        }
 
         protected override void ApplyHitAnimations()
         {
             JudgementBody.ScaleTo(0.8f);
             JudgementBody.ScaleTo(1, 250, Easing.OutElastic);
 
-            JudgementBody.Delay(FadeInDuration).ScaleTo(0.75f, 250);
-            this.Delay(FadeInDuration).FadeOut(200);
+            JudgementBody.Delay(50)
+                         .ScaleTo(0.75f, 250)
+                         .FadeOut(200);
+        }
+
+        protected override Drawable CreateDefaultJudgement(HitResult result) => new DefaultManiaJudgementPiece(result);
+
+        private class DefaultManiaJudgementPiece : DefaultJudgementPiece
+        {
+            public DefaultManiaJudgementPiece(HitResult result)
+                : base(result)
+            {
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                JudgementText.Font = JudgementText.Font.With(size: 25);
+            }
         }
     }
 }

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

@@ -167,6 +167,10 @@ namespace osu.Game.Rulesets.Mania.UI
             if (!judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 
+            // Tick judgements should not display text.
+            if (judgedObject is DrawableHoldNoteTick)
+                return;
+
             judgements.Clear(false);
             judgements.Add(judgementPool.Get(j =>
             {

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

@@ -0,0 +1,41 @@
+// 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.Beatmaps;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Tests.Beatmaps;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    [TestFixture]
+    public class TestSceneObjectBeatSnap : TestSceneOsuEditor
+    {
+        private OsuPlayfield playfield;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(Ruleset.Value, false);
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+            AddStep("get playfield", () => playfield = Editor.ChildrenOfType<OsuPlayfield>().First());
+        }
+
+        [Test]
+        public void TestBeatSnapHitCircle()
+        {
+            double firstTimingPointTime() => Beatmap.Value.Beatmap.ControlPointInfo.TimingPoints.First().Time;
+
+            AddStep("seek some milliseconds forward", () => EditorClock.Seek(firstTimingPointTime() + 10));
+
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre));
+            AddStep("enter placement mode", () => InputManager.Key(Key.Number2));
+            AddStep("place first object", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("ensure object snapped back to correct time", () => EditorBeatmap.HitObjects.First().StartTime == firstTimingPointTime());
+        }
+    }
+}

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

@@ -25,6 +25,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         {
             base.SetUpSteps();
             AddStep("get playfield", () => playfield = Editor.ChildrenOfType<OsuPlayfield>().First());
+            AddStep("seek to first control point", () => EditorClock.Seek(Beatmap.Value.Beatmap.ControlPointInfo.TimingPoints.First().Time));
         }
 
         [TestCase(true)]
@@ -51,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 var first = (OsuHitObject)objects.First();
                 var second = (OsuHitObject)objects.Last();
 
-                return first.Position == second.Position;
+                return Precision.AlmostEquals(first.EndPosition, second.Position);
             });
         }
 
@@ -66,13 +67,13 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
             AddStep("start slider placement", () => InputManager.Click(MouseButton.Left));
 
-            AddStep("move to place end", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.185f, 0)));
+            AddStep("move to place end", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.225f, 0)));
 
             AddStep("end slider placement", () => InputManager.Click(MouseButton.Right));
 
             AddStep("enter circle placement mode", () => InputManager.Key(Key.Number2));
 
-            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.20f, 0)));
+            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.235f, 0)));
 
             AddStep("place second object", () => InputManager.Click(MouseButton.Left));
 
@@ -86,5 +87,64 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 return Precision.AlmostEquals(first.EndPosition, second.Position);
             });
         }
+
+        [Test]
+        public void TestSecondCircleInSelectionAlsoSnaps()
+        {
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre));
+
+            AddStep("disable distance snap", () => InputManager.Key(Key.Q));
+
+            AddStep("enter placement mode", () => InputManager.Key(Key.Number2));
+
+            AddStep("place first object", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("increment time", () => EditorClock.SeekForward(true));
+
+            AddStep("move mouse right", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.2f, 0)));
+            AddStep("place second object", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("increment time", () => EditorClock.SeekForward(true));
+
+            AddStep("move mouse down", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(0, playfield.ScreenSpaceDrawQuad.Width * 0.2f)));
+            AddStep("place third object", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("enter selection mode", () => InputManager.Key(Key.Number1));
+
+            AddStep("select objects 2 and 3", () =>
+            {
+                // add selection backwards to test non-sequential time ordering
+                EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects[2]);
+                EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects[1]);
+            });
+
+            AddStep("begin drag", () => InputManager.PressButton(MouseButton.Left));
+
+            AddStep("move mouse slightly off centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.02f, 0)));
+
+            AddAssert("object 3 snapped to 1", () =>
+            {
+                var objects = EditorBeatmap.HitObjects;
+
+                var first = (OsuHitObject)objects.First();
+                var third = (OsuHitObject)objects.Last();
+
+                return Precision.AlmostEquals(first.EndPosition, third.Position);
+            });
+
+            AddStep("move mouse slightly off centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * -0.22f, playfield.ScreenSpaceDrawQuad.Width * 0.21f)));
+
+            AddAssert("object 2 snapped to 1", () =>
+            {
+                var objects = EditorBeatmap.HitObjects;
+
+                var first = (OsuHitObject)objects.First();
+                var second = (OsuHitObject)objects.ElementAt(1);
+
+                return Precision.AlmostEquals(first.EndPosition, second.Position);
+            });
+
+            AddStep("end drag", () => InputManager.ReleaseButton(MouseButton.Left));
+        }
     }
 }

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

@@ -174,6 +174,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
         private class SnapProvider : IPositionSnapProvider
         {
+            public SnapResult SnapScreenSpacePositionToValidPosition(Vector2 screenSpacePosition) =>
+                new SnapResult(screenSpacePosition, null);
+
             public SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition) => new SnapResult(screenSpacePosition, 0);
 
             public float GetBeatSnapDistanceAt(double referenceTime) => (float)beat_length;

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

@@ -5,7 +5,7 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests.Mods
 {
-    public class OsuModTestScene : ModTestScene
+    public abstract class OsuModTestScene : ModTestScene
     {
         protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
     }

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

@@ -2,12 +2,15 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Play;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests.Mods
@@ -17,15 +20,15 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
         [Test]
         public void TestDefaultBeatmapTest() => CreateModTest(new ModTestData
         {
-            Mod = new OsuModHidden(),
+            Mod = new TestOsuModHidden(),
             Autoplay = true,
-            PassCondition = checkSomeHit
+            PassCondition = () => checkSomeHit() && objectWithIncreasedVisibilityHasIndex(0)
         });
 
         [Test]
         public void FirstCircleAfterTwoSpinners() => CreateModTest(new ModTestData
         {
-            Mod = new OsuModHidden(),
+            Mod = new TestOsuModHidden(),
             Autoplay = true,
             Beatmap = new Beatmap
             {
@@ -54,13 +57,13 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                     }
                 }
             },
-            PassCondition = checkSomeHit
+            PassCondition = () => checkSomeHit() && objectWithIncreasedVisibilityHasIndex(2)
         });
 
         [Test]
         public void FirstSliderAfterTwoSpinners() => CreateModTest(new ModTestData
         {
-            Mod = new OsuModHidden(),
+            Mod = new TestOsuModHidden(),
             Autoplay = true,
             Beatmap = new Beatmap
             {
@@ -89,12 +92,41 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                     }
                 }
             },
+            PassCondition = () => checkSomeHit() && objectWithIncreasedVisibilityHasIndex(2)
+        });
+
+        [Test]
+        public void TestWithSliderReuse() => CreateModTest(new ModTestData
+        {
+            Mod = new TestOsuModHidden(),
+            Autoplay = true,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new Slider
+                    {
+                        StartTime = 1000,
+                        Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(100, 0), })
+                    },
+                    new Slider
+                    {
+                        StartTime = 4000,
+                        Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(100, 0), })
+                    },
+                }
+            },
             PassCondition = checkSomeHit
         });
 
-        private bool checkSomeHit()
+        private bool checkSomeHit() => Player.ScoreProcessor.JudgedHits >= 4;
+
+        private bool objectWithIncreasedVisibilityHasIndex(int index)
+            => Player.Mods.Value.OfType<TestOsuModHidden>().Single().FirstObject == Player.ChildrenOfType<GameplayBeatmap>().Single().HitObjects[index];
+
+        private class TestOsuModHidden : OsuModHidden
         {
-            return Player.ScoreProcessor.JudgedHits >= 4;
+            public new HitObject FirstObject => base.FirstObject;
         }
     }
 }

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

@@ -43,10 +43,8 @@ namespace osu.Game.Rulesets.Osu.Tests
             showResult(HitResult.Great);
 
             AddUntilStep("judgements shown", () => this.ChildrenOfType<TestDrawableOsuJudgement>().Any());
-            AddAssert("judgement body immediately visible",
-                () => this.ChildrenOfType<TestDrawableOsuJudgement>().All(judgement => judgement.JudgementBody.Alpha == 1));
-            AddAssert("hit lighting hidden",
-                () => this.ChildrenOfType<TestDrawableOsuJudgement>().All(judgement => judgement.Lighting.Alpha == 0));
+            AddAssert("hit lighting has no transforms", () => this.ChildrenOfType<TestDrawableOsuJudgement>().All(judgement => !judgement.Lighting.Transforms.Any()));
+            AddAssert("hit lighting hidden", () => this.ChildrenOfType<TestDrawableOsuJudgement>().All(judgement => judgement.Lighting.Alpha == 0));
         }
 
         [Test]
@@ -57,10 +55,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             showResult(HitResult.Great);
 
             AddUntilStep("judgements shown", () => this.ChildrenOfType<TestDrawableOsuJudgement>().Any());
-            AddAssert("judgement body not immediately visible",
-                () => this.ChildrenOfType<TestDrawableOsuJudgement>().All(judgement => judgement.JudgementBody.Alpha > 0 && judgement.JudgementBody.Alpha < 1));
-            AddAssert("hit lighting shown",
-                () => this.ChildrenOfType<TestDrawableOsuJudgement>().All(judgement => judgement.Lighting.Alpha > 0));
+            AddUntilStep("hit lighting shown", () => this.ChildrenOfType<TestDrawableOsuJudgement>().Any(judgement => judgement.Lighting.Alpha > 0));
         }
 
         private void showResult(HitResult result)
@@ -89,7 +84,13 @@ namespace osu.Game.Rulesets.Osu.Tests
                         Children = new Drawable[]
                         {
                             pool,
-                            pool.Get(j => j.Apply(new JudgementResult(new HitObject(), new Judgement()) { Type = result }, null)).With(j =>
+                            pool.Get(j => j.Apply(new JudgementResult(new HitObject
+                            {
+                                StartTime = Time.Current
+                            }, new Judgement())
+                            {
+                                Type = result,
+                            }, null)).With(j =>
                             {
                                 j.Anchor = Anchor.Centre;
                                 j.Origin = Anchor.Centre;
@@ -106,7 +107,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private class TestDrawableOsuJudgement : DrawableOsuJudgement
         {
             public new SkinnableSprite Lighting => base.Lighting;
-            public new Container JudgementBody => base.JudgementBody;
+            public new SkinnableDrawable JudgementBody => base.JudgementBody;
         }
     }
 }

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

@@ -7,6 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -94,9 +95,19 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             addMultipleObjectsStep();
 
-            AddStep("move hitobject", () => getObject(2).HitObject.Position = new Vector2(300, 100));
+            AddStep("move hitobject", () =>
+            {
+                var manualClock = new ManualClock();
+                followPointRenderer.Clock = new FramedClock(manualClock);
+
+                manualClock.CurrentTime = getObject(1).HitObject.StartTime;
+                followPointRenderer.UpdateSubTree();
+
+                getObject(2).HitObject.Position = new Vector2(300, 100);
+            });
 
             assertGroups();
+            assertDirections();
         }
 
         [TestCase(0, 0)] // Start -> Start
@@ -207,7 +218,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private void assertGroups()
         {
-            AddAssert("has correct group count", () => followPointRenderer.Connections.Count == hitObjectContainer.Count);
+            AddAssert("has correct group count", () => followPointRenderer.Entries.Count == hitObjectContainer.Count);
             AddAssert("group endpoints are correct", () =>
             {
                 for (int i = 0; i < hitObjectContainer.Count; i++)
@@ -215,10 +226,10 @@ namespace osu.Game.Rulesets.Osu.Tests
                     DrawableOsuHitObject expectedStart = getObject(i);
                     DrawableOsuHitObject expectedEnd = i < hitObjectContainer.Count - 1 ? getObject(i + 1) : null;
 
-                    if (getGroup(i).Start != expectedStart.HitObject)
+                    if (getEntry(i).Start != expectedStart.HitObject)
                         throw new AssertionException($"Object {i} expected to be the start of group {i}.");
 
-                    if (getGroup(i).End != expectedEnd?.HitObject)
+                    if (getEntry(i).End != expectedEnd?.HitObject)
                         throw new AssertionException($"Object {(expectedEnd == null ? "null" : i.ToString())} expected to be the end of group {i}.");
                 }
 
@@ -238,6 +249,12 @@ namespace osu.Game.Rulesets.Osu.Tests
                     if (expectedEnd == null)
                         continue;
 
+                    var manualClock = new ManualClock();
+                    followPointRenderer.Clock = new FramedClock(manualClock);
+
+                    manualClock.CurrentTime = expectedStart.HitObject.StartTime;
+                    followPointRenderer.UpdateSubTree();
+
                     var points = getGroup(i).ChildrenOfType<FollowPoint>().ToArray();
                     if (points.Length == 0)
                         continue;
@@ -255,7 +272,9 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private DrawableOsuHitObject getObject(int index) => hitObjectContainer[index];
 
-        private FollowPointConnection getGroup(int index) => followPointRenderer.Connections[index];
+        private FollowPointLifetimeEntry getEntry(int index) => followPointRenderer.Entries[index];
+
+        private FollowPointConnection getGroup(int index) => followPointRenderer.ChildrenOfType<FollowPointConnection>().Single(c => c.Entry == getEntry(index));
 
         private class TestHitObjectContainer : Container<DrawableOsuHitObject>
         {

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

@@ -1,17 +1,17 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osuTK;
-using osu.Game.Rulesets.Mods;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
@@ -38,13 +38,37 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         private Drawable testSingle(float circleSize, bool auto = false, double timeOffset = 0, Vector2? positionOffset = null)
+        {
+            var drawable = createSingle(circleSize, auto, timeOffset, positionOffset);
+
+            var playfield = new TestOsuPlayfield();
+            playfield.Add(drawable);
+            return playfield;
+        }
+
+        private Drawable testStream(float circleSize, bool auto = false)
+        {
+            var playfield = new TestOsuPlayfield();
+
+            Vector2 pos = new Vector2(-250, 0);
+
+            for (int i = 0; i <= 1000; i += 100)
+            {
+                playfield.Add(createSingle(circleSize, auto, i, pos));
+                pos.X += 50;
+            }
+
+            return playfield;
+        }
+
+        private TestDrawableHitCircle createSingle(float circleSize, bool auto, double timeOffset, Vector2? positionOffset)
         {
             positionOffset ??= Vector2.Zero;
 
             var circle = new HitCircle
             {
                 StartTime = Time.Current + 1000 + timeOffset,
-                Position = positionOffset.Value,
+                Position = OsuPlayfield.BASE_SIZE / 4 + positionOffset.Value,
             };
 
             circle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = circleSize });
@@ -53,31 +77,14 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             foreach (var mod in SelectedMods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
-
             return drawable;
         }
 
         protected virtual TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto) => new TestDrawableHitCircle(circle, auto)
         {
-            Anchor = Anchor.Centre,
             Depth = depthIndex++
         };
 
-        private Drawable testStream(float circleSize, bool auto = false)
-        {
-            var container = new Container { RelativeSizeAxes = Axes.Both };
-
-            Vector2 pos = new Vector2(-250, 0);
-
-            for (int i = 0; i <= 1000; i += 100)
-            {
-                container.Add(testSingle(circleSize, auto, i, pos));
-                pos.X += 50;
-            }
-
-            return container;
-        }
-
         protected class TestDrawableHitCircle : DrawableHitCircle
         {
             private readonly bool auto;
@@ -101,5 +108,13 @@ namespace osu.Game.Rulesets.Osu.Tests
                     base.CheckForResult(userTriggered, timeOffset);
             }
         }
+
+        protected class TestOsuPlayfield : OsuPlayfield
+        {
+            public TestOsuPlayfield()
+            {
+                RelativeSizeAxes = Axes.Both;
+            }
+        }
     }
 }

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

@@ -1,8 +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.
 
+using System.Collections.Generic;
 using System.Diagnostics;
+using osu.Framework.Threading;
 using osu.Framework.Utils;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 
@@ -10,6 +13,19 @@ namespace osu.Game.Rulesets.Osu.Tests
 {
     public class TestSceneShaking : TestSceneHitCircle
     {
+        private readonly List<ScheduledDelegate> scheduledTasks = new List<ScheduledDelegate>();
+
+        protected override IBeatmap CreateBeatmapForSkinProvider()
+        {
+            // best way to run cleanup before a new step is run
+            foreach (var task in scheduledTasks)
+                task.Cancel();
+
+            scheduledTasks.Clear();
+
+            return base.CreateBeatmapForSkinProvider();
+        }
+
         protected override TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto)
         {
             var drawableHitObject = base.CreateDrawableHitCircle(circle, auto);
@@ -17,7 +33,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             Debug.Assert(drawableHitObject.HitObject.HitWindows != null);
 
             double delay = drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.WindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current;
-            Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(), delay);
+            scheduledTasks.Add(Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(), delay));
 
             return drawableHitObject;
         }

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

@@ -108,8 +108,8 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             AddStep("change samples", () => slider.HitObject.Samples = new[]
             {
-                new HitSampleInfo { Name = HitSampleInfo.HIT_CLAP },
-                new HitSampleInfo { Name = HitSampleInfo.HIT_WHISTLE },
+                new HitSampleInfo(HitSampleInfo.HIT_CLAP),
+                new HitSampleInfo(HitSampleInfo.HIT_WHISTLE),
             });
 
             AddAssert("head samples updated", () => assertSamples(slider.HitObject.HeadCircle));
@@ -136,15 +136,15 @@ namespace osu.Game.Rulesets.Osu.Tests
                 slider = (DrawableSlider)createSlider(repeats: 1);
 
                 for (int i = 0; i < 2; i++)
-                    slider.HitObject.NodeSamples.Add(new List<HitSampleInfo> { new HitSampleInfo { Name = HitSampleInfo.HIT_FINISH } });
+                    slider.HitObject.NodeSamples.Add(new List<HitSampleInfo> { new HitSampleInfo(HitSampleInfo.HIT_FINISH) });
 
                 Add(slider);
             });
 
             AddStep("change samples", () => slider.HitObject.Samples = new[]
             {
-                new HitSampleInfo { Name = HitSampleInfo.HIT_CLAP },
-                new HitSampleInfo { Name = HitSampleInfo.HIT_WHISTLE },
+                new HitSampleInfo(HitSampleInfo.HIT_CLAP),
+                new HitSampleInfo(HitSampleInfo.HIT_WHISTLE),
             });
 
             AddAssert("head samples not updated", () => assertSamples(slider.HitObject.HeadCircle));

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

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

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

@@ -45,9 +45,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
             return base.OnMouseDown(e);
         }
 
-        public override void UpdatePosition(SnapResult result)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            base.UpdatePosition(result);
+            base.UpdateTimeAndPosition(result);
             HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
         }
     }

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

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
         private readonly Path path;
         private readonly Slider slider;
-        private readonly int controlPointIndex;
+        public int ControlPointIndex { get; set; }
 
         private IBindable<Vector2> sliderPosition;
         private IBindable<int> pathVersion;
@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         public PathControlPointConnectionPiece(Slider slider, int controlPointIndex)
         {
             this.slider = slider;
-            this.controlPointIndex = controlPointIndex;
+            ControlPointIndex = controlPointIndex;
 
             Origin = Anchor.Centre;
             AutoSizeAxes = Axes.Both;
@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
             path.ClearVertices();
 
-            int nextIndex = controlPointIndex + 1;
+            int nextIndex = ControlPointIndex + 1;
             if (nextIndex == 0 || nextIndex >= slider.Path.ControlPoints.Count)
                 return;
 

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

@@ -44,6 +44,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         private OsuColour colours { get; set; }
 
         private IBindable<Vector2> sliderPosition;
+        private IBindable<float> sliderScale;
         private IBindable<Vector2> controlPointPosition;
 
         public PathControlPointPiece(Slider slider, PathControlPoint controlPoint)
@@ -69,13 +70,13 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
-                            Size = new Vector2(10),
+                            Size = new Vector2(20),
                         },
                         markerRing = new CircularContainer
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
-                            Size = new Vector2(14),
+                            Size = new Vector2(28),
                             Masking = true,
                             BorderThickness = 2,
                             BorderColour = Color4.White,
@@ -102,6 +103,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             controlPointPosition = ControlPoint.Position.GetBoundCopy();
             controlPointPosition.BindValueChanged(_ => updateMarkerDisplay());
 
+            sliderScale = slider.ScaleBindable.GetBoundCopy();
+            sliderScale.BindValueChanged(_ => updateMarkerDisplay());
+
             IsSelected.BindValueChanged(_ => updateMarkerDisplay());
 
             updateMarkerDisplay();
@@ -143,6 +147,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
         protected override bool OnClick(ClickEvent e) => RequestSelection != null;
 
+        private Vector2 dragStartPosition;
+
         protected override bool OnDragStart(DragStartEvent e)
         {
             if (RequestSelection == null)
@@ -150,6 +156,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
             if (e.Button == MouseButton.Left)
             {
+                dragStartPosition = ControlPoint.Position.Value;
                 changeHandler?.BeginChange();
                 return true;
             }
@@ -174,7 +181,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                     slider.Path.ControlPoints[i].Position.Value -= movementDelta;
             }
             else
-                ControlPoint.Position.Value += e.Delta;
+                ControlPoint.Position.Value = dragStartPosition + (e.MousePosition - e.MouseDownPosition);
         }
 
         protected override void OnDragEnd(DragEndEvent e) => changeHandler?.EndChange();
@@ -194,6 +201,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                 colour = colour.Lighten(1);
 
             marker.Colour = colour;
+            marker.Scale = new Vector2(slider.Scale);
         }
     }
 }

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

@@ -20,12 +20,15 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
+using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
     public class PathControlPointVisualiser : CompositeDrawable, IKeyBindingHandler<PlatformAction>, IHasContextMenu
     {
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true; // allow context menu to appear outside of the playfield.
+
         internal readonly Container<PathControlPointPiece> Pieces;
         internal readonly Container<PathControlPointConnectionPiece> Connections;
 
@@ -66,6 +69,17 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             switch (e.Action)
             {
                 case NotifyCollectionChangedAction.Add:
+                    // If inserting in the path (not appending),
+                    // update indices of existing connections after insert location
+                    if (e.NewStartingIndex < Pieces.Count)
+                    {
+                        foreach (var connection in Connections)
+                        {
+                            if (connection.ControlPointIndex >= e.NewStartingIndex)
+                                connection.ControlPointIndex += e.NewItems.Count;
+                        }
+                    }
+
                     for (int i = 0; i < e.NewItems.Count; i++)
                     {
                         var point = (PathControlPoint)e.NewItems[i];
@@ -88,6 +102,17 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                         Connections.RemoveAll(c => c.ControlPoint == point);
                     }
 
+                    // If removing before the end of the path,
+                    // update indices of connections after remove location
+                    if (e.OldStartingIndex < Pieces.Count)
+                    {
+                        foreach (var connection in Connections)
+                        {
+                            if (connection.ControlPointIndex >= e.OldStartingIndex)
+                                connection.ControlPointIndex -= e.OldItems.Count;
+                        }
+                    }
+
                     break;
             }
         }

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

@@ -67,9 +67,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             inputManager = GetContainingInputManager();
         }
 
-        public override void UpdatePosition(SnapResult result)
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
-            base.UpdatePosition(result);
+            base.UpdateTimeAndPosition(result);
 
             switch (state)
             {

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

@@ -44,6 +44,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         [Resolved(CanBeNull = true)]
         private IEditorChangeHandler changeHandler { get; set; }
 
+        private readonly BindableList<PathControlPoint> controlPoints = new BindableList<PathControlPoint>();
+        private readonly IBindable<int> pathVersion = new Bindable<int>();
+
         public SliderSelectionBlueprint(DrawableSlider slider)
             : base(slider)
         {
@@ -61,13 +64,13 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             };
         }
 
-        private IBindable<int> pathVersion;
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            pathVersion = HitObject.Path.Version.GetBoundCopy();
+            controlPoints.BindTo(HitObject.Path.ControlPoints);
+
+            pathVersion.BindTo(HitObject.Path.Version);
             pathVersion.BindValueChanged(_ => updatePath());
 
             BodyPiece.UpdateFrom(HitObject);
@@ -164,8 +167,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             }
         }
 
-        private BindableList<PathControlPoint> controlPoints => HitObject.Path.ControlPoints;
-
         private int addControlPoint(Vector2 position)
         {
             position -= HitObject.Position;

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

@@ -1,63 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Linq;
-using osu.Framework.Graphics;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-
-namespace osu.Game.Rulesets.Osu.Edit
-{
-    public class DrawableOsuEditPool<T> : DrawableOsuPool<T>
-        where T : DrawableHitObject, new()
-    {
-        /// <summary>
-        /// Hit objects are intentionally made to fade out at a constant slower rate than in gameplay.
-        /// This allows a mapper to gain better historical context and use recent hitobjects as reference / snap points.
-        /// </summary>
-        private const double editor_hit_object_fade_out_extension = 700;
-
-        public DrawableOsuEditPool(Func<DrawableHitObject, double, bool> checkHittable, Action<Drawable> onLoaded, int initialSize, int? maximumSize = null)
-            : base(checkHittable, onLoaded, initialSize, maximumSize)
-        {
-        }
-
-        protected override T CreateNewDrawable() => base.CreateNewDrawable().With(d => d.ApplyCustomUpdateState += updateState);
-
-        private void updateState(DrawableHitObject hitObject, ArmedState state)
-        {
-            if (state == ArmedState.Idle)
-                return;
-
-            // adjust the visuals of certain object types to make them stay on screen for longer than usual.
-            switch (hitObject)
-            {
-                default:
-                    // there are quite a few drawable hit types we don't want to extend (spinners, ticks etc.)
-                    return;
-
-                case DrawableSlider _:
-                    // no specifics to sliders but let them fade slower below.
-                    break;
-
-                case DrawableHitCircle circle: // also handles slider heads
-                    circle.ApproachCircle
-                          .FadeOutFromOne(editor_hit_object_fade_out_extension)
-                          .Expire();
-                    break;
-            }
-
-            // Get the existing fade out transform
-            var existing = hitObject.Transforms.LastOrDefault(t => t.TargetMember == nameof(Alpha));
-
-            if (existing == null)
-                return;
-
-            hitObject.RemoveTransform(existing);
-
-            using (hitObject.BeginAbsoluteSequence(existing.StartTime))
-                hitObject.FadeOut(editor_hit_object_fade_out_extension).Expire();
-        }
-    }
-}

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

@@ -2,9 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using osu.Framework.Graphics.Pooling;
+using System.Linq;
+using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
 using osuTK;
@@ -26,8 +29,51 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
             protected override GameplayCursorContainer CreateCursor() => null;
 
-            protected override DrawablePool<TDrawable> CreatePool<TDrawable>(int initialSize, int? maximumSize = null)
-                => new DrawableOsuEditPool<TDrawable>(CheckHittable, OnHitObjectLoaded, initialSize, maximumSize);
+            protected override void OnNewDrawableHitObject(DrawableHitObject d)
+            {
+                d.ApplyCustomUpdateState += updateState;
+            }
+
+            /// <summary>
+            /// Hit objects are intentionally made to fade out at a constant slower rate than in gameplay.
+            /// This allows a mapper to gain better historical context and use recent hitobjects as reference / snap points.
+            /// </summary>
+            private const double editor_hit_object_fade_out_extension = 700;
+
+            private void updateState(DrawableHitObject hitObject, ArmedState state)
+            {
+                if (state == ArmedState.Idle)
+                    return;
+
+                // adjust the visuals of certain object types to make them stay on screen for longer than usual.
+                switch (hitObject)
+                {
+                    default:
+                        // there are quite a few drawable hit types we don't want to extend (spinners, ticks etc.)
+                        return;
+
+                    case DrawableSlider _:
+                        // no specifics to sliders but let them fade slower below.
+                        break;
+
+                    case DrawableHitCircle circle: // also handles slider heads
+                        circle.ApproachCircle
+                              .FadeOutFromOne(editor_hit_object_fade_out_extension)
+                              .Expire();
+                        break;
+                }
+
+                // Get the existing fade out transform
+                var existing = hitObject.Transforms.LastOrDefault(t => t.TargetMember == nameof(Alpha));
+
+                if (existing == null)
+                    return;
+
+                hitObject.RemoveTransform(existing);
+
+                using (hitObject.BeginAbsoluteSequence(existing.StartTime))
+                    hitObject.FadeOut(editor_hit_object_fade_out_extension).Expire();
+            }
         }
     }
 }

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

@@ -105,11 +105,20 @@ namespace osu.Game.Rulesets.Osu.Edit
             }
         }
 
-        public override SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition)
+        public override SnapResult SnapScreenSpacePositionToValidPosition(Vector2 screenSpacePosition)
         {
             if (snapToVisibleBlueprints(screenSpacePosition, out var snapResult))
                 return snapResult;
 
+            return new SnapResult(screenSpacePosition, null);
+        }
+
+        public override SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition)
+        {
+            var positionSnap = SnapScreenSpacePositionToValidPosition(screenSpacePosition);
+            if (positionSnap.ScreenSpacePosition != screenSpacePosition)
+                return positionSnap;
+
             // will be null if distance snap is disabled or not feasible for the current time value.
             if (distanceSnapGrid == null)
                 return base.SnapScreenSpacePositionToValidTime(screenSpacePosition);

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

@@ -5,7 +5,7 @@ using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModEasy : ModEasy
+    public class OsuModEasy : ModEasyWithExtraLives
     {
         public override string Description => @"Larger circles, more forgiving HP drain, less accuracy required, and three lives!";
     }

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

@@ -2,9 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -23,25 +24,21 @@ namespace osu.Game.Rulesets.Osu.Mods
         private const double fade_in_duration_multiplier = 0.4;
         private const double fade_out_duration_multiplier = 0.3;
 
-        protected override bool IsFirstAdjustableObject(HitObject hitObject) => !(hitObject is Spinner);
+        protected override bool IsFirstAdjustableObject(HitObject hitObject) => !(hitObject is Spinner || hitObject is SpinnerTick);
 
-        public override void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        public override void ApplyToBeatmap(IBeatmap beatmap)
         {
-            foreach (var d in drawables)
-                d.HitObjectApplied += applyFadeInAdjustment;
+            base.ApplyToBeatmap(beatmap);
 
-            base.ApplyToDrawableHitObjects(drawables);
-        }
+            foreach (var obj in beatmap.HitObjects.OfType<OsuHitObject>())
+                applyFadeInAdjustment(obj);
 
-        private void applyFadeInAdjustment(DrawableHitObject hitObject)
-        {
-            if (!(hitObject is DrawableOsuHitObject d))
-                return;
-
-            d.HitObject.TimeFadeIn = d.HitObject.TimePreempt * fade_in_duration_multiplier;
-
-            foreach (var nested in d.NestedHitObjects)
-                applyFadeInAdjustment(nested);
+            static void applyFadeInAdjustment(OsuHitObject osuObject)
+            {
+                osuObject.TimeFadeIn = osuObject.TimePreempt * fade_in_duration_multiplier;
+                foreach (var nested in osuObject.NestedHitObjects.OfType<OsuHitObject>())
+                    applyFadeInAdjustment(nested);
+            }
         }
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
@@ -56,37 +53,27 @@ namespace osu.Game.Rulesets.Osu.Mods
             applyState(hitObject, false);
         }
 
-        private void applyState(DrawableHitObject drawable, bool increaseVisibility)
+        private void applyState(DrawableHitObject drawableObject, bool increaseVisibility)
         {
-            if (!(drawable is DrawableOsuHitObject d))
+            if (!(drawableObject is DrawableOsuHitObject drawableOsuObject))
                 return;
 
-            var h = d.HitObject;
+            OsuHitObject hitObject = drawableOsuObject.HitObject;
 
-            var fadeOutStartTime = h.StartTime - h.TimePreempt + h.TimeFadeIn;
-            var fadeOutDuration = h.TimePreempt * fade_out_duration_multiplier;
+            (double startTime, double duration) fadeOut = getFadeOutParameters(drawableOsuObject);
 
-            // new duration from completed fade in to end (before fading out)
-            var longFadeDuration = h.GetEndTime() - fadeOutStartTime;
-
-            switch (drawable)
+            switch (drawableObject)
             {
-                case DrawableSliderTail sliderTail:
-                    // use stored values from head circle to achieve same fade sequence.
-                    var tailFadeOutParameters = getFadeOutParametersFromSliderHead(h);
-
-                    using (drawable.BeginAbsoluteSequence(tailFadeOutParameters.startTime, true))
-                        sliderTail.FadeOut(tailFadeOutParameters.duration);
+                case DrawableSliderTail _:
+                    using (drawableObject.BeginAbsoluteSequence(fadeOut.startTime, true))
+                        drawableObject.FadeOut(fadeOut.duration);
 
                     break;
 
                 case DrawableSliderRepeat sliderRepeat:
-                    // use stored values from head circle to achieve same fade sequence.
-                    var repeatFadeOutParameters = getFadeOutParametersFromSliderHead(h);
-
-                    using (drawable.BeginAbsoluteSequence(repeatFadeOutParameters.startTime, true))
+                    using (drawableObject.BeginAbsoluteSequence(fadeOut.startTime, true))
                         // only apply to circle piece – reverse arrow is not affected by hidden.
-                        sliderRepeat.CirclePiece.FadeOut(repeatFadeOutParameters.duration);
+                        sliderRepeat.CirclePiece.FadeOut(fadeOut.duration);
 
                     break;
 
@@ -101,29 +88,23 @@ namespace osu.Game.Rulesets.Osu.Mods
                     else
                     {
                         // we don't want to see the approach circle
-                        using (circle.BeginAbsoluteSequence(h.StartTime - h.TimePreempt, true))
+                        using (circle.BeginAbsoluteSequence(hitObject.StartTime - hitObject.TimePreempt, true))
                             circle.ApproachCircle.Hide();
                     }
 
-                    // fade out immediately after fade in.
-                    using (drawable.BeginAbsoluteSequence(fadeOutStartTime, true))
-                        fadeTarget.FadeOut(fadeOutDuration);
+                    using (drawableObject.BeginAbsoluteSequence(fadeOut.startTime, true))
+                        fadeTarget.FadeOut(fadeOut.duration);
                     break;
 
                 case DrawableSlider slider:
-                    associateNestedSliderCirclesWithHead(slider.HitObject);
-
-                    using (slider.BeginAbsoluteSequence(fadeOutStartTime, true))
-                        slider.Body.FadeOut(longFadeDuration, Easing.Out);
+                    using (slider.BeginAbsoluteSequence(fadeOut.startTime, true))
+                        slider.Body.FadeOut(fadeOut.duration, Easing.Out);
 
                     break;
 
                 case DrawableSliderTick sliderTick:
-                    // slider ticks fade out over up to one second
-                    var tickFadeOutDuration = Math.Min(sliderTick.HitObject.TimePreempt - DrawableSliderTick.ANIM_DURATION, 1000);
-
-                    using (sliderTick.BeginAbsoluteSequence(sliderTick.HitObject.StartTime - tickFadeOutDuration, true))
-                        sliderTick.FadeOut(tickFadeOutDuration);
+                    using (sliderTick.BeginAbsoluteSequence(fadeOut.startTime, true))
+                        sliderTick.FadeOut(fadeOut.duration);
 
                     break;
 
@@ -131,30 +112,55 @@ namespace osu.Game.Rulesets.Osu.Mods
                     // hide elements we don't care about.
                     // todo: hide background
 
-                    using (spinner.BeginAbsoluteSequence(fadeOutStartTime + longFadeDuration, true))
-                        spinner.FadeOut(fadeOutDuration);
+                    using (spinner.BeginAbsoluteSequence(fadeOut.startTime, true))
+                        spinner.FadeOut(fadeOut.duration);
 
                     break;
             }
         }
 
-        private readonly Dictionary<HitObject, SliderHeadCircle> correspondingSliderHeadForObject = new Dictionary<HitObject, SliderHeadCircle>();
-
-        private void associateNestedSliderCirclesWithHead(Slider slider)
+        private (double startTime, double duration) getFadeOutParameters(DrawableOsuHitObject drawableObject)
         {
-            var sliderHead = slider.NestedHitObjects.Single(obj => obj is SliderHeadCircle);
-
-            foreach (var nested in slider.NestedHitObjects)
+            switch (drawableObject)
             {
-                if ((nested is SliderRepeat || nested is SliderEndCircle) && !correspondingSliderHeadForObject.ContainsKey(nested))
-                    correspondingSliderHeadForObject[nested] = (SliderHeadCircle)sliderHead;
-            }
-        }
+                case DrawableSliderTail tail:
+                    // Use the same fade sequence as the slider head.
+                    Debug.Assert(tail.Slider != null);
+                    return getParameters(tail.Slider.HeadCircle);
 
-        private (double startTime, double duration) getFadeOutParametersFromSliderHead(OsuHitObject h)
-        {
-            var sliderHead = correspondingSliderHeadForObject[h];
-            return (sliderHead.StartTime - sliderHead.TimePreempt + sliderHead.TimeFadeIn, sliderHead.TimePreempt * fade_out_duration_multiplier);
+                case DrawableSliderRepeat repeat:
+                    // Use the same fade sequence as the slider head.
+                    Debug.Assert(repeat.Slider != null);
+                    return getParameters(repeat.Slider.HeadCircle);
+
+                default:
+                    return getParameters(drawableObject.HitObject);
+            }
+
+            static (double startTime, double duration) getParameters(OsuHitObject hitObject)
+            {
+                var fadeOutStartTime = hitObject.StartTime - hitObject.TimePreempt + hitObject.TimeFadeIn;
+                var fadeOutDuration = hitObject.TimePreempt * fade_out_duration_multiplier;
+
+                // new duration from completed fade in to end (before fading out)
+                var longFadeDuration = hitObject.GetEndTime() - fadeOutStartTime;
+
+                switch (hitObject)
+                {
+                    case Slider _:
+                        return (fadeOutStartTime, longFadeDuration);
+
+                    case SliderTick _:
+                        var tickFadeOutDuration = Math.Min(hitObject.TimePreempt - DrawableSliderTick.ANIM_DURATION, 1000);
+                        return (hitObject.StartTime - tickFadeOutDuration, tickFadeOutDuration);
+
+                    case Spinner _:
+                        return (fadeOutStartTime + longFadeDuration, fadeOutDuration);
+
+                    default:
+                        return (fadeOutStartTime, fadeOutDuration);
+                }
+            }
         }
     }
 }

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

@@ -1,12 +1,14 @@
 // 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.Bindables;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Skinning;
 
@@ -15,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
     /// <summary>
     /// A single follow point positioned between two adjacent <see cref="DrawableOsuHitObject"/>s.
     /// </summary>
-    public class FollowPoint : Container, IAnimationTimeReference
+    public class FollowPoint : PoolableDrawable, IAnimationTimeReference
     {
         private const float width = 8;
 
@@ -25,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
         {
             Origin = Anchor.Centre;
 
-            Child = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.FollowPoint), _ => new CircularContainer
+            InternalChild = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.FollowPoint), _ => new CircularContainer
             {
                 Masking = true,
                 AutoSizeAxes = Axes.Both,
@@ -46,6 +48,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
             });
         }
 
-        public double AnimationStartTime { get; set; }
+        public Bindable<double> AnimationStartTime { get; } = new BindableDouble();
     }
 }

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

@@ -2,11 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
-using JetBrains.Annotations;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
 using osu.Game.Rulesets.Objects;
 using osuTK;
 
@@ -15,150 +12,106 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
     /// <summary>
     /// Visualises the <see cref="FollowPoint"/>s between two <see cref="DrawableOsuHitObject"/>s.
     /// </summary>
-    public class FollowPointConnection : CompositeDrawable
+    public class FollowPointConnection : PoolableDrawable
     {
         // Todo: These shouldn't be constants
-        private const int spacing = 32;
-        private const double preempt = 800;
+        public const int SPACING = 32;
+        public const double PREEMPT = 800;
 
-        public override bool RemoveWhenNotAlive => false;
+        public FollowPointLifetimeEntry Entry;
+        public DrawablePool<FollowPoint> Pool;
 
-        /// <summary>
-        /// The start time of <see cref="Start"/>.
-        /// </summary>
-        public readonly Bindable<double> StartTime = new BindableDouble();
-
-        /// <summary>
-        /// The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will exit from.
-        /// </summary>
-        [NotNull]
-        public readonly OsuHitObject Start;
-
-        /// <summary>
-        /// Creates a new <see cref="FollowPointConnection"/>.
-        /// </summary>
-        /// <param name="start">The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will exit from.</param>
-        public FollowPointConnection([NotNull] OsuHitObject start)
+        protected override void PrepareForUse()
         {
-            Start = start;
+            base.PrepareForUse();
 
-            RelativeSizeAxes = Axes.Both;
+            Entry.Invalidated += onEntryInvalidated;
 
-            StartTime.BindTo(start.StartTimeBindable);
+            refreshPoints();
         }
 
-        protected override void LoadComplete()
+        protected override void FreeAfterUse()
         {
-            base.LoadComplete();
-            bindEvents(Start);
+            base.FreeAfterUse();
+
+            Entry.Invalidated -= onEntryInvalidated;
+
+            // Return points to the pool.
+            ClearInternal(false);
+
+            Entry = null;
         }
 
-        private OsuHitObject end;
+        private void onEntryInvalidated() => refreshPoints();
 
-        /// <summary>
-        /// The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will enter.
-        /// </summary>
-        [CanBeNull]
-        public OsuHitObject End
+        private void refreshPoints()
         {
-            get => end;
-            set
-            {
-                end = value;
+            ClearInternal(false);
 
-                if (end != null)
-                    bindEvents(end);
+            OsuHitObject start = Entry.Start;
+            OsuHitObject end = Entry.End;
 
-                if (IsLoaded)
-                    scheduleRefresh();
-                else
-                    refresh();
-            }
-        }
+            double startTime = start.GetEndTime();
 
-        private void bindEvents(OsuHitObject obj)
-        {
-            obj.PositionBindable.BindValueChanged(_ => scheduleRefresh());
-            obj.DefaultsApplied += _ => scheduleRefresh();
-        }
-
-        private void scheduleRefresh()
-        {
-            Scheduler.AddOnce(refresh);
-        }
-
-        private void refresh()
-        {
-            double startTime = Start.GetEndTime();
-
-            LifetimeStart = startTime;
-
-            if (End == null || End.NewCombo || Start is Spinner || End is Spinner)
-            {
-                // ensure we always set a lifetime for full LifetimeManagementContainer benefits
-                LifetimeEnd = LifetimeStart;
-                return;
-            }
-
-            Vector2 startPosition = Start.StackedEndPosition;
-            Vector2 endPosition = End.StackedPosition;
-            double endTime = End.StartTime;
+            Vector2 startPosition = start.StackedEndPosition;
+            Vector2 endPosition = end.StackedPosition;
 
             Vector2 distanceVector = endPosition - startPosition;
             int distance = (int)distanceVector.Length;
             float rotation = (float)(Math.Atan2(distanceVector.Y, distanceVector.X) * (180 / Math.PI));
-            double duration = endTime - startTime;
 
-            double? firstTransformStartTime = null;
             double finalTransformEndTime = startTime;
 
-            int point = 0;
-
-            ClearInternal();
-
-            for (int d = (int)(spacing * 1.5); d < distance - spacing; d += spacing)
+            for (int d = (int)(SPACING * 1.5); d < distance - SPACING; d += SPACING)
             {
                 float fraction = (float)d / distance;
                 Vector2 pointStartPosition = startPosition + (fraction - 0.1f) * distanceVector;
                 Vector2 pointEndPosition = startPosition + fraction * distanceVector;
-                double fadeOutTime = startTime + fraction * duration;
-                double fadeInTime = fadeOutTime - preempt;
+
+                GetFadeTimes(start, end, (float)d / distance, out var fadeInTime, out var fadeOutTime);
 
                 FollowPoint fp;
 
-                AddInternal(fp = new FollowPoint());
-
-                Debug.Assert(End != null);
+                AddInternal(fp = Pool.Get());
 
+                fp.ClearTransforms();
                 fp.Position = pointStartPosition;
                 fp.Rotation = rotation;
                 fp.Alpha = 0;
-                fp.Scale = new Vector2(1.5f * End.Scale);
+                fp.Scale = new Vector2(1.5f * end.Scale);
 
-                firstTransformStartTime ??= fadeInTime;
-
-                fp.AnimationStartTime = fadeInTime;
+                fp.AnimationStartTime.Value = fadeInTime;
 
                 using (fp.BeginAbsoluteSequence(fadeInTime))
                 {
-                    fp.FadeIn(End.TimeFadeIn);
-                    fp.ScaleTo(End.Scale, End.TimeFadeIn, Easing.Out);
-                    fp.MoveTo(pointEndPosition, End.TimeFadeIn, Easing.Out);
-                    fp.Delay(fadeOutTime - fadeInTime).FadeOut(End.TimeFadeIn);
+                    fp.FadeIn(end.TimeFadeIn);
+                    fp.ScaleTo(end.Scale, end.TimeFadeIn, Easing.Out);
+                    fp.MoveTo(pointEndPosition, end.TimeFadeIn, Easing.Out);
+                    fp.Delay(fadeOutTime - fadeInTime).FadeOut(end.TimeFadeIn);
 
-                    finalTransformEndTime = fadeOutTime + End.TimeFadeIn;
+                    finalTransformEndTime = fadeOutTime + end.TimeFadeIn;
                 }
-
-                point++;
             }
 
-            int excessPoints = InternalChildren.Count - point;
-            for (int i = 0; i < excessPoints; i++)
-                RemoveInternal(InternalChildren[^1]);
-
             // todo: use Expire() on FollowPoints and take lifetime from them when https://github.com/ppy/osu-framework/issues/3300 is fixed.
-            LifetimeStart = firstTransformStartTime ?? startTime;
-            LifetimeEnd = finalTransformEndTime;
+            Entry.LifetimeEnd = finalTransformEndTime;
+        }
+
+        /// <summary>
+        /// Computes the fade time of follow point positioned between two hitobjects.
+        /// </summary>
+        /// <param name="start">The first <see cref="OsuHitObject"/>, where follow points should originate from.</param>
+        /// <param name="end">The second <see cref="OsuHitObject"/>, which follow points should target.</param>
+        /// <param name="fraction">The fractional distance along <paramref name="start"/> and <paramref name="end"/> at which the follow point is to be located.</param>
+        /// <param name="fadeInTime">The fade-in time of the follow point/</param>
+        /// <param name="fadeOutTime">The fade-out time of the follow point.</param>
+        public static void GetFadeTimes(OsuHitObject start, OsuHitObject end, float fraction, out double fadeInTime, out double fadeOutTime)
+        {
+            double startTime = start.GetEndTime();
+            double duration = end.StartTime - startTime;
+
+            fadeOutTime = startTime + fraction * duration;
+            fadeInTime = fadeOutTime - PREEMPT;
         }
     }
 }

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

@@ -0,0 +1,98 @@
+// 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.Bindables;
+using osu.Framework.Graphics.Performance;
+using osu.Game.Rulesets.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
+{
+    public class FollowPointLifetimeEntry : LifetimeEntry
+    {
+        public event Action Invalidated;
+        public readonly OsuHitObject Start;
+
+        public FollowPointLifetimeEntry(OsuHitObject start)
+        {
+            Start = start;
+            LifetimeStart = Start.StartTime;
+
+            bindEvents();
+        }
+
+        private OsuHitObject end;
+
+        public OsuHitObject End
+        {
+            get => end;
+            set
+            {
+                UnbindEvents();
+
+                end = value;
+
+                bindEvents();
+
+                refreshLifetimes();
+            }
+        }
+
+        private void bindEvents()
+        {
+            UnbindEvents();
+
+            // Note: Positions are bound for instantaneous feedback from positional changes from the editor, before ApplyDefaults() is called on hitobjects.
+            Start.DefaultsApplied += onDefaultsApplied;
+            Start.PositionBindable.ValueChanged += onPositionChanged;
+
+            if (End != null)
+            {
+                End.DefaultsApplied += onDefaultsApplied;
+                End.PositionBindable.ValueChanged += onPositionChanged;
+            }
+        }
+
+        public void UnbindEvents()
+        {
+            if (Start != null)
+            {
+                Start.DefaultsApplied -= onDefaultsApplied;
+                Start.PositionBindable.ValueChanged -= onPositionChanged;
+            }
+
+            if (End != null)
+            {
+                End.DefaultsApplied -= onDefaultsApplied;
+                End.PositionBindable.ValueChanged -= onPositionChanged;
+            }
+        }
+
+        private void onDefaultsApplied(HitObject obj) => refreshLifetimes();
+
+        private void onPositionChanged(ValueChangedEvent<Vector2> obj) => refreshLifetimes();
+
+        private void refreshLifetimes()
+        {
+            if (End == null || End.NewCombo || Start is Spinner || End is Spinner)
+            {
+                LifetimeEnd = LifetimeStart;
+                return;
+            }
+
+            Vector2 startPosition = Start.StackedEndPosition;
+            Vector2 endPosition = End.StackedPosition;
+            Vector2 distanceVector = endPosition - startPosition;
+
+            // The lifetime start will match the fade-in time of the first follow point.
+            float fraction = (int)(FollowPointConnection.SPACING * 1.5) / distanceVector.Length;
+            FollowPointConnection.GetFadeTimes(Start, End, fraction, out var fadeInTime, out _);
+
+            LifetimeStart = fadeInTime;
+            LifetimeEnd = double.MaxValue; // This will be set by the connection.
+
+            Invalidated?.Invoke();
+        }
+    }
+}

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

@@ -2,53 +2,74 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Performance;
+using osu.Framework.Graphics.Pooling;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 {
     /// <summary>
     /// Visualises connections between <see cref="DrawableOsuHitObject"/>s.
     /// </summary>
-    public class FollowPointRenderer : LifetimeManagementContainer
+    public class FollowPointRenderer : CompositeDrawable
     {
-        /// <summary>
-        /// All the <see cref="FollowPointConnection"/>s contained by this <see cref="FollowPointRenderer"/>.
-        /// </summary>
-        internal IReadOnlyList<FollowPointConnection> Connections => connections;
-
-        private readonly List<FollowPointConnection> connections = new List<FollowPointConnection>();
-
         public override bool RemoveCompletedTransforms => false;
 
-        /// <summary>
-        /// Adds the <see cref="FollowPoint"/>s around an <see cref="OsuHitObject"/>.
-        /// This includes <see cref="FollowPoint"/>s leading into <paramref name="hitObject"/>, and <see cref="FollowPoint"/>s exiting <paramref name="hitObject"/>.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="OsuHitObject"/> to add <see cref="FollowPoint"/>s for.</param>
-        public void AddFollowPoints(OsuHitObject hitObject)
-            => addConnection(new FollowPointConnection(hitObject).With(g => g.StartTime.BindValueChanged(_ => onStartTimeChanged(g))));
+        public IReadOnlyList<FollowPointLifetimeEntry> Entries => lifetimeEntries;
 
-        /// <summary>
-        /// Removes the <see cref="FollowPoint"/>s around an <see cref="OsuHitObject"/>.
-        /// This includes <see cref="FollowPoint"/>s leading into <paramref name="hitObject"/>, and <see cref="FollowPoint"/>s exiting <paramref name="hitObject"/>.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="OsuHitObject"/> to remove <see cref="FollowPoint"/>s for.</param>
-        public void RemoveFollowPoints(OsuHitObject hitObject) => removeGroup(connections.Single(g => g.Start == hitObject));
+        private DrawablePool<FollowPointConnection> connectionPool;
+        private DrawablePool<FollowPoint> pointPool;
 
-        /// <summary>
-        /// Adds a <see cref="FollowPointConnection"/> to this <see cref="FollowPointRenderer"/>.
-        /// </summary>
-        /// <param name="connection">The <see cref="FollowPointConnection"/> to add.</param>
-        /// <returns>The index of <paramref name="connection"/> in <see cref="connections"/>.</returns>
-        private void addConnection(FollowPointConnection connection)
+        private readonly List<FollowPointLifetimeEntry> lifetimeEntries = new List<FollowPointLifetimeEntry>();
+        private readonly Dictionary<LifetimeEntry, FollowPointConnection> connectionsInUse = new Dictionary<LifetimeEntry, FollowPointConnection>();
+        private readonly Dictionary<HitObject, IBindable> startTimeMap = new Dictionary<HitObject, IBindable>();
+        private readonly LifetimeEntryManager lifetimeManager = new LifetimeEntryManager();
+
+        public FollowPointRenderer()
         {
-            // Groups are sorted by their start time when added such that the index can be used to post-process other surrounding connections
-            int index = connections.AddInPlace(connection, Comparer<FollowPointConnection>.Create((g1, g2) =>
+            lifetimeManager.EntryBecameAlive += onEntryBecameAlive;
+            lifetimeManager.EntryBecameDead += onEntryBecameDead;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
             {
-                int comp = g1.StartTime.Value.CompareTo(g2.StartTime.Value);
+                connectionPool = new DrawablePoolNoLifetime<FollowPointConnection>(1, 200),
+                pointPool = new DrawablePoolNoLifetime<FollowPoint>(50, 1000)
+            };
+        }
+
+        public void AddFollowPoints(OsuHitObject hitObject)
+        {
+            addEntry(hitObject);
+
+            var startTimeBindable = hitObject.StartTimeBindable.GetBoundCopy();
+            startTimeBindable.ValueChanged += _ => onStartTimeChanged(hitObject);
+            startTimeMap[hitObject] = startTimeBindable;
+        }
+
+        public void RemoveFollowPoints(OsuHitObject hitObject)
+        {
+            removeEntry(hitObject);
+
+            startTimeMap[hitObject].UnbindAll();
+            startTimeMap.Remove(hitObject);
+        }
+
+        private void addEntry(OsuHitObject hitObject)
+        {
+            var newEntry = new FollowPointLifetimeEntry(hitObject);
+
+            var index = lifetimeEntries.AddInPlace(newEntry, Comparer<FollowPointLifetimeEntry>.Create((e1, e2) =>
+            {
+                int comp = e1.Start.StartTime.CompareTo(e2.Start.StartTime);
 
                 if (comp != 0)
                     return comp;
@@ -61,19 +82,19 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                 return -1;
             }));
 
-            if (index < connections.Count - 1)
+            if (index < lifetimeEntries.Count - 1)
             {
                 // Update the connection's end point to the next connection's start point
                 //     h1 -> -> -> h2
                 //    connection    nextGroup
 
-                FollowPointConnection nextConnection = connections[index + 1];
-                connection.End = nextConnection.Start;
+                FollowPointLifetimeEntry nextEntry = lifetimeEntries[index + 1];
+                newEntry.End = nextEntry.Start;
             }
             else
             {
                 // The end point may be non-null during re-ordering
-                connection.End = null;
+                newEntry.End = null;
             }
 
             if (index > 0)
@@ -82,23 +103,22 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                 //     h1 -> -> -> h2
                 //  prevGroup    connection
 
-                FollowPointConnection previousConnection = connections[index - 1];
-                previousConnection.End = connection.Start;
+                FollowPointLifetimeEntry previousEntry = lifetimeEntries[index - 1];
+                previousEntry.End = newEntry.Start;
             }
 
-            AddInternal(connection);
+            lifetimeManager.AddEntry(newEntry);
         }
 
-        /// <summary>
-        /// Removes a <see cref="FollowPointConnection"/> from this <see cref="FollowPointRenderer"/>.
-        /// </summary>
-        /// <param name="connection">The <see cref="FollowPointConnection"/> to remove.</param>
-        /// <returns>Whether <paramref name="connection"/> was removed.</returns>
-        private void removeGroup(FollowPointConnection connection)
+        private void removeEntry(OsuHitObject hitObject)
         {
-            RemoveInternal(connection);
+            int index = lifetimeEntries.FindIndex(e => e.Start == hitObject);
 
-            int index = connections.IndexOf(connection);
+            var entry = lifetimeEntries[index];
+            entry.UnbindEvents();
+
+            lifetimeEntries.RemoveAt(index);
+            lifetimeManager.RemoveEntry(entry);
 
             if (index > 0)
             {
@@ -106,18 +126,61 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                 //     h1 -> -> -> h2 -> -> -> h3
                 //  prevGroup    connection       nextGroup
                 // The current connection's end point is used since there may not be a next connection
-                FollowPointConnection previousConnection = connections[index - 1];
-                previousConnection.End = connection.End;
+                FollowPointLifetimeEntry previousEntry = lifetimeEntries[index - 1];
+                previousEntry.End = entry.End;
             }
-
-            connections.Remove(connection);
         }
 
-        private void onStartTimeChanged(FollowPointConnection connection)
+        protected override bool CheckChildrenLife()
         {
-            // Naive but can be improved if performance becomes an issue
-            removeGroup(connection);
-            addConnection(connection);
+            bool anyAliveChanged = base.CheckChildrenLife();
+            anyAliveChanged |= lifetimeManager.Update(Time.Current);
+            return anyAliveChanged;
+        }
+
+        private void onEntryBecameAlive(LifetimeEntry entry)
+        {
+            var connection = connectionPool.Get(c =>
+            {
+                c.Entry = (FollowPointLifetimeEntry)entry;
+                c.Pool = pointPool;
+            });
+
+            connectionsInUse[entry] = connection;
+
+            AddInternal(connection);
+        }
+
+        private void onEntryBecameDead(LifetimeEntry entry)
+        {
+            RemoveInternal(connectionsInUse[entry]);
+            connectionsInUse.Remove(entry);
+        }
+
+        private void onStartTimeChanged(OsuHitObject hitObject)
+        {
+            removeEntry(hitObject);
+            addEntry(hitObject);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            foreach (var entry in lifetimeEntries)
+                entry.UnbindEvents();
+            lifetimeEntries.Clear();
+        }
+
+        private class DrawablePoolNoLifetime<T> : DrawablePool<T>
+            where T : PoolableDrawable, new()
+        {
+            public override bool RemoveWhenNotAlive => false;
+
+            public DrawablePoolNoLifetime(int initialSize, int? maximumSize = null)
+                : base(initialSize, maximumSize)
+            {
+            }
         }
     }
 }

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

@@ -19,7 +19,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
-    public class DrawableHitCircle : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
+    public class DrawableHitCircle : DrawableOsuHitObject
     {
         public OsuAction? HitAction => HitArea.HitAction;
         protected virtual OsuSkinComponents CirclePieceComponent => OsuSkinComponents.HitCircle;
@@ -180,6 +180,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     this.Delay(800).FadeOut();
                     break;
             }
+
+            Expire();
         }
 
         public Drawable ProxiedLayer => ApproachCircle;

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

@@ -9,7 +9,6 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Graphics.Containers;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.UI;
 using osuTK;
 
@@ -52,9 +51,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             });
         }
 
-        protected override void OnApply(HitObject hitObject)
+        protected override void OnApply()
         {
-            base.OnApply(hitObject);
+            base.OnApply();
 
             IndexInCurrentComboBindable.BindTo(HitObject.IndexInCurrentComboBindable);
             PositionBindable.BindTo(HitObject.PositionBindable);
@@ -62,9 +61,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             ScaleBindable.BindTo(HitObject.ScaleBindable);
         }
 
-        protected override void OnFree(HitObject hitObject)
+        protected override void OnFree()
         {
-            base.OnFree(hitObject);
+            base.OnFree();
 
             IndexInCurrentComboBindable.UnbindFrom(HitObject.IndexInCurrentComboBindable);
             PositionBindable.UnbindFrom(HitObject.PositionBindable);
@@ -85,14 +84,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public virtual void Shake(double maximumLength) => shakeContainer.Shake(maximumLength);
 
-        protected override void UpdateInitialTransforms()
-        {
-            base.UpdateInitialTransforms();
-
-            // Manually set to reduce the number of future alive objects to a bare minimum.
-            LifetimeStart = HitObject.StartTime - HitObject.TimePreempt;
-        }
-
         /// <summary>
         /// Causes this <see cref="DrawableOsuHitObject"/> to get missed, disregarding all conditions in implementations of <see cref="DrawableHitObject.CheckForResult"/>.
         /// </summary>

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

@@ -4,9 +4,9 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
-using osuTK;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -17,15 +17,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         [Resolved]
         private OsuConfigManager config { get; set; }
 
-        public DrawableOsuJudgement(JudgementResult result, DrawableHitObject judgedObject)
-            : base(result, judgedObject)
-        {
-        }
-
-        public DrawableOsuJudgement()
-        {
-        }
-
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -39,48 +30,55 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             });
         }
 
-        public override void Apply(JudgementResult result, DrawableHitObject judgedObject)
-        {
-            base.Apply(result, judgedObject);
-
-            if (judgedObject?.HitObject is OsuHitObject osuObject)
-            {
-                Position = osuObject.StackedPosition;
-                Scale = new Vector2(osuObject.Scale);
-            }
-        }
-
         protected override void PrepareForUse()
         {
             base.PrepareForUse();
 
             Lighting.ResetAnimation();
             Lighting.SetColourFrom(JudgedObject, Result);
-        }
 
-        private double fadeOutDelay;
-        protected override double FadeOutDelay => fadeOutDelay;
+            if (JudgedObject?.HitObject is OsuHitObject osuObject)
+            {
+                Position = osuObject.StackedPosition;
+                Scale = new Vector2(osuObject.Scale);
+            }
+        }
 
         protected override void ApplyHitAnimations()
         {
             bool hitLightingEnabled = config.Get<bool>(OsuSetting.HitLighting);
 
-            if (hitLightingEnabled)
-            {
-                JudgementBody.FadeIn().Delay(FadeInDuration).FadeOut(400);
+            Lighting.Alpha = 0;
 
+            if (hitLightingEnabled && Lighting.Drawable != null)
+            {
+                // todo: this animation changes slightly based on new/old legacy skin versions.
                 Lighting.ScaleTo(0.8f).ScaleTo(1.2f, 600, Easing.Out);
                 Lighting.FadeIn(200).Then().Delay(200).FadeOut(1000);
-            }
-            else
-            {
-                JudgementBody.Alpha = 1;
+
+                // extend the lifetime to cover lighting fade
+                LifetimeEnd = Lighting.LatestTransformEndTime;
             }
 
-            fadeOutDelay = hitLightingEnabled ? 1400 : base.FadeOutDelay;
-
-            JudgementText?.TransformSpacingTo(Vector2.Zero).Then().TransformSpacingTo(new Vector2(14, 0), 1800, Easing.OutQuint);
             base.ApplyHitAnimations();
         }
+
+        protected override Drawable CreateDefaultJudgement(HitResult result) => new OsuJudgementPiece(result);
+
+        private class OsuJudgementPiece : DefaultJudgementPiece
+        {
+            public OsuJudgementPiece(HitResult result)
+                : base(result)
+            {
+            }
+
+            public override void PlayAnimation()
+            {
+                base.PlayAnimation();
+
+                if (Result != HitResult.Miss)
+                    JudgementText.TransformSpacingTo(Vector2.Zero).Then().TransformSpacingTo(new Vector2(14, 0), 1800, Easing.OutQuint);
+            }
+        }
     }
 }

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

@@ -1,32 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Pooling;
-using osu.Game.Rulesets.Objects.Drawables;
-
-namespace osu.Game.Rulesets.Osu.Objects.Drawables
-{
-    public class DrawableOsuPool<T> : DrawablePool<T>
-        where T : DrawableHitObject, new()
-    {
-        private readonly Func<DrawableHitObject, double, bool> checkHittable;
-        private readonly Action<Drawable> onLoaded;
-
-        public DrawableOsuPool(Func<DrawableHitObject, double, bool> checkHittable, Action<Drawable> onLoaded, int initialSize, int? maximumSize = null)
-            : base(initialSize, maximumSize)
-        {
-            this.checkHittable = checkHittable;
-            this.onLoaded = onLoaded;
-        }
-
-        protected override T CreateNewDrawable() => base.CreateNewDrawable().With(o =>
-        {
-            var osuObject = (DrawableOsuHitObject)(object)o;
-
-            osuObject.CheckHittable = checkHittable;
-            osuObject.OnLoadComplete += onLoaded;
-        });
-    }
-}

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

@@ -11,6 +11,7 @@ using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.UI;
@@ -19,7 +20,7 @@ using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
-    public class DrawableSlider : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
+    public class DrawableSlider : DrawableOsuHitObject
     {
         public new Slider HitObject => (Slider)base.HitObject;
 
@@ -40,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private Container<DrawableSliderTail> tailContainer;
         private Container<DrawableSliderTick> tickContainer;
         private Container<DrawableSliderRepeat> repeatContainer;
-        private Container<PausableSkinnableSound> samplesContainer;
+        private PausableSkinnableSound slidingSample;
 
         public DrawableSlider()
             : this(null)
@@ -69,7 +70,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Alpha = 0
                 },
                 headContainer = new Container<DrawableSliderHead> { RelativeSizeAxes = Axes.Both },
-                samplesContainer = new Container<PausableSkinnableSound> { RelativeSizeAxes = Axes.Both }
+                slidingSample = new PausableSkinnableSound { Looping = true }
             };
 
             PositionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
@@ -86,42 +87,35 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Tracking.BindValueChanged(updateSlidingSample);
         }
 
-        protected override void OnApply(HitObject hitObject)
+        protected override void OnApply()
         {
-            base.OnApply(hitObject);
+            base.OnApply();
 
             // Ensure that the version will change after the upcoming BindTo().
             pathVersion.Value = int.MaxValue;
             PathVersion.BindTo(HitObject.Path.Version);
         }
 
-        protected override void OnFree(HitObject hitObject)
+        protected override void OnFree()
         {
-            base.OnFree(hitObject);
+            base.OnFree();
 
             PathVersion.UnbindFrom(HitObject.Path.Version);
-        }
 
-        private PausableSkinnableSound slidingSample;
+            slidingSample.Samples = null;
+        }
 
         protected override void LoadSamples()
         {
             base.LoadSamples();
 
-            samplesContainer.Clear();
-            slidingSample = null;
-
             var firstSample = HitObject.Samples.FirstOrDefault();
 
             if (firstSample != null)
             {
-                var clone = HitObject.SampleControlPoint.ApplyTo(firstSample);
-                clone.Name = "sliderslide";
+                var clone = HitObject.SampleControlPoint.ApplyTo(firstSample).With("sliderslide");
 
-                samplesContainer.Add(slidingSample = new PausableSkinnableSound(clone)
-                {
-                    Looping = true
-                });
+                slidingSample.Samples = new ISampleInfo[] { clone };
             }
         }
 
@@ -193,13 +187,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             return base.CreateNestedHitObject(hitObject);
         }
 
-        protected override void UpdateInitialTransforms()
-        {
-            base.UpdateInitialTransforms();
-
-            Body.FadeInFromZero(HitObject.TimeFadeIn);
-        }
-
         public readonly Bindable<bool> Tracking = new Bindable<bool>();
 
         protected override void Update()
@@ -262,7 +249,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (userTriggered || Time.Current < HitObject.EndTime)
                 return;
 
-            ApplyResult(r => r.Type = r.Judgement.MaxResult);
+            ApplyResult(r => r.Type = NestedHitObjects.Any(h => h.Result.IsHit) ? r.Judgement.MaxResult : r.Judgement.MinResult);
         }
 
         public override void PlaySamples()
@@ -273,6 +260,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 base.PlaySamples();
         }
 
+        protected override void UpdateInitialTransforms()
+        {
+            base.UpdateInitialTransforms();
+
+            Body.FadeInFromZero(HitObject.TimeFadeIn);
+        }
+
         protected override void UpdateStartTimeStateTransforms()
         {
             base.UpdateStartTimeStateTransforms();
@@ -294,14 +288,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             {
                 case ArmedState.Hit:
                     Ball.ScaleTo(HitObject.Scale * 1.4f, fade_out_time, Easing.Out);
+                    if (sliderBody?.SnakingOut.Value == true)
+                        Body.FadeOut(40); // short fade to allow for any body colour to smoothly disappear.
                     break;
             }
 
-            this.FadeOut(fade_out_time, Easing.OutQuint);
+            this.FadeOut(fade_out_time, Easing.OutQuint).Expire();
         }
 
-        public Drawable ProxiedLayer => HeadCircle.ProxiedLayer;
-
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => sliderBody?.ReceivePositionalInputAt(screenSpacePos) ?? base.ReceivePositionalInputAt(screenSpacePos);
 
         private class DefaultSliderBody : PlaySliderBody

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

@@ -2,24 +2,25 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableSliderHead : DrawableHitCircle
     {
+        [CanBeNull]
+        public Slider Slider => DrawableSlider?.HitObject;
+
+        protected DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
+
         private readonly IBindable<int> pathVersion = new Bindable<int>();
 
         protected override OsuSkinComponents CirclePieceComponent => OsuSkinComponents.SliderHeadHitCircle;
 
-        private DrawableSlider drawableSlider;
-
-        private Slider slider => drawableSlider?.HitObject;
-
         public DrawableSliderHead()
         {
         }
@@ -36,34 +37,34 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             pathVersion.BindValueChanged(_ => updatePosition());
         }
 
-        protected override void OnFree(HitObject hitObject)
+        protected override void OnFree()
         {
-            base.OnFree(hitObject);
+            base.OnFree();
 
-            pathVersion.UnbindFrom(drawableSlider.PathVersion);
+            pathVersion.UnbindFrom(DrawableSlider.PathVersion);
         }
 
-        protected override void OnParentReceived(DrawableHitObject parent)
+        protected override void OnApply()
         {
-            base.OnParentReceived(parent);
+            base.OnApply();
 
-            drawableSlider = (DrawableSlider)parent;
+            pathVersion.BindTo(DrawableSlider.PathVersion);
 
-            pathVersion.BindTo(drawableSlider.PathVersion);
-
-            OnShake = drawableSlider.Shake;
-            CheckHittable = (d, t) => drawableSlider.CheckHittable?.Invoke(d, t) ?? true;
+            OnShake = DrawableSlider.Shake;
+            CheckHittable = (d, t) => DrawableSlider.CheckHittable?.Invoke(d, t) ?? true;
         }
 
         protected override void Update()
         {
             base.Update();
 
-            double completionProgress = Math.Clamp((Time.Current - slider.StartTime) / slider.Duration, 0, 1);
+            Debug.Assert(Slider != null);
+
+            double completionProgress = Math.Clamp((Time.Current - Slider.StartTime) / Slider.Duration, 0, 1);
 
             //todo: we probably want to reconsider this before adding scoring, but it looks and feels nice.
             if (!IsHit)
-                Position = slider.CurvePositionAt(completionProgress);
+                Position = Slider.CurvePositionAt(completionProgress);
         }
 
         public Action<double> OnShake;
@@ -72,8 +73,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private void updatePosition()
         {
-            if (slider != null)
-                Position = HitObject.Position - slider.Position;
+            if (Slider != null)
+                Position = HitObject.Position - Slider.Position;
         }
     }
 }

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -18,6 +19,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
     {
         public new SliderRepeat HitObject => (SliderRepeat)base.HitObject;
 
+        [CanBeNull]
+        public Slider Slider => DrawableSlider?.HitObject;
+
+        protected DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
+
         private double animDuration;
 
         public Drawable CirclePiece { get; private set; }
@@ -26,8 +32,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public override bool DisplayResult => false;
 
-        private DrawableSlider drawableSlider;
-
         public DrawableSliderRepeat()
             : base(null)
         {
@@ -60,19 +64,17 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue));
         }
 
-        protected override void OnParentReceived(DrawableHitObject parent)
+        protected override void OnApply()
         {
-            base.OnParentReceived(parent);
+            base.OnApply();
 
-            drawableSlider = (DrawableSlider)parent;
-
-            Position = HitObject.Position - drawableSlider.Position;
+            Position = HitObject.Position - DrawableSlider.Position;
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (HitObject.StartTime <= Time.Current)
-                ApplyResult(r => r.Type = drawableSlider.Tracking.Value ? r.Judgement.MaxResult : r.Judgement.MinResult);
+                ApplyResult(r => r.Type = DrawableSlider.Tracking.Value ? r.Judgement.MaxResult : r.Judgement.MinResult);
         }
 
         protected override void UpdateInitialTransforms()
@@ -114,7 +116,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (IsHit) return;
 
             bool isRepeatAtEnd = HitObject.RepeatIndex % 2 == 0;
-            List<Vector2> curve = ((PlaySliderBody)drawableSlider.Body.Drawable).CurrentCurve;
+            List<Vector2> curve = ((PlaySliderBody)DrawableSlider.Body.Drawable).CurrentCurve;
 
             Position = isRepeatAtEnd ? end : start;
 

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Diagnostics;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -15,6 +16,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
     {
         public new SliderTailCircle HitObject => (SliderTailCircle)base.HitObject;
 
+        [CanBeNull]
+        public Slider Slider => DrawableSlider?.HitObject;
+
+        protected DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
+
         /// <summary>
         /// The judgement text is provided by the <see cref="DrawableSlider"/>.
         /// </summary>

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

@@ -22,6 +22,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public override bool DisplayResult => false;
 
+        protected DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
+
         private SkinnableDrawable scaleContainer;
 
         public DrawableSliderTick()
@@ -62,11 +64,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue));
         }
 
-        protected override void OnParentReceived(DrawableHitObject parent)
+        protected override void OnApply()
         {
-            base.OnParentReceived(parent);
+            base.OnApply();
 
-            Position = HitObject.Position - ((DrawableSlider)parent).HitObject.Position;
+            Position = HitObject.Position - DrawableSlider.HitObject.Position;
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)

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

@@ -9,6 +9,7 @@ using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Audio;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
@@ -33,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private Container<DrawableSpinnerTick> ticks;
         private SpinnerBonusDisplay bonusDisplay;
-        private Container<PausableSkinnableSound> samplesContainer;
+        private PausableSkinnableSound spinningSample;
 
         private Bindable<bool> isSpinning;
         private bool spinnerFrequencyModulate;
@@ -81,7 +82,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Origin = Anchor.Centre,
                     Y = -120,
                 },
-                samplesContainer = new Container<PausableSkinnableSound> { RelativeSizeAxes = Axes.Both }
+                spinningSample = new PausableSkinnableSound
+                {
+                    Volume = { Value = 0 },
+                    Looping = true,
+                    Frequency = { Value = spinning_sample_initial_frequency }
+                }
             };
 
             PositionBindable.BindValueChanged(pos => Position = pos.NewValue);
@@ -95,30 +101,28 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             isSpinning.BindValueChanged(updateSpinningSample);
         }
 
-        private PausableSkinnableSound spinningSample;
         private const float spinning_sample_initial_frequency = 1.0f;
         private const float spinning_sample_modulated_base_frequency = 0.5f;
 
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            spinningSample.Samples = null;
+        }
+
         protected override void LoadSamples()
         {
             base.LoadSamples();
 
-            samplesContainer.Clear();
-            spinningSample = null;
-
             var firstSample = HitObject.Samples.FirstOrDefault();
 
             if (firstSample != null)
             {
-                var clone = HitObject.SampleControlPoint.ApplyTo(firstSample);
-                clone.Name = "spinnerspin";
+                var clone = HitObject.SampleControlPoint.ApplyTo(firstSample).With("spinnerspin");
 
-                samplesContainer.Add(spinningSample = new PausableSkinnableSound(clone)
-                {
-                    Volume = { Value = 0 },
-                    Looping = true,
-                    Frequency = { Value = spinning_sample_initial_frequency }
-                });
+                spinningSample.Samples = new ISampleInfo[] { clone };
+                spinningSample.Frequency.Value = spinning_sample_initial_frequency;
             }
         }
 
@@ -157,7 +161,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             base.UpdateHitStateTransforms(state);
 
-            this.FadeOut(160);
+            this.FadeOut(160).Expire();
 
             // skin change does a rewind of transforms, which will stop the spinning sound from playing if it's currently in playback.
             isSpinning?.TriggerChange();