Fix merge conflicts.

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.Game.Resources" Version="2020.1202.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1201.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;

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="Microsoft.Win32.Registry" Version="5.0.0" />
-    <PackageReference Include="DiscordRichPresence" Version="1.0.150" />
+    <PackageReference Include="DiscordRichPresence" Version="1.0.169" />
     <!-- .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/CatchSkinColourDecodingTest.cs

@@ -4,6 +4,7 @@
 using NUnit.Framework;
 using osu.Framework.IO.Stores;
 using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Rulesets.Catch.Skinning.Legacy;
 using osu.Game.Skinning;
 using osuTK.Graphics;
 

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,272 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.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.Judgements;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneCatcher : CatchSkinnableTestScene
+    public class TestSceneCatcher : OsuTestScene
     {
-        [BackgroundDependencyLoader]
+        [Resolved]
-        private void load()
+        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 TestCatcherHyperStateReverted()
+        {
+            DrawableCatchHitObject drawableObject1 = null;
+            DrawableCatchHitObject drawableObject2 = null;
+            JudgementResult result1 = null;
+            JudgementResult result2 = null;
+            AddStep("catch hyper fruit", () =>
+            {
+                drawableObject1 = createDrawableObject(new Fruit { HyperDashTarget = new Fruit { X = 100 } });
+                result1 = attemptCatch(drawableObject1);
             });
+            AddStep("catch normal fruit", () =>
+            {
+                drawableObject2 = createDrawableObject(new Fruit());
+                result2 = attemptCatch(drawableObject2);
+            });
+            AddStep("revert second result", () =>
+            {
+                catcher.OnRevertResult(drawableObject2, result2);
+            });
+            checkHyperDash(true);
+            AddStep("revert first result", () =>
+            {
+                catcher.OnRevertResult(drawableObject1, result1);
+            });
+            checkHyperDash(false);
+        }
+
+        [Test]
+        public void TestCatcherAnimationStateReverted()
+        {
+            DrawableCatchHitObject drawableObject = null;
+            JudgementResult result = null;
+            AddStep("catch kiai fruit", () =>
+            {
+                drawableObject = createDrawableObject(new TestKiaiFruit());
+                result = attemptCatch(drawableObject);
+            });
+            checkState(CatcherAnimationState.Kiai);
+            AddStep("revert result", () =>
+            {
+                catcher.OnRevertResult(drawableObject, result);
+            });
+            checkState(CatcherAnimationState.Idle);
+        }
+
+        [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)
+        {
+            for (var i = 0; i < count; i++)
+                attemptCatch(createDrawableObject(hitObject));
+        }
+
+        private JudgementResult attemptCatch(DrawableCatchHitObject drawableObject)
+        {
+            drawableObject.HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+            var result = new CatchJudgementResult(drawableObject.HitObject, drawableObject.HitObject.CreateJudgement())
+            {
+                Type = catcher.CanCatch(drawableObject.HitObject) ? HitResult.Great : HitResult.Miss
+            };
+            catcher.OnNewResult(drawableObject, result);
+            return result;
+        }
+
+        private DrawableCatchHitObject createDrawableObject(CatchHitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Banana banana:
+                    return new DrawableBanana(banana);
+
+                case Droplet droplet:
+                    return new DrawableDroplet(droplet);
+
+                case Fruit fruit:
+                    return new DrawableFruit(fruit);
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(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,16 @@ 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 +27,67 @@ 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);
+            AddSliderStep<float>("circle size", 0, 8, 5, createCatcher);
-            AddToggleStep("Hyperdash", t =>
+            AddToggleStep("hyper dash", t => this.ChildrenOfType<TestCatcherArea>().ForEach(area => area.ToggleHyperDash(t)));
-                CreatedDrawables.OfType<CatchInputManager>().Select(i => i.Child)
-                                .OfType<TestCatcherArea>().ForEach(c => c.ToggleHyperDash(t)));
 
-            AddRepeatStep("catch fruit", () => catchFruit(new TestFruit(false)
+            AddStep("catch fruit", () => attemptCatch(new Fruit()));
-            {
+            AddStep("catch fruit last in combo", () => attemptCatch(new Fruit { LastInCombo = true }));
-                X = catcher.X
+            AddStep("catch kiai fruit", () => attemptCatch(new TestSceneCatcher.TestKiaiFruit()));
-            }), 20);
+            AddStep("miss last in combo", () => attemptCatch(new Fruit { X = 100, LastInCombo = true }));
-            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);
         }
 
-        [TestCase(true)]
+        private void attemptCatch(Fruit fruit)
-        [TestCase(false)]
-        public void TestHitLighting(bool enable)
         {
-            AddStep("create catcher", () => createCatcher(5));
+            fruit.X += catcher.X;
-
+            fruit.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty
-            AddStep("toggle hit lighting", () => config.Set(OsuSetting.HitLighting, enable));
-            AddStep("catch fruit", () => catchFruit(new TestFruit(false)
             {
-                X = catcher.X
+                CircleSize = circleSize
-            }));
+            });
-            AddStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
-            {
-                X = catcher.X,
-                LastInCombo = true
-            }));
-            AddAssert("check hit explosion", () => catcher.ChildrenOfType<HitExplosion>().Any() == enable);
-        }
 
-        private void catchFruit(Fruit fruit, bool miss = false)
+            foreach (var area in this.ChildrenOfType<CatcherArea>())
-        {
-            this.ChildrenOfType<CatcherArea>().ForEach(area =>
             {
                 DrawableFruit drawable = new DrawableFruit(fruit);
                 area.Add(drawable);
 
                 Schedule(() =>
                 {
-                    area.AttemptCatch(fruit);
+                    area.OnNewResult(drawable, new CatchJudgementResult(fruit, new CatchJudgement())
-                    area.OnNewResult(drawable, new JudgementResult(fruit, new CatchJudgement()) { Type = miss ? HitResult.Miss : HitResult.Great });
+                    {
+                        Type = area.MovableCatcher.CanCatch(fruit) ? HitResult.Great : HitResult.Miss
+                    });
 
                     drawable.Expire();
                 });
-            });
+            }
         }
 
         private void createCatcher(float size)
         {
-            SetContents(() => new CatchInputManager(catchRuleset)
+            circleSize = size;
+
+            SetContents(() =>
             {
-                RelativeSizeAxes = Axes.Both,
+                var droppedObjectContainer = new Container();
-                Child = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
+
+                return new CatchInputManager(catchRuleset)
                 {
-                    Anchor = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
-                    Origin = Anchor.TopCentre,
+                    Children = new Drawable[]
-                    CreateDrawableRepresentation = ((DrawableRuleset<CatchHitObject>)catchRuleset.CreateInstance().CreateDrawableRulesetWith(new CatchBeatmap())).CreateDrawableRepresentation
+                    {
-                },
+                        droppedObjectContainer,
+                        new TestCatcherArea(droppedObjectContainer, new BeatmapDifficulty { CircleSize = size })
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.TopCentre,
+                        }
+                    }
+                };
             });
         }
 
@@ -114,26 +97,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)
+            public TestCatcherArea(Container droppedObjectContainer, BeatmapDifficulty beatmapDifficulty)
-                : base(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

@@ -3,11 +3,12 @@
 
 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
 {
@@ -37,39 +38,50 @@ namespace osu.Game.Rulesets.Catch.Tests
         }
 
         private Drawable createDrawableFruit(int indexInBeatmap, bool hyperdash = false) =>
-            SetProperties(new DrawableFruit(new Fruit
+            new TestDrawableCatchHitObjectSpecimen(new DrawableFruit(new Fruit
             {
                 IndexInBeatmap = indexInBeatmap,
                 HyperDashBindable = { Value = hyperdash }
             }));
 
         private Drawable createDrawableBanana() =>
-            SetProperties(new DrawableBanana(new Banana()));
+            new TestDrawableCatchHitObjectSpecimen(new DrawableBanana(new Banana()));
 
         private Drawable createDrawableDroplet(bool hyperdash = false) =>
-            SetProperties(new DrawableDroplet(new Droplet
+            new TestDrawableCatchHitObjectSpecimen(new DrawableDroplet(new Droplet
             {
                 HyperDashBindable = { Value = hyperdash }
             }));
 
-        private Drawable createDrawableTinyDroplet() => SetProperties(new DrawableTinyDroplet(new TinyDroplet()));
+        private Drawable createDrawableTinyDroplet() => new TestDrawableCatchHitObjectSpecimen(new DrawableTinyDroplet(new TinyDroplet()));
+    }
 
-        protected virtual DrawableCatchHitObject SetProperties(DrawableCatchHitObject d)
+    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 { CircleSize = 0 });
+            hitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-            hitObject.StartTime = 1000000000000;
             hitObject.Scale = 1.5f;
+            hitObject.StartTime = 500;
 
             d.Anchor = Anchor.Centre;
-            d.RelativePositionAxes = Axes.None;
-            d.Position = Vector2.Zero;
             d.HitObjectApplied += _ =>
             {
                 d.LifetimeStart = double.NegativeInfinity;
                 d.LifetimeEnd = double.PositiveInfinity;
             };
-            return d;
+
+            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

@@ -14,13 +14,13 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         protected override void LoadComplete()
         {
-            AddStep("fruit changes visual and hyper", () => SetContents(() => SetProperties(new DrawableFruit(new Fruit
+            AddStep("fruit changes visual and hyper", () => SetContents(() => new TestDrawableCatchHitObjectSpecimen(new DrawableFruit(new Fruit
             {
                 IndexInBeatmapBindable = { BindTarget = indexInBeatmap },
                 HyperDashBindable = { BindTarget = hyperDash },
             }))));
 
-            AddStep("droplet changes hyper", () => SetContents(() => SetProperties(new DrawableDroplet(new Droplet
+            AddStep("droplet changes hyper", () => SetContents(() => new TestDrawableCatchHitObjectSpecimen(new DrawableDroplet(new Droplet
             {
                 HyperDashBindable = { BindTarget = hyperDash },
             }))));

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

@@ -13,6 +13,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Rulesets.Catch.Skinning.Legacy;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Skinning;
 using osu.Game.Tests.Visual;
@@ -117,7 +118,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/CatchRuleset.cs

@@ -21,7 +21,7 @@ using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using System;
-using osu.Game.Rulesets.Catch.Skinning;
+using osu.Game.Rulesets.Catch.Skinning.Legacy;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch

osu.Game.Rulesets.Catch/CatchSkinComponents.cs

@@ -5,11 +5,8 @@ namespace osu.Game.Rulesets.Catch
 {
     public enum CatchSkinComponents
     {
-        FruitBananas,
+        Fruit,
-        FruitApple,
+        Banana,
-        FruitGrapes,
-        FruitOrange,
-        FruitPear,
         Droplet,
         CatcherIdle,
         CatcherFail,

osu.Game.Rulesets.Catch/Judgements/CatchJudgementResult.cs

@@ -0,0 +1,28 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using JetBrains.Annotations;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Catch.Judgements
+{
+    public class CatchJudgementResult : JudgementResult
+    {
+        /// <summary>
+        /// The catcher animation state prior to this judgement.
+        /// </summary>
+        public CatcherAnimationState CatcherAnimationState;
+
+        /// <summary>
+        /// Whether the catcher was hyper dashing prior to this judgement.
+        /// </summary>
+        public bool CatcherHyperDash;
+
+        public CatchJudgementResult([NotNull] HitObject hitObject, [NotNull] Judgement judgement)
+            : base(hitObject, judgement)
+        {
+        }
+    }
+}

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

@@ -1,17 +1,20 @@
 // 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.Framework.Utils;
 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, IHasComboInformation
+    public class Banana : PalpableCatchHitObject, IHasComboInformation
     {
         /// <summary>
         /// Index of banana in current shower.
@@ -27,17 +30,12 @@ namespace osu.Game.Rulesets.Catch.Objects
             Samples = samples;
         }
 
-        private Color4? colour;
+        // override any external colour changes with banananana
-
+        Color4 IHasComboInformation.GetComboColour(IReadOnlyList<Color4> comboColours) => getBananaColour();
-        Color4 IHasComboInformation.GetComboColour(IReadOnlyList<Color4> comboColours)
-        {
-            // override any external colour changes with banananana
-            return colour ??= getBananaColour();
-        }
 
         private Color4 getBananaColour()
         {
-            switch (RNG.Next(0, 3))
+            switch (StatelessRNG.NextInt(3, RandomSeed))
             {
                 default:
                     return new Color4(255, 240, 0, 255);
@@ -50,11 +48,27 @@ namespace osu.Game.Rulesets.Catch.Objects
             }
         }
 
-        private class BananaHitSampleInfo : HitSampleInfo
+        private class BananaHitSampleInfo : HitSampleInfo, IEquatable<BananaHitSampleInfo>
         {
-            private static string[] lookupNames { get; } = { "metronomelow", "catch-banana" };
+            private static readonly string[] lookup_names = { "Gameplay/metronomelow", "Gameplay/catch-banana" };
 
-            public override IEnumerable<string> LookupNames => lookupNames;
+            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/CatchHitObject.cs

@@ -97,6 +97,12 @@ namespace osu.Game.Rulesets.Catch.Objects
             set => ScaleBindable.Value = value;
         }
 
+        /// <summary>
+        /// The seed value used for visual randomness such as fruit rotation.
+        /// The value is <see cref="HitObject.StartTime"/> truncated to an integer.
+        /// </summary>
+        public int RandomSeed => (int)StartTime;
+
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);

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

@@ -1,20 +1,42 @@
 // 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.Skinning.Default;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
-    public class DrawableBanana : DrawableFruit
+    public class DrawableBanana : DrawablePalpableCatchHitObject
     {
-        protected override FruitVisualRepresentation GetVisualRepresentation(int indexInBeatmap) => FruitVisualRepresentation.Banana;
+        public DrawableBanana()
+            : this(null)
+        {
+        }
 
-        public DrawableBanana(Banana h)
+        public DrawableBanana([CanBeNull] Banana h)
             : base(h)
         {
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            ScaleContainer.Child = new SkinnableDrawable(
+                new CatchSkinComponent(CatchSkinComponents.Banana),
+                _ => new BananaPiece());
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // start time affects the random seed which is used to determine the banana colour
+            StartTimeBindable.BindValueChanged(_ => UpdateComboColour());
+        }
+
         protected override void UpdateInitialTransforms()
         {
             base.UpdateInitialTransforms();
@@ -22,14 +44,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()

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
     {
-        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();
+            bananaContainer.Clear(false);
-        }
-
-        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
-        {
-            switch (hitObject)
-            {
-                case Banana banana:
-                    return createDrawableRepresentation?.Invoke(banana);
-            }
-
-            return base.CreateNestedHitObject(hitObject);
         }
     }
 }

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

@@ -5,8 +5,11 @@ using System;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
@@ -16,16 +19,21 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
 
         protected override double InitialLifetimeOffset => HitObject.TimePreempt;
 
-        public float DisplayRadius => DrawSize.X / 2 * Scale.X * HitObject.Scale;
-
         protected override float SamplePlaybackPosition => HitObject.X / CatchPlayfield.WIDTH;
 
+        public int RandomSeed => HitObject?.RandomSeed ?? 0;
+
         protected DrawableCatchHitObject([CanBeNull] CatchHitObject hitObject)
             : base(hitObject)
         {
             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();
@@ -46,6 +54,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
 
         public override bool RemoveWhenNotAlive => IsOnPlate;
 
+        protected override JudgementResult CreateResult(Judgement judgement) => new CatchJudgementResult(HitObject, judgement);
+
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (CheckPosition == null) return;

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

@@ -1,10 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Skinning.Default;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
@@ -13,25 +13,22 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
     {
         public override bool StaysOnPlate => false;
 
-        public DrawableDroplet(CatchHitObject h)
+        public DrawableDroplet()
+            : this(null)
+        {
+        }
+
+        public DrawableDroplet([CanBeNull] CatchHitObject h)
             : base(h)
         {
         }
 
         [BackgroundDependencyLoader]
         private void load()
-        {
-            HyperDash.BindValueChanged(_ => updatePiece(), true);
-        }
-
-        private void updatePiece()
         {
             ScaleContainer.Child = new SkinnableDrawable(
                 new CatchSkinComponent(CatchSkinComponents.Droplet),
-                _ => new DropletPiece
+                _ => new DropletPiece());
-                {
-                    HyperDash = { BindTarget = HyperDash }
-                });
         }
 
         protected override void UpdateInitialTransforms()
@@ -39,7 +36,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

@@ -1,11 +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;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Utils;
+using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
@@ -14,9 +14,12 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
     {
         public readonly Bindable<FruitVisualRepresentation> VisualRepresentation = new Bindable<FruitVisualRepresentation>();
 
-        protected virtual FruitVisualRepresentation GetVisualRepresentation(int indexInBeatmap) => (FruitVisualRepresentation)(indexInBeatmap % 4);
+        public DrawableFruit()
+            : this(null)
+        {
+        }
 
-        public DrawableFruit(CatchHitObject h)
+        public DrawableFruit([CanBeNull] Fruit h)
             : base(h)
         {
         }
@@ -24,50 +27,21 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load()
         {
-            ScaleContainer.Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
-
             IndexInBeatmap.BindValueChanged(change =>
             {
-                VisualRepresentation.Value = GetVisualRepresentation(change.NewValue);
+                VisualRepresentation.Value = (FruitVisualRepresentation)(change.NewValue % 4);
             }, true);
 
-            VisualRepresentation.BindValueChanged(_ => updatePiece());
-            HyperDash.BindValueChanged(_ => updatePiece(), true);
-        }
-
-        private void updatePiece()
-        {
             ScaleContainer.Child = new SkinnableDrawable(
-                new CatchSkinComponent(getComponent(VisualRepresentation.Value)),
+                new CatchSkinComponent(CatchSkinComponents.Fruit),
-                _ => new FruitPiece
+                _ => new FruitPiece());
-                {
-                    VisualRepresentation = { BindTarget = VisualRepresentation },
-                    HyperDash = { BindTarget = HyperDash },
-                });
         }
 
-        private CatchSkinComponents getComponent(FruitVisualRepresentation hitObjectVisualRepresentation)
+        protected override void UpdateInitialTransforms()
         {
-            switch (hitObjectVisualRepresentation)
+            base.UpdateInitialTransforms();
-            {
-                case FruitVisualRepresentation.Pear:
-                    return CatchSkinComponents.FruitPear;
 
-                case FruitVisualRepresentation.Grape:
+            ScaleContainer.RotateTo((RandomSingle(1) - 0.5f) * 40);
-                    return CatchSkinComponents.FruitGrapes;
-
-                case FruitVisualRepresentation.Pineapple:
-                    return CatchSkinComponents.FruitApple;
-
-                case FruitVisualRepresentation.Raspberry:
-                    return CatchSkinComponents.FruitOrange;
-
-                case FruitVisualRepresentation.Banana:
-                    return CatchSkinComponents.FruitBananas;
-
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(hitObjectVisualRepresentation), hitObjectVisualRepresentation, null);
-            }
         }
     }
 
@@ -77,6 +51,5 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         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
     {
-        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,18 +35,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         protected override void ClearNestedHitObjects()
         {
             base.ClearNestedHitObjects();
-            dropletContainer.Clear();
+            dropletContainer.Clear(false);
-        }
-
-        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
-        {
-            switch (hitObject)
-            {
-                case CatchHitObject catchObject:
-                    return createDrawableRepresentation?.Invoke(catchObject);
-            }
-
-            throw new ArgumentException($"{nameof(hitObject)} must be of type {nameof(CatchHitObject)}.");
         }
     }
 }

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

@@ -30,6 +30,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         /// </summary>
         public virtual bool StaysOnPlate => true;
 
+        public float DisplayRadius => CatchHitObject.OBJECT_RADIUS * HitObject.Scale * ScaleFactor;
+
         protected readonly Container ScaleContainer;
 
         protected DrawablePalpableCatchHitObject([CanBeNull] CatchHitObject h)

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

@@ -1,13 +1,20 @@
 // 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;
+
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public class DrawableTinyDroplet : DrawableDroplet
     {
         protected override float ScaleFactor => base.ScaleFactor / 2;
 
-        public DrawableTinyDroplet(TinyDroplet h)
+        public DrawableTinyDroplet()
+            : this(null)
+        {
+        }
+
+        public DrawableTinyDroplet([CanBeNull] TinyDroplet h)
             : base(h)
         {
         }

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

@@ -1,30 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
-{
-    public class BananaPiece : PulpFormation
-    {
-        public BananaPiece()
-        {
-            InternalChildren = new Drawable[]
-            {
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(SMALL_PULP),
-                    Y = -0.3f
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_4 * 0.8f, LARGE_PULP_4 * 2.5f),
-                    Y = 0.05f,
-                },
-            };
-        }
-    }
-}

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

@@ -1,37 +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.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

@@ -1,79 +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 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

@@ -1,42 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
-{
-    public class GrapePiece : PulpFormation
-    {
-        public GrapePiece()
-        {
-            InternalChildren = new Drawable[]
-            {
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(SMALL_PULP),
-                    Y = -0.25f,
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_3),
-                    Position = PositionAt(0, DISTANCE_FROM_CENTRE_3),
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_3),
-                    Position = PositionAt(120, DISTANCE_FROM_CENTRE_3),
-                },
-                new Pulp
-                {
-                    Size = new Vector2(LARGE_PULP_3),
-                    AccentColour = { BindTarget = AccentColour },
-                    Position = PositionAt(240, DISTANCE_FROM_CENTRE_3),
-                },
-            };
-        }
-    }
-}

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

@@ -1,42 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
-{
-    public class PearPiece : PulpFormation
-    {
-        public PearPiece()
-        {
-            InternalChildren = new Drawable[]
-            {
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(SMALL_PULP),
-                    Y = -0.33f,
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_3),
-                    Position = PositionAt(60, DISTANCE_FROM_CENTRE_3),
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_3),
-                    Position = PositionAt(180, DISTANCE_FROM_CENTRE_3),
-                },
-                new Pulp
-                {
-                    Size = new Vector2(LARGE_PULP_3),
-                    AccentColour = { BindTarget = AccentColour },
-                    Position = PositionAt(300, DISTANCE_FROM_CENTRE_3),
-                },
-            };
-        }
-    }
-}

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

@@ -1,48 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
-{
-    public class PineapplePiece : PulpFormation
-    {
-        public PineapplePiece()
-        {
-            InternalChildren = new Drawable[]
-            {
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(SMALL_PULP),
-                    Y = -0.3f,
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_4),
-                    Position = PositionAt(45, DISTANCE_FROM_CENTRE_4),
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_4),
-                    Position = PositionAt(135, DISTANCE_FROM_CENTRE_4),
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_4),
-                    Position = PositionAt(225, DISTANCE_FROM_CENTRE_4),
-                },
-                new Pulp
-                {
-                    Size = new Vector2(LARGE_PULP_4),
-                    AccentColour = { BindTarget = AccentColour },
-                    Position = PositionAt(315, DISTANCE_FROM_CENTRE_4),
-                },
-            };
-        }
-    }
-}

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

@@ -1,48 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
-{
-    public class RaspberryPiece : PulpFormation
-    {
-        public RaspberryPiece()
-        {
-            InternalChildren = new Drawable[]
-            {
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(SMALL_PULP),
-                    Y = -0.34f,
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_4),
-                    Position = PositionAt(0, DISTANCE_FROM_CENTRE_4),
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_4),
-                    Position = PositionAt(90, DISTANCE_FROM_CENTRE_4),
-                },
-                new Pulp
-                {
-                    AccentColour = { BindTarget = AccentColour },
-                    Size = new Vector2(LARGE_PULP_4),
-                    Position = PositionAt(180, DISTANCE_FROM_CENTRE_4),
-                },
-                new Pulp
-                {
-                    Size = new Vector2(LARGE_PULP_4),
-                    AccentColour = { BindTarget = AccentColour },
-                    Position = PositionAt(270, DISTANCE_FROM_CENTRE_4),
-                },
-            };
-        }
-    }
-}

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
+            var dropletSamples = Samples.Select(s => s.With(@"slidertick")).ToList();
-            {
-                Bank = s.Bank,
-                Name = @"slidertick",
-                Volume = s.Volume
-            }).ToList();
 
             int nodeIndex = 0;
             SliderEventDescriptor? lastEvent = null;

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

@@ -0,0 +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.
+
+using osu.Framework.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Default
+{
+    public class BananaPiece : CatchHitObjectPiece
+    {
+        protected override BorderPiece BorderPiece { get; }
+
+        public BananaPiece()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                new BananaPulpFormation
+                {
+                    AccentColour = { BindTarget = AccentColour },
+                },
+                BorderPiece = new BorderPiece(),
+            };
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+// 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 osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Default
+{
+    public class BananaPulpFormation : PulpFormation
+    {
+        public BananaPulpFormation()
+        {
+            AddPulp(new Vector2(0, -0.3f), new Vector2(SMALL_PULP));
+            AddPulp(new Vector2(0, 0.05f), new Vector2(LARGE_PULP_4 * 0.8f, LARGE_PULP_4 * 2.5f));
+        }
+    }
+}

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

@@ -3,10 +3,11 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Catch.Objects;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+namespace osu.Game.Rulesets.Catch.Skinning.Default
 {
     public class BorderPiece : Circle
     {

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Default
+{
+    public abstract class CatchHitObjectPiece : CompositeDrawable
+    {
+        public readonly Bindable<Color4> AccentColour = new Bindable<Color4>();
+        public readonly Bindable<bool> HyperDash = new Bindable<bool>();
+
+        [Resolved(canBeNull: true)]
+        [CanBeNull]
+        protected DrawableHitObject DrawableHitObject { get; private set; }
+
+        /// <summary>
+        /// A part of this piece that will be faded out while falling in the playfield.
+        /// </summary>
+        [CanBeNull]
+        protected virtual BorderPiece BorderPiece => null;
+
+        /// <summary>
+        /// A part of this piece that will be only visible when <see cref="HyperDash"/> is true.
+        /// </summary>
+        [CanBeNull]
+        protected virtual HyperBorderPiece HyperBorderPiece => null;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            var hitObject = (DrawablePalpableCatchHitObject)DrawableHitObject;
+
+            if (hitObject != null)
+            {
+                AccentColour.BindTo(hitObject.AccentColour);
+                HyperDash.BindTo(hitObject.HyperDash);
+            }
+
+            HyperDash.BindValueChanged(hyper =>
+            {
+                if (HyperBorderPiece != null)
+                    HyperBorderPiece.Alpha = hyper.NewValue ? 1 : 0;
+            }, true);
+        }
+
+        protected override void Update()
+        {
+            if (BorderPiece != null && DrawableHitObject?.HitObject != null)
+                BorderPiece.Alpha = (float)Math.Clamp((DrawableHitObject.HitObject.StartTime - Time.Current) / 500, 0, 1);
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Default
+{
+    public class DropletPiece : CatchHitObjectPiece
+    {
+        protected override HyperBorderPiece HyperBorderPiece { get; }
+
+        public DropletPiece()
+        {
+            Size = new Vector2(CatchHitObject.OBJECT_RADIUS / 2);
+
+            InternalChildren = new Drawable[]
+            {
+                new Pulp
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    AccentColour = { BindTarget = AccentColour }
+                },
+                HyperBorderPiece = new HyperDropletBorderPiece()
+            };
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/Default/FruitPiece.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 osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Default
+{
+    internal class FruitPiece : CatchHitObjectPiece
+    {
+        /// <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>();
+
+        protected override BorderPiece BorderPiece { get; }
+        protected override HyperBorderPiece HyperBorderPiece { get; }
+
+        public FruitPiece()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                new FruitPulpFormation
+                {
+                    AccentColour = { BindTarget = AccentColour },
+                    VisualRepresentation = { BindTarget = VisualRepresentation }
+                },
+                BorderPiece = new BorderPiece(),
+                HyperBorderPiece = new HyperBorderPiece()
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            var fruit = (DrawableFruit)DrawableHitObject;
+
+            if (fruit != null)
+                VisualRepresentation.BindTo(fruit.VisualRepresentation);
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Default
+{
+    public class FruitPulpFormation : PulpFormation
+    {
+        public readonly Bindable<FruitVisualRepresentation> VisualRepresentation = new Bindable<FruitVisualRepresentation>();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            VisualRepresentation.BindValueChanged(setFormation, true);
+        }
+
+        private void setFormation(ValueChangedEvent<FruitVisualRepresentation> visualRepresentation)
+        {
+            Clear();
+
+            switch (visualRepresentation.NewValue)
+            {
+                case FruitVisualRepresentation.Pear:
+                    AddPulp(new Vector2(0, -0.33f), new Vector2(SMALL_PULP));
+                    AddPulp(PositionAt(60, DISTANCE_FROM_CENTRE_3), new Vector2(LARGE_PULP_3));
+                    AddPulp(PositionAt(180, DISTANCE_FROM_CENTRE_3), new Vector2(LARGE_PULP_3));
+                    AddPulp(PositionAt(300, DISTANCE_FROM_CENTRE_3), new Vector2(LARGE_PULP_3));
+                    break;
+
+                case FruitVisualRepresentation.Grape:
+                    AddPulp(new Vector2(0, -0.25f), new Vector2(SMALL_PULP));
+                    AddPulp(PositionAt(0, DISTANCE_FROM_CENTRE_3), new Vector2(LARGE_PULP_3));
+                    AddPulp(PositionAt(120, DISTANCE_FROM_CENTRE_3), new Vector2(LARGE_PULP_3));
+                    AddPulp(PositionAt(240, DISTANCE_FROM_CENTRE_3), new Vector2(LARGE_PULP_3));
+                    break;
+
+                case FruitVisualRepresentation.Pineapple:
+                    AddPulp(new Vector2(0, -0.3f), new Vector2(SMALL_PULP));
+                    AddPulp(PositionAt(45, DISTANCE_FROM_CENTRE_4), new Vector2(LARGE_PULP_4));
+                    AddPulp(PositionAt(135, DISTANCE_FROM_CENTRE_4), new Vector2(LARGE_PULP_4));
+                    AddPulp(PositionAt(225, DISTANCE_FROM_CENTRE_4), new Vector2(LARGE_PULP_4));
+                    AddPulp(PositionAt(315, DISTANCE_FROM_CENTRE_4), new Vector2(LARGE_PULP_4));
+                    break;
+
+                case FruitVisualRepresentation.Raspberry:
+                    AddPulp(new Vector2(0, -0.34f), new Vector2(SMALL_PULP));
+                    AddPulp(PositionAt(0, DISTANCE_FROM_CENTRE_4), new Vector2(LARGE_PULP_4));
+                    AddPulp(PositionAt(90, DISTANCE_FROM_CENTRE_4), new Vector2(LARGE_PULP_4));
+                    AddPulp(PositionAt(180, DISTANCE_FROM_CENTRE_4), new Vector2(LARGE_PULP_4));
+                    AddPulp(PositionAt(270, DISTANCE_FROM_CENTRE_4), new Vector2(LARGE_PULP_4));
+                    break;
+            }
+        }
+    }
+}

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

@@ -4,7 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.UI;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+namespace osu.Game.Rulesets.Catch.Skinning.Default
 {
     public class HyperBorderPiece : BorderPiece
     {

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

@@ -1,7 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+namespace osu.Game.Rulesets.Catch.Skinning.Default
 {
     public class HyperDropletBorderPiece : HyperBorderPiece
     {

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

@@ -8,10 +8,12 @@ using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+namespace osu.Game.Rulesets.Catch.Skinning.Default
 {
     public class Pulp : Circle
     {
+        public readonly Bindable<Color4> AccentColour = new Bindable<Color4>();
+
         public Pulp()
         {
             RelativePositionAxes = Axes.Both;
@@ -22,8 +24,6 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
             Colour = Color4.White.Opacity(0.9f);
         }
 
-        public readonly Bindable<Color4> AccentColour = new Bindable<Color4>();
-
         protected override void LoadComplete()
         {
             base.LoadComplete();

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

@@ -2,19 +2,17 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Objects.Drawables;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
+namespace osu.Game.Rulesets.Catch.Skinning.Default
 {
     public abstract class PulpFormation : CompositeDrawable
     {
-        protected readonly IBindable<Color4> AccentColour = new Bindable<Color4>();
+        public readonly Bindable<Color4> AccentColour = new Bindable<Color4>();
 
         protected const float LARGE_PULP_3 = 16f * FruitPiece.RADIUS_ADJUST;
         protected const float DISTANCE_FROM_CENTRE_3 = 0.15f;
@@ -24,6 +22,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 
         protected const float SMALL_PULP = LARGE_PULP_3 / 2;
 
+        private int pulpsInUse;
+
         protected PulpFormation()
         {
             RelativeSizeAxes = Axes.Both;
@@ -33,11 +33,24 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
             distance * MathF.Sin(angle * MathF.PI / 180),
             distance * MathF.Cos(angle * MathF.PI / 180));
 
-        [BackgroundDependencyLoader]
+        protected void Clear()
-        private void load(DrawableHitObject drawableObject)
         {
-            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
+            for (int i = 0; i < pulpsInUse; i++)
-            AccentColour.BindTo(drawableCatchObject.AccentColour);
+                InternalChildren[i].Alpha = 0;
+            pulpsInUse = 0;
+        }
+
+        protected void AddPulp(Vector2 position, Vector2 size)
+        {
+            if (pulpsInUse == InternalChildren.Count)
+                AddInternal(new Pulp { AccentColour = { BindTarget = AccentColour } });
+
+            var pulp = InternalChildren[pulpsInUse];
+            pulp.Position = position;
+            pulp.Size = size;
+            pulp.Alpha = 1;
+
+            pulpsInUse++;
         }
     }
 }

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

@@ -1,15 +1,13 @@
 // 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 Humanizer;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Skinning;
-using osuTK;
 using osuTK.Graphics;
 using static osu.Game.Skinning.LegacySkinConfiguration;
 
-namespace osu.Game.Rulesets.Catch.Skinning
+namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     public class CatchLegacySkinTransformer : LegacySkinTransformer
     {
@@ -40,20 +38,21 @@ namespace osu.Game.Rulesets.Catch.Skinning
 
             switch (catchSkinComponent.Component)
             {
-                case CatchSkinComponents.FruitApple:
+                case CatchSkinComponents.Fruit:
-                case CatchSkinComponents.FruitBananas:
+                    if (GetTexture("fruit-pear") != null)
-                case CatchSkinComponents.FruitOrange:
+                        return new LegacyFruitPiece();
-                case CatchSkinComponents.FruitGrapes:
+
-                case CatchSkinComponents.FruitPear:
+                    break;
-                    var lookupName = catchSkinComponent.Component.ToString().Kebaberize();
+
-                    if (GetTexture(lookupName) != null)
+                case CatchSkinComponents.Banana:
-                        return new LegacyFruitPiece(lookupName);
+                    if (GetTexture("fruit-bananas") != null)
+                        return new LegacyBananaPiece();
 
                     break;
 
                 case CatchSkinComponents.Droplet:
                     if (GetTexture("fruit-drop") != null)
-                        return new LegacyFruitPiece("fruit-drop") { Scale = new Vector2(0.8f) };
+                        return new LegacyDropletPiece();
 
                     break;
 

osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchComboCounter.cs

@@ -9,7 +9,7 @@ using osuTK;
 using osuTK.Graphics;
 using static osu.Game.Skinning.LegacySkinConfiguration;
 
-namespace osu.Game.Rulesets.Catch.Skinning
+namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
     /// <summary>
     /// A combo counter implementation that visually behaves almost similar to stable's osu!catch combo counter.

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

@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Catch.Skinning.Legacy
+{
+    internal class LegacyFruitPiece : LegacyCatchHitObjectPiece
+    {
+        public readonly Bindable<FruitVisualRepresentation> VisualRepresentation = new Bindable<FruitVisualRepresentation>();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            var fruit = (DrawableFruit)DrawableHitObject;
+
+            if (fruit != null)
+                VisualRepresentation.BindTo(fruit.VisualRepresentation);
+
+            VisualRepresentation.BindValueChanged(visual => setTexture(visual.NewValue), true);
+        }
+
+        private void setTexture(FruitVisualRepresentation visualRepresentation)
+        {
+            switch (visualRepresentation)
+            {
+                case FruitVisualRepresentation.Pear:
+                    SetTexture(Skin.GetTexture("fruit-pear"), Skin.GetTexture("fruit-pear-overlay"));
+                    break;
+
+                case FruitVisualRepresentation.Grape:
+                    SetTexture(Skin.GetTexture("fruit-grapes"), Skin.GetTexture("fruit-grapes-overlay"));
+                    break;
+
+                case FruitVisualRepresentation.Pineapple:
+                    SetTexture(Skin.GetTexture("fruit-apple"), Skin.GetTexture("fruit-apple-overlay"));
+                    break;
+
+                case FruitVisualRepresentation.Raspberry:
+                    SetTexture(Skin.GetTexture("fruit-orange"), Skin.GetTexture("fruit-orange-overlay"));
+                    break;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+// 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.Textures;
+
+namespace osu.Game.Rulesets.Catch.Skinning
+{
+    public class LegacyBananaPiece : LegacyCatchHitObjectPiece
+    {
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Texture texture = Skin.GetTexture("fruit-bananas");
+            Texture overlayTexture = Skin.GetTexture("fruit-bananas-overlay");
+
+            SetTexture(texture, overlayTexture);
+        }
+    }
+}

osu.Game.Rulesets.Catch/Skinning/LegacyCatchHitObjectPiece.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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Skinning
+{
+    public abstract class LegacyCatchHitObjectPiece : PoolableDrawable
+    {
+        public readonly Bindable<Color4> AccentColour = new Bindable<Color4>();
+        public readonly Bindable<bool> HyperDash = new Bindable<bool>();
+
+        private readonly Sprite colouredSprite;
+        private readonly Sprite overlaySprite;
+        private readonly Sprite hyperSprite;
+
+        [Resolved]
+        protected ISkinSource Skin { get; private set; }
+
+        [Resolved(canBeNull: true)]
+        [CanBeNull]
+        protected DrawableHitObject DrawableHitObject { get; private set; }
+
+        protected LegacyCatchHitObjectPiece()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                colouredSprite = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+                overlaySprite = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+                hyperSprite = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Blending = BlendingParameters.Additive,
+                    Depth = 1,
+                    Alpha = 0,
+                    Scale = new Vector2(1.2f),
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            var hitObject = (DrawablePalpableCatchHitObject)DrawableHitObject;
+
+            if (hitObject != null)
+            {
+                AccentColour.BindTo(hitObject.AccentColour);
+                HyperDash.BindTo(hitObject.HyperDash);
+            }
+
+            hyperSprite.Colour = Skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashFruit)?.Value ??
+                                 Skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDash)?.Value ??
+                                 Catcher.DEFAULT_HYPER_DASH_COLOUR;
+
+            AccentColour.BindValueChanged(colour =>
+            {
+                colouredSprite.Colour = LegacyColourCompatibility.DisallowZeroAlpha(colour.NewValue);
+            }, true);
+
+            HyperDash.BindValueChanged(hyper =>
+            {
+                hyperSprite.Alpha = hyper.NewValue ? 0.7f : 0;
+            }, true);
+        }
+
+        protected void SetTexture(Texture texture, Texture overlayTexture)
+        {
+            colouredSprite.Texture = texture;
+            overlaySprite.Texture = overlayTexture;
+            hyperSprite.Texture = texture;
+        }
+    }
+}

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

@@ -0,0 +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.
+
+using osu.Framework.Graphics.Textures;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning
+{
+    public class LegacyDropletPiece : LegacyCatchHitObjectPiece
+    {
+        public LegacyDropletPiece()
+        {
+            Scale = new Vector2(0.8f);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Texture texture = Skin.GetTexture("fruit-drop");
+            Texture overlayTexture = Skin.GetTexture("fruit-drop-overlay");
+
+            SetTexture(texture, overlayTexture);
+        }
+    }
+}

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

@@ -1,81 +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.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Game.Rulesets.Catch.Objects.Drawables;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Skinning;
-using osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Rulesets.Catch.Skinning
-{
-    internal class LegacyFruitPiece : CompositeDrawable
-    {
-        private readonly string lookupName;
-
-        private readonly IBindable<Color4> accentColour = new Bindable<Color4>();
-        private Sprite colouredSprite;
-
-        public LegacyFruitPiece(string lookupName)
-        {
-            this.lookupName = lookupName;
-            RelativeSizeAxes = Axes.Both;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(DrawableHitObject drawableObject, ISkinSource skin)
-        {
-            var drawableCatchObject = (DrawablePalpableCatchHitObject)drawableObject;
-
-            accentColour.BindTo(drawableCatchObject.AccentColour);
-
-            InternalChildren = new Drawable[]
-            {
-                colouredSprite = new Sprite
-                {
-                    Texture = skin.GetTexture(lookupName),
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                },
-                new Sprite
-                {
-                    Texture = skin.GetTexture($"{lookupName}-overlay"),
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                },
-            };
-
-            if (drawableCatchObject.HitObject.HyperDash)
-            {
-                var hyperDash = new Sprite
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Blending = BlendingParameters.Additive,
-                    Depth = 1,
-                    Alpha = 0.7f,
-                    Scale = new Vector2(1.2f),
-                    Texture = skin.GetTexture(lookupName),
-                    Colour = skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashFruit)?.Value ??
-                             skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDash)?.Value ??
-                             Catcher.DEFAULT_HYPER_DASH_COLOUR,
-                };
-
-                AddInternal(hyperDash);
-            }
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            accentColour.BindValueChanged(colour => colouredSprite.Colour = LegacyColourCompatibility.DisallowZeroAlpha(colour.NewValue), true);
-        }
-    }
-}

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,28 +36,37 @@ 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,
             };
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            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();
@@ -71,7 +81,7 @@ namespace osu.Game.Rulesets.Catch.UI
             ((DrawableCatchHitObject)d).CheckPosition = checkIfWeCanCatch;
         }
 
-        private bool checkIfWeCanCatch(CatchHitObject obj) => CatcherArea.AttemptCatch(obj);
+        private bool checkIfWeCanCatch(CatchHitObject obj) => CatcherArea.MovableCatcher.CanCatch(obj);
 
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
             => CatcherArea.OnNewResult((DrawableCatchHitObject)judgedObject, result);

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

@@ -14,10 +14,11 @@ using osu.Framework.Input.Bindings;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Rulesets.Catch.Judgements;
 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.Rulesets.Judgements;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
@@ -47,19 +48,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>
@@ -92,9 +89,9 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private readonly float catchWidth;
 
-        private CatcherSprite catcherIdle;
+        private readonly CatcherSprite catcherIdle;
-        private CatcherSprite catcherKiai;
+        private readonly CatcherSprite catcherKiai;
-        private CatcherSprite catcherFail;
+        private readonly CatcherSprite catcherFail;
 
         private CatcherSprite currentCatcher;
 
@@ -108,12 +105,13 @@ namespace osu.Game.Rulesets.Catch.UI
         private float hyperDashTargetPosition;
         private Bindable<bool> hitLighting;
 
-        private DrawablePool<HitExplosion> hitExplosionPool;
+        private readonly DrawablePool<HitExplosion> hitExplosionPool;
-        private Container<HitExplosion> hitExplosionContainer;
+        private readonly Container<HitExplosion> hitExplosionContainer;
 
-        public Catcher([NotNull] Container trailsTarget, BeatmapDifficulty difficulty = null)
+        public Catcher([NotNull] Container trailsTarget, [NotNull] Container droppedObjectTarget, BeatmapDifficulty difficulty = null)
         {
             this.trailsTarget = trailsTarget;
+            this.droppedObjectTarget = droppedObjectTarget;
 
             Origin = Anchor.TopCentre;
 
@@ -122,17 +120,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[]
             {
                 hitExplosionPool = new DrawablePool<HitExplosion>(10),
-                caughtFruitContainer,
+                caughtFruitContainer = new Container<DrawablePalpableCatchHitObject>
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.BottomCentre,
+                },
                 catcherIdle = new CatcherSprite(CatcherAnimationState.Idle)
                 {
                     Anchor = Anchor.TopCentre,
@@ -154,7 +150,12 @@ namespace osu.Game.Rulesets.Catch.UI
                     Origin = Anchor.BottomCentre,
                 },
             };
+        }
 
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            hitLighting = config.GetBindable<bool>(OsuSetting.HitLighting);
             trails = new CatcherTrailDisplay(this);
 
             updateCatcher();
@@ -176,63 +177,24 @@ 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)
+        private static Vector2 calculateScale(BeatmapDifficulty difficulty) => new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
-            => 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)
+        internal static float CalculateCatchWidth(Vector2 scale) => CatcherArea.CATCHER_SIZE * Math.Abs(scale.X) * ALLOWED_CATCH_RANGE;
-            => 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)
+        internal static float CalculateCatchWidth(BeatmapDifficulty difficulty) => CalculateCatchWidth(calculateScale(difficulty));
-            => CalculateCatchWidth(calculateScale(difficulty));
 
         /// <summary>
-        /// Add a caught fruit to the catcher's stack.
+        /// Determine if this catcher can catch a <see cref="CatchHitObject"/> in the current position.
         /// </summary>
-        /// <param name="fruit">The fruit that was caught.</param>
+        public bool CanCatch(CatchHitObject hitObject)
-        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)
-            {
-                HitExplosion hitExplosion = hitExplosionPool.Get();
-                hitExplosion.X = fruit.X;
-                hitExplosion.Scale = new Vector2(fruit.HitObject.Scale);
-                hitExplosion.ObjectColour = fruit.AccentColour.Value;
-                hitExplosionContainer.Add(hitExplosion);
-            }
-        }
-
-        /// <summary>
-        /// Let the catcher attempt to catch a fruit.
-        /// </summary>
-        /// <param name="hitObject">The fruit to catch.</param>
-        /// <returns>Whether the catch is possible.</returns>
-        public bool AttemptCatch(CatchHitObject hitObject)
         {
             if (!(hitObject is PalpableCatchHitObject fruit))
                 return false;
@@ -243,18 +205,29 @@ namespace osu.Game.Rulesets.Catch.UI
             var catchObjectPosition = fruit.X;
             var catcherPosition = Position.X;
 
-            var validCatch =
+            return catchObjectPosition >= catcherPosition - halfCatchWidth &&
-                catchObjectPosition >= catcherPosition - halfCatchWidth &&
+                   catchObjectPosition <= catcherPosition + halfCatchWidth;
-                catchObjectPosition <= catcherPosition + halfCatchWidth;
+        }
 
-            // only update hyperdash state if we are not catching a tiny droplet.
+        public void OnNewResult(DrawableCatchHitObject drawableObject, JudgementResult result)
-            if (fruit is TinyDroplet) return validCatch;
+        {
+            var catchResult = (CatchJudgementResult)result;
+            catchResult.CatcherAnimationState = CurrentState;
+            catchResult.CatcherHyperDash = HyperDashing;
 
-            if (validCatch && fruit.HyperDash)
+            if (!(drawableObject.HitObject is PalpableCatchHitObject hitObject)) return;
+
+            if (result.IsHit)
+                placeCaughtObject(hitObject);
+
+            // droplet doesn't affect the catcher state
+            if (hitObject is TinyDroplet) return;
+
+            if (result.IsHit && hitObject.HyperDash)
             {
-                var target = fruit.HyperDashTarget;
+                var target = hitObject.HyperDashTarget;
-                var timeDifference = target.StartTime - fruit.StartTime;
+                var timeDifference = target.StartTime - hitObject.StartTime;
-                double positionDifference = target.X - catcherPosition;
+                double positionDifference = target.X - X;
                 var velocity = positionDifference / Math.Max(1.0, timeDifference - 1000.0 / 60.0);
 
                 SetHyperDashState(Math.Abs(velocity), target.X);
@@ -262,12 +235,30 @@ namespace osu.Game.Rulesets.Catch.UI
             else
                 SetHyperDashState();
 
-            if (validCatch)
+            if (result.IsHit)
-                updateState(fruit.Kiai ? CatcherAnimationState.Kiai : CatcherAnimationState.Idle);
+                updateState(hitObject.Kiai ? CatcherAnimationState.Kiai : CatcherAnimationState.Idle);
-            else if (!(fruit is Banana))
+            else if (!(hitObject is Banana))
                 updateState(CatcherAnimationState.Fail);
+        }
 
-            return validCatch;
+        public void OnRevertResult(DrawableCatchHitObject drawableObject, JudgementResult result)
+        {
+            var catchResult = (CatchJudgementResult)result;
+
+            if (CurrentState != catchResult.CatcherAnimationState)
+                updateState(catchResult.CatcherAnimationState);
+
+            if (HyperDashing != catchResult.CatcherHyperDash)
+            {
+                if (catchResult.CatcherHyperDash)
+                    SetHyperDashState(2);
+                else
+                    SetHyperDashState();
+            }
+
+            caughtFruitContainer.RemoveAll(d => d.HitObject == drawableObject.HitObject);
+            droppedObjectTarget.RemoveAll(d => (d as DrawableCatchHitObject)?.HitObject == drawableObject.HitObject);
+            hitExplosionContainer.RemoveAll(d => d.HitObject == drawableObject.HitObject);
         }
 
         /// <summary>
@@ -301,24 +292,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)
+            if (position == X)
-            {
+                return;
-                this.FadeColour(hyperDashColour, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+
-                this.FadeTo(0.2f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
+            Scale = new Vector2(Math.Abs(Scale.X) * (position > X ? 1 : -1), Scale.Y);
-            }
+            X = position;
-            else
-            {
-                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;
-
         public bool OnPressed(CatchAction action)
         {
             switch (action)
@@ -357,56 +341,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()
+        public void Drop() => clearPlate(DroppedObjectAnimation.Drop);
-        {
-            foreach (var f in caughtFruitContainer.ToArray())
-                Drop(f);
-        }
 
         /// <summary>
-        /// Explode any fruit off the plate.
+        /// Explode all fruit off the plate.
         /// </summary>
-        public void Explode()
+        public void Explode() => clearPlate(DroppedObjectAnimation.Explode);
-        {
-            foreach (var f in caughtFruitContainer.ToArray())
-                Explode(f);
-        }
 
-        public void Drop(DrawableHitObject fruit)
+        private void runHyperDashStateTransition(bool hyperDashing)
         {
-            removeFromPlateWithTransform(fruit, f =>
+            updateTrailVisibility();
+
+            if (hyperDashing)
             {
-                f.MoveToY(f.Y + 75, 750, Easing.InSine);
+                this.FadeColour(hyperDashColour, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-                f.FadeOut(750);
+                this.FadeTo(0.2f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-            });
+            }
-        }
+            else
-
-        public void Explode(DrawableHitObject fruit)
-        {
-            var originalX = fruit.X * Scale.X;
-
-            removeFromPlateWithTransform(fruit, f =>
             {
-                f.MoveToY(f.Y - 50, 250, Easing.OutSine).Then().MoveToY(f.Y + 50, 500, Easing.InSine);
+                this.FadeColour(Color4.White, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-                f.MoveToX(f.X + originalX * 6, 1000);
+                this.FadeTo(1f, HYPER_DASH_TRANSITION_DURATION, Easing.OutQuint);
-                f.FadeOut(750);
+            }
-            });
         }
 
+        private void updateTrailVisibility() => trails.DisplayTrail = Dashing || HyperDashing;
+
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)
         {
             base.SkinChanged(skin, allowFallback);
@@ -479,33 +441,144 @@ 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;
+                float diff = (caughtObjectRadius + radius_div_2) / allowance;
-                fruit.Position = caughtFruitContainer.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
 
-                if (!caughtFruitContainer.Remove(fruit))
+                caughtObject.X += (RNG.NextSingle() - 0.5f) * diff * 2;
-                    // we may have already been removed by a previous operation (due to the weird OnLoadComplete scheduling).
+                caughtObject.Y -= RNG.NextSingle() * diff;
-                    // this avoids a crash on potentially attempting to Add a fruit to ExplodingFruitTarget twice.
-                    return;
-
-                ExplodingFruitTarget.Add(fruit);
             }
 
-            var actionTime = Clock.CurrentTime;
+            caughtObject.X = Math.Clamp(caughtObject.X, -CatcherArea.CATCHER_SIZE / 2, CatcherArea.CATCHER_SIZE / 2);
+        }
 
-            fruit.ApplyCustomUpdateState += onFruitOnApplyCustomUpdateState;
+        private void addLighting(DrawablePalpableCatchHitObject caughtObject)
-            onFruitOnApplyCustomUpdateState(fruit, fruit.State.Value);
+        {
+            if (!hitLighting.Value) return;
 
-            void onFruitOnApplyCustomUpdateState(DrawableHitObject o, ArmedState state)
+            HitExplosion hitExplosion = hitExplosionPool.Get();
+            hitExplosion.HitObject = caughtObject.HitObject;
+            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))
+                case Banana banana:
-                    action(fruit);
+                    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,16 +1,13 @@
 // 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;
 using osu.Game.Rulesets.Catch.Judgements;
-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 +18,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
+        public CatcherArea(Container droppedObjectContainer, BeatmapDifficulty difficulty = null)
-        {
-            set => MovableCatcher.ExplodingFruitTarget = value;
-        }
-
-        private DrawableCatchHitObject lastPlateableFruit;
-
-        public CatcherArea(BeatmapDifficulty difficulty = null)
         {
             Size = new Vector2(CatchPlayfield.WIDTH, CATCHER_SIZE);
             Children = new Drawable[]
@@ -47,56 +35,21 @@ 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 hitObject, JudgementResult result)
         {
+            MovableCatcher.OnNewResult(hitObject, 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 && hitObject is DrawablePalpableCatchHitObject fruit)
-            {
-                // 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(hitObject.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 (hitObject.HitObject.LastInCombo)
             {
                 if (result.Judgement is CatchJudgement catchJudgement && catchJudgement.ShouldExplodeFor(result))
-                    runAfterLoaded(() => MovableCatcher.Explode());
+                    MovableCatcher.Explode();
                 else
                     MovableCatcher.Drop();
             }
@@ -104,16 +57,10 @@ namespace osu.Game.Rulesets.Catch.UI
             comboDisplay.OnNewResult(hitObject, result);
         }
 
-        public void OnRevertResult(DrawableCatchHitObject fruit, JudgementResult result)
+        public void OnRevertResult(DrawableCatchHitObject hitObject, JudgementResult result)
-            => comboDisplay.OnRevertResult(fruit, result);
-
-        public void OnReleased(CatchAction action)
         {
-        }
+            comboDisplay.OnRevertResult(hitObject, result);
-
+            MovableCatcher.OnRevertResult(hitObject, result);
-        public bool AttemptCatch(CatchHitObject obj)
-        {
-            return MovableCatcher.AttemptCatch(obj);
         }
 
         protected override void UpdateAfterChildren()

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

@@ -6,6 +6,7 @@ using JetBrains.Annotations;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Sprites;
 using osuTK;
 using osuTK.Graphics;
@@ -20,6 +21,8 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         private readonly Catcher catcher;
 
+        private readonly DrawablePool<CatcherTrailSprite> trailPool;
+
         private readonly Container<CatcherTrailSprite> dashTrails;
         private readonly Container<CatcherTrailSprite> hyperDashTrails;
         private readonly Container<CatcherTrailSprite> endGlowSprites;
@@ -80,8 +83,9 @@ namespace osu.Game.Rulesets.Catch.UI
 
             RelativeSizeAxes = Axes.Both;
 
-            InternalChildren = new[]
+            InternalChildren = new Drawable[]
             {
+                trailPool = new DrawablePool<CatcherTrailSprite>(30),
                 dashTrails = new Container<CatcherTrailSprite> { RelativeSizeAxes = Axes.Both },
                 hyperDashTrails = new Container<CatcherTrailSprite> { RelativeSizeAxes = Axes.Both, Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR },
                 endGlowSprites = new Container<CatcherTrailSprite> { RelativeSizeAxes = Axes.Both, Colour = Catcher.DEFAULT_HYPER_DASH_COLOUR },
@@ -118,14 +122,14 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             var texture = (catcher.CurrentDrawableCatcher as TextureAnimation)?.CurrentFrame ?? ((Sprite)catcher.CurrentDrawableCatcher).Texture;
 
-            var sprite = new CatcherTrailSprite(texture)
+            CatcherTrailSprite sprite = trailPool.Get();
-            {
+
-                Anchor = catcher.Anchor,
+            sprite.Texture = texture;
-                Scale = catcher.Scale,
+            sprite.Anchor = catcher.Anchor;
-                Blending = BlendingParameters.Additive,
+            sprite.Scale = catcher.Scale;
-                RelativePositionAxes = catcher.RelativePositionAxes,
+            sprite.Blending = BlendingParameters.Additive;
-                Position = catcher.Position
+            sprite.RelativePositionAxes = catcher.RelativePositionAxes;
-            };
+            sprite.Position = catcher.Position;
 
             target.Add(sprite);
 

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

@@ -1,22 +1,40 @@
 // 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.Pooling;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class CatcherTrailSprite : Sprite
+    public class CatcherTrailSprite : PoolableDrawable
     {
-        public CatcherTrailSprite(Texture texture)
+        public Texture Texture
         {
-            Texture = texture;
+            set => sprite.Texture = value;
+        }
+
+        private readonly Sprite sprite;
+
+        public CatcherTrailSprite()
+        {
+            InternalChild = sprite = new Sprite
+            {
+                RelativeSizeAxes = Axes.Both
+            };
 
             Size = new Vector2(CatcherArea.CATCHER_SIZE);
 
             // Sets the origin roughly to the centre of the catcher's plate to allow for correct scaling.
             OriginPosition = new Vector2(0.5f, 0.06f) * CatcherArea.CATCHER_SIZE;
         }
+
+        protected override void FreeAfterUse()
+        {
+            ClearTransforms();
+            base.FreeAfterUse();
+        }
     }
 }

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)
+        public override DrawableHitObject<CatchHitObject> CreateDrawableRepresentation(CatchHitObject h) => null;
-        {
-            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;
-        }
     }
 }

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

@@ -7,6 +7,7 @@ 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;
 using osuTK;
 using osuTK.Graphics;
 
@@ -15,6 +16,7 @@ namespace osu.Game.Rulesets.Catch.UI
     public class HitExplosion : PoolableDrawable
     {
         private Color4 objectColour;
+        public CatchHitObject HitObject;
 
         public Color4 ObjectColour
         {

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

@@ -15,7 +15,7 @@ using osu.Game.Rulesets.Mania.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit;

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

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects;
 using osuTK;

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/Components/EditBodyPiece.cs

@@ -4,7 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
 {

osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditNotePiece.cs

@@ -4,7 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
 {

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

@@ -9,7 +9,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Input;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -26,7 +26,7 @@ using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Difficulty;
 using osu.Game.Rulesets.Mania.Edit;
 using osu.Game.Rulesets.Mania.Scoring;
-using osu.Game.Rulesets.Mania.Skinning;
+using osu.Game.Rulesets.Mania.Skinning.Legacy;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osu.Game.Scoring;

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

@@ -4,9 +4,9 @@
 using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;

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

@@ -5,7 +5,7 @@ using System.Diagnostics;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;

osu.Game.Rulesets.Mania/Skinning/Default/DefaultBodyPiece.cs

@@ -5,16 +5,17 @@ using System;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-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.Shapes;
 using osu.Framework.Layout;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
+using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
+namespace osu.Game.Rulesets.Mania.Skinning.Default
 {
     /// <summary>
     /// Represents length-wise portion of a hold note.

osu.Game.Rulesets.Mania/Skinning/Default/DefaultNotePiece.cs

@@ -4,7 +4,6 @@
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -12,8 +11,9 @@ using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
+using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
+namespace osu.Game.Rulesets.Mania.Skinning.Default
 {
     /// <summary>
     /// Represents the static hit markers of notes.

osu.Game.Rulesets.Mania/Skinning/Default/IHoldNoteBody.cs

@@ -1,7 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
+namespace osu.Game.Rulesets.Mania.Skinning.Default
 {
     /// <summary>
     /// Interface for mania hold note bodies.

osu.Game.Rulesets.Mania/Skinning/Legacy/HitTargetInsetContainer.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class HitTargetInsetContainer : Container
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBodyPiece.cs

@@ -14,7 +14,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyBodyPiece : LegacyManiaColumnElement
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyColumnBackground.cs

@@ -12,7 +12,7 @@ using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyColumnBackground : LegacyManiaColumnElement, IKeyBindingHandler<ManiaAction>
     {

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

@@ -13,7 +13,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyHitExplosion : LegacyManiaColumnElement, IHitExplosion
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHitTarget.cs

@@ -12,7 +12,7 @@ using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyHitTarget : CompositeDrawable
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHoldNoteHeadPiece.cs

@@ -4,7 +4,7 @@
 using osu.Framework.Graphics.Textures;
 using osu.Game.Skinning;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyHoldNoteHeadPiece : LegacyNotePiece
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHoldNoteTailPiece.cs

@@ -6,7 +6,7 @@ using osu.Framework.Graphics.Textures;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyHoldNoteTailPiece : LegacyNotePiece
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyKeyArea.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyKeyArea : LegacyManiaColumnElement, IKeyBindingHandler<ManiaAction>
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyManiaColumnElement.cs

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Skinning;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     /// <summary>
     /// A <see cref="CompositeDrawable"/> which is placed somewhere within a <see cref="Column"/>.

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyNotePiece.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyNotePiece : LegacyManiaColumnElement
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyStageBackground.cs

@@ -12,7 +12,7 @@ using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyStageBackground : CompositeDrawable
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyStageForeground.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class LegacyStageForeground : CompositeDrawable
     {

osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs

@@ -2,19 +2,19 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Graphics;
-using osu.Framework.Bindables;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Skinning;
 using System.Collections.Generic;
 using System.Diagnostics;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Objects.Legacy;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
 
-namespace osu.Game.Rulesets.Mania.Skinning
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
     public class ManiaLegacySkinTransformer : LegacySkinTransformer
     {

osu.Game.Rulesets.Mania/UI/Components/DefaultHitTarget.cs

@@ -8,7 +8,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK.Graphics;
 

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

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Effects;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
 using osuTK.Graphics;

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/Mods/TestSceneOsuModSpunOut.cs

@@ -13,7 +13,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests.Mods

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

@@ -12,7 +12,7 @@ using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Testing.Input;
 using osu.Game.Audio;
-using osu.Game.Rulesets.Osu.Skinning;
+using osu.Game.Rulesets.Osu.Skinning.Legacy;
 using osu.Game.Rulesets.Osu.UI.Cursor;
 using osu.Game.Skinning;
 using osu.Game.Tests.Visual;

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(HitSampleInfo.HIT_CLAP),
-                new HitSampleInfo { Name = HitSampleInfo.HIT_WHISTLE },
+                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(HitSampleInfo.HIT_CLAP),
-                new HitSampleInfo { Name = HitSampleInfo.HIT_WHISTLE },
+                new HitSampleInfo(HitSampleInfo.HIT_WHISTLE),
             });
 
             AddAssert("head samples not updated", () => assertSamples(slider.HitObject.HeadCircle));

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

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Skinning;
 using osu.Game.Tests.Visual;
 using osuTK;

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

@@ -19,7 +19,7 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Storyboards;
 using osuTK;
 

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/Difficulty/OsuPerformanceCalculator.cs

@@ -99,16 +99,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             if (Attributes.MaxCombo > 0)
                 aimValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
 
-            double approachRateFactor = 1.0;
+            double approachRateFactor = 0.0;
-
             if (Attributes.ApproachRate > 10.33)
-                approachRateFactor += 0.3 * (Attributes.ApproachRate - 10.33);
+                approachRateFactor += 0.4 * (Attributes.ApproachRate - 10.33);
             else if (Attributes.ApproachRate < 8.0)
-            {
+                approachRateFactor += 0.1 * (8.0 - Attributes.ApproachRate);
-                approachRateFactor += 0.01 * (8.0 - Attributes.ApproachRate);
-            }
 
-            aimValue *= approachRateFactor;
+            aimValue *= 1.0 + Math.Min(approachRateFactor, approachRateFactor * (totalHits / 1000.0));
 
             // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
             if (mods.Any(h => h is OsuModHidden))
@@ -137,8 +134,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double speedValue = Math.Pow(5.0 * Math.Max(1.0, Attributes.SpeedStrain / 0.0675) - 4.0, 3.0) / 100000.0;
 
             // Longer maps are worth more
-            speedValue *= 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
+            double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
-                          (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
+                                 (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
+            speedValue *= lengthBonus;
 
             // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
             speedValue *= Math.Pow(0.97, countMiss);
@@ -147,11 +145,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             if (Attributes.MaxCombo > 0)
                 speedValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
 
-            double approachRateFactor = 1.0;
+            double approachRateFactor = 0.0;
             if (Attributes.ApproachRate > 10.33)
-                approachRateFactor += 0.3 * (Attributes.ApproachRate - 10.33);
+                approachRateFactor += 0.4 * (Attributes.ApproachRate - 10.33);
 
-            speedValue *= approachRateFactor;
+            speedValue *= 1.0 + Math.Min(approachRateFactor, approachRateFactor * (totalHits / 1000.0));
 
             if (mods.Any(m => m is OsuModHidden))
                 speedValue *= 1.0 + 0.04 * (12.0 - Attributes.ApproachRate);

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCirclePiece.cs

@@ -5,7 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components

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/SliderBodyPiece.cs

@@ -5,7 +5,7 @@ using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osuTK;
 using osuTK.Graphics;