Merge remote-tracking branch 'origin/master' into comment-editor

README.md

@@ -13,25 +13,17 @@ Rhythm is just a *click* away. The future of [osu!](https://osu.ppy.sh) and the
 
 ## Status
 
-This project is still heavily under development, but is in a state where users are encouraged to try it out and keep it installed alongside the stable *osu!* client. It will continue to evolve over the coming months and hopefully bring some new unique features to the table.
+This project is under heavy development, but is in a stable state. Users are encouraged to try it out and keep it installed alongside the stable *osu!* client. It will continue to evolve to the point of eventually replacing the existing stable client as an update.
 
-We are accepting bug reports (please report with as much detail as possible). Feature requests are welcome as long as you read and understand the contribution guidelines listed below.
+We are accepting bug reports (please report with as much detail as possible). Feature requests are also welcome, but understand that our focus is on completing the game to feature parity before adding new features. A few resources are available as starting points to getting involved and understanding the project:
 
-Detailed changelogs are published on the [official osu! site](https://osu.ppy.sh/home/changelog).
-
-## Requirements
-
-- A desktop platform with the [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download) or higher installed.
-- When running on Linux, please have a system-wide FFmpeg installation available to support video decoding.
-- When running on Windows 7 or 8.1, **[additional prerequisites](https://docs.microsoft.com/en-us/dotnet/core/install/dependencies?tabs=netcore31&pivots=os-windows)** may be required to correctly run .NET Core applications if your operating system is not up-to-date with the latest service packs.
-- When developing with mobile, [Xamarin](https://docs.microsoft.com/en-us/xamarin/) is required, which is shipped together with Visual Studio or [Visual Studio for Mac](https://visualstudio.microsoft.com/vs/mac/).
-- When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as [Visual Studio 2019+](https://visualstudio.microsoft.com/vs/), [JetBrains Rider](https://www.jetbrains.com/rider/) or [Visual Studio Code](https://code.visualstudio.com/).
+- Detailed release changelogs are available on the [official osu! site](https://osu.ppy.sh/home/changelog/lazer).
+- You can learn more about our approach to [project management](https://github.com/ppy/osu/wiki/Project-management).
+- Read peppy's [latest blog post](https://blog.ppy.sh/a-definitive-lazer-faq/) exploring where lazer is currently and the roadmap going forward.
 
 ## Running osu!
 
-### Releases
-
-If you are not interested in developing the game, you can still consume our [binary releases](https://github.com/ppy/osu/releases).
+If you are looking to install or test osu! without setting up a development environment, you can consume our [binary releases](https://github.com/ppy/osu/releases). Handy links below will download the latest version for your operating system of choice:
 
 **Latest build:**
 
@@ -39,9 +31,19 @@ If you are not interested in developing the game, you can still consume our [bin
 | ------------- | ------------- | ------------- | ------------- |
 
 - **Linux** users are recommended to self-compile until we have official deployment in place.
+- When running on Windows 7 or 8.1, **[additional prerequisites](https://docs.microsoft.com/en-us/dotnet/core/install/dependencies?tabs=netcore31&pivots=os-windows)** may be required to correctly run .NET Core applications if your operating system is not up-to-date with the latest service packs.
 
 If your platform is not listed above, there is still a chance you can manually build it by following the instructions below.
 
+## Developing or debugging
+
+Please make sure you have the following prerequisites:
+
+- A desktop platform with the [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download) or higher installed.
+- When developing with mobile, [Xamarin](https://docs.microsoft.com/en-us/xamarin/) is required, which is shipped together with Visual Studio or [Visual Studio for Mac](https://visualstudio.microsoft.com/vs/mac/).
+- When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as [Visual Studio 2019+](https://visualstudio.microsoft.com/vs/), [JetBrains Rider](https://www.jetbrains.com/rider/) or [Visual Studio Code](https://code.visualstudio.com/).
+- When running on Linux, please have a system-wide FFmpeg installation available to support video decoding.
+
 ### Downloading the source code
 
 Clone the repository:

build/InspectCode.cake

@@ -1,5 +1,5 @@
 #addin "nuget:?package=CodeFileSanity&version=0.0.33"
-#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2019.3.0"
+#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2019.3.2"
 #tool "nuget:?package=NVika.MSBuild&version=1.0.1"
 var nVikaToolPath = GetFiles("./tools/NVika.MSBuild.*/tools/NVika.exe").First();
 

osu.Android.props

@@ -53,7 +53,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.1230.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.207.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.221.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.218.0" />
   </ItemGroup>
 </Project>

osu.Desktop/osu.Desktop.csproj

@@ -29,7 +29,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.2.6" />
     <PackageReference Include="Microsoft.Win32.Registry" Version="4.7.0" />
-    <PackageReference Include="DiscordRichPresence" Version="1.0.147" />
+    <PackageReference Include="DiscordRichPresence" Version="1.0.150" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

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

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Tests.Visual;
 

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

@@ -3,104 +3,31 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Tests.Visual;
 using System;
 using System.Collections.Generic;
-using osu.Game.Skinning;
-using osu.Framework.Graphics.Shapes;
-using osuTK.Graphics;
-using osu.Framework.Audio.Sample;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics.Textures;
-using osu.Game.Audio;
-using osu.Game.Graphics.Sprites;
+using osu.Framework.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneCatcher : OsuTestScene
+    public class TestSceneCatcher : SkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(CatcherSprite),
+            typeof(CatcherArea),
         };
 
-        private readonly Container container;
-
-        public TestSceneCatcher()
-        {
-            Child = container = new Container
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-            };
-        }
-
         [BackgroundDependencyLoader]
         private void load()
         {
-            AddStep("show default catcher implementation", () => { container.Child = new CatcherSprite(); });
-
-            AddStep("show custom catcher implementation", () =>
+            SetContents(() => new CatcherArea.Catcher
             {
-                container.Child = new CatchCustomSkinSourceContainer
-                {
-                    Child = new CatcherSprite()
-                };
+                RelativePositionAxes = Axes.None,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
             });
         }
-
-        private class CatcherCustomSkin : Container
-        {
-            public CatcherCustomSkin()
-            {
-                RelativeSizeAxes = Axes.Both;
-
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.Blue
-                    },
-                    new OsuSpriteText
-                    {
-                        Text = "custom"
-                    }
-                };
-            }
-        }
-
-        [Cached(typeof(ISkinSource))]
-        private class CatchCustomSkinSourceContainer : Container, ISkinSource
-        {
-            public event Action SourceChanged
-            {
-                add { }
-                remove { }
-            }
-
-            public Drawable GetDrawableComponent(ISkinComponent component)
-            {
-                switch (component.LookupName)
-                {
-                    case "Gameplay/catch/fruit-catcher-idle":
-                        return new CatcherCustomSkin();
-                }
-
-                return null;
-            }
-
-            public SampleChannel GetSample(ISampleInfo sampleInfo) =>
-                throw new NotImplementedException();
-
-            public Texture GetTexture(string componentName) =>
-                throw new NotImplementedException();
-
-            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
-        }
     }
 }

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

@@ -3,8 +3,10 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.UI;
@@ -13,10 +15,9 @@ using osu.Game.Tests.Visual;
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneCatcherArea : OsuTestScene
+    public class TestSceneCatcherArea : SkinnableTestScene
     {
         private RulesetInfo catchRuleset;
-        private TestCatcherArea catcherArea;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -26,20 +27,22 @@ namespace osu.Game.Rulesets.Catch.Tests
         public TestSceneCatcherArea()
         {
             AddSliderStep<float>("CircleSize", 0, 8, 5, createCatcher);
-            AddToggleStep("Hyperdash", t => catcherArea.ToggleHyperDash(t));
+            AddToggleStep("Hyperdash", t =>
+                CreatedDrawables.OfType<CatchInputManager>().Select(i => i.Child)
+                                .OfType<TestCatcherArea>().ForEach(c => c.ToggleHyperDash(t)));
         }
 
         private void createCatcher(float size)
         {
-            Child = new CatchInputManager(catchRuleset)
+            SetContents(() => new CatchInputManager(catchRuleset)
             {
                 RelativeSizeAxes = Axes.Both,
-                Child = catcherArea = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
+                Child = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
                 {
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.TopLeft
                 },
-            };
+            });
         }
 
         [BackgroundDependencyLoader]

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

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;

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

@@ -5,78 +5,110 @@ using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
-using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
 using osu.Game.Tests.Visual;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
-    public class TestSceneFruitObjects : OsuTestScene
+    public class TestSceneFruitObjects : SkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(CatchHitObject),
             typeof(Fruit),
+            typeof(FruitPiece),
             typeof(Droplet),
+            typeof(Banana),
+            typeof(BananaShower),
             typeof(DrawableCatchHitObject),
             typeof(DrawableFruit),
             typeof(DrawableDroplet),
-            typeof(BananaShower),
+            typeof(DrawableBanana),
+            typeof(DrawableBananaShower),
             typeof(Pulp),
         };
 
-        public TestSceneFruitObjects()
+        protected override void LoadComplete()
         {
-            Add(new GridContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                Content = new[]
-                {
-                    new Drawable[]
-                    {
-                        createDrawable(0),
-                        createDrawable(1),
-                        createDrawable(2),
-                    },
-                    new Drawable[]
-                    {
-                        createDrawable(3),
-                        createDrawable(4),
-                        createDrawable(5),
-                    },
-                }
-            });
+            base.LoadComplete();
+
+            foreach (FruitVisualRepresentation rep in Enum.GetValues(typeof(FruitVisualRepresentation)))
+                AddStep($"show {rep}", () => SetContents(() => createDrawable(rep)));
+
+            AddStep("show droplet", () => SetContents(createDrawableDroplet));
+
+            AddStep("show tiny droplet", () => SetContents(createDrawableTinyDroplet));
         }
 
-        private DrawableFruit createDrawable(int index)
+        private Drawable createDrawableTinyDroplet()
         {
-            Fruit fruit = index == 5
-                ? new Banana
-                {
-                    StartTime = 1000000000000,
-                    IndexInBeatmap = index,
-                    Scale = 1.5f,
-                }
-                : new Fruit
-                {
-                    StartTime = 1000000000000,
-                    IndexInBeatmap = index,
-                    Scale = 1.5f,
-                };
+            var droplet = new TinyDroplet
+            {
+                StartTime = Clock.CurrentTime,
+                Scale = 1.5f,
+            };
 
-            return new DrawableFruit(fruit)
+            return new DrawableTinyDroplet(droplet)
             {
                 Anchor = Anchor.Centre,
-                RelativePositionAxes = Axes.Both,
+                RelativePositionAxes = Axes.None,
                 Position = Vector2.Zero,
                 Alpha = 1,
                 LifetimeStart = double.NegativeInfinity,
                 LifetimeEnd = double.PositiveInfinity,
             };
         }
+
+        private Drawable createDrawableDroplet()
+        {
+            var droplet = new Droplet
+            {
+                StartTime = Clock.CurrentTime,
+                Scale = 1.5f,
+            };
+
+            return new DrawableDroplet(droplet)
+            {
+                Anchor = Anchor.Centre,
+                RelativePositionAxes = Axes.None,
+                Position = Vector2.Zero,
+                Alpha = 1,
+                LifetimeStart = double.NegativeInfinity,
+                LifetimeEnd = double.PositiveInfinity,
+            };
+        }
+
+        private Drawable createDrawable(FruitVisualRepresentation rep)
+        {
+            Fruit fruit = new TestCatchFruit(rep)
+            {
+                StartTime = 1000000000000,
+                Scale = 1.5f,
+            };
+
+            return new DrawableFruit(fruit)
+            {
+                Anchor = Anchor.Centre,
+                RelativePositionAxes = Axes.None,
+                Position = Vector2.Zero,
+                Alpha = 1,
+                LifetimeStart = double.NegativeInfinity,
+                LifetimeEnd = double.PositiveInfinity,
+            };
+        }
+
+        private class TestCatchFruit : Fruit
+        {
+            public TestCatchFruit(FruitVisualRepresentation rep)
+            {
+                VisualRepresentation = rep;
+            }
+
+            public override FruitVisualRepresentation VisualRepresentation { get; }
+        }
     }
 }

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

@@ -34,9 +34,14 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
             foreach (var obj in Beatmap.HitObjects.OfType<CatchHitObject>())
             {
-                obj.IndexInBeatmap = index++;
+                obj.IndexInBeatmap = index;
+                foreach (var nested in obj.NestedHitObjects.OfType<CatchHitObject>())
+                    nested.IndexInBeatmap = index;
+
                 if (obj.LastInCombo && obj.NestedHitObjects.LastOrDefault() is IHasComboInformation lastNested)
                     lastNested.LastInCombo = true;
+
+                index++;
             }
         }
 

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -21,6 +21,8 @@ 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.Skinning;
 
 namespace osu.Game.Rulesets.Catch
 {
@@ -141,6 +143,8 @@ namespace osu.Game.Rulesets.Catch
 
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
 
+        public override ISkin CreateLegacySkinProvider(ISkinSource source) => new CatchLegacySkinTransformer(source);
+
         public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new CatchPerformanceCalculator(this, beatmap, score);
 
         public int LegacyID => 2;

osu.Game.Rulesets.Catch/CatchSkinComponents.cs

@@ -5,5 +5,11 @@ namespace osu.Game.Rulesets.Catch
 {
     public enum CatchSkinComponents
     {
+        FruitBananas,
+        FruitApple,
+        FruitGrapes,
+        FruitOrange,
+        FruitPear,
+        Droplet
     }
 }

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

@@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModDifficultyAdjust : ModDifficultyAdjust
     {
-        [SettingSource("Fruit Size", "Override a beatmap's set CS.")]
+        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1)]
         public BindableNumber<float> CircleSize { get; } = new BindableFloat
         {
             Precision = 0.1f,
@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Catch.Mods
             Value = 5,
         };
 
-        [SettingSource("Approach Rate", "Override a beatmap's set AR.")]
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1)]
         public BindableNumber<float> ApproachRate { get; } = new BindableFloat
         {
             Precision = 0.1f,

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

@@ -3,7 +3,7 @@
 
 using System.Linq;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 

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

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 {
     public abstract class CatchHitObject : HitObject, IHasXPosition, IHasComboInformation
     {
-        public const double OBJECT_RADIUS = 44;
+        public const float OBJECT_RADIUS = 64;
 
         private float x;
 
@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int IndexInBeatmap { get; set; }
 
-        public virtual FruitVisualRepresentation VisualRepresentation => (FruitVisualRepresentation)(ComboIndex % 4);
+        public virtual FruitVisualRepresentation VisualRepresentation => (FruitVisualRepresentation)(IndexInBeatmap % 4);
 
         public virtual bool NewCombo { get; set; }
 
@@ -90,7 +90,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 
             TimePreempt = (float)BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
 
-            Scale = 1.0f - 0.7f * (difficulty.CircleSize - 5) / 5;
+            Scale = (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5) / 2;
         }
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
@@ -100,8 +100,8 @@ namespace osu.Game.Rulesets.Catch.Objects
     {
         Pear,
         Grape,
-        Raspberry,
         Pineapple,
+        Raspberry,
         Banana // banananananannaanana
     }
 }

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

@@ -1,13 +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.
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
-{
-    public class DrawableBanana : DrawableFruit
-    {
-        public DrawableBanana(Banana h)
-            : base(h)
-        {
-        }
-    }
-}

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

@@ -1,33 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using osuTK;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
-{
-    public class DrawableDroplet : PalpableCatchHitObject<Droplet>
-    {
-        private Pulp pulp;
-
-        public override bool StaysOnPlate => false;
-
-        public DrawableDroplet(Droplet h)
-            : base(h)
-        {
-            Origin = Anchor.Centre;
-            Size = new Vector2((float)CatchHitObject.OBJECT_RADIUS) / 4;
-            Masking = false;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            AddInternal(pulp = new Pulp { Size = Size });
-
-            AccentColour.BindValueChanged(colour => { pulp.AccentColour = colour.NewValue; }, true);
-        }
-    }
-}

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

@@ -1,316 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Effects;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Utils;
-using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
-{
-    public class DrawableFruit : PalpableCatchHitObject<Fruit>
-    {
-        private Circle border;
-
-        private const float drawable_radius = (float)CatchHitObject.OBJECT_RADIUS * radius_adjust;
-
-        /// <summary>
-        /// Because we're adding a border around the fruit, we need to scale down some.
-        /// </summary>
-        private const float radius_adjust = 1.1f;
-
-        public DrawableFruit(Fruit h)
-            : base(h)
-        {
-            Origin = Anchor.Centre;
-
-            Size = new Vector2(drawable_radius);
-            Masking = false;
-
-            Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            // todo: this should come from the skin.
-            AccentColour.Value = colourForRepresentation(HitObject.VisualRepresentation);
-
-            AddRangeInternal(new[]
-            {
-                createPulp(HitObject.VisualRepresentation),
-                border = new Circle
-                {
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Hollow = !HitObject.HyperDash,
-                        Type = EdgeEffectType.Glow,
-                        Radius = 4 * radius_adjust,
-                        Colour = HitObject.HyperDash ? Color4.Red : AccentColour.Value.Darken(1).Opacity(0.6f)
-                    },
-                    Size = new Vector2(Height),
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    BorderColour = Color4.White,
-                    BorderThickness = 3f * radius_adjust,
-                    Children = new Framework.Graphics.Drawable[]
-                    {
-                        new Box
-                        {
-                            AlwaysPresent = true,
-                            Colour = AccentColour.Value,
-                            Alpha = 0,
-                            RelativeSizeAxes = Axes.Both
-                        }
-                    }
-                },
-            });
-
-            if (HitObject.HyperDash)
-            {
-                AddInternal(new Pulp
-                {
-                    RelativePositionAxes = Axes.Both,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    AccentColour = Color4.Red,
-                    Blending = BlendingParameters.Additive,
-                    Alpha = 0.5f,
-                    Scale = new Vector2(1.333f)
-                });
-            }
-        }
-
-        private Framework.Graphics.Drawable createPulp(FruitVisualRepresentation representation)
-        {
-            const float large_pulp_3 = 8f * radius_adjust;
-            const float distance_from_centre_3 = 0.15f;
-
-            const float large_pulp_4 = large_pulp_3 * 0.925f;
-            const float distance_from_centre_4 = distance_from_centre_3 / 0.925f;
-
-            const float small_pulp = large_pulp_3 / 2;
-
-            static Vector2 positionAt(float angle, float distance) => new Vector2(
-                distance * MathF.Sin(angle * MathF.PI / 180),
-                distance * MathF.Cos(angle * MathF.PI / 180));
-
-            switch (representation)
-            {
-                default:
-                    return new Container();
-
-                case FruitVisualRepresentation.Raspberry:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.34f,
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(0, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(90, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(180, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                Size = new Vector2(large_pulp_4),
-                                AccentColour = AccentColour.Value,
-                                Position = positionAt(270, distance_from_centre_4),
-                            },
-                        }
-                    };
-
-                case FruitVisualRepresentation.Pineapple:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.3f,
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(45, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(135, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4),
-                                Position = positionAt(225, distance_from_centre_4),
-                            },
-                            new Pulp
-                            {
-                                Size = new Vector2(large_pulp_4),
-                                AccentColour = AccentColour.Value,
-                                Position = positionAt(315, distance_from_centre_4),
-                            },
-                        }
-                    };
-
-                case FruitVisualRepresentation.Pear:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.33f,
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_3),
-                                Position = positionAt(60, distance_from_centre_3),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_3),
-                                Position = positionAt(180, distance_from_centre_3),
-                            },
-                            new Pulp
-                            {
-                                Size = new Vector2(large_pulp_3),
-                                AccentColour = AccentColour.Value,
-                                Position = positionAt(300, distance_from_centre_3),
-                            },
-                        }
-                    };
-
-                case FruitVisualRepresentation.Grape:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.25f,
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_3),
-                                Position = positionAt(0, distance_from_centre_3),
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_3),
-                                Position = positionAt(120, distance_from_centre_3),
-                            },
-                            new Pulp
-                            {
-                                Size = new Vector2(large_pulp_3),
-                                AccentColour = AccentColour.Value,
-                                Position = positionAt(240, distance_from_centre_3),
-                            },
-                        }
-                    };
-
-                case FruitVisualRepresentation.Banana:
-                    return new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Framework.Graphics.Drawable[]
-                        {
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(small_pulp),
-                                Y = -0.3f
-                            },
-                            new Pulp
-                            {
-                                AccentColour = AccentColour.Value,
-                                Size = new Vector2(large_pulp_4 * 0.8f, large_pulp_4 * 2.5f),
-                                Y = 0.05f,
-                            },
-                        }
-                    };
-            }
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            border.Alpha = (float)Math.Clamp((HitObject.StartTime - Time.Current) / 500, 0, 1);
-        }
-
-        private Color4 colourForRepresentation(FruitVisualRepresentation representation)
-        {
-            switch (representation)
-            {
-                default:
-                case FruitVisualRepresentation.Pear:
-                    return new Color4(17, 136, 170, 255);
-
-                case FruitVisualRepresentation.Grape:
-                    return new Color4(204, 102, 0, 255);
-
-                case FruitVisualRepresentation.Raspberry:
-                    return new Color4(121, 9, 13, 255);
-
-                case FruitVisualRepresentation.Pineapple:
-                    return new Color4(102, 136, 0, 255);
-
-                case FruitVisualRepresentation.Banana:
-                    switch (RNG.Next(0, 3))
-                    {
-                        default:
-                            return new Color4(255, 240, 0, 255);
-
-                        case 1:
-                            return new Color4(255, 192, 0, 255);
-
-                        case 2:
-                            return new Color4(214, 221, 28, 255);
-                    }
-            }
-        }
-    }
-}

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

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    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/DrawableBanana.cs

@@ -0,0 +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 System.Collections.Generic;
+using osu.Framework.Utils;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public class DrawableBanana : DrawableFruit
+    {
+        public DrawableBanana(Banana h)
+            : base(h)
+        {
+        }
+
+        private Color4? colour;
+
+        protected override Color4 GetComboColour(IReadOnlyList<Color4> comboColours)
+        {
+            // override any external colour changes with banananana
+            return colour ??= getBananaColour();
+        }
+
+        private Color4 getBananaColour()
+        {
+            switch (RNG.Next(0, 3))
+            {
+                default:
+                    return new Color4(255, 240, 0, 255);
+
+                case 1:
+                    return new Color4(255, 192, 0, 255);
+
+                case 2:
+                    return new Color4(214, 221, 28, 255);
+            }
+        }
+    }
+}

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

@@ -7,7 +7,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public class DrawableBananaShower : DrawableCatchHitObject<BananaShower>
     {

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

@@ -2,24 +2,51 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osuTK;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
+using osuTK;
+using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public abstract class PalpableCatchHitObject<TObject> : DrawableCatchHitObject<TObject>
         where TObject : CatchHitObject
     {
         public override bool CanBePlated => true;
 
+        protected Container ScaleContainer { get; private set; }
+
         protected PalpableCatchHitObject(TObject hitObject)
             : base(hitObject)
         {
-            Scale = new Vector2(HitObject.Scale);
+            Origin = Anchor.Centre;
+            Size = new Vector2(CatchHitObject.OBJECT_RADIUS * 2);
+            Masking = false;
         }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddRangeInternal(new Drawable[]
+            {
+                ScaleContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                }
+            });
+
+            ScaleContainer.Scale = new Vector2(HitObject.Scale);
+        }
+
+        protected override Color4 GetComboColour(IReadOnlyList<Color4> comboColours) =>
+            comboColours[(HitObject.IndexInBeatmap + 1) % comboColours.Count];
     }
 
     public abstract class DrawableCatchHitObject<TObject> : DrawableCatchHitObject
@@ -41,6 +68,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
 
         public virtual bool StaysOnPlate => CanBePlated;
 
+        public float DisplayRadius => DrawSize.X / 2 * Scale.X * HitObject.Scale;
+
         protected DrawableCatchHitObject(CatchHitObject hitObject)
             : base(hitObject)
         {

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

@@ -0,0 +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 osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Objects.Drawables.Pieces;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public class DrawableDroplet : PalpableCatchHitObject<Droplet>
+    {
+        public override bool StaysOnPlate => false;
+
+        public DrawableDroplet(Droplet h)
+            : base(h)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            ScaleContainer.Child = new SkinnableDrawable(new CatchSkinComponent(CatchSkinComponents.Droplet), _ => new Pulp
+            {
+                Size = Size / 4,
+                AccentColour = { BindTarget = AccentColour }
+            });
+        }
+
+        protected override void UpdateInitialTransforms()
+        {
+            base.UpdateInitialTransforms();
+
+            // roughly matches osu-stable
+            float startRotation = RNG.NextSingle() * 20;
+            double duration = HitObject.TimePreempt + 2000;
+
+            this.RotateTo(startRotation).RotateTo(startRotation + 720, duration);
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Utils;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public class DrawableFruit : PalpableCatchHitObject<Fruit>
+    {
+        public DrawableFruit(Fruit h)
+            : base(h)
+        {
+            Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            ScaleContainer.Child = new SkinnableDrawable(
+                new CatchSkinComponent(getComponent(HitObject.VisualRepresentation)), _ => new FruitPiece());
+        }
+
+        private CatchSkinComponents getComponent(FruitVisualRepresentation hitObjectVisualRepresentation)
+        {
+            switch (hitObjectVisualRepresentation)
+            {
+                case FruitVisualRepresentation.Pear:
+                    return CatchSkinComponents.FruitPear;
+
+                case FruitVisualRepresentation.Grape:
+                    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);
+            }
+        }
+    }
+}

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

@@ -7,7 +7,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public class DrawableJuiceStream : DrawableCatchHitObject<JuiceStream>
     {
@@ -42,10 +42,11 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             switch (hitObject)
             {
                 case CatchHitObject catchObject:
-                    return createDrawableRepresentation?.Invoke(catchObject)?.With(o => ((DrawableCatchHitObject)o).CheckPosition = p => CheckPosition?.Invoke(p) ?? false);
+                    return createDrawableRepresentation?.Invoke(catchObject)?.With(o =>
+                        ((DrawableCatchHitObject)o).CheckPosition = p => CheckPosition?.Invoke(p) ?? false);
             }
 
-            return base.CreateNestedHitObject(hitObject);
+            throw new ArgumentException($"{nameof(hitObject)} must be of type {nameof(CatchHitObject)}.");
         }
     }
 }

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

@@ -1,16 +1,21 @@
 // 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;
+using osu.Framework.Allocation;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawable
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
     public class DrawableTinyDroplet : DrawableDroplet
     {
         public DrawableTinyDroplet(TinyDroplet h)
             : base(h)
         {
-            Size = new Vector2((float)CatchHitObject.OBJECT_RADIUS) / 8;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            ScaleContainer.Scale /= 2;
         }
     }
 }

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

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

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

@@ -0,0 +1,43 @@
+// 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.Drawables.Pieces;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    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/PearPiece.cs

@@ -0,0 +1,43 @@
+// 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.Drawables.Pieces;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    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/Pulp.cs

@@ -1,16 +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 osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Catch.Objects.Drawable.Pieces
+namespace osu.Game.Rulesets.Catch.Objects.Drawables.Pieces
 {
-    public class Pulp : Circle, IHasAccentColour
+    public class Pulp : Circle
     {
         public Pulp()
         {
@@ -22,32 +22,23 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable.Pieces
             Colour = Color4.White.Opacity(0.9f);
         }
 
-        private Color4 accentColour;
+        public readonly Bindable<Color4> AccentColour = new Bindable<Color4>();
 
-        public Color4 AccentColour
+        protected override void LoadComplete()
         {
-            get => accentColour;
-            set
-            {
-                accentColour = value;
-                if (IsLoaded) updateAccentColour();
-            }
+            base.LoadComplete();
+
+            AccentColour.BindValueChanged(updateAccentColour, true);
         }
 
-        private void updateAccentColour()
+        private void updateAccentColour(ValueChangedEvent<Color4> colour)
         {
             EdgeEffect = new EdgeEffectParameters
             {
                 Type = EdgeEffectType.Glow,
                 Radius = Size.X / 2,
-                Colour = accentColour.Darken(0.2f).Opacity(0.75f)
+                Colour = colour.NewValue.Darken(0.2f).Opacity(0.75f)
             };
         }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            updateAccentColour();
-        }
     }
 }

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

@@ -0,0 +1,49 @@
+// 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.Drawables.Pieces;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    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/PulpFormation.cs

@@ -0,0 +1,43 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public abstract class PulpFormation : CompositeDrawable
+    {
+        protected readonly IBindable<Color4> AccentColour = new Bindable<Color4>();
+
+        protected const float LARGE_PULP_3 = 16f * FruitPiece.RADIUS_ADJUST;
+        protected const float DISTANCE_FROM_CENTRE_3 = 0.15f;
+
+        protected const float LARGE_PULP_4 = LARGE_PULP_3 * 0.925f;
+        protected const float DISTANCE_FROM_CENTRE_4 = DISTANCE_FROM_CENTRE_3 / 0.925f;
+
+        protected const float SMALL_PULP = LARGE_PULP_3 / 2;
+
+        protected PulpFormation()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        protected static Vector2 PositionAt(float angle, float distance) => new Vector2(
+            distance * MathF.Sin(angle * MathF.PI / 180),
+            distance * MathF.Cos(angle * MathF.PI / 180));
+
+        [BackgroundDependencyLoader]
+        private void load(DrawableHitObject drawableObject)
+        {
+            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
+            AccentColour.BindTo(drawableCatchObject.AccentColour);
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+// 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.Drawables.Pieces;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    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

@@ -75,7 +75,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                                 Samples = tickSamples,
                                 StartTime = t + lastEvent.Value.Time,
                                 X = X + Path.PositionAt(
-                                        lastEvent.Value.PathProgress + (t / sinceLastTick) * (e.PathProgress - lastEvent.Value.PathProgress)).X / CatchPlayfield.BASE_WIDTH,
+                                    lastEvent.Value.PathProgress + (t / sinceLastTick) * (e.PathProgress - lastEvent.Value.PathProgress)).X / CatchPlayfield.BASE_WIDTH,
                             });
                         }
                     }

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

@@ -0,0 +1,58 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using Humanizer;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Audio;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Skinning
+{
+    public class CatchLegacySkinTransformer : ISkin
+    {
+        private readonly ISkin source;
+
+        public CatchLegacySkinTransformer(ISkinSource source)
+        {
+            this.source = source;
+        }
+
+        public Drawable GetDrawableComponent(ISkinComponent component)
+        {
+            if (!(component is CatchSkinComponent catchSkinComponent))
+                return null;
+
+            switch (catchSkinComponent.Component)
+            {
+                case CatchSkinComponents.FruitApple:
+                case CatchSkinComponents.FruitBananas:
+                case CatchSkinComponents.FruitOrange:
+                case CatchSkinComponents.FruitGrapes:
+                case CatchSkinComponents.FruitPear:
+                    var lookupName = catchSkinComponent.Component.ToString().Kebaberize();
+                    if (GetTexture(lookupName) != null)
+                        return new LegacyFruitPiece(lookupName);
+
+                    break;
+
+                case CatchSkinComponents.Droplet:
+                    if (GetTexture("fruit-drop") != null)
+                        return new LegacyFruitPiece("fruit-drop") { Scale = new Vector2(0.8f) };
+
+                    break;
+            }
+
+            return null;
+        }
+
+        public Texture GetTexture(string componentName) => source.GetTexture(componentName);
+
+        public SampleChannel GetSample(ISampleInfo sample) => source.GetSample(sample);
+
+        public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => source.GetConfig<TLookup, TValue>(lookup);
+    }
+}

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

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.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.Objects.Drawables;
+using osu.Game.Skinning;
+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)
+        {
+            DrawableCatchHitObject drawableCatchObject = (DrawableCatchHitObject)drawableObject;
+
+            accentColour.BindTo(drawableCatchObject.AccentColour);
+
+            InternalChildren = new Drawable[]
+            {
+                colouredSprite = new Sprite
+                {
+                    Texture = skin.GetTexture(lookupName),
+                    Colour = drawableObject.AccentColour.Value,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+                new Sprite
+                {
+                    Texture = skin.GetTexture($"{lookupName}-overlay"),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            accentColour.BindValueChanged(colour => colouredSprite.Colour = colour.NewValue, true);
+        }
+    }
+}

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

@@ -6,7 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;

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

@@ -11,7 +11,7 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -63,6 +63,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
             if (result.IsHit && fruit.CanBePlated)
             {
+                // create a new (cloned) fruit to stay on the plate. the original is faded out immediately.
                 var caughtFruit = (DrawableCatchHitObject)CreateDrawableRepresentation?.Invoke(fruit.HitObject);
 
                 if (caughtFruit == null) return;
@@ -73,11 +74,11 @@ namespace osu.Game.Rulesets.Catch.UI
 
                 caughtFruit.Anchor = Anchor.TopCentre;
                 caughtFruit.Origin = Anchor.Centre;
-                caughtFruit.Scale *= 0.7f;
+                caughtFruit.Scale *= 0.5f;
                 caughtFruit.LifetimeStart = caughtFruit.HitObject.StartTime;
                 caughtFruit.LifetimeEnd = double.MaxValue;
 
-                MovableCatcher.Add(caughtFruit);
+                MovableCatcher.PlaceOnPlate(caughtFruit);
                 lastPlateableFruit = caughtFruit;
 
                 if (!fruit.StaysOnPlate)
@@ -133,7 +134,6 @@ namespace osu.Game.Rulesets.Catch.UI
                 X = 0.5f;
 
                 Origin = Anchor.TopCentre;
-                Anchor = Anchor.TopLeft;
 
                 Size = new Vector2(CATCHER_SIZE);
                 if (difficulty != null)
@@ -221,9 +221,9 @@ namespace osu.Game.Rulesets.Catch.UI
             /// Add a caught fruit to the catcher's stack.
             /// </summary>
             /// <param name="fruit">The fruit that was caught.</param>
-            public void Add(DrawableHitObject fruit)
+            public void PlaceOnPlate(DrawableCatchHitObject fruit)
             {
-                float ourRadius = fruit.DrawSize.X / 2 * fruit.Scale.X;
+                float ourRadius = fruit.DisplayRadius;
                 float theirRadius = 0;
 
                 const float allowance = 6;
@@ -388,32 +388,24 @@ namespace osu.Game.Rulesets.Catch.UI
                 }
             }
 
+            public void UpdatePosition(float position)
+            {
+                position = Math.Clamp(position, 0, 1);
+
+                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()
             {
-                var fruit = caughtFruit.ToArray();
-
-                foreach (var f in fruit)
-                {
-                    if (ExplodingFruitTarget != null)
-                    {
-                        f.Anchor = Anchor.TopLeft;
-                        f.Position = caughtFruit.ToSpaceOfOtherDrawable(f.DrawPosition, ExplodingFruitTarget);
-
-                        caughtFruit.Remove(f);
-
-                        ExplodingFruitTarget.Add(f);
-                    }
-
-                    f.MoveToY(f.Y + 75, 750, Easing.InSine);
-                    f.FadeOut(750);
-
-                    // todo: this shouldn't exist once DrawableHitObject's ClearTransformsAfter overrides are repaired.
-                    f.LifetimeStart = Time.Current;
-                    f.Expire();
-                }
+                foreach (var f in caughtFruit.ToArray())
+                    Drop(f);
             }
 
             /// <summary>
@@ -425,10 +417,26 @@ namespace osu.Game.Rulesets.Catch.UI
                     Explode(f);
             }
 
+            public void Drop(DrawableHitObject fruit) => removeFromPlateWithTransform(fruit, f =>
+            {
+                f.MoveToY(f.Y + 75, 750, Easing.InSine);
+                f.FadeOut(750);
+            });
+
             public void Explode(DrawableHitObject fruit)
             {
                 var originalX = fruit.X * Scale.X;
 
+                removeFromPlateWithTransform(fruit, f =>
+                {
+                    f.MoveToY(f.Y - 50, 250, Easing.OutSine).Then().MoveToY(f.Y + 50, 500, Easing.InSine);
+                    f.MoveToX(f.X + originalX * 6, 1000);
+                    f.FadeOut(750);
+                });
+            }
+
+            private void removeFromPlateWithTransform(DrawableHitObject fruit, Action<DrawableHitObject> action)
+            {
                 if (ExplodingFruitTarget != null)
                 {
                     fruit.Anchor = Anchor.TopLeft;
@@ -442,25 +450,18 @@ namespace osu.Game.Rulesets.Catch.UI
                     ExplodingFruitTarget.Add(fruit);
                 }
 
-                fruit.ClearTransforms();
-                fruit.MoveToY(fruit.Y - 50, 250, Easing.OutSine).Then().MoveToY(fruit.Y + 50, 500, Easing.InSine);
-                fruit.MoveToX(fruit.X + originalX * 6, 1000);
-                fruit.FadeOut(750);
+                double actionTime = Clock.CurrentTime;
 
-                // todo: this shouldn't exist once DrawableHitObject's ClearTransformsAfter overrides are repaired.
-                fruit.LifetimeStart = Time.Current;
-                fruit.Expire();
-            }
+                fruit.ApplyCustomUpdateState += onFruitOnApplyCustomUpdateState;
+                onFruitOnApplyCustomUpdateState(fruit, fruit.State.Value);
 
-            public void UpdatePosition(float position)
-            {
-                position = Math.Clamp(position, 0, 1);
+                void onFruitOnApplyCustomUpdateState(DrawableHitObject o, ArmedState state)
+                {
+                    using (fruit.BeginAbsoluteSequence(actionTime))
+                        action(fruit);
 
-                if (position == X)
-                    return;
-
-                Scale = new Vector2(Math.Abs(Scale.X) * (position > X ? 1 : -1), Scale.Y);
-                X = position;
+                    fruit.Expire();
+                }
             }
         }
     }

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

@@ -8,7 +8,7 @@ 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.Drawable;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;

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

@@ -1,46 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Skinning;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    public abstract class SkinnableTestScene : OsuGridTestScene
-    {
-        private Skin defaultSkin;
-
-        protected SkinnableTestScene()
-            : base(1, 2)
-        {
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio, SkinManager skinManager)
-        {
-            defaultSkin = skinManager.GetSkin(DefaultLegacySkin.Info);
-        }
-
-        public void SetContents(Func<Drawable> creationFunction)
-        {
-            Cell(0).Child = createProvider(null, creationFunction);
-            Cell(1).Child = createProvider(defaultSkin, creationFunction);
-        }
-
-        private Drawable createProvider(Skin skin, Func<Drawable> creationFunction)
-        {
-            var mainProvider = new SkinProvidingContainer(skin);
-
-            return mainProvider
-                .WithChild(new SkinProvidingContainer(Ruleset.Value.CreateInstance().CreateLegacySkinProvider(mainProvider))
-                {
-                    Child = creationFunction()
-                });
-        }
-    }
-}

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

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
+using osu.Game.Tests.Visual;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;

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

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         {
             base.UpdatePosition(screenSpacePosition);
 
-            if (PlacementBegun)
+            if (PlacementActive)
             {
                 var endTime = TimeAt(screenSpacePosition);
 

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

@@ -62,7 +62,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 
         public override void UpdatePosition(Vector2 screenSpacePosition)
         {
-            if (!PlacementBegun)
+            if (!PlacementActive)
                 Column = ColumnAt(screenSpacePosition);
 
             if (Column == null) return;

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

@@ -1,85 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Text.RegularExpressions;
-using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.IO.Stores;
-using osu.Game.Skinning;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Osu.Tests
-{
-    public abstract class SkinnableTestScene : OsuGridTestScene
-    {
-        private Skin metricsSkin;
-        private Skin defaultSkin;
-        private Skin specialSkin;
-        private Skin oldSkin;
-
-        protected SkinnableTestScene()
-            : base(2, 3)
-        {
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio, SkinManager skinManager)
-        {
-            var dllStore = new DllResourceStore(typeof(SkinnableTestScene).Assembly);
-
-            metricsSkin = new TestLegacySkin(new SkinInfo(), new NamespacedResourceStore<byte[]>(dllStore, "Resources/metrics_skin"), audio, true);
-            defaultSkin = skinManager.GetSkin(DefaultLegacySkin.Info);
-            specialSkin = new TestLegacySkin(new SkinInfo(), new NamespacedResourceStore<byte[]>(dllStore, "Resources/special_skin"), audio, true);
-            oldSkin = new TestLegacySkin(new SkinInfo(), new NamespacedResourceStore<byte[]>(dllStore, "Resources/old_skin"), audio, true);
-        }
-
-        public void SetContents(Func<Drawable> creationFunction)
-        {
-            Cell(0).Child = createProvider(null, creationFunction);
-            Cell(1).Child = createProvider(metricsSkin, creationFunction);
-            Cell(2).Child = createProvider(defaultSkin, creationFunction);
-            Cell(3).Child = createProvider(specialSkin, creationFunction);
-            Cell(4).Child = createProvider(oldSkin, creationFunction);
-        }
-
-        private Drawable createProvider(Skin skin, Func<Drawable> creationFunction)
-        {
-            var mainProvider = new SkinProvidingContainer(skin);
-
-            return mainProvider
-                .WithChild(new SkinProvidingContainer(Ruleset.Value.CreateInstance().CreateLegacySkinProvider(mainProvider))
-                {
-                    Child = creationFunction()
-                });
-        }
-
-        private class TestLegacySkin : LegacySkin
-        {
-            private readonly bool extrapolateAnimations;
-
-            public TestLegacySkin(SkinInfo skin, IResourceStore<byte[]> storage, AudioManager audioManager, bool extrapolateAnimations)
-                : base(skin, storage, audioManager, "skin.ini")
-            {
-                this.extrapolateAnimations = extrapolateAnimations;
-            }
-
-            public override Texture GetTexture(string componentName)
-            {
-                // extrapolate frames to test longer animations
-                if (extrapolateAnimations)
-                {
-                    var match = Regex.Match(componentName, "-([0-9]*)");
-
-                    if (match.Length > 0 && int.TryParse(match.Groups[1].Value, out var number) && number < 60)
-                        return base.GetTexture(componentName.Replace($"-{number}", $"-{number % 2}"));
-                }
-
-                return base.GetTexture(componentName);
-            }
-        }
-    }
-}

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

@@ -10,6 +10,7 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {

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

@@ -7,7 +7,10 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing.Input;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
@@ -21,12 +24,50 @@ namespace osu.Game.Rulesets.Osu.Tests
             typeof(CursorTrail)
         };
 
-        [BackgroundDependencyLoader]
-        private void load()
+        [Cached]
+        private GameplayBeatmap gameplayBeatmap;
+
+        private ClickingCursorContainer lastContainer;
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        public TestSceneGameplayCursor()
+        {
+            gameplayBeatmap = new GameplayBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
+        }
+
+        [TestCase(1, 1)]
+        [TestCase(5, 1)]
+        [TestCase(10, 1)]
+        [TestCase(1, 1.5f)]
+        [TestCase(5, 1.5f)]
+        [TestCase(10, 1.5f)]
+        public void TestSizing(int circleSize, float userScale)
+        {
+            AddStep($"set user scale to {userScale}", () => config.Set(OsuSetting.GameplayCursorSize, userScale));
+            AddStep($"adjust cs to {circleSize}", () => gameplayBeatmap.BeatmapInfo.BaseDifficulty.CircleSize = circleSize);
+            AddStep("turn on autosizing", () => config.Set(OsuSetting.AutoCursorSize, true));
+
+            AddStep("load content", loadContent);
+
+            AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == OsuCursorContainer.GetScaleForCircleSize(circleSize) * userScale);
+
+            AddStep("set user scale to 1", () => config.Set(OsuSetting.GameplayCursorSize, 1f));
+            AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == OsuCursorContainer.GetScaleForCircleSize(circleSize));
+
+            AddStep("turn off autosizing", () => config.Set(OsuSetting.AutoCursorSize, false));
+            AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == 1);
+
+            AddStep($"set user scale to {userScale}", () => config.Set(OsuSetting.GameplayCursorSize, userScale));
+            AddUntilStep("cursor size correct", () => lastContainer.ActiveCursor.Scale.X == userScale);
+        }
+
+        private void loadContent()
         {
             SetContents(() => new MovingCursorInputManager
             {
-                Child = new ClickingCursorContainer
+                Child = lastContainer = new ClickingCursorContainer
                 {
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,

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

@@ -14,6 +14,7 @@ using osu.Game.Rulesets.Mods;
 using System.Linq;
 using NUnit.Framework;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {

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

@@ -22,6 +22,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {

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

@@ -126,7 +126,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private void beginCurve()
         {
-            BeginPlacement();
+            BeginPlacement(commitStart: true);
             setState(PlacementState.Body);
         }
 

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
                 if (e.Button != MouseButton.Left)
                     return false;
 
-                BeginPlacement();
+                BeginPlacement(commitStart: true);
                 piece.FadeTo(1f, 150, Easing.OutQuint);
 
                 isPlacingEnd = true;

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

@@ -40,6 +40,8 @@ namespace osu.Game.Rulesets.Osu.Edit
                     if (existing == null)
                         return;
 
+                    hitObject.RemoveTransform(existing);
+
                     using (hitObject.BeginAbsoluteSequence(existing.StartTime))
                         hitObject.FadeOut(editor_hit_object_fade_out_extension).Expire();
                     break;

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

@@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModDifficultyAdjust : ModDifficultyAdjust
     {
-        [SettingSource("Circle Size", "Override a beatmap's set CS.")]
+        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1)]
         public BindableNumber<float> CircleSize { get; } = new BindableFloat
         {
             Precision = 0.1f,
@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Mods
             Value = 5,
         };
 
-        [SettingSource("Approach Rate", "Override a beatmap's set AR.")]
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1)]
         public BindableNumber<float> ApproachRate { get; } = new BindableFloat
         {
             Precision = 0.1f,

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

@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.UI;
 using static osu.Game.Input.Handlers.ReplayInputHandler;
 
@@ -19,69 +20,18 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).ToArray();
 
-        public void Update(Playfield playfield)
-        {
-            bool requiresHold = false;
-            bool requiresHit = false;
+        /// <summary>
+        /// How early before a hitobject's start time to trigger a hit.
+        /// </summary>
+        private const float relax_leniency = 3;
 
-            const float relax_leniency = 3;
-
-            foreach (var drawable in playfield.HitObjectContainer.AliveObjects)
-            {
-                if (!(drawable is DrawableOsuHitObject osuHit))
-                    continue;
-
-                double time = osuHit.Clock.CurrentTime;
-                double relativetime = time - osuHit.HitObject.StartTime;
-
-                if (time < osuHit.HitObject.StartTime - relax_leniency) continue;
-
-                if ((osuHit.HitObject is IHasEndTime hasEnd && time > hasEnd.EndTime) || osuHit.IsHit)
-                    continue;
-
-                if (osuHit is DrawableHitCircle && osuHit.IsHovered)
-                {
-                    Debug.Assert(osuHit.HitObject.HitWindows != null);
-                    requiresHit |= osuHit.HitObject.HitWindows.CanBeHit(relativetime);
-                }
-
-                requiresHold |= (osuHit is DrawableSlider slider && (slider.Ball.IsHovered || osuHit.IsHovered)) || osuHit is DrawableSpinner;
-            }
-
-            if (requiresHit)
-            {
-                addAction(false);
-                addAction(true);
-            }
-
-            addAction(requiresHold);
-        }
-
-        private bool wasHit;
+        private bool isDownState;
         private bool wasLeft;
 
         private OsuInputManager osuInputManager;
 
-        private void addAction(bool hitting)
-        {
-            if (wasHit == hitting)
-                return;
-
-            wasHit = hitting;
-
-            var state = new ReplayState<OsuAction>
-            {
-                PressedActions = new List<OsuAction>()
-            };
-
-            if (hitting)
-            {
-                state.PressedActions.Add(wasLeft ? OsuAction.LeftButton : OsuAction.RightButton);
-                wasLeft = !wasLeft;
-            }
-
-            state.Apply(osuInputManager.CurrentState, osuInputManager);
-        }
+        private ReplayState<OsuAction> state;
+        private double lastStateChangeTime;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
@@ -89,5 +39,85 @@ namespace osu.Game.Rulesets.Osu.Mods
             osuInputManager = (OsuInputManager)drawableRuleset.KeyBindingInputManager;
             osuInputManager.AllowUserPresses = false;
         }
+
+        public void Update(Playfield playfield)
+        {
+            bool requiresHold = false;
+            bool requiresHit = false;
+
+            double time = playfield.Clock.CurrentTime;
+
+            foreach (var h in playfield.HitObjectContainer.AliveObjects.OfType<DrawableOsuHitObject>())
+            {
+                // we are not yet close enough to the object.
+                if (time < h.HitObject.StartTime - relax_leniency)
+                    break;
+
+                // already hit or beyond the hittable end time.
+                if (h.IsHit || (h.HitObject is IHasEndTime hasEnd && time > hasEnd.EndTime))
+                    continue;
+
+                switch (h)
+                {
+                    case DrawableHitCircle circle:
+                        handleHitCircle(circle);
+                        break;
+
+                    case DrawableSlider slider:
+                        // Handles cases like "2B" beatmaps, where sliders may be overlapping and simply holding is not enough.
+                        if (!slider.HeadCircle.IsHit)
+                            handleHitCircle(slider.HeadCircle);
+
+                        requiresHold |= slider.Ball.IsHovered || h.IsHovered;
+                        break;
+
+                    case DrawableSpinner _:
+                        requiresHold = true;
+                        break;
+                }
+            }
+
+            if (requiresHit)
+            {
+                changeState(false);
+                changeState(true);
+            }
+
+            if (requiresHold)
+                changeState(true);
+            else if (isDownState && time - lastStateChangeTime > AutoGenerator.KEY_UP_DELAY)
+                changeState(false);
+
+            void handleHitCircle(DrawableHitCircle circle)
+            {
+                if (!circle.IsHovered)
+                    return;
+
+                Debug.Assert(circle.HitObject.HitWindows != null);
+                requiresHit |= circle.HitObject.HitWindows.CanBeHit(time - circle.HitObject.StartTime);
+            }
+
+            void changeState(bool down)
+            {
+                if (isDownState == down)
+                    return;
+
+                isDownState = down;
+                lastStateChangeTime = time;
+
+                state = new ReplayState<OsuAction>
+                {
+                    PressedActions = new List<OsuAction>()
+                };
+
+                if (down)
+                {
+                    state.PressedActions.Add(wasLeft ? OsuAction.LeftButton : OsuAction.RightButton);
+                    wasLeft = !wasLeft;
+                }
+
+                state?.Apply(osuInputManager.CurrentState, osuInputManager);
+            }
+        }
     }
 }

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

@@ -8,6 +8,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
@@ -27,26 +28,40 @@ namespace osu.Game.Rulesets.Osu.Mods
         public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
         {
             foreach (var drawable in drawables)
+                drawable.ApplyCustomUpdateState += applyTransform;
+        }
+
+        private void applyTransform(DrawableHitObject drawable, ArmedState state)
+        {
+            switch (drawable)
             {
-                var hitObject = (OsuHitObject)drawable.HitObject;
+                case DrawableSliderHead _:
+                case DrawableSliderTail _:
+                case DrawableSliderTick _:
+                case DrawableRepeatPoint _:
+                    return;
 
-                float appearDistance = (float)(hitObject.TimePreempt - hitObject.TimeFadeIn) / 2;
+                default:
+                    var hitObject = (OsuHitObject)drawable.HitObject;
 
-                Vector2 originalPosition = drawable.Position;
-                Vector2 appearOffset = new Vector2(MathF.Cos(theta), MathF.Sin(theta)) * appearDistance;
+                    float appearDistance = (float)(hitObject.TimePreempt - hitObject.TimeFadeIn) / 2;
 
-                //the - 1 and + 1 prevents the hit objects to appear in the wrong position.
-                double appearTime = hitObject.StartTime - hitObject.TimePreempt - 1;
-                double moveDuration = hitObject.TimePreempt + 1;
+                    Vector2 originalPosition = drawable.Position;
+                    Vector2 appearOffset = new Vector2(MathF.Cos(theta), MathF.Sin(theta)) * appearDistance;
 
-                using (drawable.BeginAbsoluteSequence(appearTime, true))
-                {
-                    drawable
-                        .MoveToOffset(appearOffset)
-                        .MoveTo(originalPosition, moveDuration, Easing.InOutSine);
-                }
+                    //the - 1 and + 1 prevents the hit objects to appear in the wrong position.
+                    double appearTime = hitObject.StartTime - hitObject.TimePreempt - 1;
+                    double moveDuration = hitObject.TimePreempt + 1;
 
-                theta += (float)hitObject.TimeFadeIn / 1000;
+                    using (drawable.BeginAbsoluteSequence(appearTime, true))
+                    {
+                        drawable
+                            .MoveToOffset(appearOffset)
+                            .MoveTo(originalPosition, moveDuration, Easing.InOutSine);
+                    }
+
+                    theta += (float)hitObject.TimeFadeIn / 1000;
+                    break;
             }
         }
     }

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

@@ -116,8 +116,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public Slider()
         {
-            SamplesBindable.ItemsAdded += _ => updateNestedSamples();
-            SamplesBindable.ItemsRemoved += _ => updateNestedSamples();
+            SamplesBindable.CollectionChanged += (_, __) => updateNestedSamples();
             Path.Version.ValueChanged += _ => updateNestedPositions();
         }
 

osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs

@@ -12,6 +12,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
 using osu.Game.Skinning;
 using osuTK;
 
@@ -29,10 +30,10 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 
         private readonly Drawable cursorTrail;
 
-        public Bindable<float> CursorScale;
+        public Bindable<float> CursorScale = new BindableFloat(1);
+
         private Bindable<float> userCursorScale;
         private Bindable<bool> autoCursorScale;
-        private readonly IBindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
         public OsuCursorContainer()
         {
@@ -43,37 +44,16 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             };
         }
 
+        [Resolved(canBeNull: true)]
+        private GameplayBeatmap beatmap { get; set; }
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
         [BackgroundDependencyLoader(true)]
-        private void load(OsuConfigManager config, OsuRulesetConfigManager rulesetConfig, IBindable<WorkingBeatmap> beatmap)
+        private void load(OsuConfigManager config, OsuRulesetConfigManager rulesetConfig)
         {
             rulesetConfig?.BindWith(OsuRulesetSetting.ShowCursorTrail, showTrail);
-
-            this.beatmap.BindTo(beatmap);
-            this.beatmap.ValueChanged += _ => calculateScale();
-
-            userCursorScale = config.GetBindable<float>(OsuSetting.GameplayCursorSize);
-            userCursorScale.ValueChanged += _ => calculateScale();
-
-            autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
-            autoCursorScale.ValueChanged += _ => calculateScale();
-
-            CursorScale = new BindableFloat();
-            CursorScale.ValueChanged += e => ActiveCursor.Scale = cursorTrail.Scale = new Vector2(e.NewValue);
-
-            calculateScale();
-        }
-
-        private void calculateScale()
-        {
-            float scale = userCursorScale.Value;
-
-            if (autoCursorScale.Value && beatmap.Value != null)
-            {
-                // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
-                scale *= 1f - 0.7f * (1f + beatmap.Value.BeatmapInfo.BaseDifficulty.CircleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY;
-            }
-
-            CursorScale.Value = scale;
         }
 
         protected override void LoadComplete()
@@ -81,6 +61,46 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             base.LoadComplete();
 
             showTrail.BindValueChanged(v => cursorTrail.FadeTo(v.NewValue ? 1 : 0, 200), true);
+
+            userCursorScale = config.GetBindable<float>(OsuSetting.GameplayCursorSize);
+            userCursorScale.ValueChanged += _ => calculateScale();
+
+            autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
+            autoCursorScale.ValueChanged += _ => calculateScale();
+
+            CursorScale.ValueChanged += e =>
+            {
+                var newScale = new Vector2(e.NewValue);
+
+                ActiveCursor.Scale = newScale;
+                cursorTrail.Scale = newScale;
+            };
+
+            calculateScale();
+        }
+
+        /// <summary>
+        /// Get the scale applicable to the ActiveCursor based on a beatmap's circle size.
+        /// </summary>
+        public static float GetScaleForCircleSize(float circleSize) =>
+            1f - 0.7f * (1f + circleSize - BeatmapDifficulty.DEFAULT_DIFFICULTY) / BeatmapDifficulty.DEFAULT_DIFFICULTY;
+
+        private void calculateScale()
+        {
+            float scale = userCursorScale.Value;
+
+            if (autoCursorScale.Value && beatmap != null)
+            {
+                // if we have a beatmap available, let's get its circle size to figure out an automatic cursor scale modifier.
+                scale *= GetScaleForCircleSize(beatmap.BeatmapInfo.BaseDifficulty.CircleSize);
+            }
+
+            CursorScale.Value = scale;
+
+            var newScale = new Vector2(scale);
+
+            ActiveCursor.ScaleTo(newScale, 400, Easing.OutQuint);
+            cursorTrail.Scale = newScale;
         }
 
         private int downCount;