Merge pull request #8428 from peppy/replay-recording

Add local replay support for all rulesets

.github/ISSUE_TEMPLATE/01-bug-issues.md

@@ -9,6 +9,8 @@ about: Issues regarding encountered bugs.
 **osu!lazer version:** 
 
 **Logs:**
+<!--
 *please attach logs here, which are located at:*
 - `%AppData%/osu/logs` *(on Windows),*
 - `~/.local/share/osu/logs` *(on Linux & macOS).*
+-->

.github/ISSUE_TEMPLATE/02-crash-issues.md

@@ -9,8 +9,10 @@ about: Issues regarding crashes or permanent freezes.
 **osu!lazer version:** 
 
 **Logs:**
+<!--
 *please attach logs here, which are located at:*
 - `%AppData%/osu/logs` *(on Windows),*
 - `~/.local/share/osu/logs` *(on Linux & macOS).*
+-->
 
 **Computer Specifications:** 

.idea/.idea.osu.Desktop/.idea/modules.xml

@@ -2,6 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.osu.Desktop/.idea/.idea.osu.Desktop.iml" filepath="$PROJECT_DIR$/.idea/.idea.osu.Desktop/.idea/.idea.osu.Desktop.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/.idea.osu.Desktop/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.osu.Desktop/riderModule.iml" />
     </modules>
   </component>

.vscode/launch.json

@@ -11,11 +11,6 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build osu! (Debug)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
             "console": "internalConsole"
         },
         {
@@ -28,11 +23,6 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build osu! (Release)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
             "console": "internalConsole"
         },
         {
@@ -45,11 +35,6 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build tests (Debug)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
             "console": "internalConsole"
         },
         {
@@ -62,11 +47,6 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build tests (Release)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tests/bin/Release/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
             "console": "internalConsole"
         },
         {
@@ -80,11 +60,6 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build osu! (Debug)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
             "console": "internalConsole"
         },
         {
@@ -98,11 +73,6 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build osu! (Release)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Desktop/bin/Release/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
             "console": "internalConsole"
         },
         {
@@ -116,11 +86,6 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build tournament tests (Debug)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tournament.Tests/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
             "console": "internalConsole"
         },
         {
@@ -134,11 +99,6 @@
             ],
             "cwd": "${workspaceRoot}",
             "preLaunchTask": "Build tournament tests (Release)",
-            "linux": {
-                "env": {
-                    "LD_LIBRARY_PATH": "${workspaceRoot}/osu.Game.Tournament.Tests/bin/Debug/netcoreapp3.1:${env:LD_LIBRARY_PATH}"
-                }
-            },
             "console": "internalConsole"
         },
         {
@@ -169,4 +129,4 @@
             "externalConsole": false
         }
     ]
-}
+}

README.md

@@ -27,7 +27,7 @@ If you are looking to install or test osu! without setting up a development envi
 
 **Latest build:**
 
-| [Windows (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe)  | [macOS 10.12+](https://github.com/ppy/osu/releases/latest/download/osu.app.zip) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.x86_64.AppImage) | [iOS(iOS 10+)](https://osu.ppy.sh/home/testflight) | [Android (5+)](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
+| [Windows (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe)  | [macOS 10.12+](https://github.com/ppy/osu/releases/latest/download/osu.app.zip) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.AppImage) | [iOS(iOS 10+)](https://osu.ppy.sh/home/testflight) | [Android (5+)](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
 | ------------- | ------------- | ------------- | ------------- | ------------- |
 
 - 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.
@@ -93,7 +93,7 @@ JetBrains ReSharper InspectCode is also used for wider rule sets. You can run it
 
 We welcome all contributions, but keep in mind that we already have a lot of the UI designed. If you wish to work on something with the intention of having it included in the official distribution, please open an issue for discussion and we will give you what you need from a design perspective to proceed. If you want to make *changes* to the design, we recommend you open an issue with your intentions before spending too much time to ensure no effort is wasted.
 
-If you're unsure of what you can help with, check out the [list of open issues](https://github.com/ppy/osu/issues) (especially those with the ["good first issue"](https://github.com/ppy/osu/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22good+first+issue%22) label).
+If you're unsure of what you can help with, check out the [list of open issues](https://github.com/ppy/osu/issues) (especially those with the ["good first issue"](https://github.com/ppy/osu/issues?q=is%3Aopen+label%3Agood-first-issue+sort%3Aupdated-desc) label).
 
 Before starting, please make sure you are familiar with the [development and testing](https://github.com/ppy/osu-framework/wiki/Development-and-Testing) procedure we have set up. New component development, and where possible, bug fixing and debugging existing components **should always be done under VisualTests**.
 

fastlane/Fastfile

@@ -97,8 +97,10 @@ platform :ios do
     changelog.gsub!('$BUILD_ID', options[:build])
 
     pilot(
-      wait_processing_interval: 1800,
+      wait_processing_interval: 900,
       changelog: changelog,
+      groups: ['osu! supporters', 'public'],
+      distribute_external: true,
       ipa: './osu.iOS/bin/iPhone/Release/osu.iOS.ipa'
     )
   end

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.221.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.229.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.315.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.319.0" />
   </ItemGroup>
 </Project>

osu.Android/OsuGameAndroid.cs

@@ -30,11 +30,6 @@ namespace osu.Android
             }
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Add(new SimpleUpdateManager());
-        }
+        protected override UpdateManager CreateUpdateManager() => new SimpleUpdateManager();
     }
 }

osu.Desktop/OsuGameDesktop.cs

@@ -47,20 +47,25 @@ namespace osu.Desktop
             return null;
         }
 
+        protected override UpdateManager CreateUpdateManager()
+        {
+            switch (RuntimeInfo.OS)
+            {
+                case RuntimeInfo.Platform.Windows:
+                    return new SquirrelUpdateManager();
+
+                default:
+                    return new SimpleUpdateManager();
+            }
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
             if (!noVersionOverlay)
-            {
                 LoadComponentAsync(versionManager = new VersionManager { Depth = int.MinValue }, Add);
 
-                if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows)
-                    Add(new SquirrelUpdateManager());
-                else
-                    Add(new SimpleUpdateManager());
-            }
-
             LoadComponentAsync(new DiscordRichPresence(), Add);
         }
 

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

@@ -0,0 +1,54 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Catch.Mods;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Tests.Mods
+{
+    public class TestSceneCatchModPerfect : ModPerfectTestScene
+    {
+        public TestSceneCatchModPerfect()
+            : base(new CatchRuleset(), new CatchModPerfect())
+        {
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestBananaShower(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new BananaShower { StartTime = 1000, EndTime = 3000 }, false), shouldMiss);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestFruit(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Fruit { StartTime = 1000 }), shouldMiss);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestJuiceStream(bool shouldMiss)
+        {
+            var stream = new JuiceStream
+            {
+                StartTime = 1000,
+                Path = new SliderPath(PathType.Linear, new[]
+                {
+                    Vector2.Zero,
+                    new Vector2(100, 0),
+                })
+            };
+
+            CreateHitObjectTest(new HitObjectTestData(stream), shouldMiss);
+        }
+
+        // We only care about testing misses, hits are tested via JuiceStream
+        [TestCase(true)]
+        public void TestDroplet(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Droplet { StartTime = 1000 }), shouldMiss);
+
+        // We only care about testing misses, hits are tested via JuiceStream
+        [TestCase(true)]
+        public void TestTinyDroplet(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new TinyDroplet { StartTime = 1000 }), shouldMiss);
+    }
+}

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

@@ -7,7 +7,6 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual;
 using osuTK;
 
@@ -51,7 +50,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             return beatmap;
         }
 
-        protected override Player CreatePlayer(Ruleset ruleset)
+        protected override TestPlayer CreatePlayer(Ruleset ruleset)
         {
             SelectedMods.Value = SelectedMods.Value.Concat(new[] { ruleset.GetAutoplayMod() }).ToArray();
             return base.CreatePlayer(ruleset);

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

@@ -18,7 +18,9 @@ namespace osu.Game.Rulesets.Catch.Tests
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(BananaShower),
+            typeof(Banana),
             typeof(DrawableBananaShower),
+            typeof(DrawableBanana),
 
             typeof(CatchRuleset),
             typeof(DrawableCatchRuleset),

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

@@ -17,12 +17,13 @@ namespace osu.Game.Rulesets.Catch.Tests
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(CatcherArea),
+            typeof(CatcherSprite)
         };
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            SetContents(() => new CatcherArea.Catcher
+            SetContents(() => new Catcher
             {
                 RelativePositionAxes = Axes.None,
                 Anchor = Anchor.Centre,

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

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -10,9 +8,15 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Catch.Beatmaps;
+using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Catch.Tests
@@ -22,11 +26,6 @@ namespace osu.Game.Rulesets.Catch.Tests
     {
         private RulesetInfo catchRuleset;
 
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(CatcherArea),
-        };
-
         public TestSceneCatcherArea()
         {
             AddSliderStep<float>("CircleSize", 0, 8, 5, createCatcher);
@@ -34,9 +33,41 @@ namespace osu.Game.Rulesets.Catch.Tests
                 CreatedDrawables.OfType<CatchInputManager>().Select(i => i.Child)
                                 .OfType<TestCatcherArea>().ForEach(c => c.ToggleHyperDash(t)));
 
-            AddRepeatStep("catch fruit", () =>
-                this.ChildrenOfType<CatcherArea>().ForEach(area =>
-                    area.MovableCatcher.PlaceOnPlate(new DrawableFruit(new TestSceneFruitObjects.TestCatchFruit(FruitVisualRepresentation.Grape)))), 20);
+            AddRepeatStep("catch fruit", () => catchFruit(new TestFruit(false)
+            {
+                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X
+            }), 20);
+            AddRepeatStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
+            {
+                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X,
+                LastInCombo = true,
+            }), 20);
+            AddRepeatStep("catch kiai fruit", () => catchFruit(new TestFruit(true)
+            {
+                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X,
+            }), 20);
+            AddRepeatStep("miss fruit", () => catchFruit(new Fruit
+            {
+                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X + 100,
+                LastInCombo = true,
+            }, true), 20);
+        }
+
+        private void catchFruit(Fruit fruit, bool miss = false)
+        {
+            this.ChildrenOfType<CatcherArea>().ForEach(area =>
+            {
+                DrawableFruit drawable = new DrawableFruit(fruit);
+                area.Add(drawable);
+
+                Schedule(() =>
+                {
+                    area.AttemptCatch(fruit);
+                    area.OnResult(drawable, new JudgementResult(fruit, new CatchJudgement()) { Type = miss ? HitResult.Miss : HitResult.Great });
+
+                    drawable.Expire();
+                });
+            });
         }
 
         private void createCatcher(float size)
@@ -47,7 +78,8 @@ namespace osu.Game.Rulesets.Catch.Tests
                 Child = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
                 {
                     Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.TopLeft
+                    Origin = Anchor.TopLeft,
+                    CreateDrawableRepresentation = ((DrawableRuleset<CatchHitObject>)catchRuleset.CreateInstance().CreateDrawableRulesetWith(new CatchBeatmap())).CreateDrawableRepresentation
                 },
             });
         }
@@ -58,6 +90,17 @@ namespace osu.Game.Rulesets.Catch.Tests
             catchRuleset = rulesets.GetRuleset(2);
         }
 
+        public class TestFruit : Fruit
+        {
+            public TestFruit(bool kiai)
+            {
+                var kiaiCpi = new ControlPointInfo();
+                kiaiCpi.Add(0, new EffectControlPoint { KiaiMode = kiai });
+
+                ApplyDefaultsToSelf(kiaiCpi, new BeatmapDifficulty());
+            }
+        }
+
         private class TestCatcherArea : CatcherArea
         {
             public TestCatcherArea(BeatmapDifficulty beatmapDifficulty)

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

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Allocation;
+using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Tests
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(CatcherArea.Catcher),
+            typeof(Catcher),
             typeof(DrawableCatchRuleset),
             typeof(DrawableFruit),
             typeof(DrawableJuiceStream),
@@ -34,8 +34,8 @@ namespace osu.Game.Rulesets.Catch.Tests
         private DrawableCatchRuleset drawableRuleset;
         private double playfieldTime => drawableRuleset.Playfield.Time.Current;
 
-        [BackgroundDependencyLoader]
-        private void load()
+        [SetUp]
+        public void Setup() => Schedule(() =>
         {
             var controlPointInfo = new ControlPointInfo();
             controlPointInfo.Add(0, new TimingControlPoint());
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                 ControlPointInfo = controlPointInfo
             });
 
-            Add(new Container
+            Child = new Container
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -66,16 +66,49 @@ namespace osu.Game.Rulesets.Catch.Tests
                 {
                     drawableRuleset = new DrawableCatchRuleset(new CatchRuleset(), beatmap.GetPlayableBeatmap(new CatchRuleset().RulesetInfo))
                 }
-            });
+            };
+        });
+
+        [Test]
+        public void TestFruits()
+        {
+            AddStep("hit fruits", () => spawnFruits(true));
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is idle", () => catcherState == CatcherAnimationState.Idle);
 
             AddStep("miss fruits", () => spawnFruits());
-            AddStep("hit fruits", () => spawnFruits(true));
-            AddStep("miss juicestream", () => spawnJuiceStream());
-            AddStep("hit juicestream", () => spawnJuiceStream(true));
-            AddStep("miss bananas", () => spawnBananas());
-            AddStep("hit bananas", () => spawnBananas(true));
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is failed", () => catcherState == CatcherAnimationState.Fail);
         }
 
+        [Test]
+        public void TestJuicestream()
+        {
+            AddStep("hit juicestream", () => spawnJuiceStream(true));
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is idle", () => catcherState == CatcherAnimationState.Idle);
+
+            AddStep("miss juicestream", () => spawnJuiceStream());
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is failed", () => catcherState == CatcherAnimationState.Fail);
+        }
+
+        [Test]
+        public void TestBananas()
+        {
+            AddStep("hit bananas", () => spawnBananas(true));
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is idle", () => catcherState == CatcherAnimationState.Idle);
+
+            AddStep("miss bananas", () => spawnBananas());
+            AddUntilStep("wait for completion", () => playfieldIsEmpty);
+            AddAssert("catcher state is idle", () => catcherState == CatcherAnimationState.Idle);
+        }
+
+        private bool playfieldIsEmpty => !((CatchPlayfield)drawableRuleset.Playfield).AllHitObjects.Any(h => h.IsAlive);
+
+        private CatcherAnimationState catcherState => ((CatchPlayfield)drawableRuleset.Playfield).CatcherArea.MovableCatcher.CurrentState;
+
         private void spawnFruits(bool hit = false)
         {
             for (int i = 1; i <= 4; i++)

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

@@ -1,16 +1,28 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Tests.Visual;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
     public class TestSceneHyperDash : PlayerTestScene
     {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(CatcherArea),
+        };
+
         public TestSceneHyperDash()
             : base(new CatchRuleset())
         {
@@ -22,8 +34,19 @@ namespace osu.Game.Rulesets.Catch.Tests
         public void TestHyperDash()
         {
             AddAssert("First note is hyperdash", () => Beatmap.Value.Beatmap.HitObjects[0] is Fruit f && f.HyperDash);
+            AddUntilStep("wait for right movement", () => getCatcher().Scale.X > 0); // don't check hyperdashing as it happens too fast.
+
+            AddUntilStep("wait for left movement", () => getCatcher().Scale.X < 0);
+
+            for (int i = 0; i < 3; i++)
+            {
+                AddUntilStep("wait for right hyperdash", () => getCatcher().Scale.X > 0 && getCatcher().HyperDashing);
+                AddUntilStep("wait for left hyperdash", () => getCatcher().Scale.X < 0 && getCatcher().HyperDashing);
+            }
         }
 
+        private Catcher getCatcher() => Player.ChildrenOfType<CatcherArea>().First().MovableCatcher;
+
         protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
         {
             var beatmap = new Beatmap
@@ -35,17 +58,52 @@ namespace osu.Game.Rulesets.Catch.Tests
                 }
             };
 
-            // Should produce a hyper-dash
-            beatmap.HitObjects.Add(new Fruit { StartTime = 816, X = 308 / 512f, NewCombo = true });
-            beatmap.HitObjects.Add(new Fruit { StartTime = 1008, X = 56 / 512f, });
+            // Should produce a hyper-dash (edge case test)
+            beatmap.HitObjects.Add(new Fruit { StartTime = 1816, X = 56 / 512f, NewCombo = true });
+            beatmap.HitObjects.Add(new Fruit { StartTime = 2008, X = 308 / 512f, NewCombo = true });
 
-            for (int i = 0; i < 512; i++)
-            {
-                if (i % 5 < 3)
-                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = 2000 + i * 100, NewCombo = i % 8 == 0 });
-            }
+            double startTime = 3000;
+
+            const float left_x = 0.02f;
+            const float right_x = 0.98f;
+
+            createObjects(() => new Fruit { X = left_x });
+            createObjects(() => new TestJuiceStream(right_x), 1);
+            createObjects(() => new TestJuiceStream(left_x), 1);
+            createObjects(() => new Fruit { X = right_x });
+            createObjects(() => new Fruit { X = left_x });
+            createObjects(() => new Fruit { X = right_x });
+            createObjects(() => new TestJuiceStream(left_x), 1);
 
             return beatmap;
+
+            void createObjects(Func<CatchHitObject> createObject, int count = 3)
+            {
+                const float spacing = 140;
+
+                for (int i = 0; i < count; i++)
+                {
+                    var hitObject = createObject();
+                    hitObject.StartTime = startTime + i * spacing;
+                    beatmap.HitObjects.Add(hitObject);
+                }
+
+                startTime += 700;
+            }
+        }
+
+        private class TestJuiceStream : JuiceStream
+        {
+            public TestJuiceStream(float x)
+            {
+                X = x;
+
+                Path = new SliderPath(new[]
+                {
+                    new PathControlPoint(Vector2.Zero),
+                    new PathControlPoint(new Vector2(30, 0)),
+                });
+            }
         }
     }
 }

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

@@ -28,8 +28,6 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
             ApplyPositionOffsets(Beatmap);
 
-            initialiseHyperDash((List<CatchHitObject>)Beatmap.HitObjects);
-
             int index = 0;
 
             foreach (var obj in Beatmap.HitObjects.OfType<CatchHitObject>())
@@ -76,6 +74,12 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         break;
 
                     case JuiceStream juiceStream:
+                        // Todo: BUG!! Stable used the last control point as the final position of the path, but it should use the computed path instead.
+                        lastPosition = juiceStream.X + juiceStream.Path.ControlPoints[^1].Position.Value.X / CatchPlayfield.BASE_WIDTH;
+
+                        // Todo: BUG!! Stable attempted to use the end time of the stream, but referenced it too early in execution and used the start time instead.
+                        lastStartTime = juiceStream.StartTime;
+
                         foreach (var nested in juiceStream.NestedHitObjects)
                         {
                             var catchObject = (CatchHitObject)nested;
@@ -90,20 +94,12 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         break;
                 }
             }
+
+            initialiseHyperDash(beatmap);
         }
 
         private static void applyHardRockOffset(CatchHitObject hitObject, ref float? lastPosition, ref double lastStartTime, FastRandom rng)
         {
-            if (hitObject is JuiceStream stream)
-            {
-                lastPosition = stream.EndX;
-                lastStartTime = stream.EndTime;
-                return;
-            }
-
-            if (!(hitObject is Fruit))
-                return;
-
             float offsetPosition = hitObject.X;
             double startTime = hitObject.StartTime;
 
@@ -116,7 +112,9 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             }
 
             float positionDiff = offsetPosition - lastPosition.Value;
-            double timeDiff = startTime - lastStartTime;
+
+            // Todo: BUG!! Stable calculated time deltas as ints, which affects randomisation. This should be changed to a double.
+            int timeDiff = (int)(startTime - lastStartTime);
 
             if (timeDiff > 1000)
             {
@@ -132,7 +130,8 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 return;
             }
 
-            if (Math.Abs(positionDiff * CatchPlayfield.BASE_WIDTH) < timeDiff / 3d)
+            // ReSharper disable once PossibleLossOfFraction
+            if (Math.Abs(positionDiff * CatchPlayfield.BASE_WIDTH) < timeDiff / 3)
                 applyOffset(ref offsetPosition, positionDiff);
 
             hitObject.XOffset = offsetPosition - hitObject.X;
@@ -191,14 +190,14 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             }
         }
 
-        private void initialiseHyperDash(List<CatchHitObject> objects)
+        private static void initialiseHyperDash(IBeatmap beatmap)
         {
             List<CatchHitObject> objectWithDroplets = new List<CatchHitObject>();
 
-            foreach (var currentObject in objects)
+            foreach (var currentObject in beatmap.HitObjects)
             {
-                if (currentObject is Fruit)
-                    objectWithDroplets.Add(currentObject);
+                if (currentObject is Fruit fruitObject)
+                    objectWithDroplets.Add(fruitObject);
 
                 if (currentObject is JuiceStream)
                 {
@@ -212,7 +211,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
             objectWithDroplets.Sort((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));
 
-            double halfCatcherWidth = CatcherArea.GetCatcherSize(Beatmap.BeatmapInfo.BaseDifficulty) / 2;
+            double halfCatcherWidth = CatcherArea.GetCatcherSize(beatmap.BeatmapInfo.BaseDifficulty) / 2;
             int lastDirection = 0;
             double lastExcess = halfCatcherWidth;
 
@@ -221,10 +220,14 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 CatchHitObject currentObject = objectWithDroplets[i];
                 CatchHitObject nextObject = objectWithDroplets[i + 1];
 
+                // Reset variables in-case values have changed (e.g. after applying HR)
+                currentObject.HyperDashTarget = null;
+                currentObject.DistanceToHyperDash = 0;
+
                 int thisDirection = nextObject.X > currentObject.X ? 1 : -1;
                 double timeToNext = nextObject.StartTime - currentObject.StartTime - 1000f / 60f / 4; // 1/4th of a frame of grace time, taken from osu-stable
                 double distanceToNext = Math.Abs(nextObject.X - currentObject.X) - (lastDirection == thisDirection ? lastExcess : halfCatcherWidth);
-                float distanceToHyper = (float)(timeToNext * CatcherArea.Catcher.BASE_SPEED - distanceToNext);
+                float distanceToHyper = (float)(timeToNext * Catcher.BASE_SPEED - distanceToNext);
 
                 if (distanceToHyper < 0)
                 {

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Catch
             new KeyBinding(InputKey.Shift, CatchAction.Dash),
         };
 
-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
                 yield return new CatchModNightcore();

osu.Game.Rulesets.Catch/CatchSkinComponents.cs

@@ -10,6 +10,9 @@ namespace osu.Game.Rulesets.Catch
         FruitGrapes,
         FruitOrange,
         FruitPear,
-        Droplet
+        Droplet,
+        CatcherIdle,
+        CatcherFail,
+        CatcherKiai
     }
 }

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

@@ -23,6 +23,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         protected override int SectionLength => 750;
 
+        private float halfCatcherWidth;
+
         public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
@@ -48,14 +50,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
-            float halfCatchWidth;
-
-            using (var catcher = new CatcherArea.Catcher(beatmap.BeatmapInfo.BaseDifficulty))
-            {
-                halfCatchWidth = catcher.CatchWidth * 0.5f;
-                halfCatchWidth *= 0.8f; // We're only using 80% of the catcher's width to simulate imperfect gameplay.
-            }
-
             CatchHitObject lastObject = null;
 
             // In 2B beatmaps, it is possible that a normal Fruit is placed in the middle of a JuiceStream.
@@ -69,16 +63,25 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                     continue;
 
                 if (lastObject != null)
-                    yield return new CatchDifficultyHitObject(hitObject, lastObject, clockRate, halfCatchWidth);
+                    yield return new CatchDifficultyHitObject(hitObject, lastObject, clockRate, halfCatcherWidth);
 
                 lastObject = hitObject;
             }
         }
 
-        protected override Skill[] CreateSkills(IBeatmap beatmap) => new Skill[]
+        protected override Skill[] CreateSkills(IBeatmap beatmap)
         {
-            new Movement(),
-        };
+            using (var catcher = new Catcher(beatmap.BeatmapInfo.BaseDifficulty))
+            {
+                halfCatcherWidth = catcher.CatchWidth * 0.5f;
+                halfCatcherWidth *= 0.8f; // We're only using 80% of the catcher's width to simulate imperfect gameplay.
+            }
+
+            return new Skill[]
+            {
+                new Movement(halfCatcherWidth),
+            };
+        }
 
         protected override Mod[] DifficultyAdjustmentMods => new Mod[]
         {

osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs

@@ -20,9 +20,16 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         protected override double DecayWeight => 0.94;
 
+        protected readonly float HalfCatcherWidth;
+
         private float? lastPlayerPosition;
         private float lastDistanceMoved;
 
+        public Movement(float halfCatcherWidth)
+        {
+            HalfCatcherWidth = halfCatcherWidth;
+        }
+
         protected override double StrainValueOf(DifficultyHitObject current)
         {
             var catchCurrent = (CatchDifficultyHitObject)current;

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

@@ -1,11 +1,17 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModPerfect : ModPerfect
     {
+        protected override bool FailCondition(HealthProcessor healthProcessor, JudgementResult result)
+            => !(result.Judgement is CatchBananaJudgement)
+               && base.FailCondition(healthProcessor, result);
     }
 }

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Mods
 
         private class MouseInputHelper : Drawable, IKeyBindingHandler<CatchAction>, IRequireHighFrequencyMousePosition
         {
-            private readonly CatcherArea.Catcher catcher;
+            private readonly Catcher catcher;
 
             public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using osu.Framework.Graphics;
 using osu.Framework.Utils;
 using osuTK.Graphics;
 
@@ -22,6 +23,23 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             return colour ??= getBananaColour();
         }
 
+        protected override void UpdateInitialTransforms()
+        {
+            base.UpdateInitialTransforms();
+
+            const float end_scale = 0.6f;
+            const float random_scale_range = 1.6f;
+
+            ScaleContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RNG.NextSingle()))
+                          .Then().ScaleTo(HitObject.Scale * end_scale, HitObject.TimePreempt);
+
+            ScaleContainer.RotateTo(getRandomAngle())
+                          .Then()
+                          .RotateTo(getRandomAngle(), HitObject.TimePreempt);
+
+            float getRandomAngle() => 180 * (RNG.NextSingle() * 2 - 1);
+        }
+
         private Color4 getBananaColour()
         {
             switch (RNG.Next(0, 3))

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

@@ -91,10 +91,6 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
                 ApplyResult(r => r.Type = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss);
         }
 
-        protected sealed override double InitialLifetimeOffset => HitObject.TimePreempt;
-
-        protected override void UpdateInitialTransforms() => this.FadeInFromZero(200);
-
         protected override void UpdateStateTransforms(ArmedState state)
         {
             var endTime = HitObject.GetEndTime();

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

@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             float startRotation = RNG.NextSingle() * 20;
             double duration = HitObject.TimePreempt + 2000;
 
-            this.RotateTo(startRotation).RotateTo(startRotation + 720, duration);
+            ScaleContainer.RotateTo(startRotation).RotateTo(startRotation + 720, duration);
         }
     }
 }

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

@@ -13,7 +13,6 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         public DrawableFruit(Fruit h)
             : base(h)
         {
-            Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
         }
 
         [BackgroundDependencyLoader]
@@ -21,6 +20,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         {
             ScaleContainer.Child = new SkinnableDrawable(
                 new CatchSkinComponent(getComponent(HitObject.VisualRepresentation)), _ => new FruitPiece());
+
+            ScaleContainer.Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
         }
 
         private CatchSkinComponents getComponent(FruitVisualRepresentation hitObjectVisualRepresentation)

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

@@ -6,6 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
@@ -14,11 +15,13 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
         private readonly Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation;
         private readonly Container dropletContainer;
 
+        public override Vector2 OriginPosition => base.OriginPosition - new Vector2(0, CatchHitObject.OBJECT_RADIUS);
+
         public DrawableJuiceStream(JuiceStream s, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation = null)
             : base(s)
         {
             this.createDrawableRepresentation = createDrawableRepresentation;
-            RelativeSizeAxes = Axes.Both;
+            RelativeSizeAxes = Axes.X;
             Origin = Anchor.BottomLeft;
             X = 0;
 
@@ -27,6 +30,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
 
         protected override void AddNestedHitObject(DrawableHitObject hitObject)
         {
+            hitObject.Origin = Anchor.BottomCentre;
+
             base.AddNestedHitObject(hitObject);
             dropletContainer.Add(hitObject);
         }

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

@@ -24,8 +24,8 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int RepeatCount { get; set; }
 
-        public double Velocity;
-        public double TickDistance;
+        public double Velocity { get; private set; }
+        public double TickDistance { get; private set; }
 
         /// <summary>
         /// The length of one span of this <see cref="JuiceStream"/>.
@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Catch.Objects
         {
             base.CreateNestedHitObjects();
 
-            var tickSamples = Samples.Select(s => new HitSampleInfo
+            var dropletSamples = Samples.Select(s => new HitSampleInfo
             {
                 Bank = s.Bank,
                 Name = @"slidertick",
@@ -75,7 +75,6 @@ namespace osu.Game.Rulesets.Catch.Objects
                         {
                             AddNested(new TinyDroplet
                             {
-                                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,
@@ -93,7 +92,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                     case SliderEventType.Tick:
                         AddNested(new Droplet
                         {
-                            Samples = tickSamples,
+                            Samples = dropletSamples,
                             StartTime = e.Time,
                             X = X + Path.PositionAt(e.PathProgress).X / CatchPlayfield.BASE_WIDTH,
                         });

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

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Catch.Replays
         public override Replay Generate()
         {
             // todo: add support for HT DT
-            const double dash_speed = CatcherArea.Catcher.BASE_SPEED;
+            const double dash_speed = Catcher.BASE_SPEED;
             const double movement_speed = dash_speed / 2;
             float lastPosition = 0.5f;
             double lastTime = 0;

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

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Catch.Replays
             }
         }
 
-        public void ConvertFrom(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+        public void FromLegacy(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
         {
             Position = currentFrame.Position.X / CatchPlayfield.BASE_WIDTH;
             Dashing = currentFrame.ButtonState == ReplayButtonState.Left1;
@@ -56,5 +56,14 @@ namespace osu.Game.Rulesets.Catch.Replays
                     Actions.Add(CatchAction.MoveLeft);
             }
         }
+
+        public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+        {
+            ReplayButtonState state = ReplayButtonState.None;
+
+            if (Actions.Contains(CatchAction.Dash)) state |= ReplayButtonState.Left1;
+
+            return new LegacyReplayFrame(Time, Position * CatchPlayfield.BASE_WIDTH, null, state);
+        }
     }
 }

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

@@ -44,6 +44,18 @@ namespace osu.Game.Rulesets.Catch.Skinning
                         return new LegacyFruitPiece("fruit-drop") { Scale = new Vector2(0.8f) };
 
                     break;
+
+                case CatchSkinComponents.CatcherIdle:
+                    return this.GetAnimation("fruit-catcher-idle", true, true, true) ??
+                           this.GetAnimation("fruit-ryuuta", true, true, true);
+
+                case CatchSkinComponents.CatcherFail:
+                    return this.GetAnimation("fruit-catcher-fail", true, true, true) ??
+                           this.GetAnimation("fruit-ryuuta", true, true, true);
+
+                case CatchSkinComponents.CatcherKiai:
+                    return this.GetAnimation("fruit-catcher-kiai", true, true, true) ??
+                           this.GetAnimation("fruit-ryuuta", true, true, true);
             }
 
             return null;

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

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Catch.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatchReplayRecorder : ReplayRecorder<CatchAction>
+    {
+        private readonly CatchPlayfield playfield;
+
+        public CatchReplayRecorder(Replay target, CatchPlayfield playfield)
+            : base(target)
+        {
+            this.playfield = playfield;
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<CatchAction> actions, ReplayFrame previousFrame)
+            => new CatchReplayFrame(Time.Current, playfield.CatcherArea.MovableCatcher.X, actions.Contains(CatchAction.Dash), previousFrame as CatchReplayFrame);
+    }
+}

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

@@ -0,0 +1,458 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Animations;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class Catcher : Container, IKeyBindingHandler<CatchAction>
+    {
+        /// <summary>
+        /// Whether we are hyper-dashing or not.
+        /// </summary>
+        public bool HyperDashing => hyperDashModifier != 1;
+
+        /// <summary>
+        /// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
+        /// </summary>
+        public const double BASE_SPEED = 1.0 / 512;
+
+        public Container ExplodingFruitTarget;
+
+        public Container AdditiveTarget;
+
+        public CatcherAnimationState CurrentState { get; private set; }
+
+        /// <summary>
+        /// Width of the area that can be used to attempt catches during gameplay.
+        /// </summary>
+        internal float CatchWidth => CatcherArea.CATCHER_SIZE * Math.Abs(Scale.X);
+
+        protected bool Dashing
+        {
+            get => dashing;
+            set
+            {
+                if (value == dashing) return;
+
+                dashing = value;
+
+                Trail |= dashing;
+            }
+        }
+
+        /// <summary>
+        /// Activate or deactivate the trail. Will be automatically deactivated when conditions to keep the trail displayed are no longer met.
+        /// </summary>
+        protected bool Trail
+        {
+            get => trail;
+            set
+            {
+                if (value == trail || AdditiveTarget == null) return;
+
+                trail = value;
+
+                if (Trail)
+                    beginTrail();
+            }
+        }
+
+        private Container<DrawableHitObject> caughtFruit;
+
+        private CatcherSprite catcherIdle;
+        private CatcherSprite catcherKiai;
+        private CatcherSprite catcherFail;
+
+        private CatcherSprite currentCatcher;
+
+        private int currentDirection;
+
+        private bool dashing;
+
+        private bool trail;
+
+        private double hyperDashModifier = 1;
+        private int hyperDashDirection;
+        private float hyperDashTargetPosition;
+
+        public Catcher(BeatmapDifficulty difficulty = null)
+        {
+            RelativePositionAxes = Axes.X;
+            X = 0.5f;
+
+            Origin = Anchor.TopCentre;
+
+            Size = new Vector2(CatcherArea.CATCHER_SIZE);
+            if (difficulty != null)
+                Scale = new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                caughtFruit = new Container<DrawableHitObject>
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.BottomCentre,
+                },
+                catcherIdle = new CatcherSprite(CatcherAnimationState.Idle)
+                {
+                    Anchor = Anchor.TopCentre,
+                    Alpha = 0,
+                },
+                catcherKiai = new CatcherSprite(CatcherAnimationState.Kiai)
+                {
+                    Anchor = Anchor.TopCentre,
+                    Alpha = 0,
+                },
+                catcherFail = new CatcherSprite(CatcherAnimationState.Fail)
+                {
+                    Anchor = Anchor.TopCentre,
+                    Alpha = 0,
+                }
+            };
+
+            updateCatcher();
+        }
+
+        /// <summary>
+        /// Add a caught fruit to the catcher's stack.
+        /// </summary>
+        /// <param name="fruit">The fruit that was caught.</param>
+        public void PlaceOnPlate(DrawableCatchHitObject fruit)
+        {
+            var ourRadius = fruit.DisplayRadius;
+            float theirRadius = 0;
+
+            const float allowance = 6;
+
+            while (caughtFruit.Any(f =>
+                f.LifetimeEnd == double.MaxValue &&
+                Vector2Extensions.Distance(f.Position, fruit.Position) < (ourRadius + (theirRadius = f.DrawSize.X / 2 * f.Scale.X)) / (allowance / 2)))
+            {
+                var diff = (ourRadius + theirRadius) / allowance;
+                fruit.X += (RNG.NextSingle() - 0.5f) * 2 * diff;
+                fruit.Y -= RNG.NextSingle() * diff;
+            }
+
+            fruit.X = Math.Clamp(fruit.X, -CatcherArea.CATCHER_SIZE / 2, CatcherArea.CATCHER_SIZE / 2);
+
+            caughtFruit.Add(fruit);
+
+            Add(new HitExplosion(fruit)
+            {
+                X = fruit.X,
+                Scale = new Vector2(fruit.HitObject.Scale)
+            });
+        }
+
+        /// <summary>
+        /// Let the catcher attempt to catch a fruit.
+        /// </summary>
+        /// <param name="fruit">The fruit to catch.</param>
+        /// <returns>Whether the catch is possible.</returns>
+        public bool AttemptCatch(CatchHitObject fruit)
+        {
+            var halfCatchWidth = CatchWidth * 0.5f;
+
+            // this stuff wil disappear once we move fruit to non-relative coordinate space in the future.
+            var catchObjectPosition = fruit.X * CatchPlayfield.BASE_WIDTH;
+            var catcherPosition = Position.X * CatchPlayfield.BASE_WIDTH;
+
+            var validCatch =
+                catchObjectPosition >= catcherPosition - halfCatchWidth &&
+                catchObjectPosition <= catcherPosition + halfCatchWidth;
+
+            // only update hyperdash state if we are catching a fruit.
+            // exceptions are Droplets and JuiceStreams.
+            if (!(fruit is Fruit)) return validCatch;
+
+            if (validCatch && fruit.HyperDash)
+            {
+                var target = fruit.HyperDashTarget;
+                var timeDifference = target.StartTime - fruit.StartTime;
+                double positionDifference = target.X * CatchPlayfield.BASE_WIDTH - catcherPosition;
+                var velocity = positionDifference / Math.Max(1.0, timeDifference - 1000.0 / 60.0);
+
+                SetHyperDashState(Math.Abs(velocity), target.X);
+            }
+            else
+                SetHyperDashState();
+
+            if (validCatch)
+                updateState(fruit.Kiai ? CatcherAnimationState.Kiai : CatcherAnimationState.Idle);
+            else if (!(fruit is Banana))
+                updateState(CatcherAnimationState.Fail);
+
+            return validCatch;
+        }
+
+        /// <summary>
+        /// Set hyper-dash state.
+        /// </summary>
+        /// <param name="modifier">The speed multiplier. If this is less or equals to 1, this catcher will be non-hyper-dashing state.</param>
+        /// <param name="targetPosition">When this catcher crosses this position, this catcher ends hyper-dashing.</param>
+        public void SetHyperDashState(double modifier = 1, float targetPosition = -1)
+        {
+            const float hyper_dash_transition_length = 180;
+
+            var wasHyperDashing = HyperDashing;
+
+            if (modifier <= 1 || X == targetPosition)
+            {
+                hyperDashModifier = 1;
+                hyperDashDirection = 0;
+
+                if (wasHyperDashing)
+                {
+                    this.FadeColour(Color4.White, hyper_dash_transition_length, Easing.OutQuint);
+                    this.FadeTo(1, hyper_dash_transition_length, Easing.OutQuint);
+                    Trail &= Dashing;
+                }
+            }
+            else
+            {
+                hyperDashModifier = modifier;
+                hyperDashDirection = Math.Sign(targetPosition - X);
+                hyperDashTargetPosition = targetPosition;
+
+                if (!wasHyperDashing)
+                {
+                    this.FadeColour(Color4.OrangeRed, hyper_dash_transition_length, Easing.OutQuint);
+                    this.FadeTo(0.2f, hyper_dash_transition_length, Easing.OutQuint);
+                    Trail = true;
+
+                    var hyperDashEndGlow = createAdditiveSprite();
+
+                    hyperDashEndGlow.MoveToOffset(new Vector2(0, -10), 1200, Easing.In);
+                    hyperDashEndGlow.ScaleTo(hyperDashEndGlow.Scale * 0.95f).ScaleTo(hyperDashEndGlow.Scale * 1.2f, 1200, Easing.In);
+                    hyperDashEndGlow.FadeOut(1200);
+                    hyperDashEndGlow.Expire(true);
+                }
+            }
+        }
+
+        public bool OnPressed(CatchAction action)
+        {
+            switch (action)
+            {
+                case CatchAction.MoveLeft:
+                    currentDirection--;
+                    return true;
+
+                case CatchAction.MoveRight:
+                    currentDirection++;
+                    return true;
+
+                case CatchAction.Dash:
+                    Dashing = true;
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(CatchAction action)
+        {
+            switch (action)
+            {
+                case CatchAction.MoveLeft:
+                    currentDirection++;
+                    break;
+
+                case CatchAction.MoveRight:
+                    currentDirection--;
+                    break;
+
+                case CatchAction.Dash:
+                    Dashing = false;
+                    break;
+            }
+        }
+
+        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()
+        {
+            foreach (var f in caughtFruit.ToArray())
+                Drop(f);
+        }
+
+        /// <summary>
+        /// Explode any fruit off the plate.
+        /// </summary>
+        public void Explode()
+        {
+            foreach (var f in caughtFruit.ToArray())
+                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);
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (currentDirection == 0) return;
+
+            var direction = Math.Sign(currentDirection);
+
+            var dashModifier = Dashing ? 1 : 0.5;
+            var speed = BASE_SPEED * dashModifier * hyperDashModifier;
+
+            UpdatePosition((float)(X + direction * Clock.ElapsedFrameTime * speed));
+
+            // Correct overshooting.
+            if ((hyperDashDirection > 0 && hyperDashTargetPosition < X) ||
+                (hyperDashDirection < 0 && hyperDashTargetPosition > X))
+            {
+                X = hyperDashTargetPosition;
+                SetHyperDashState();
+            }
+        }
+
+        private void updateCatcher()
+        {
+            currentCatcher?.Hide();
+
+            switch (CurrentState)
+            {
+                default:
+                    currentCatcher = catcherIdle;
+                    break;
+
+                case CatcherAnimationState.Fail:
+                    currentCatcher = catcherFail;
+                    break;
+
+                case CatcherAnimationState.Kiai:
+                    currentCatcher = catcherKiai;
+                    break;
+            }
+
+            currentCatcher.Show();
+            (currentCatcher.Drawable as IAnimation)?.GotoFrame(0);
+        }
+
+        private void beginTrail()
+        {
+            if (!dashing && !HyperDashing)
+            {
+                Trail = false;
+                return;
+            }
+
+            var additive = createAdditiveSprite();
+
+            additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint);
+            additive.Expire(true);
+
+            Scheduler.AddDelayed(beginTrail, HyperDashing ? 25 : 50);
+        }
+
+        private void updateState(CatcherAnimationState state)
+        {
+            if (CurrentState == state)
+                return;
+
+            CurrentState = state;
+            updateCatcher();
+        }
+
+        private CatcherTrailSprite createAdditiveSprite()
+        {
+            var tex = (currentCatcher.Drawable as TextureAnimation)?.CurrentFrame ?? ((Sprite)currentCatcher.Drawable).Texture;
+
+            var sprite = new CatcherTrailSprite(tex)
+            {
+                Anchor = Anchor,
+                Scale = Scale,
+                Colour = HyperDashing ? Color4.Red : Color4.White,
+                Blending = BlendingParameters.Additive,
+                RelativePositionAxes = RelativePositionAxes,
+                Position = Position
+            };
+
+            AdditiveTarget?.Add(sprite);
+
+            return sprite;
+        }
+
+        private void removeFromPlateWithTransform(DrawableHitObject fruit, Action<DrawableHitObject> action)
+        {
+            if (ExplodingFruitTarget != null)
+            {
+                fruit.Anchor = Anchor.TopLeft;
+                fruit.Position = caughtFruit.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
+
+                if (!caughtFruit.Remove(fruit))
+                    // we may have already been removed by a previous operation (due to the weird OnLoadComplete scheduling).
+                    // this avoids a crash on potentially attempting to Add a fruit to ExplodingFruitTarget twice.
+                    return;
+
+                ExplodingFruitTarget.Add(fruit);
+            }
+
+            var actionTime = Clock.CurrentTime;
+
+            fruit.ApplyCustomUpdateState += onFruitOnApplyCustomUpdateState;
+            onFruitOnApplyCustomUpdateState(fruit, fruit.State.Value);
+
+            void onFruitOnApplyCustomUpdateState(DrawableHitObject o, ArmedState state)
+            {
+                using (fruit.BeginAbsoluteSequence(actionTime))
+                    action(fruit);
+
+                fruit.Expire();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public enum CatcherAnimationState
+    {
+        Idle,
+        Fail,
+        Kiai
+    }
+}

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

@@ -2,14 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Effects;
-using osu.Framework.Input.Bindings;
-using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
@@ -19,7 +13,6 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -27,8 +20,6 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float CATCHER_SIZE = 106.75f;
 
-        protected internal readonly Catcher MovableCatcher;
-
         public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> CreateDrawableRepresentation;
 
         public Container ExplodingFruitTarget
@@ -36,6 +27,8 @@ namespace osu.Game.Rulesets.Catch.UI
             set => MovableCatcher.ExplodingFruitTarget = value;
         }
 
+        private DrawableCatchHitObject lastPlateableFruit;
+
         public CatcherArea(BeatmapDifficulty difficulty = null)
         {
             RelativeSizeAxes = Axes.X;
@@ -46,7 +39,10 @@ namespace osu.Game.Rulesets.Catch.UI
             };
         }
 
-        private DrawableCatchHitObject lastPlateableFruit;
+        public static float GetCatcherSize(BeatmapDifficulty difficulty)
+        {
+            return CATCHER_SIZE / CatchPlayfield.BASE_WIDTH * (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+        }
 
         public void OnResult(DrawableCatchHitObject fruit, JudgementResult result)
         {
@@ -99,6 +95,15 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
+        public void OnReleased(CatchAction action)
+        {
+        }
+
+        public bool AttemptCatch(CatchHitObject obj)
+        {
+            return MovableCatcher.AttemptCatch(obj);
+        }
+
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
@@ -109,479 +114,6 @@ namespace osu.Game.Rulesets.Catch.UI
                 MovableCatcher.X = state.CatcherX.Value;
         }
 
-        public void OnReleased(CatchAction action)
-        {
-        }
-
-        public bool AttemptCatch(CatchHitObject obj) => MovableCatcher.AttemptCatch(obj);
-
-        public static float GetCatcherSize(BeatmapDifficulty difficulty)
-        {
-            return CATCHER_SIZE / CatchPlayfield.BASE_WIDTH * (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
-        }
-
-        public class Catcher : Container, IKeyBindingHandler<CatchAction>
-        {
-            /// <summary>
-            /// Width of the area that can be used to attempt catches during gameplay.
-            /// </summary>
-            internal float CatchWidth => CATCHER_SIZE * Math.Abs(Scale.X);
-
-            private Container<DrawableHitObject> caughtFruit;
-
-            public Container ExplodingFruitTarget;
-
-            public Container AdditiveTarget;
-
-            public Catcher(BeatmapDifficulty difficulty = null)
-            {
-                RelativePositionAxes = Axes.X;
-                X = 0.5f;
-
-                Origin = Anchor.TopCentre;
-
-                Size = new Vector2(CATCHER_SIZE);
-                if (difficulty != null)
-                    Scale = new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                Children = new[]
-                {
-                    caughtFruit = new Container<DrawableHitObject>
-                    {
-                        Anchor = Anchor.TopCentre,
-                        Origin = Anchor.BottomCentre,
-                    },
-                    createCatcherSprite(),
-                };
-            }
-
-            private int currentDirection;
-
-            private bool dashing;
-
-            protected bool Dashing
-            {
-                get => dashing;
-                set
-                {
-                    if (value == dashing) return;
-
-                    dashing = value;
-
-                    Trail |= dashing;
-                }
-            }
-
-            private bool trail;
-
-            /// <summary>
-            /// Activate or deactive the trail. Will be automatically deactivated when conditions to keep the trail displayed are no longer met.
-            /// </summary>
-            protected bool Trail
-            {
-                get => trail;
-                set
-                {
-                    if (value == trail) return;
-
-                    trail = value;
-
-                    if (Trail)
-                        beginTrail();
-                }
-            }
-
-            private void beginTrail()
-            {
-                Trail &= dashing || HyperDashing;
-                Trail &= AdditiveTarget != null;
-
-                if (!Trail) return;
-
-                var additive = createCatcherSprite();
-
-                additive.Anchor = Anchor;
-                additive.OriginPosition += new Vector2(DrawWidth / 2, 0); // also temporary to align sprite correctly.
-                additive.Position = Position;
-                additive.Scale = Scale;
-                additive.Colour = HyperDashing ? Color4.Red : Color4.White;
-                additive.RelativePositionAxes = RelativePositionAxes;
-                additive.Blending = BlendingParameters.Additive;
-
-                AdditiveTarget.Add(additive);
-
-                additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint);
-                additive.Expire(true);
-
-                Scheduler.AddDelayed(beginTrail, HyperDashing ? 25 : 50);
-            }
-
-            private Drawable createCatcherSprite() => new CatcherSprite();
-
-            /// <summary>
-            /// Add a caught fruit to the catcher's stack.
-            /// </summary>
-            /// <param name="fruit">The fruit that was caught.</param>
-            public void PlaceOnPlate(DrawableCatchHitObject fruit)
-            {
-                float ourRadius = fruit.DisplayRadius;
-                float theirRadius = 0;
-
-                const float allowance = 6;
-
-                while (caughtFruit.Any(f =>
-                    f.LifetimeEnd == double.MaxValue &&
-                    Vector2Extensions.Distance(f.Position, fruit.Position) < (ourRadius + (theirRadius = f.DrawSize.X / 2 * f.Scale.X)) / (allowance / 2)))
-                {
-                    float diff = (ourRadius + theirRadius) / allowance;
-                    fruit.X += (RNG.NextSingle() - 0.5f) * 2 * diff;
-                    fruit.Y -= RNG.NextSingle() * diff;
-                }
-
-                fruit.X = Math.Clamp(fruit.X, -CATCHER_SIZE / 2, CATCHER_SIZE / 2);
-
-                caughtFruit.Add(fruit);
-
-                Add(new HitExplosion(fruit)
-                {
-                    X = fruit.X,
-                    Scale = new Vector2(fruit.HitObject.Scale)
-                });
-            }
-
-            /// <summary>
-            /// Let the catcher attempt to catch a fruit.
-            /// </summary>
-            /// <param name="fruit">The fruit to catch.</param>
-            /// <returns>Whether the catch is possible.</returns>
-            public bool AttemptCatch(CatchHitObject fruit)
-            {
-                float halfCatchWidth = CatchWidth * 0.5f;
-
-                // this stuff wil disappear once we move fruit to non-relative coordinate space in the future.
-                var catchObjectPosition = fruit.X * CatchPlayfield.BASE_WIDTH;
-                var catcherPosition = Position.X * CatchPlayfield.BASE_WIDTH;
-
-                var validCatch =
-                    catchObjectPosition >= catcherPosition - halfCatchWidth &&
-                    catchObjectPosition <= catcherPosition + halfCatchWidth;
-
-                if (validCatch && fruit.HyperDash)
-                {
-                    var target = fruit.HyperDashTarget;
-                    double timeDifference = target.StartTime - fruit.StartTime;
-                    double positionDifference = target.X * CatchPlayfield.BASE_WIDTH - catcherPosition;
-                    double velocity = positionDifference / Math.Max(1.0, timeDifference - 1000.0 / 60.0);
-
-                    SetHyperDashState(Math.Abs(velocity), target.X);
-                }
-                else
-                {
-                    SetHyperDashState();
-                }
-
-                return validCatch;
-            }
-
-            private double hyperDashModifier = 1;
-            private int hyperDashDirection;
-            private float hyperDashTargetPosition;
-
-            /// <summary>
-            /// Whether we are hyper-dashing or not.
-            /// </summary>
-            public bool HyperDashing => hyperDashModifier != 1;
-
-            /// <summary>
-            /// Set hyper-dash state.
-            /// </summary>
-            /// <param name="modifier">The speed multiplier. If this is less or equals to 1, this catcher will be non-hyper-dashing state.</param>
-            /// <param name="targetPosition">When this catcher crosses this position, this catcher ends hyper-dashing.</param>
-            public void SetHyperDashState(double modifier = 1, float targetPosition = -1)
-            {
-                const float hyper_dash_transition_length = 180;
-
-                bool previouslyHyperDashing = HyperDashing;
-
-                if (modifier <= 1 || X == targetPosition)
-                {
-                    hyperDashModifier = 1;
-                    hyperDashDirection = 0;
-
-                    if (previouslyHyperDashing)
-                    {
-                        this.FadeColour(Color4.White, hyper_dash_transition_length, Easing.OutQuint);
-                        this.FadeTo(1, hyper_dash_transition_length, Easing.OutQuint);
-                        Trail &= Dashing;
-                    }
-                }
-                else
-                {
-                    hyperDashModifier = modifier;
-                    hyperDashDirection = Math.Sign(targetPosition - X);
-                    hyperDashTargetPosition = targetPosition;
-
-                    if (!previouslyHyperDashing)
-                    {
-                        this.FadeColour(Color4.OrangeRed, hyper_dash_transition_length, Easing.OutQuint);
-                        this.FadeTo(0.2f, hyper_dash_transition_length, Easing.OutQuint);
-                        Trail = true;
-                    }
-                }
-            }
-
-            public bool OnPressed(CatchAction action)
-            {
-                switch (action)
-                {
-                    case CatchAction.MoveLeft:
-                        currentDirection--;
-                        return true;
-
-                    case CatchAction.MoveRight:
-                        currentDirection++;
-                        return true;
-
-                    case CatchAction.Dash:
-                        Dashing = true;
-                        return true;
-                }
-
-                return false;
-            }
-
-            public void OnReleased(CatchAction action)
-            {
-                switch (action)
-                {
-                    case CatchAction.MoveLeft:
-                        currentDirection++;
-                        break;
-
-                    case CatchAction.MoveRight:
-                        currentDirection--;
-                        break;
-
-                    case CatchAction.Dash:
-                        Dashing = false;
-                        break;
-                }
-            }
-
-            /// <summary>
-            /// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
-            /// </summary>
-            public const double BASE_SPEED = 1.0 / 512;
-
-            protected override void Update()
-            {
-                base.Update();
-
-                if (currentDirection == 0) return;
-
-                var direction = Math.Sign(currentDirection);
-
-                double dashModifier = Dashing ? 1 : 0.5;
-                double speed = BASE_SPEED * dashModifier * hyperDashModifier;
-
-                UpdatePosition((float)(X + direction * Clock.ElapsedFrameTime * speed));
-
-                // Correct overshooting.
-                if ((hyperDashDirection > 0 && hyperDashTargetPosition < X) ||
-                    (hyperDashDirection < 0 && hyperDashTargetPosition > X))
-                {
-                    X = hyperDashTargetPosition;
-                    SetHyperDashState();
-                }
-            }
-
-            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()
-            {
-                foreach (var f in caughtFruit.ToArray())
-                    Drop(f);
-            }
-
-            /// <summary>
-            /// Explode any fruit off the plate.
-            /// </summary>
-            public void Explode()
-            {
-                foreach (var f in caughtFruit.ToArray())
-                    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;
-                    fruit.Position = caughtFruit.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
-
-                    if (!caughtFruit.Remove(fruit))
-                        // we may have already been removed by a previous operation (due to the weird OnLoadComplete scheduling).
-                        // this avoids a crash on potentially attempting to Add a fruit to ExplodingFruitTarget twice.
-                        return;
-
-                    ExplodingFruitTarget.Add(fruit);
-                }
-
-                double actionTime = Clock.CurrentTime;
-
-                fruit.ApplyCustomUpdateState += onFruitOnApplyCustomUpdateState;
-                onFruitOnApplyCustomUpdateState(fruit, fruit.State.Value);
-
-                void onFruitOnApplyCustomUpdateState(DrawableHitObject o, ArmedState state)
-                {
-                    using (fruit.BeginAbsoluteSequence(actionTime))
-                        action(fruit);
-
-                    fruit.Expire();
-                }
-            }
-        }
-    }
-
-    public class HitExplosion : CompositeDrawable
-    {
-        private readonly CircularContainer largeFaint;
-
-        public HitExplosion(DrawableCatchHitObject fruit)
-        {
-            Size = new Vector2(20);
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.BottomCentre;
-
-            Color4 objectColour = fruit.AccentColour.Value;
-
-            // scale roughly in-line with visual appearance of notes
-
-            const float angle_variangle = 15; // should be less than 45
-
-            const float roundness = 100;
-
-            const float initial_height = 10;
-
-            var colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1);
-
-            InternalChildren = new Drawable[]
-            {
-                largeFaint = new CircularContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    // we want our size to be very small so the glow dominates it.
-                    Size = new Vector2(0.8f),
-                    Blending = BlendingParameters.Additive,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
-                        Roundness = 160,
-                        Radius = 200,
-                    },
-                },
-                new CircularContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    Blending = BlendingParameters.Additive,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
-                        Roundness = 20,
-                        Radius = 50,
-                    },
-                },
-                new CircularContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    Size = new Vector2(0.01f, initial_height),
-                    Blending = BlendingParameters.Additive,
-                    Rotation = RNG.NextSingle(-angle_variangle, angle_variangle),
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = colour,
-                        Roundness = roundness,
-                        Radius = 40,
-                    },
-                },
-                new CircularContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    Size = new Vector2(0.01f, initial_height),
-                    Blending = BlendingParameters.Additive,
-                    Rotation = RNG.NextSingle(-angle_variangle, angle_variangle),
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Glow,
-                        Colour = colour,
-                        Roundness = roundness,
-                        Radius = 40,
-                    },
-                }
-            };
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            const double duration = 400;
-
-            largeFaint
-                .ResizeTo(largeFaint.Size * new Vector2(5, 1), duration, Easing.OutQuint)
-                .FadeOut(duration * 2);
-
-            this.FadeInFromZero(50).Then().FadeOut(duration, Easing.Out);
-            Expire(true);
-        }
+        protected internal readonly Catcher MovableCatcher;
     }
 }

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

@@ -3,31 +3,57 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
 using osu.Game.Skinning;
 using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class CatcherSprite : CompositeDrawable
+    public class CatcherSprite : SkinnableDrawable
     {
-        public CatcherSprite()
+        protected override bool ApplySizeRestrictionsToDefault => true;
+
+        public CatcherSprite(CatcherAnimationState state)
+            : base(new CatchSkinComponent(componentFromState(state)), _ =>
+                new DefaultCatcherSprite(state), confineMode: ConfineMode.ScaleDownToFit)
         {
+            RelativeSizeAxes = Axes.None;
             Size = new Vector2(CatcherArea.CATCHER_SIZE);
 
             // Sets the origin roughly to the centre of the catcher's plate to allow for correct scaling.
-            OriginPosition = new Vector2(-0.02f, 0.06f) * CatcherArea.CATCHER_SIZE;
+            OriginPosition = new Vector2(0.5f, 0.06f) * CatcherArea.CATCHER_SIZE;
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
+        private static CatchSkinComponents componentFromState(CatcherAnimationState state)
         {
-            InternalChild = new SkinnableSprite("Gameplay/catch/fruit-catcher-idle", confineMode: ConfineMode.ScaleDownToFit)
+            switch (state)
             {
-                RelativeSizeAxes = Axes.Both,
-                Anchor = Anchor.TopCentre,
-                Origin = Anchor.TopCentre,
-            };
+                case CatcherAnimationState.Fail:
+                    return CatchSkinComponents.CatcherFail;
+
+                case CatcherAnimationState.Kiai:
+                    return CatchSkinComponents.CatcherKiai;
+
+                default:
+                    return CatchSkinComponents.CatcherIdle;
+            }
+        }
+
+        private class DefaultCatcherSprite : Sprite
+        {
+            private readonly CatcherAnimationState state;
+
+            public DefaultCatcherSprite(CatcherAnimationState state)
+            {
+                this.state = state;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                Texture = textures.Get($"Gameplay/catch/fruit-catcher-{state.ToString().ToLower()}");
+            }
         }
     }
 }

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

@@ -0,0 +1,22 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatcherTrailSprite : Sprite
+    {
+        public CatcherTrailSprite(Texture texture)
+        {
+            Texture = texture;
+
+            Size = new Vector2(CatcherArea.CATCHER_SIZE);
+
+            // Sets the origin roughly to the centre of the catcher's plate to allow for correct scaling.
+            OriginPosition = new Vector2(0.5f, 0.06f) * CatcherArea.CATCHER_SIZE;
+        }
+    }
+}

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

@@ -32,6 +32,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new CatchFramedReplayInputHandler(replay);
 
+        protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new CatchReplayRecorder(replay, (CatchPlayfield)Playfield);
+
         protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty, CreateDrawableRepresentation);
 
         public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new CatchPlayfieldAdjustmentContainer();

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

@@ -0,0 +1,122 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class HitExplosion : CompositeDrawable
+    {
+        private readonly CircularContainer largeFaint;
+
+        public HitExplosion(DrawableCatchHitObject fruit)
+        {
+            Size = new Vector2(20);
+            Anchor = Anchor.TopCentre;
+            Origin = Anchor.BottomCentre;
+
+            Color4 objectColour = fruit.AccentColour.Value;
+
+            // scale roughly in-line with visual appearance of notes
+
+            const float angle_variangle = 15; // should be less than 45
+
+            const float roundness = 100;
+
+            const float initial_height = 10;
+
+            var colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1);
+
+            InternalChildren = new Drawable[]
+            {
+                largeFaint = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    // we want our size to be very small so the glow dominates it.
+                    Size = new Vector2(0.8f),
+                    Blending = BlendingParameters.Additive,
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Type = EdgeEffectType.Glow,
+                        Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
+                        Roundness = 160,
+                        Radius = 200,
+                    },
+                },
+                new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Blending = BlendingParameters.Additive,
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Type = EdgeEffectType.Glow,
+                        Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
+                        Roundness = 20,
+                        Radius = 50,
+                    },
+                },
+                new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Size = new Vector2(0.01f, initial_height),
+                    Blending = BlendingParameters.Additive,
+                    Rotation = RNG.NextSingle(-angle_variangle, angle_variangle),
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Type = EdgeEffectType.Glow,
+                        Colour = colour,
+                        Roundness = roundness,
+                        Radius = 40,
+                    },
+                },
+                new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    Size = new Vector2(0.01f, initial_height),
+                    Blending = BlendingParameters.Additive,
+                    Rotation = RNG.NextSingle(-angle_variangle, angle_variangle),
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Type = EdgeEffectType.Glow,
+                        Colour = colour,
+                        Roundness = roundness,
+                        Radius = 40,
+                    },
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            const double duration = 400;
+
+            largeFaint
+                .ResizeTo(largeFaint.Size * new Vector2(5, 1), duration, Easing.OutQuint)
+                .FadeOut(duration * 2);
+
+            this.FadeInFromZero(50).Then().FadeOut(duration, Easing.Out);
+            Expire(true);
+        }
+    }
+}

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             {
             }
 
-            protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+            protected override KeyBindingContainer<ManiaAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
                 => new LocalKeyBindingContainer(ruleset, variant, unique);
 
             private class LocalKeyBindingContainer : RulesetKeyBindingContainer

osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModPerfect.cs

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests.Mods
+{
+    public class TestSceneManiaModPerfect : ModPerfectTestScene
+    {
+        public TestSceneManiaModPerfect()
+            : base(new ManiaRuleset(), new ManiaModPerfect())
+        {
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestNote(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Note { StartTime = 1000 }), shouldMiss);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestHoldNote(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new HoldNote { StartTime = 1000, EndTime = 3000 }), shouldMiss);
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override ISkin CreateLegacySkinProvider(ISkinSource source) => new ManiaLegacySkinTransformer(source);
 
-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
                 yield return new ManiaModNightcore();
@@ -118,6 +118,59 @@ namespace osu.Game.Rulesets.Mania
                 yield return new ManiaModRandom();
         }
 
+        public override LegacyMods ConvertToLegacyMods(Mod[] mods)
+        {
+            var value = base.ConvertToLegacyMods(mods);
+
+            foreach (var mod in mods)
+            {
+                switch (mod)
+                {
+                    case ManiaModKey1 _:
+                        value |= LegacyMods.Key1;
+                        break;
+
+                    case ManiaModKey2 _:
+                        value |= LegacyMods.Key2;
+                        break;
+
+                    case ManiaModKey3 _:
+                        value |= LegacyMods.Key3;
+                        break;
+
+                    case ManiaModKey4 _:
+                        value |= LegacyMods.Key4;
+                        break;
+
+                    case ManiaModKey5 _:
+                        value |= LegacyMods.Key5;
+                        break;
+
+                    case ManiaModKey6 _:
+                        value |= LegacyMods.Key6;
+                        break;
+
+                    case ManiaModKey7 _:
+                        value |= LegacyMods.Key7;
+                        break;
+
+                    case ManiaModKey8 _:
+                        value |= LegacyMods.Key8;
+                        break;
+
+                    case ManiaModKey9 _:
+                        value |= LegacyMods.Key9;
+                        break;
+
+                    case ManiaModFadeIn _:
+                        value |= LegacyMods.FadeIn;
+                        break;
+                }
+            }
+
+            return value;
+        }
+
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
             switch (type)

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

@@ -3,8 +3,8 @@
 
 using System;
 using osu.Framework.Bindables;
-using osu.Framework.Caching;
 using osu.Framework.Graphics;
+using osu.Framework.Layout;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 using osuTK;
@@ -22,21 +22,13 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         private class ManiaFlashlight : Flashlight
         {
-            private readonly Cached flashlightProperties = new Cached();
+            private readonly LayoutValue flashlightProperties = new LayoutValue(Invalidation.DrawSize);
 
             public ManiaFlashlight()
             {
                 FlashlightSize = new Vector2(0, default_flashlight_size);
-            }
 
-            public override bool Invalidate(Invalidation invalidation = Invalidation.All, Drawable source = null, bool shallPropagate = true)
-            {
-                if ((invalidation & Invalidation.DrawSize) > 0)
-                {
-                    flashlightProperties.Invalidate();
-                }
-
-                return base.Invalidate(invalidation, source, shallPropagate);
+                AddLayout(flashlightProperties);
             }
 
             protected override void Update()

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

@@ -3,24 +3,17 @@
 
 using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModRandom : Mod, IApplicableToBeatmap
+    public class ManiaModRandom : ModRandom, IApplicableToBeatmap
     {
-        public override string Name => "Random";
-        public override string Acronym => "RD";
-        public override ModType Type => ModType.Conversion;
-        public override IconUsage? Icon => OsuIcon.Dice;
         public override string Description => @"Shuffle around the keys!";
-        public override double ScoreMultiplier => 1;
 
         public void ApplyToBeatmap(IBeatmap beatmap)
         {

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

@@ -2,13 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Caching;
 using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Layout;
 using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
@@ -65,6 +65,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
                     }
                 }
             };
+
+            AddLayout(subtractionCache);
         }
 
         protected override void LoadComplete()
@@ -100,15 +102,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
             }
         }
 
-        private readonly Cached subtractionCache = new Cached();
-
-        public override bool Invalidate(Invalidation invalidation = Invalidation.All, Drawable source = null, bool shallPropagate = true)
-        {
-            if ((invalidation & Invalidation.DrawSize) > 0)
-                subtractionCache.Invalidate();
-
-            return base.Invalidate(invalidation, source, shallPropagate);
-        }
+        private readonly LayoutValue subtractionCache = new LayoutValue(Invalidation.DrawSize);
 
         protected override void Update()
         {

osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Replays
             Actions.AddRange(actions);
         }
 
-        public void ConvertFrom(LegacyReplayFrame legacyFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+        public void FromLegacy(LegacyReplayFrame legacyFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
         {
             // We don't need to fully convert, just create the converter
             var converter = new ManiaBeatmapConverter(beatmap, new ManiaRuleset());
@@ -56,5 +56,42 @@ namespace osu.Game.Rulesets.Mania.Replays
                 activeColumns >>= 1;
             }
         }
+
+        public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+        {
+            int keys = 0;
+
+            var converter = new ManiaBeatmapConverter(beatmap, new ManiaRuleset());
+
+            var stage = new StageDefinition { Columns = converter.TargetColumns };
+
+            var specialColumns = new List<int>();
+
+            for (int i = 0; i < converter.TargetColumns; i++)
+            {
+                if (stage.IsSpecialColumn(i))
+                    specialColumns.Add(i);
+            }
+
+            foreach (var action in Actions)
+            {
+                switch (action)
+                {
+                    case ManiaAction.Special1:
+                        keys |= 1 << specialColumns[0];
+                        break;
+
+                    case ManiaAction.Special2:
+                        keys |= 1 << specialColumns[1];
+                        break;
+
+                    default:
+                        keys |= 1 << (action - ManiaAction.Key1);
+                        break;
+                }
+            }
+
+            return new LegacyReplayFrame(Time, keys, null, ReplayButtonState.None);
+        }
     }
 }

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

@@ -85,5 +85,7 @@ namespace osu.Game.Rulesets.Mania.UI
         }
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new ManiaFramedReplayInputHandler(replay);
+
+        protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new ManiaReplayRecorder(replay);
     }
 }

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

@@ -0,0 +1,23 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class ManiaReplayRecorder : ReplayRecorder<ManiaAction>
+    {
+        public ManiaReplayRecorder(Replay replay)
+            : base(replay)
+        {
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<ManiaAction> actions, ReplayFrame previousFrame)
+            => new ManiaReplayFrame(Time.Current, actions.ToArray());
+    }
+}

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

@@ -115,9 +115,8 @@ namespace osu.Game.Rulesets.Mania.UI
                         {
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.Centre,
-                            AutoSizeAxes = Axes.Both,
+                            RelativeSizeAxes = Axes.Both,
                             Y = HIT_TARGET_POSITION + 150,
-                            BypassAutoSizeAxes = Axes.Both
                         },
                         topLevelContainer = new Container { RelativeSizeAxes = Axes.Both }
                     }

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

@@ -0,0 +1,86 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Graphics.Containers;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModDifficultyAdjust : ModTestScene
+    {
+        public TestSceneOsuModDifficultyAdjust()
+            : base(new OsuRuleset())
+        {
+        }
+
+        [Test]
+        public void TestNoAdjustment() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModDifficultyAdjust(),
+            Autoplay = true,
+            PassCondition = checkSomeHit
+        });
+
+        [Test]
+        public void TestCircleSize1() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModDifficultyAdjust { CircleSize = { Value = 1 } },
+            Autoplay = true,
+            PassCondition = () => checkSomeHit() && checkObjectsScale(0.78f)
+        });
+
+        [Test]
+        public void TestCircleSize10() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModDifficultyAdjust { CircleSize = { Value = 10 } },
+            Autoplay = true,
+            PassCondition = () => checkSomeHit() && checkObjectsScale(0.15f)
+        });
+
+        [Test]
+        public void TestApproachRate1() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModDifficultyAdjust { ApproachRate = { Value = 1 } },
+            Autoplay = true,
+            PassCondition = () => checkSomeHit() && checkObjectsPreempt(1680)
+        });
+
+        [Test]
+        public void TestApproachRate10() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModDifficultyAdjust { ApproachRate = { Value = 10 } },
+            Autoplay = true,
+            PassCondition = () => checkSomeHit() && checkObjectsPreempt(450)
+        });
+
+        private bool checkObjectsPreempt(double target)
+        {
+            var objects = Player.ChildrenOfType<DrawableHitCircle>();
+            if (!objects.Any())
+                return false;
+
+            return objects.All(o => o.HitObject.TimePreempt == target);
+        }
+
+        private bool checkObjectsScale(float target)
+        {
+            var objects = Player.ChildrenOfType<DrawableHitCircle>();
+            if (!objects.Any())
+                return false;
+
+            return objects.All(o => Precision.AlmostEquals(o.ChildrenOfType<ShakeContainer>().First().Children.OfType<Container>().Single().Scale.X, target));
+        }
+
+        private bool checkSomeHit()
+        {
+            return Player.ScoreProcessor.JudgedHits >= 2;
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModDoubleTime : ModTestScene
+    {
+        public TestSceneOsuModDoubleTime()
+            : base(new OsuRuleset())
+        {
+        }
+
+        [TestCase(0.5)]
+        [TestCase(1.01)]
+        [TestCase(1.5)]
+        [TestCase(2)]
+        [TestCase(5)]
+        public void TestSpeedChangeCustomisation(double rate)
+        {
+            var mod = new OsuModDoubleTime { SpeedChange = { Value = rate } };
+
+            CreateModTest(new ModTestData
+            {
+                Mod = mod,
+                PassCondition = () => Player.ScoreProcessor.JudgedHits >= 2 &&
+                                      Precision.AlmostEquals(Player.GameplayClockContainer.GameplayClock.Rate, mod.SpeedChange.Value)
+            });
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModPerfect : ModPerfectTestScene
+    {
+        public TestSceneOsuModPerfect()
+            : base(new OsuRuleset(), new OsuModPerfect())
+        {
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestHitCircle(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new HitCircle { StartTime = 1000 }), shouldMiss);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestSlider(bool shouldMiss)
+        {
+            var slider = new Slider
+            {
+                StartTime = 1000,
+                Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(100, 0), })
+            };
+
+            CreateHitObjectTest(new HitObjectTestData(slider), shouldMiss);
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestSpinner(bool shouldMiss)
+        {
+            var spinner = new Spinner
+            {
+                StartTime = 1000,
+                EndTime = 3000,
+                Position = new Vector2(256, 192)
+            };
+
+            CreateHitObjectTest(new HitObjectTestData(spinner), shouldMiss);
+        }
+    }
+}

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

@@ -2,9 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
@@ -114,6 +117,22 @@ namespace osu.Game.Rulesets.Osu.Tests
             assertGroups();
         }
 
+        [Test]
+        public void TestStackedObjects()
+        {
+            addObjectsStep(() => new OsuHitObject[]
+            {
+                new HitCircle { Position = new Vector2(300, 100) },
+                new HitCircle
+                {
+                    Position = new Vector2(300, 300),
+                    StackHeight = 20
+                },
+            });
+
+            assertDirections();
+        }
+
         private void addMultipleObjectsStep() => addObjectsStep(() => new OsuHitObject[]
         {
             new HitCircle { Position = new Vector2(100, 100) },
@@ -207,6 +226,33 @@ namespace osu.Game.Rulesets.Osu.Tests
             });
         }
 
+        private void assertDirections()
+        {
+            AddAssert("group directions are correct", () =>
+            {
+                for (int i = 0; i < hitObjectContainer.Count; i++)
+                {
+                    DrawableOsuHitObject expectedStart = getObject(i);
+                    DrawableOsuHitObject expectedEnd = i < hitObjectContainer.Count - 1 ? getObject(i + 1) : null;
+
+                    if (expectedEnd == null)
+                        continue;
+
+                    var points = getGroup(i).ChildrenOfType<FollowPoint>().ToArray();
+                    if (points.Length == 0)
+                        continue;
+
+                    float expectedDirection = MathF.Atan2(expectedStart.Position.Y - expectedEnd.Position.Y, expectedStart.Position.X - expectedEnd.Position.X);
+                    float realDirection = MathF.Atan2(expectedStart.Position.Y - points[^1].Position.Y, expectedStart.Position.X - points[^1].Position.X);
+
+                    if (!Precision.AlmostEquals(expectedDirection, realDirection))
+                        throw new AssertionException($"Expected group {i} in direction {expectedDirection}, but was {realDirection}.");
+                }
+
+                return true;
+            });
+        }
+
         private DrawableOsuHitObject getObject(int index) => hitObjectContainer[index];
 
         private FollowPointConnection getGroup(int index) => followPointRenderer.Connections[index];

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

@@ -0,0 +1,103 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneHitCircleArea : OsuManualInputManagerTestScene
+    {
+        private HitCircle hitCircle;
+        private DrawableHitCircle drawableHitCircle;
+        private DrawableHitCircle.HitReceptor hitAreaReceptor => drawableHitCircle.HitArea;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            hitCircle = new HitCircle
+            {
+                Position = new Vector2(100, 100),
+                StartTime = Time.Current + 500
+            };
+
+            hitCircle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            Child = new SkinProvidingContainer(new DefaultSkin())
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = drawableHitCircle = new DrawableHitCircle(hitCircle)
+                {
+                    Size = new Vector2(100)
+                }
+            };
+        });
+
+        [Test]
+        public void TestCircleHitCentre()
+        {
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(hitAreaReceptor.ScreenSpaceDrawQuad.Centre));
+            scheduleHit();
+
+            AddAssert("hit registered", () => hitAreaReceptor.HitAction == OsuAction.LeftButton);
+        }
+
+        [Test]
+        public void TestCircleHitLeftEdge()
+        {
+            AddStep("move mouse to left edge", () =>
+            {
+                var drawQuad = hitAreaReceptor.ScreenSpaceDrawQuad;
+                var mousePosition = new Vector2(drawQuad.TopLeft.X, drawQuad.Centre.Y);
+
+                InputManager.MoveMouseTo(mousePosition);
+            });
+            scheduleHit();
+
+            AddAssert("hit registered", () => hitAreaReceptor.HitAction == OsuAction.LeftButton);
+        }
+
+        [TestCase(0.95f, OsuAction.LeftButton)]
+        [TestCase(1.05f, null)]
+        public void TestHitsCloseToEdge(float relativeDistanceFromCentre, OsuAction? expectedAction)
+        {
+            AddStep("move mouse to top left circle edge", () =>
+            {
+                var drawQuad = hitAreaReceptor.ScreenSpaceDrawQuad;
+                // sqrt(2) / 2 = sin(45deg) = cos(45deg)
+                // draw width halved to get radius
+                float correction = relativeDistanceFromCentre * (float)Math.Sqrt(2) / 2 * (drawQuad.Width / 2);
+                var mousePosition = new Vector2(drawQuad.Centre.X - correction, drawQuad.Centre.Y - correction);
+
+                InputManager.MoveMouseTo(mousePosition);
+            });
+            scheduleHit();
+
+            AddAssert($"hit {(expectedAction == null ? "not " : string.Empty)}registered", () => hitAreaReceptor.HitAction == expectedAction);
+        }
+
+        [Test]
+        public void TestCircleMissBoundingBoxCorner()
+        {
+            AddStep("move mouse to top left corner of bounding box", () => InputManager.MoveMouseTo(hitAreaReceptor.ScreenSpaceDrawQuad.TopLeft));
+            scheduleHit();
+
+            AddAssert("hit not registered", () => hitAreaReceptor.HitAction == null);
+        }
+
+        private void scheduleHit() => AddStep("schedule action", () =>
+        {
+            var delay = hitCircle.StartTime - hitCircle.HitWindows.WindowFor(HitResult.Great) - Time.Current;
+            Scheduler.AddDelayed(() => hitAreaReceptor.OnPressed(OsuAction.LeftButton), delay);
+        });
+    }
+}

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

@@ -0,0 +1,101 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneMissHitWindowJudgements : ModTestScene
+    {
+        public TestSceneMissHitWindowJudgements()
+            : base(new OsuRuleset())
+        {
+        }
+
+        [Test]
+        public void TestMissViaEarlyHit()
+        {
+            var beatmap = new Beatmap
+            {
+                HitObjects = { new HitCircle { Position = new Vector2(256, 192) } }
+            };
+
+            var hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
+
+            CreateModTest(new ModTestData
+            {
+                Autoplay = false,
+                Mod = new TestAutoMod(),
+                Beatmap = new Beatmap
+                {
+                    HitObjects = { new HitCircle { Position = new Vector2(256, 192) } }
+                },
+                PassCondition = () => Player.Results.Count > 0 && Player.Results[0].TimeOffset < -hitWindows.WindowFor(HitResult.Meh) && Player.Results[0].Type == HitResult.Miss
+            });
+        }
+
+        [Test]
+        public void TestMissViaNotHitting()
+        {
+            var beatmap = new Beatmap
+            {
+                HitObjects = { new HitCircle { Position = new Vector2(256, 192) } }
+            };
+
+            var hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
+
+            CreateModTest(new ModTestData
+            {
+                Autoplay = false,
+                Beatmap = beatmap,
+                PassCondition = () => Player.Results.Count > 0 && Player.Results[0].TimeOffset >= hitWindows.WindowFor(HitResult.Meh) && Player.Results[0].Type == HitResult.Miss
+            });
+        }
+
+        private class TestAutoMod : OsuModAutoplay
+        {
+            public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+            {
+                ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
+                Replay = new MissingAutoGenerator(beatmap).Generate()
+            };
+        }
+
+        private class MissingAutoGenerator : OsuAutoGeneratorBase
+        {
+            public new OsuBeatmap Beatmap => (OsuBeatmap)base.Beatmap;
+
+            public MissingAutoGenerator(IBeatmap beatmap)
+                : base(beatmap)
+            {
+            }
+
+            public override Replay Generate()
+            {
+                AddFrameToReplay(new OsuReplayFrame(-100000, new Vector2(256, 500)));
+                AddFrameToReplay(new OsuReplayFrame(Beatmap.HitObjects[0].StartTime - 1500, new Vector2(256, 500)));
+                AddFrameToReplay(new OsuReplayFrame(Beatmap.HitObjects[0].StartTime - 1500, new Vector2(256, 500)));
+
+                AddFrameToReplay(new OsuReplayFrame(Beatmap.HitObjects[0].StartTime - 450, Beatmap.HitObjects[0].StackedPosition));
+                AddFrameToReplay(new OsuReplayFrame(Beatmap.HitObjects[0].StartTime - 350, Beatmap.HitObjects[0].StackedPosition, OsuAction.LeftButton));
+                AddFrameToReplay(new OsuReplayFrame(Beatmap.HitObjects[0].StartTime - 325, Beatmap.HitObjects[0].StackedPosition));
+
+                return Replay;
+            }
+        }
+    }
+}

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

@@ -23,7 +23,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestSceneOsuDistanceSnapGrid : ManualInputManagerTestScene
+    public class TestSceneOsuDistanceSnapGrid : OsuManualInputManagerTestScene
     {
         private const double beat_length = 100;
         private static readonly Vector2 grid_position = new Vector2(512, 384);

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

@@ -3,13 +3,13 @@
 
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     public class TestSceneOsuFlashlight : TestSceneOsuPlayer
     {
-        protected override Player CreatePlayer(Ruleset ruleset)
+        protected override TestPlayer CreatePlayer(Ruleset ruleset)
         {
             SelectedMods.Value = new Mod[] { new OsuModAutoplay(), new OsuModFlashlight(), };
 

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

@@ -12,7 +12,7 @@ using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestSceneResumeOverlay : ManualInputManagerTestScene
+    public class TestSceneResumeOverlay : OsuManualInputManagerTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

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

@@ -18,7 +18,6 @@ using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Screens.Play;
 using osu.Game.Skinning;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Visual;
@@ -56,7 +55,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private void checkNextHitObject(string skin) =>
             AddUntilStep($"check skin from {skin}", () =>
             {
-                var firstObject = ((TestPlayer)Player).DrawableRuleset.Playfield.HitObjectContainer.AliveObjects.OfType<DrawableHitCircle>().FirstOrDefault();
+                var firstObject = Player.DrawableRuleset.Playfield.HitObjectContainer.AliveObjects.OfType<DrawableHitCircle>().FirstOrDefault();
 
                 if (firstObject == null)
                     return false;
@@ -75,7 +74,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Resolved]
         private AudioManager audio { get; set; }
 
-        protected override Player CreatePlayer(Ruleset ruleset) => new SkinProvidingPlayer(testUserSkin);
+        protected override TestPlayer CreatePlayer(Ruleset ruleset) => new SkinProvidingPlayer(testUserSkin);
 
         protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null) => new CustomSkinWorkingBeatmap(beatmap, storyboard, Clock, audio, testBeatmapSkin);
 

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

@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             typeof(DrawableSliderTick),
             typeof(DrawableSliderTail),
             typeof(DrawableSliderHead),
-            typeof(DrawableRepeatPoint),
+            typeof(DrawableSliderRepeat),
             typeof(DrawableOsuHitObject)
         };
 
@@ -146,7 +146,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             AddAssert("head samples updated", () => assertSamples(((Slider)slider.HitObject).HeadCircle));
             AddAssert("tick samples not updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<SliderTick>().All(assertTickSamples));
-            AddAssert("repeat samples updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<RepeatPoint>().All(assertSamples));
+            AddAssert("repeat samples updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<SliderRepeat>().All(assertSamples));
             AddAssert("tail has no samples", () => ((Slider)slider.HitObject).TailCircle.Samples.Count == 0);
 
             static bool assertTickSamples(SliderTick tick) => tick.Samples.Single().Name == "slidertick";
@@ -181,7 +181,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             AddAssert("head samples not updated", () => assertSamples(((Slider)slider.HitObject).HeadCircle));
             AddAssert("tick samples not updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<SliderTick>().All(assertTickSamples));
-            AddAssert("repeat samples not updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<RepeatPoint>().All(assertSamples));
+            AddAssert("repeat samples not updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<SliderRepeat>().All(assertSamples));
             AddAssert("tail has no samples", () => ((Slider)slider.HitObject).TailCircle.Samples.Count == 0);
 
             static bool assertTickSamples(SliderTick tick) => tick.Samples.Single().Name == "slidertick";

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

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             typeof(SliderBall),
             typeof(DrawableSlider),
             typeof(DrawableSliderTick),
-            typeof(DrawableRepeatPoint),
+            typeof(DrawableSliderRepeat),
             typeof(DrawableOsuHitObject),
             typeof(DrawableSliderHead),
             typeof(DrawableSliderTail),
@@ -327,7 +327,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("Tracking dropped", assertMidSliderJudgementFail);
         }
 
-        private bool assertGreatJudge() => judgementResults.Last().Type == HitResult.Great;
+        private bool assertGreatJudge() => judgementResults.Any() && judgementResults.All(t => t.Type == HitResult.Great);
 
         private bool assertHeadMissTailTracked() => judgementResults[^2].Type == HitResult.Great && judgementResults.First().Type == HitResult.Miss;
 

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

@@ -11,7 +11,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Tests.Visual;
 using osuTK;
 using System.Collections.Generic;
 using System.Linq;
@@ -44,7 +43,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             base.SetUpSteps();
 
             AddUntilStep("wait for track to start running", () => track.IsRunning);
-            AddStep("retrieve spinner", () => drawableSpinner = (DrawableSpinner)((TestPlayer)Player).DrawableRuleset.Playfield.AllHitObjects.First());
+            AddStep("retrieve spinner", () => drawableSpinner = (DrawableSpinner)Player.DrawableRuleset.Playfield.AllHitObjects.First());
         }
 
         [Test]
@@ -89,7 +88,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             AddStep($"seek to {time}", () => track.Seek(time));
 
-            AddUntilStep("wait for seek to finish", () => Precision.AlmostEquals(time, ((TestPlayer)Player).DrawableRuleset.FrameStableClock.CurrentTime, 100));
+            AddUntilStep("wait for seek to finish", () => Precision.AlmostEquals(time, Player.DrawableRuleset.FrameStableClock.CurrentTime, 100));
         }
 
         protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap

osu.Game.Rulesets.Osu/Judgements/OsuIgnoreJudgement.cs

@@ -0,0 +1,16 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Judgements
+{
+    public class OsuIgnoreJudgement : OsuJudgement
+    {
+        public override bool AffectsCombo => false;
+
+        protected override int NumericResultFor(HitResult result) => 0;
+
+        protected override double HealthIncreaseFor(HitResult result) => 0;
+    }
+}

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 return;
 
             slider.NestedHitObjects.OfType<SliderTick>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));
-            slider.NestedHitObjects.OfType<RepeatPoint>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));
+            slider.NestedHitObjects.OfType<SliderRepeat>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));
 
             foreach (var point in slider.Path.ControlPoints)
                 point.Position.Value = new Vector2(point.Position.Value.X, -point.Position.Value.Y);

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

@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 case DrawableSliderHead _:
                 case DrawableSliderTail _:
                 case DrawableSliderTick _:
-                case DrawableRepeatPoint _:
+                case DrawableSliderRepeat _:
                     return;
 
                 default:

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

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             // Wiggle the repeat points with the slider instead of independently.
             // Also fixes an issue with repeat points being positioned incorrectly.
-            if (osuObject is RepeatPoint)
+            if (osuObject is SliderRepeat)
                 return;
 
             Random objRand = new Random((int)osuObject.StartTime);

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

@@ -88,8 +88,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 
         private void refresh()
         {
-            ClearInternal();
-
             OsuHitObject osuStart = Start.HitObject;
             double startTime = osuStart.GetEndTime();
 
@@ -104,8 +102,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                 return;
             }
 
-            Vector2 startPosition = osuStart.EndPosition;
-            Vector2 endPosition = osuEnd.Position;
+            Vector2 startPosition = osuStart.StackedEndPosition;
+            Vector2 endPosition = osuEnd.StackedPosition;
             double endTime = osuEnd.StartTime;
 
             Vector2 distanceVector = endPosition - startPosition;
@@ -116,6 +114,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
             double? firstTransformStartTime = null;
             double finalTransformEndTime = startTime;
 
+            int point = 0;
+
             for (int d = (int)(spacing * 1.5); d < distance - spacing; d += spacing)
             {
                 float fraction = (float)d / distance;
@@ -126,13 +126,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 
                 FollowPoint fp;
 
-                AddInternal(fp = new FollowPoint
+                if (InternalChildren.Count > point)
                 {
-                    Position = pointStartPosition,
-                    Rotation = rotation,
-                    Alpha = 0,
-                    Scale = new Vector2(1.5f * osuEnd.Scale),
-                });
+                    fp = (FollowPoint)InternalChildren[point];
+                    fp.ClearTransforms();
+                }
+                else
+                    AddInternal(fp = new FollowPoint());
+
+                fp.Position = pointStartPosition;
+                fp.Rotation = rotation;
+                fp.Alpha = 0;
+                fp.Scale = new Vector2(1.5f * osuEnd.Scale);
 
                 if (firstTransformStartTime == null)
                     firstTransformStartTime = fadeInTime;
@@ -146,8 +151,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 
                     finalTransformEndTime = fadeOutTime + osuEnd.TimeFadeIn;
                 }
+
+                point++;
             }
 
+            int excessPoints = InternalChildren.Count - point;
+            for (int i = 0; i < excessPoints; i++)
+                RemoveInternal(InternalChildren[^1]);
+
             // todo: use Expire() on FollowPoints and take lifetime from them when https://github.com/ppy/osu-framework/issues/3300 is fixed.
             LifetimeStart = firstTransformStartTime ?? startTime;
             LifetimeEnd = finalTransformEndTime;

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

@@ -170,7 +170,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public Drawable ProxiedLayer => ApproachCircle;
 
-        public class HitReceptor : Drawable, IKeyBindingHandler<OsuAction>
+        public class HitReceptor : CompositeDrawable, IKeyBindingHandler<OsuAction>
         {
             // IsHovered is used
             public override bool HandlePositionalInput => true;
@@ -185,6 +185,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
                 Anchor = Anchor.Centre;
                 Origin = Anchor.Centre;
+
+                CornerRadius = OsuHitObject.OBJECT_RADIUS;
+                CornerExponent = 2;
             }
 
             public bool OnPressed(OsuAction action)

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

@@ -6,13 +6,11 @@ using osuTK;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Skinning;
-using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
 using osu.Game.Skinning;
 
@@ -26,12 +24,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public readonly SliderBall Ball;
         public readonly SkinnableDrawable Body;
 
+        public override bool DisplayResult => false;
+
         private PlaySliderBody sliderBody => Body.Drawable as PlaySliderBody;
 
         private readonly Container<DrawableSliderHead> headContainer;
         private readonly Container<DrawableSliderTail> tailContainer;
         private readonly Container<DrawableSliderTick> tickContainer;
-        private readonly Container<DrawableRepeatPoint> repeatContainer;
+        private readonly Container<DrawableSliderRepeat> repeatContainer;
 
         private readonly Slider slider;
 
@@ -50,7 +50,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             {
                 Body = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderBody), _ => new DefaultSliderBody(), confineMode: ConfineMode.NoScaling),
                 tickContainer = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both },
-                repeatContainer = new Container<DrawableRepeatPoint> { RelativeSizeAxes = Axes.Both },
+                repeatContainer = new Container<DrawableSliderRepeat> { RelativeSizeAxes = Axes.Both },
                 Ball = new SliderBall(s, this)
                 {
                     GetInitialHitAction = () => HeadCircle.HitAction,
@@ -100,7 +100,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     tickContainer.Add(tick);
                     break;
 
-                case DrawableRepeatPoint repeat:
+                case DrawableSliderRepeat repeat:
                     repeatContainer.Add(repeat);
                     break;
             }
@@ -129,8 +129,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 case SliderTick tick:
                     return new DrawableSliderTick(tick) { Position = tick.Position - slider.Position };
 
-                case RepeatPoint repeat:
-                    return new DrawableRepeatPoint(repeat, this) { Position = repeat.Position - slider.Position };
+                case SliderRepeat repeat:
+                    return new DrawableSliderRepeat(repeat, this) { Position = repeat.Position - slider.Position };
             }
 
             return base.CreateNestedHitObject(hitObject);
@@ -193,22 +193,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (userTriggered || Time.Current < slider.EndTime)
                 return;
 
-            ApplyResult(r =>
-            {
-                var judgementsCount = NestedHitObjects.Count;
-                var judgementsHit = NestedHitObjects.Count(h => h.IsHit);
-
-                var hitFraction = (double)judgementsHit / judgementsCount;
-
-                if (hitFraction == 1 && HeadCircle.Result.Type == HitResult.Great)
-                    r.Type = HitResult.Great;
-                else if (hitFraction >= 0.5 && HeadCircle.Result.Type >= HitResult.Good)
-                    r.Type = HitResult.Good;
-                else if (hitFraction > 0)
-                    r.Type = HitResult.Meh;
-                else
-                    r.Type = HitResult.Miss;
-            });
+            ApplyResult(r => r.Type = r.Judgement.MaxResult);
         }
 
         protected override void UpdateStateTransforms(ArmedState state)

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

@@ -14,19 +14,19 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
-    public class DrawableRepeatPoint : DrawableOsuHitObject, ITrackSnaking
+    public class DrawableSliderRepeat : DrawableOsuHitObject, ITrackSnaking
     {
-        private readonly RepeatPoint repeatPoint;
+        private readonly SliderRepeat sliderRepeat;
         private readonly DrawableSlider drawableSlider;
 
         private double animDuration;
 
         private readonly Drawable scaleContainer;
 
-        public DrawableRepeatPoint(RepeatPoint repeatPoint, DrawableSlider drawableSlider)
-            : base(repeatPoint)
+        public DrawableSliderRepeat(SliderRepeat sliderRepeat, DrawableSlider drawableSlider)
+            : base(sliderRepeat)
         {
-            this.repeatPoint = repeatPoint;
+            this.sliderRepeat = sliderRepeat;
             this.drawableSlider = drawableSlider;
 
             Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
@@ -48,13 +48,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
-            if (repeatPoint.StartTime <= Time.Current)
+            if (sliderRepeat.StartTime <= Time.Current)
                 ApplyResult(r => r.Type = drawableSlider.Tracking.Value ? HitResult.Great : HitResult.Miss);
         }
 
         protected override void UpdateInitialTransforms()
         {
-            animDuration = Math.Min(300, repeatPoint.SpanDuration);
+            animDuration = Math.Min(300, sliderRepeat.SpanDuration);
 
             this.Animate(
                 d => d.FadeIn(animDuration),
@@ -87,7 +87,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public void UpdateSnakingPosition(Vector2 start, Vector2 end)
         {
-            bool isRepeatAtEnd = repeatPoint.RepeatIndex % 2 == 0;
+            bool isRepeatAtEnd = sliderRepeat.RepeatIndex % 2 == 0;
             List<Vector2> curve = ((PlaySliderBody)drawableSlider.Body.Drawable).CurrentCurve;
 
             Position = isRepeatAtEnd ? end : start;

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

@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (!userTriggered && timeOffset >= 0)
-                ApplyResult(r => r.Type = Tracking ? HitResult.Great : HitResult.Miss);
+                ApplyResult(r => r.Type = Tracking ? r.Judgement.MaxResult : HitResult.Miss);
         }
 
         private void updatePosition() => Position = HitObject.Position - slider.Position;

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

@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (timeOffset >= 0)
-                ApplyResult(r => r.Type = Tracking ? HitResult.Great : HitResult.Miss);
+                ApplyResult(r => r.Type = Tracking ? r.Judgement.MaxResult : HitResult.Miss);
         }
 
         protected override void UpdateInitialTransforms()

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

@@ -36,8 +36,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private readonly SpriteIcon symbol;
 
-        private readonly Color4 baseColour = OsuColour.FromHex(@"002c3c");
-        private readonly Color4 fillColour = OsuColour.FromHex(@"005b7c");
+        private readonly Color4 baseColour = Color4Extensions.FromHex(@"002c3c");
+        private readonly Color4 fillColour = Color4Extensions.FromHex(@"005b7c");
 
         private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
 

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBall.cs

@@ -16,16 +16,24 @@ using osu.Game.Rulesets.Osu.Skinning;
 using osuTK.Graphics;
 using osu.Game.Skinning;
 using osuTK;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class SliderBall : CircularContainer, ISliderProgress, IRequireHighFrequencyMousePosition
+    public class SliderBall : CircularContainer, ISliderProgress, IRequireHighFrequencyMousePosition, IHasAccentColour
     {
         public Func<OsuAction?> GetInitialHitAction;
 
+        public Color4 AccentColour
+        {
+            get => ball.Colour;
+            set => ball.Colour = value;
+        }
+
         private readonly Slider slider;
         private readonly Drawable followCircle;
         private readonly DrawableSlider drawableSlider;
+        private readonly CircularContainer ball;
 
         public SliderBall(Slider slider, DrawableSlider drawableSlider = null)
         {
@@ -47,7 +55,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     Alpha = 0,
                     Child = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderFollowCircle), _ => new DefaultFollowCircle()),
                 },
-                new CircularContainer
+                ball = new CircularContainer
                 {
                     Masking = true,
                     RelativeSizeAxes = Axes.Both,

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerDisc.cs

@@ -126,7 +126,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     .FadeTo(tracking_alpha, 250, Easing.OutQuint);
             }
 
-            this.RotateTo(currentRotation / 2, validAndTracking ? 500 : 1500, Easing.OutExpo);
+            Rotation = (float)Interpolation.Lerp(Rotation, currentRotation / 2, Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
         }
     }
 }

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

@@ -177,7 +177,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                         break;
 
                     case SliderEventType.Repeat:
-                        AddNested(new RepeatPoint
+                        AddNested(new SliderRepeat
                         {
                             RepeatIndex = e.SpanIndex,
                             SpanDuration = SpanDuration,
@@ -223,7 +223,7 @@ namespace osu.Game.Rulesets.Osu.Objects
             foreach (var tick in NestedHitObjects.OfType<SliderTick>())
                 tick.Samples = sampleList;
 
-            foreach (var repeat in NestedHitObjects.OfType<RepeatPoint>())
+            foreach (var repeat in NestedHitObjects.OfType<SliderRepeat>())
                 repeat.Samples = getNodeSamples(repeat.RepeatIndex + 1);
 
             if (HeadCircle != null)
@@ -233,7 +233,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         private IList<HitSampleInfo> getNodeSamples(int nodeIndex) =>
             nodeIndex < NodeSamples.Count ? NodeSamples[nodeIndex] : Samples;
 
-        public override Judgement CreateJudgement() => new OsuJudgement();
+        public override Judgement CreateJudgement() => new OsuIgnoreJudgement();
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
     }

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

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
-    public class RepeatPoint : OsuHitObject
+    public class SliderRepeat : OsuHitObject
     {
         public int RepeatIndex { get; set; }
         public double SpanDuration { get; set; }
@@ -28,8 +28,15 @@ namespace osu.Game.Rulesets.Osu.Objects
                 TimePreempt = Math.Min(SpanDuration * 2, TimePreempt);
         }
 
-        public override Judgement CreateJudgement() => new OsuJudgement();
-
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+
+        public override Judgement CreateJudgement() => new SliderRepeatJudgement();
+
+        public class SliderRepeatJudgement : OsuJudgement
+        {
+            public override bool IsBonus => true;
+
+            protected override int NumericResultFor(HitResult result) => result == MaxResult ? 30 : 0;
+        }
     }
 }

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

@@ -22,8 +22,8 @@ namespace osu.Game.Rulesets.Osu.Objects
             pathVersion.BindValueChanged(_ => Position = slider.EndPosition);
         }
 
-        public override Judgement CreateJudgement() => new IgnoreJudgement();
-
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+
+        public override Judgement CreateJudgement() => new SliderRepeat.SliderRepeatJudgement();
     }
 }

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

@@ -30,8 +30,15 @@ namespace osu.Game.Rulesets.Osu.Objects
             TimePreempt = (StartTime - SpanStartTime) / 2 + offset;
         }
 
-        public override Judgement CreateJudgement() => new OsuJudgement();
-
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+
+        public override Judgement CreateJudgement() => new SliderTickJudgement();
+
+        public class SliderTickJudgement : OsuJudgement
+        {
+            public override bool IsBonus => true;
+
+            protected override int NumericResultFor(HitResult result) => result == MaxResult ? 10 : 0;
+        }
     }
 }

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu
         /// </summary>
         public bool AllowUserCursorMovement { get; set; } = true;
 
-        protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+        protected override KeyBindingContainer<OsuAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
             => new OsuKeyBindingContainer(ruleset, variant, unique);
 
         public OsuInputManager(RulesetInfo ruleset)

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu
             new KeyBinding(InputKey.MouseRight, OsuAction.RightButton),
         };
 
-        public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
+        public override IEnumerable<Mod> ConvertFromLegacyMods(LegacyMods mods)
         {
             if (mods.HasFlag(LegacyMods.Nightcore))
                 yield return new OsuModNightcore();

osu.Game.Rulesets.Osu/Replays/OsuReplayFrame.cs

@@ -26,11 +26,23 @@ namespace osu.Game.Rulesets.Osu.Replays
             Actions.AddRange(actions);
         }
 
-        public void ConvertFrom(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
+        public void FromLegacy(LegacyReplayFrame currentFrame, IBeatmap beatmap, ReplayFrame lastFrame = null)
         {
             Position = currentFrame.Position;
             if (currentFrame.MouseLeft) Actions.Add(OsuAction.LeftButton);
             if (currentFrame.MouseRight) Actions.Add(OsuAction.RightButton);
         }
+
+        public LegacyReplayFrame ToLegacy(IBeatmap beatmap)
+        {
+            ReplayButtonState state = ReplayButtonState.None;
+
+            if (Actions.Contains(OsuAction.LeftButton))
+                state |= ReplayButtonState.Left1;
+            if (Actions.Contains(OsuAction.RightButton))
+                state |= ReplayButtonState.Right1;
+
+            return new LegacyReplayFrame(Time, Position.X, Position.Y, state);
+        }
     }
 }

osu.Game.Rulesets.Osu/Scoring/OsuHitWindows.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Rulesets.Osu.Scoring
             new DifficultyRange(HitResult.Great, 80, 50, 20),
             new DifficultyRange(HitResult.Good, 140, 100, 60),
             new DifficultyRange(HitResult.Meh, 200, 150, 100),
-            new DifficultyRange(HitResult.Miss, 200, 200, 200),
+            new DifficultyRange(HitResult.Miss, 400, 400, 400),
         };
 
         public override bool IsHitResultAllowed(HitResult result)

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

@@ -5,7 +5,6 @@ using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using osu.Framework.Allocation;
-using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Batches;
 using osu.Framework.Graphics.OpenGL.Vertices;
@@ -14,6 +13,7 @@ using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
+using osu.Framework.Layout;
 using osu.Framework.Timing;
 using osuTK;
 using osuTK.Graphics;
@@ -43,6 +43,8 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 // -1 signals that the part is unusable, and should not be drawn
                 parts[i].InvalidationID = -1;
             }
+
+            AddLayout(partSizeCache);
         }
 
         [BackgroundDependencyLoader]
@@ -72,20 +74,12 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             }
         }
 
-        private readonly Cached<Vector2> partSizeCache = new Cached<Vector2>();
+        private readonly LayoutValue<Vector2> partSizeCache = new LayoutValue<Vector2>(Invalidation.DrawInfo | Invalidation.RequiredParentSizeToFit | Invalidation.Presence);
 
         private Vector2 partSize => partSizeCache.IsValid
             ? partSizeCache.Value
             : (partSizeCache.Value = new Vector2(Texture.DisplayWidth, Texture.DisplayHeight) * DrawInfo.Matrix.ExtractScale().Xy);
 
-        public override bool Invalidate(Invalidation invalidation = Invalidation.All, Drawable source = null, bool shallPropagate = true)
-        {
-            if ((invalidation & (Invalidation.DrawInfo | Invalidation.RequiredParentSizeToFit | Invalidation.Presence)) > 0)
-                partSizeCache.Invalidate();
-
-            return base.Invalidate(invalidation, source, shallPropagate);
-        }
-
         /// <summary>
         /// The amount of time to fade the cursor trail pieces.
         /// </summary>
@@ -97,7 +91,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         {
             base.Update();
 
-            Invalidate(Invalidation.DrawNode, shallPropagate: false);
+            Invalidate(Invalidation.DrawNode);
 
             const int fade_clock_reset_threshold = 1000000;
 

osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs

@@ -58,6 +58,8 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new OsuFramedReplayInputHandler(replay);
 
+        protected override ReplayRecorder CreateReplayRecorder(Replay replay) => new OsuReplayRecorder(replay);
+
         public override double GameplayStartTime
         {
             get

osu.Game.Rulesets.Osu/UI/OsuReplayRecorder.cs

@@ -0,0 +1,23 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public class OsuReplayRecorder : ReplayRecorder<OsuAction>
+    {
+        public OsuReplayRecorder(Replay replay)
+            : base(replay)
+        {
+        }
+
+        protected override ReplayFrame HandleFrame(Vector2 mousePosition, List<OsuAction> actions, ReplayFrame previousFrame)
+            => new OsuReplayFrame(Time.Current, mousePosition, actions.ToArray());
+    }
+}

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

@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Mods;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Mods
+{
+    public class TestSceneTaikoModPerfect : ModPerfectTestScene
+    {
+        public TestSceneTaikoModPerfect()
+            : base(new TestTaikoRuleset(), new TaikoModPerfect())
+        {
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestHit(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Hit { StartTime = 1000, Type = HitType.Centre }), shouldMiss);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestDrumRoll(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new DrumRoll { StartTime = 1000, EndTime = 3000 }), shouldMiss);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestSwell(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Swell { StartTime = 1000, EndTime = 3000 }), shouldMiss);
+
+        private class TestTaikoRuleset : TaikoRuleset
+        {
+            public override HealthProcessor CreateHealthProcessor(double drainStartTime) => new TestTaikoHealthProcessor();
+
+            private class TestTaikoHealthProcessor : TaikoHealthProcessor
+            {
+                protected override void Reset(bool storeResults)
+                {
+                    base.Reset(storeResults);
+
+                    Health.Value = 1; // Don't care about the health condition (only the mod condition)
+                }
+            }
+        }
+    }
+}

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

@@ -27,8 +27,8 @@ namespace osu.Game.Rulesets.Taiko.Tests
             {
                 StartTime = hitObject.StartTime,
                 EndTime = hitObject.GetEndTime(),
-                IsRim = hitObject is RimHit,
-                IsCentre = hitObject is CentreHit,
+                IsRim = (hitObject as Hit)?.Type == HitType.Rim,
+                IsCentre = (hitObject as Hit)?.Type == HitType.Centre,
                 IsDrumRoll = hitObject is DrumRoll,
                 IsSwell = hitObject is Swell,
                 IsStrong = ((TaikoHitObject)hitObject).IsStrong

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

@@ -1,23 +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 System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
-using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
     public class TestSceneSwellJudgements : PlayerTestScene
     {
-        protected new TestPlayer Player => (TestPlayer)base.Player;
-
         public TestSceneSwellJudgements()
             : base(new TaikoRuleset())
         {
@@ -49,25 +42,5 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             return beatmap;
         }
-
-        protected override Player CreatePlayer(Ruleset ruleset) => new TestPlayer();
-
-        protected class TestPlayer : Player
-        {
-            public readonly List<JudgementResult> Results = new List<JudgementResult>();
-
-            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
-
-            public TestPlayer()
-                : base(false, false)
-            {
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                ScoreProcessor.NewJudgement += r => Results.Add(r);
-            }
-        }
     }
 }

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

@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             WorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
             {
-                HitObjects = new List<HitObject> { new CentreHit() },
+                HitObjects = new List<HitObject> { new Hit { Type = HitType.Centre } },
                 BeatmapInfo = new BeatmapInfo
                 {
                     BaseDifficulty = new BeatmapDifficulty(),

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

@@ -4,11 +4,9 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Beatmaps;
 using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
-using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Taiko.Tests
@@ -22,10 +20,10 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
         protected override bool AllowFail => true;
 
-        protected override Player CreatePlayer(Ruleset ruleset)
+        protected override TestPlayer CreatePlayer(Ruleset ruleset)
         {
             SelectedMods.Value = SelectedMods.Value.Concat(new[] { new TaikoModSuddenDeath() }).ToArray();
-            return new ScoreAccessiblePlayer();
+            return base.CreatePlayer(ruleset);
         }
 
         protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) =>
@@ -49,20 +47,10 @@ namespace osu.Game.Rulesets.Taiko.Tests
             AddStep("Setup judgements", () =>
             {
                 judged = false;
-                ((ScoreAccessiblePlayer)Player).ScoreProcessor.NewJudgement += b => judged = true;
+                Player.ScoreProcessor.NewJudgement += b => judged = true;
             });
             AddUntilStep("swell judged", () => judged);
             AddAssert("not failed", () => !Player.HasFailed);
         }
-
-        private class ScoreAccessiblePlayer : TestPlayer
-        {
-            public ScoreAccessiblePlayer()
-                : base(false, false)
-            {
-            }
-
-            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
-        }
     }
 }

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

@@ -124,24 +124,13 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                             bool isRim = currentSamples.Any(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE);
                             strong = currentSamples.Any(s => s.Name == HitSampleInfo.HIT_FINISH);
 
-                            if (isRim)
+                            yield return new Hit
                             {
-                                yield return new RimHit
-                                {
-                                    StartTime = j,
-                                    Samples = currentSamples,
-                                    IsStrong = strong
-                                };
-                            }
-                            else
-                            {
-                                yield return new CentreHit
-                                {
-                                    StartTime = j,
-                                    Samples = currentSamples,
-                                    IsStrong = strong
-                                };
-                            }
+                                StartTime = j,
+                                Type = isRim ? HitType.Rim : HitType.Centre,
+                                Samples = currentSamples,
+                                IsStrong = strong
+                            };
 
                             i = (i + 1) % allSamples.Count;
                         }
@@ -180,24 +169,13 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 {
                     bool isRim = samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE);
 
-                    if (isRim)
+                    yield return new Hit
                     {
-                        yield return new RimHit
-                        {
-                            StartTime = obj.StartTime,
-                            Samples = obj.Samples,
-                            IsStrong = strong
-                        };
-                    }
-                    else
-                    {
-                        yield return new CentreHit
-                        {
-                            StartTime = obj.StartTime,
-                            Samples = obj.Samples,
-                            IsStrong = strong
-                        };
-                    }
+                        StartTime = obj.StartTime,
+                        Type = isRim ? HitType.Rim : HitType.Centre,
+                        Samples = obj.Samples,
+                        IsStrong = strong
+                    };
 
                     break;
                 }