Merge remote-tracking branch 'refs/remotes/ppy/master' into beatmap-video

appveyor.yml

@@ -2,7 +2,5 @@ clone_depth: 1
 version: '{branch}-{build}'
 image: Previous Visual Studio 2017
 test: off
-install:
-  - cmd: git submodule update --init --recursive --depth=5
 build_script:
   - cmd: PowerShell -Version 2.0 .\build.ps1

appveyor_deploy.yml

@@ -0,0 +1,10 @@
+clone_depth: 1
+version: '{build}'
+image: Previous Visual Studio 2017
+test: off
+skip_non_tags: true
+build_script:
+  - cmd: PowerShell -Version 2.0 .\build.ps1
+deploy:
+  - provider: Environment
+    name: nuget

osu.Android.props

@@ -1,5 +1,7 @@
 <Project>
   <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <OutputPath>bin\$(Configuration)</OutputPath>
     <WarningLevel>4</WarningLevel>
     <SchemaVersion>2.0</SchemaVersion>
@@ -35,7 +37,7 @@
     <DebugType>None</DebugType>
     <Optimize>True</Optimize>
     <ErrorReport>prompt</ErrorReport>
-	<EnableLLVM>true</EnableLLVM>
+    <EnableLLVM>true</EnableLLVM>
     <AndroidManagedSymbols>false</AndroidManagedSymbols>
     <AndroidLinkMode>SdkOnly</AndroidLinkMode>
     <AndroidUseSharedRuntime>False</AndroidUseSharedRuntime>
@@ -60,7 +62,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.830.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.913.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.830.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.911.0" />
   </ItemGroup>
 </Project>

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

@@ -14,6 +14,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osuTK.Graphics;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
 
@@ -82,11 +83,11 @@ namespace osu.Game.Rulesets.Catch.Tests
                 remove { }
             }
 
-            public Drawable GetDrawableComponent(string componentName)
+            public Drawable GetDrawableComponent(ISkinComponent component)
             {
-                switch (componentName)
+                switch (component.LookupName)
                 {
-                    case "Play/Catch/fruit-catcher-idle":
+                    case "Gameplay/catch/fruit-catcher-idle":
                         return new CatcherCustomSkin();
                 }
 
@@ -99,8 +100,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             public Texture GetTexture(string componentName) =>
                 throw new NotImplementedException();
 
-            public TValue GetValue<TConfiguration, TValue>(Func<TConfiguration, TValue> query) where TConfiguration : SkinConfiguration =>
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
-                throw new NotImplementedException();
         }
     }
 }

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -27,6 +27,8 @@ namespace osu.Game.Rulesets.Catch
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new CatchBeatmapConverter(beatmap);
         public override IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => new CatchBeatmapProcessor(beatmap);
 
+        public const string SHORT_NAME = "fruits";
+
         public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
         {
             new KeyBinding(InputKey.Z, CatchAction.MoveLeft),
@@ -117,7 +119,7 @@ namespace osu.Game.Rulesets.Catch
 
         public override string Description => "osu!catch";
 
-        public override string ShortName => "fruits";
+        public override string ShortName => SHORT_NAME;
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetCatch };
 

osu.Game.Rulesets.Catch/CatchSkinComponent.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Catch
+{
+    public class CatchSkinComponent : GameplaySkinComponent<CatchSkinComponents>
+    {
+        public CatchSkinComponent(CatchSkinComponents component)
+            : base(component)
+        {
+        }
+
+        protected override string RulesetPrefix => "catch"; // todo: use CatchRuleset.SHORT_NAME;
+
+        protected override string ComponentName => Component.ToString().ToLower();
+    }
+}

osu.Game.Rulesets.Catch/CatchSkinComponents.cs

@@ -0,0 +1,9 @@
+// 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
+{
+    public enum CatchSkinComponents
+    {
+    }
+}

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

@@ -6,6 +6,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {

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

@@ -71,11 +71,11 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                 switch (state)
                 {
                     case ArmedState.Miss:
-                        this.FadeOut(250).RotateTo(Rotation * 2, 250, Easing.Out).Expire();
+                        this.FadeOut(250).RotateTo(Rotation * 2, 250, Easing.Out);
                         break;
 
                     case ArmedState.Hit:
-                        this.FadeOut().Expire();
+                        this.FadeOut();
                         break;
                 }
             }

osu.Game.Rulesets.Catch/Scoring/CatchHitWindows.cs

@@ -1,10 +1,9 @@
 // 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.Objects;
 using osu.Game.Rulesets.Scoring;
 
-namespace osu.Game.Rulesets.Catch.Objects
+namespace osu.Game.Rulesets.Catch.Scoring
 {
     public class CatchHitWindows : HitWindows
     {

osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs

@@ -4,7 +4,6 @@
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            InternalChild = new SkinnableSprite(@"Play/Catch/fruit-catcher-idle")
+            InternalChild = new SkinnableSprite("Gameplay/catch/fruit-catcher-idle")
             {
                 RelativeSizeAxes = Axes.Both,
                 Anchor = Anchor.TopCentre,

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

@@ -3,6 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Replays;
@@ -12,6 +13,7 @@ using osu.Game.Tests.Visual;
 namespace osu.Game.Rulesets.Mania.Tests
 {
     [TestFixture]
+    [HeadlessTest]
     public class TestSceneAutoGeneration : OsuTestScene
     {
         [Test]

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

@@ -0,0 +1,62 @@
+// 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 NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class TestSceneHitExplosion : OsuTestScene
+    {
+        private ScrollingTestContainer scrolling;
+
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(DrawableNote),
+            typeof(DrawableManiaHitObject),
+        };
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Child = scrolling = new ScrollingTestContainer(ScrollingDirection.Down)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativePositionAxes = Axes.Y,
+                Y = -0.25f,
+                Size = new Vector2(Column.COLUMN_WIDTH, NotePiece.NOTE_HEIGHT),
+            };
+
+            int runcount = 0;
+
+            AddRepeatStep("explode", () =>
+            {
+                runcount++;
+
+                if (runcount % 15 > 12)
+                    return;
+
+                scrolling.AddRange(new Drawable[]
+                {
+                    new HitExplosion((runcount / 15) % 2 == 0 ? new Color4(94, 0, 57, 255) : new Color4(6, 84, 0, 255), runcount % 6 != 0)
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                });
+            }, 100);
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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;
@@ -11,6 +11,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
@@ -40,6 +41,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
             Child = new FillFlowContainer
             {
+                Clock = new FramedClock(new ManualClock()),
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 AutoSizeAxes = Axes.Both,
@@ -62,7 +64,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
         private Drawable createNoteDisplay(ScrollingDirection direction, int identifier, out DrawableNote hitObject)
         {
-            var note = new Note { StartTime = 999999999 };
+            var note = new Note { StartTime = 0 };
             note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
             return new ScrollingTestContainer(direction)
@@ -77,7 +79,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
         private Drawable createHoldNoteDisplay(ScrollingDirection direction, int identifier, out DrawableHoldNote hitObject)
         {
-            var note = new HoldNote { StartTime = 999999999, Duration = 5000 };
+            var note = new HoldNote { StartTime = 0, Duration = 5000 };
             note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
             return new ScrollingTestContainer(direction)
@@ -133,7 +135,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                                     Origin = Anchor.TopCentre,
                                     RelativeSizeAxes = Axes.Both,
                                     Width = 1.25f,
-                                    Colour = Color4.Black.Opacity(0.5f)
+                                    Colour = Color4.Green.Opacity(0.5f)
                                 },
                                 content = new Container { RelativeSizeAxes = Axes.Both }
                             }

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

@@ -15,6 +15,7 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -114,8 +115,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 var obj = new BarLine
                 {
                     StartTime = Time.Current + 2000,
-                    ControlPoint = new TimingControlPoint(),
+                    Major = major,
-                    BeatIndex = major ? 0 : 1
                 };
 
                 obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());

osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
         {
             base.InitialiseDefaults();
 
-            Set(ManiaRulesetSetting.ScrollTime, 2250.0, 50.0, 10000.0, 50.0);
+            Set(ManiaRulesetSetting.ScrollTime, 1500.0, 50.0, 5000.0, 50.0);
             Set(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
         }
 

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs

@@ -11,7 +11,9 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mania.Difficulty.Skills;
 using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Difficulty
 {
@@ -32,12 +34,15 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             if (beatmap.HitObjects.Count == 0)
                 return new ManiaDifficultyAttributes { Mods = mods, Skills = skills };
 
+            HitWindows hitWindows = new ManiaHitWindows();
+            hitWindows.SetDifficulty(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
+
             return new ManiaDifficultyAttributes
             {
                 StarRating = difficultyValue(skills) * star_scaling_factor,
                 Mods = mods,
                 // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be removed in the future
-                GreatHitWindow = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / clockRate,
+                GreatHitWindow = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate,
                 Skills = skills
             };
         }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -35,6 +35,8 @@ namespace osu.Game.Rulesets.Mania
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap);
         public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new ManiaPerformanceCalculator(this, beatmap, score);
 
+        public const string SHORT_NAME = "mania";
+
         public override HitObjectComposer CreateHitObjectComposer() => new ManiaHitObjectComposer(this);
 
         public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
@@ -163,7 +165,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override string Description => "osu!mania";
 
-        public override string ShortName => "mania";
+        public override string ShortName => SHORT_NAME;
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetMania };
 

osu.Game.Rulesets.Mania/ManiaSkinComponent.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class ManiaSkinComponent : GameplaySkinComponent<ManiaSkinComponents>
+    {
+        public ManiaSkinComponent(ManiaSkinComponents component)
+            : base(component)
+        {
+        }
+
+        protected override string RulesetPrefix => ManiaRuleset.SHORT_NAME;
+
+        protected override string ComponentName => Component.ToString().ToLower();
+    }
+}

osu.Game.Rulesets.Mania/ManiaSkinComponents.cs

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

osu.Game.Rulesets.Mania/Objects/BarLine.cs

@@ -1,21 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Game.Beatmaps.ControlPoints;
-
-namespace osu.Game.Rulesets.Mania.Objects
-{
-    public class BarLine : ManiaHitObject
-    {
-        /// <summary>
-        /// The control point which this bar line is part of.
-        /// </summary>
-        public TimingControlPoint ControlPoint;
-
-        /// <summary>
-        /// The index of the beat which this bar line represents within the control point.
-        /// This is a "major" bar line if <see cref="BeatIndex"/> % <see cref="TimingControlPoint.TimeSignature"/> == 0.
-        /// </summary>
-        public int BeatIndex;
-    }
-}

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

@@ -4,6 +4,7 @@
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osuTK.Graphics;
 
@@ -13,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// Visualises a <see cref="BarLine"/>. Although this derives DrawableManiaHitObject,
     /// this does not handle input/sound like a normal hit object.
     /// </summary>
-    public class DrawableBarLine : DrawableManiaHitObject<BarLine>
+    public class DrawableBarLine : DrawableHitObject<BarLine>
     {
         /// <summary>
         /// Height of major bar line triangles.
@@ -40,9 +41,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 Colour = new Color4(255, 204, 33, 255),
             });
 
-            bool isMajor = barLine.BeatIndex % (int)barLine.ControlPoint.TimeSignature == 0;
+            if (barLine.Major)
-
-            if (isMajor)
             {
                 AddInternal(new EquilateralTriangle
                 {
@@ -65,10 +64,14 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 });
             }
 
-            if (!isMajor && barLine.BeatIndex % 2 == 1)
+            if (!barLine.Major)
                 Alpha = 0.2f;
         }
 
+        protected override void UpdateInitialTransforms()
+        {
+        }
+
         protected override void UpdateStateTransforms(ArmedState state)
         {
         }

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
@@ -209,6 +210,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
             protected override void CheckForResult(bool userTriggered, double timeOffset)
             {
+                Debug.Assert(HitObject.HitWindows != null);
+
                 // Factor in the release lenience
                 timeOffset /= release_window_lenience;
 

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

@@ -51,11 +51,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             switch (state)
             {
                 case ArmedState.Miss:
-                    this.FadeOut(150, Easing.In).Expire();
+                    this.FadeOut(150, Easing.In);
                     break;
 
                 case ArmedState.Hit:
-                    this.FadeOut(150, Easing.OutQuint).Expire();
+                    this.FadeOut(150, Easing.OutQuint);
                     break;
             }
         }

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Diagnostics;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -17,6 +18,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// </summary>
     public class DrawableNote : DrawableManiaHitObject<Note>, IKeyBindingHandler<ManiaAction>
     {
+        public const float CORNER_RADIUS = NotePiece.NOTE_HEIGHT / 2;
+
         private readonly NotePiece headPiece;
 
         public DrawableNote(Note hitObject)
@@ -37,7 +40,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 EdgeEffect = new EdgeEffectParameters
                 {
                     Type = EdgeEffectType.Glow,
-                    Colour = colour.NewValue.Lighten(1f).Opacity(0.6f),
+                    Colour = colour.NewValue.Lighten(1f).Opacity(0.2f),
                     Radius = 10,
                 };
             }, true);
@@ -52,6 +55,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
+            Debug.Assert(HitObject.HitWindows != null);
+
             if (!userTriggered)
             {
                 if (!HitObject.HitWindows.CanBeHit(timeOffset))

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

@@ -18,8 +18,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
     /// </summary>
     internal class NotePiece : Container, IHasAccentColour
     {
-        public const float NOTE_HEIGHT = 10;
+        public const float NOTE_HEIGHT = 12;
-        private const float head_colour_height = 6;
 
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
@@ -39,8 +38,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
                 colouredBox = new Box
                 {
                     RelativeSizeAxes = Axes.X,
-                    Height = head_colour_height,
+                    Height = NOTE_HEIGHT / 2,
-                    Alpha = 0.2f
+                    Alpha = 0.1f
                 }
             };
         }

osu.Game.Rulesets.Mania/Objects/HoldNote.cs

@@ -6,6 +6,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {
@@ -99,5 +100,7 @@ namespace osu.Game.Rulesets.Mania.Objects
         }
 
         public override Judgement CreateJudgement() => new HoldNoteJudgement();
+
+        protected override HitWindows CreateHitWindows() => null;
     }
 }

osu.Game.Rulesets.Mania/Objects/HoldNoteTick.cs

@@ -3,6 +3,7 @@
 
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {
@@ -12,5 +13,7 @@ namespace osu.Game.Rulesets.Mania.Objects
     public class HoldNoteTick : ManiaHitObject
     {
         public override Judgement CreateJudgement() => new HoldNoteTickJudgement();
+
+        protected override HitWindows CreateHitWindows() => null;
     }
 }

osu.Game.Rulesets.Mania/Objects/ManiaHitObject.cs

@@ -3,7 +3,9 @@
 
 using osu.Framework.Bindables;
 using osu.Game.Rulesets.Mania.Objects.Types;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {

osu.Game.Rulesets.Mania/Objects/ManiaHitWindows.cs

@@ -1,35 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Mania.Objects
-{
-    public class ManiaHitWindows : HitWindows
-    {
-        private static readonly IReadOnlyDictionary<HitResult, (double od0, double od5, double od10)> base_ranges = new Dictionary<HitResult, (double, double, double)>
-        {
-            { HitResult.Perfect, (44.8, 38.8, 27.8) },
-            { HitResult.Great, (128, 98, 68) },
-            { HitResult.Good, (194, 164, 134) },
-            { HitResult.Ok, (254, 224, 194) },
-            { HitResult.Meh, (302, 272, 242) },
-            { HitResult.Miss, (376, 346, 316) },
-        };
-
-        public override bool IsHitResultAllowed(HitResult result) => true;
-
-        public override void SetDifficulty(double difficulty)
-        {
-            Perfect = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Perfect]);
-            Great = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Great]);
-            Good = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Good]);
-            Ok = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Ok]);
-            Meh = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Meh]);
-            Miss = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Miss]);
-        }
-    }
-}

osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs

@@ -1,9 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-namespace osu.Game.Rulesets.Taiko.Objects
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Mania.Scoring
 {
-    public class BarLine : TaikoHitObject
+    public class ManiaHitWindows : HitWindows
     {
     }
 }

osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs

@@ -4,7 +4,6 @@
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 

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

@@ -1,4 +1,4 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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;
@@ -11,6 +11,8 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
@@ -19,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.UI
 {
     public class Column : ScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
     {
-        private const float column_width = 45;
+        public const float COLUMN_WIDTH = 80;
         private const float special_column_width = 70;
 
         /// <summary>
@@ -41,10 +43,7 @@ namespace osu.Game.Rulesets.Mania.UI
             Index = index;
 
             RelativeSizeAxes = Axes.Y;
-            Width = column_width;
+            Width = COLUMN_WIDTH;
-
-            Masking = true;
-            CornerRadius = 5;
 
             background = new ColumnBackground { RelativeSizeAxes = Axes.Both };
 
@@ -67,7 +66,7 @@ namespace osu.Game.Rulesets.Mania.UI
                         explosionContainer = new Container
                         {
                             Name = "Hit explosions",
-                            RelativeSizeAxes = Axes.Both
+                            RelativeSizeAxes = Axes.Both,
                         }
                     }
                 },
@@ -90,6 +89,12 @@ namespace osu.Game.Rulesets.Mania.UI
                     Bottom = dir.NewValue == ScrollingDirection.Down ? ManiaStage.HIT_TARGET_POSITION : 0,
                 };
 
+                explosionContainer.Padding = new MarginPadding
+                {
+                    Top = dir.NewValue == ScrollingDirection.Up ? NotePiece.NOTE_HEIGHT / 2 : 0,
+                    Bottom = dir.NewValue == ScrollingDirection.Down ? NotePiece.NOTE_HEIGHT / 2 : 0
+                };
+
                 keyArea.Anchor = keyArea.Origin = dir.NewValue == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
             }, true);
         }
@@ -108,7 +113,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
                 isSpecial = value;
 
-                Width = isSpecial ? special_column_width : column_width;
+                Width = isSpecial ? special_column_width : COLUMN_WIDTH;
             }
         }
 
@@ -163,9 +168,10 @@ namespace osu.Game.Rulesets.Mania.UI
             if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 
-            explosionContainer.Add(new HitExplosion(judgedObject)
+            explosionContainer.Add(new HitExplosion(judgedObject.AccentColour.Value, judgedObject is DrawableHoldNoteTick)
             {
-                Anchor = Direction.Value == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre
+                Anchor = Direction.Value == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre,
+                Origin = Anchor.Centre
             });
         }
 

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

@@ -35,7 +35,6 @@ namespace osu.Game.Rulesets.Mania.UI.Components
                 {
                     Name = "Background",
                     RelativeSizeAxes = Axes.Both,
-                    Alpha = 0.3f
                 },
                 backgroundOverlay = new Box
                 {
@@ -82,7 +81,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             if (!IsLoaded)
                 return;
 
-            background.Colour = AccentColour;
+            background.Colour = AccentColour.Darken(5);
 
             var brightPoint = AccentColour.Opacity(0.6f);
             var dimPoint = AccentColour.Opacity(0);

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

@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK.Graphics;
@@ -17,7 +18,6 @@ namespace osu.Game.Rulesets.Mania.UI.Components
 {
     public class ColumnHitObjectArea : CompositeDrawable, IHasAccentColour
     {
-        private const float hit_target_height = 10;
         private const float hit_target_bar_height = 2;
 
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
@@ -32,7 +32,8 @@ namespace osu.Game.Rulesets.Mania.UI.Components
                 hitTargetBar = new Box
                 {
                     RelativeSizeAxes = Axes.X,
-                    Height = hit_target_height,
+                    Height = NotePiece.NOTE_HEIGHT,
+                    Alpha = 0.6f,
                     Colour = Color4.Black
                 },
                 hitTargetLine = new Container

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

@@ -2,14 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Input;
-using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Input.Handlers;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -19,8 +16,8 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -45,33 +42,7 @@ namespace osu.Game.Rulesets.Mania.UI
         public DrawableManiaRuleset(Ruleset ruleset, IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
             : base(ruleset, beatmap, mods)
         {
-            // Generate the bar lines
+            BarLines = new BarLineGenerator(Beatmap).BarLines;
-            double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
-
-            var timingPoints = Beatmap.ControlPointInfo.TimingPoints;
-            var barLines = new List<BarLine>();
-
-            for (int i = 0; i < timingPoints.Count; i++)
-            {
-                TimingControlPoint point = timingPoints[i];
-
-                // Stop on the beat before the next timing point, or if there is no next timing point stop slightly past the last object
-                double endTime = i < timingPoints.Count - 1 ? timingPoints[i + 1].Time - point.BeatLength : lastObjectTime + point.BeatLength * (int)point.TimeSignature;
-
-                int index = 0;
-
-                for (double t = timingPoints[i].Time; Precision.DefinitelyBigger(endTime, t); t += point.BeatLength, index++)
-                {
-                    barLines.Add(new BarLine
-                    {
-                        StartTime = t,
-                        ControlPoint = point,
-                        BeatIndex = index
-                    });
-                }
-            }
-
-            BarLines = barLines;
         }
 
         [BackgroundDependencyLoader]

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

@@ -1,16 +1,14 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using 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.MathUtils;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
-using osu.Game.Rulesets.Objects.Drawables;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -18,51 +16,112 @@ namespace osu.Game.Rulesets.Mania.UI
     {
         public override bool RemoveWhenNotAlive => true;
 
-        private readonly CircularContainer circle;
+        private readonly CircularContainer largeFaint;
+        private readonly CircularContainer mainGlow1;
 
-        public HitExplosion(DrawableHitObject judgedObject)
+        public HitExplosion(Color4 objectColour, bool isSmall = false)
         {
-            bool isTick = judgedObject is DrawableHoldNoteTick;
-
-            Origin = Anchor.Centre;
-
             RelativeSizeAxes = Axes.X;
-            Y = NotePiece.NOTE_HEIGHT / 2;
             Height = NotePiece.NOTE_HEIGHT;
 
             // scale roughly in-line with visual appearance of notes
-            Scale = new Vector2(isTick ? 0.4f : 0.8f);
+            Scale = new Vector2(1f, 0.6f);
 
-            InternalChild = circle = new CircularContainer
+            if (isSmall)
+                Scale *= 0.5f;
+
+            const float angle_variangle = 15; // should be less than 45
+
+            const float roundness = 80;
+
+            const float initial_height = 10;
+
+            var colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1);
+
+            InternalChildren = new Drawable[]
             {
-                Anchor = Anchor.Centre,
+                largeFaint = new CircularContainer
-                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.1f),
-                EdgeEffect = new EdgeEffectParameters
                 {
-                    Type = EdgeEffectType.Glow,
+                    Anchor = Anchor.Centre,
-                    Colour = Interpolation.ValueAt(0.1f, judgedObject.AccentColour.Value, Color4.White, 0, 1),
+                    Origin = Anchor.Centre,
-                    Radius = 100,
-                },
-                Child = new Box
-                {
-                    Alpha = 0,
                     RelativeSizeAxes = Axes.Both,
-                    AlwaysPresent = true
+                    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,
+                    },
+                },
+                mainGlow1 = 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()
         {
+            const double duration = 200;
+
             base.LoadComplete();
 
-            circle.ResizeTo(circle.Size * new Vector2(4, 20), 1000, Easing.OutQuint);
+            largeFaint
-            this.FadeIn(16).Then().FadeOut(500, Easing.OutQuint);
+                .ResizeTo(largeFaint.Size * new Vector2(5, 1), duration, Easing.OutQuint)
+                .FadeOut(duration * 2);
 
+            mainGlow1.ScaleTo(1.4f, duration, Easing.OutQuint);
+
+            this.FadeOut(duration, Easing.Out);
             Expire(true);
         }
     }

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

@@ -8,6 +8,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;

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

@@ -12,6 +12,7 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;

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

@@ -26,12 +26,12 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        private void load(AudioManager audio, SkinManager skinManager)
         {
             var dllStore = new DllResourceStore("osu.Game.Rulesets.Osu.Tests.dll");
 
             metricsSkin = new TestLegacySkin(new SkinInfo(), new NamespacedResourceStore<byte[]>(dllStore, "Resources/metrics_skin"), audio, true);
-            defaultSkin = new TestLegacySkin(new SkinInfo(), new NamespacedResourceStore<byte[]>(dllStore, "Resources/default_skin"), audio, false);
+            defaultSkin = skinManager.GetSkin(DefaultLegacySkin.Info);
             specialSkin = new TestLegacySkin(new SkinInfo(), new NamespacedResourceStore<byte[]>(dllStore, "Resources/special_skin"), audio, true);
         }
 

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

@@ -0,0 +1,128 @@
+// 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.Allocation;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Testing.Input;
+using osu.Game.Audio;
+using osu.Game.Rulesets.Osu.Skinning;
+using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneCursorTrail : OsuTestScene
+    {
+        [Test]
+        public void TestSmoothCursorTrail()
+        {
+            Container scalingContainer = null;
+
+            createTest(() => scalingContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = new CursorTrail()
+            });
+
+            AddStep("set large scale", () => scalingContainer.Scale = new Vector2(10));
+        }
+
+        [Test]
+        public void TestLegacySmoothCursorTrail()
+        {
+            createTest(() => new LegacySkinContainer(false)
+            {
+                Child = new LegacyCursorTrail()
+            });
+        }
+
+        [Test]
+        public void TestLegacyDisjointCursorTrail()
+        {
+            createTest(() => new LegacySkinContainer(true)
+            {
+                Child = new LegacyCursorTrail()
+            });
+        }
+
+        private void createTest(Func<Drawable> createContent) => AddStep("create trail", () =>
+        {
+            Clear();
+
+            Add(new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.8f),
+                Child = new MovingCursorInputManager { Child = createContent?.Invoke() }
+            });
+        });
+
+        [Cached(typeof(ISkinSource))]
+        private class LegacySkinContainer : Container, ISkinSource
+        {
+            private readonly bool disjoint;
+
+            public LegacySkinContainer(bool disjoint)
+            {
+                this.disjoint = disjoint;
+
+                RelativeSizeAxes = Axes.Both;
+            }
+
+            public Drawable GetDrawableComponent(ISkinComponent component) => throw new NotImplementedException();
+
+            public Texture GetTexture(string componentName)
+            {
+                switch (componentName)
+                {
+                    case "cursortrail":
+                        var tex = new Texture(Texture.WhitePixel.TextureGL);
+
+                        if (disjoint)
+                            tex.ScaleAdjust = 1 / 25f;
+                        return tex;
+
+                    case "cursormiddle":
+                        return disjoint ? null : Texture.WhitePixel;
+                }
+
+                return null;
+            }
+
+            public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
+
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
+
+            public event Action SourceChanged;
+        }
+
+        private class MovingCursorInputManager : ManualInputManager
+        {
+            public MovingCursorInputManager()
+            {
+                UseParentInput = false;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                const double spin_duration = 1000;
+                double currentTime = Time.Current;
+
+                double angle = (currentTime % spin_duration) / spin_duration * 2 * Math.PI;
+                Vector2 rPos = new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle));
+
+                MoveMouseTo(ToScreenSpace(DrawSize / 2 + DrawSize / 3 * rPos));
+            }
+        }
+    }
+}

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

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 
@@ -24,7 +25,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             foreach (HitResult result in Enum.GetValues(typeof(HitResult)).OfType<HitResult>().Skip(1))
                 AddStep("Show " + result.GetDescription(), () => SetContents(() =>
-                    new DrawableOsuJudgement(new JudgementResult(null) { Type = result }, null)
+                    new DrawableOsuJudgement(new JudgementResult(new HitObject(), new Judgement()) { Type = result }, null)
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,

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

@@ -6,23 +6,68 @@ using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Testing.Input;
 using osu.Game.Rulesets.Osu.UI.Cursor;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
     public class TestSceneGameplayCursor : SkinnableTestScene
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(CursorTrail) };
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(OsuCursorContainer),
+            typeof(CursorTrail)
+        };
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            SetContents(() => new OsuCursorContainer
+            SetContents(() => new MovingCursorInputManager
             {
-                RelativeSizeAxes = Axes.Both,
+                Child = new ClickingCursorContainer
-                Masking = true,
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                }
             });
         }
+
+        private class ClickingCursorContainer : OsuCursorContainer
+        {
+            protected override void Update()
+            {
+                base.Update();
+
+                double currentTime = Time.Current;
+
+                if (((int)(currentTime / 1000)) % 2 == 0)
+                    OnPressed(OsuAction.LeftButton);
+                else
+                    OnReleased(OsuAction.LeftButton);
+            }
+        }
+
+        private class MovingCursorInputManager : ManualInputManager
+        {
+            public MovingCursorInputManager()
+            {
+                UseParentInput = false;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                const double spin_duration = 5000;
+                double currentTime = Time.Current;
+
+                double angle = (currentTime % spin_duration) / spin_duration * 2 * Math.PI;
+                Vector2 rPos = new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle));
+
+                MoveMouseTo(ToScreenSpace(DrawSize / 2 + DrawSize / 3 * rPos));
+            }
+        }
     }
 }

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Diagnostics;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
@@ -13,8 +14,10 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var drawableHitObject = base.CreateDrawableHitCircle(circle, auto);
 
-            Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(),
+            Debug.Assert(drawableHitObject.HitObject.HitWindows != null);
-                drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.HalfWindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current);
+
+            double delay = drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.WindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current;
+            Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(), delay);
 
             return drawableHitObject;
         }

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

@@ -7,6 +7,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
@@ -119,7 +120,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 this.identifier = identifier;
             }
 
-            public Drawable GetDrawableComponent(string componentName)
+            public Drawable GetDrawableComponent(ISkinComponent component)
             {
                 if (!enabled) return null;
 
@@ -135,6 +136,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             public SampleChannel GetSample(ISampleInfo sampleInfo) => null;
 
             public TValue GetValue<TConfiguration, TValue>(Func<TConfiguration, TValue> query) where TConfiguration : SkinConfiguration => default;
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => null;
 
             public event Action SourceChanged;
 

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs

@@ -13,6 +13,8 @@ using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
@@ -34,8 +36,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
             double starRating = aimRating + speedRating + Math.Abs(aimRating - speedRating) / 2;
 
+            HitWindows hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
+
             // Todo: These int casts are temporary to achieve 1:1 results with osu!stable, and should be removed in the future
-            double hitWindowGreat = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / clockRate;
+            double hitWindowGreat = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate;
             double preempt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / clockRate;
 
             int maxCombo = beatmap.HitObjects.Count;

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Osu.Judgements
 {
@@ -9,8 +10,8 @@ namespace osu.Game.Rulesets.Osu.Judgements
     {
         public ComboResult ComboType;
 
-        public OsuJudgementResult(Judgement judgement)
+        public OsuJudgementResult(HitObject hitObject, Judgement judgement)
-            : base(judgement)
+            : base(hitObject, judgement)
         {
         }
     }

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

@@ -188,7 +188,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 [BackgroundDependencyLoader]
                 private void load(TextureStore textures)
                 {
-                    Texture = textures.Get("Play/osu/blinds-panel");
+                    Texture = textures.Get("Gameplay/osu/blinds-panel");
                 }
             }
         }

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Types;
@@ -38,7 +39,12 @@ namespace osu.Game.Rulesets.Osu.Mods
                 if ((osuHit.HitObject is IHasEndTime hasEnd && time > hasEnd.EndTime) || osuHit.IsHit)
                     continue;
 
-                requiresHit |= osuHit is DrawableHitCircle && osuHit.IsHovered && osuHit.HitObject.HitWindows.CanBeHit(relativetime);
+                if (osuHit is DrawableHitCircle && osuHit.IsHovered)
+                {
+                    Debug.Assert(osuHit.HitObject.HitWindows != null);
+                    requiresHit |= osuHit.HitObject.HitWindows.CanBeHit(relativetime);
+                }
+
                 requiresHold |= (osuHit is DrawableSlider slider && (slider.Ball.IsHovered || osuHit.IsHovered)) || osuHit is DrawableSpinner;
             }
 

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
         {
             Origin = Anchor.Centre;
 
-            Child = new SkinnableDrawable("Play/osu/followpoint", _ => new Container
+            Child = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.FollowPoint), _ => new Container
             {
                 Masking = true,
                 AutoSizeAxes = Axes.Both,

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -9,8 +10,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using osuTK;
 using osu.Game.Rulesets.Scoring;
+using osuTK;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
@@ -58,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                                 return true;
                             },
                         },
-                        mainContent = new SkinnableDrawable("Play/osu/hitcircle", _ => new MainCirclePiece(HitObject.IndexInCurrentCombo)),
+                        mainContent = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.HitCircle), _ => new MainCirclePiece(HitObject.IndexInCurrentCombo)),
                         ApproachCircle = new ApproachCircle
                         {
                             Alpha = 0,
@@ -85,8 +86,30 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             AccentColour.BindValueChanged(accent => ApproachCircle.Colour = accent.NewValue, true);
         }
 
+        public override double LifetimeStart
+        {
+            get => base.LifetimeStart;
+            set
+            {
+                base.LifetimeStart = value;
+                ApproachCircle.LifetimeStart = value;
+            }
+        }
+
+        public override double LifetimeEnd
+        {
+            get => base.LifetimeEnd;
+            set
+            {
+                base.LifetimeEnd = value;
+                ApproachCircle.LifetimeEnd = value;
+            }
+        }
+
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
+            Debug.Assert(HitObject.HitWindows != null);
+
             if (!userTriggered)
             {
                 if (!HitObject.HitWindows.CanBeHit(timeOffset))
@@ -99,7 +122,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             if (result == HitResult.None)
             {
-                Shake(Math.Abs(timeOffset) - HitObject.HitWindows.HalfWindowFor(HitResult.Miss));
+                Shake(Math.Abs(timeOffset) - HitObject.HitWindows.WindowFor(HitResult.Miss));
                 return;
             }
 
@@ -119,6 +142,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateStateTransforms(ArmedState state)
         {
+            base.UpdateStateTransforms(state);
+
+            Debug.Assert(HitObject.HitWindows != null);
+
             switch (state)
             {
                 case ArmedState.Idle:
@@ -127,22 +154,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Expire(true);
 
                     hitArea.HitAction = null;
-
-                    // override lifetime end as FadeIn may have been changed externally, causing out expiration to be too early.
-                    LifetimeEnd = HitObject.StartTime + HitObject.HitWindows.HalfWindowFor(HitResult.Miss);
                     break;
 
                 case ArmedState.Miss:
                     ApproachCircle.FadeOut(50);
                     this.FadeOut(100);
-                    Expire();
                     break;
 
                 case ArmedState.Hit:
                     ApproachCircle.FadeOut(50);
 
                     // todo: temporary / arbitrary
-                    this.Delay(800).Expire();
+                    this.Delay(800).FadeOut();
                     break;
             }
         }

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

@@ -41,6 +41,19 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected virtual void Shake(double maximumLength) => shakeContainer.Shake(maximumLength);
 
-        protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(judgement);
+        protected override void UpdateStateTransforms(ArmedState state)
+        {
+            base.UpdateStateTransforms(state);
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    // Manually set to reduce the number of future alive objects to a bare minimum.
+                    LifetimeStart = HitObject.StartTime - HitObject.TimePreempt;
+                    break;
+            }
+        }
+
+        protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(HitObject, judgement);
     }
 }

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

@@ -9,8 +9,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
 using osu.Game.Rulesets.Scoring;
+using osuTK;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Blending = BlendingParameters.Additive;
             Origin = Anchor.Centre;
 
-            InternalChild = scaleContainer = new SkinnableDrawable("Play/osu/reversearrow", _ => new SpriteIcon
+            InternalChild = scaleContainer = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.ReverseArrow), _ => new SpriteIcon
             {
                 RelativeSizeAxes = Axes.Both,
                 Icon = FontAwesome.Solid.ChevronRight,
@@ -74,6 +74,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateStateTransforms(ArmedState state)
         {
+            base.UpdateStateTransforms(state);
+
             switch (state)
             {
                 case ArmedState.Idle:

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

@@ -12,6 +12,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Configuration;
+using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
 using osu.Game.Skinning;
@@ -166,12 +167,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             base.SkinChanged(skin, allowFallback);
 
-            Body.BorderSize = skin.GetValue<SkinConfiguration, float?>(s => s.SliderBorderSize) ?? SliderBody.DEFAULT_BORDER_SIZE;
+            Body.BorderSize = skin.GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.SliderBorderSize)?.Value ?? SliderBody.DEFAULT_BORDER_SIZE;
-            sliderPathRadius = skin.GetValue<SkinConfiguration, float?>(s => s.SliderPathRadius) ?? OsuHitObject.OBJECT_RADIUS;
+            sliderPathRadius = skin.GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.SliderPathRadius)?.Value ?? OsuHitObject.OBJECT_RADIUS;
             updatePathRadius();
 
-            Body.AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderTrackOverride") ? s.CustomColours["SliderTrackOverride"] : (Color4?)null) ?? AccentColour.Value;
+            Body.AccentColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderTrackOverride)?.Value ?? AccentColour.Value;
-            Body.BorderColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderBorder") ? s.CustomColours["SliderBorder"] : (Color4?)null) ?? Color4.White;
+            Body.BorderColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBorder)?.Value ?? Color4.White;
         }
 
         private void updatePathRadius() => Body.PathRadius = slider.Scale * sliderPathRadius;
@@ -201,6 +202,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateStateTransforms(ArmedState state)
         {
+            base.UpdateStateTransforms(state);
+
             Ball.FadeIn();
             Ball.ScaleTo(HitObject.Scale);
 
@@ -218,10 +221,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                         break;
                 }
 
-                this.FadeOut(fade_out_time, Easing.OutQuint).Expire();
+                this.FadeOut(fade_out_time, Easing.OutQuint);
             }
-
-            Expire(true);
         }
 
         public Drawable ProxiedLayer => HeadCircle.ApproachCircle;

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

@@ -8,9 +8,9 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
             Origin = Anchor.Centre;
 
-            InternalChild = scaleContainer = new SkinnableDrawable("Play/osu/sliderscorepoint", _ => new CircularContainer
+            InternalChild = scaleContainer = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderScorePoint), _ => new CircularContainer
             {
                 Masking = true,
                 Origin = Anchor.Centre,
@@ -75,6 +75,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateStateTransforms(ArmedState state)
         {
+            base.UpdateStateTransforms(state);
+
             switch (state)
             {
                 case ArmedState.Idle:

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

@@ -13,8 +13,8 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Screens.Ranking;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Ranking;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -215,14 +215,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateStateTransforms(ArmedState state)
         {
+            base.UpdateStateTransforms(state);
+
             var sequence = this.Delay(Spinner.Duration).FadeOut(160);
 
             switch (state)
             {
-                case ArmedState.Idle:
-                    Expire(true);
-                    break;
-
                 case ArmedState.Hit:
                     sequence.ScaleTo(Scale * 1.2f, 320, Easing.Out);
                     break;
@@ -231,8 +229,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     sequence.ScaleTo(Scale * 0.8f, 320, Easing.In);
                     break;
             }
-
-            Expire();
         }
     }
 }

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

@@ -31,13 +31,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         private class SkinnableApproachCircle : SkinnableSprite
         {
             public SkinnableApproachCircle()
-                : base("Play/osu/approachcircle")
+                : base("Gameplay/osu/approachcircle")
             {
             }
 
-            protected override Drawable CreateDefault(string name)
+            protected override Drawable CreateDefault(ISkinComponent component)
             {
-                var drawable = base.CreateDefault(name);
+                var drawable = base.CreateDefault(component);
 
                 // account for the sprite being used for the default approach circle being taken from stable,
                 // when hitcircles have 5px padding on each size. this should be removed if we update the sprite.

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

@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Texture = textures.Get(@"Play/osu/disc"),
+                    Texture = textures.Get(@"Gameplay/osu/disc"),
                 },
                 new TrianglesPiece
                 {

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

@@ -3,7 +3,6 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Skinning;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
@@ -20,12 +19,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             Blending = BlendingParameters.Additive;
             Alpha = 0;
 
-            Child = new SkinnableDrawable("Play/osu/hitcircle-explode", _ => new TrianglesPiece
+            Child = new TrianglesPiece
             {
                 Blending = BlendingParameters.Additive,
                 RelativeSizeAxes = Axes.Both,
                 Alpha = 0.2f,
-            }, s => s.GetTexture("Play/osu/hitcircle") == null);
+            };
         }
     }
 }

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

@@ -5,7 +5,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osuTK;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -21,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             Blending = BlendingParameters.Additive;
             Alpha = 0;
 
-            Child = new SkinnableDrawable("Play/osu/hitcircle-flash", name => new CircularContainer
+            Child = new CircularContainer
             {
                 Masking = true,
                 RelativeSizeAxes = Axes.Both,
@@ -29,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 {
                     RelativeSizeAxes = Axes.Both
                 }
-            }, s => s.GetTexture("Play/osu/hitcircle") == null);
+            };
         }
     }
 }

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

@@ -6,7 +6,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
-using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -22,14 +21,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         [BackgroundDependencyLoader]
         private void load(TextureStore textures)
         {
-            Child = new SkinnableDrawable("Play/osu/ring-glow", name => new Sprite
+            Child = new Sprite
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                Texture = textures.Get(name),
+                Texture = textures.Get("Gameplay/osu/ring-glow"),
                 Blending = BlendingParameters.Additive,
                 Alpha = 0.5f
-            }, s => s.GetTexture("Play/osu/hitcircle") == null);
+            };
         }
     }
 }

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

@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
             Children = new Drawable[]
             {
-                new SkinnableDrawable("Play/osu/number-glow", name => new CircularContainer
+                new CircularContainer
                 {
                     Masking = true,
                     Origin = Anchor.Centre,
@@ -41,8 +41,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                         Colour = Color4.White.Opacity(0.5f),
                     },
                     Child = new Box()
-                }, s => s.GetTexture("Play/osu/hitcircle") == null),
+                },
-                number = new SkinnableSpriteText("Play/osu/number-text", _ => new OsuSpriteText
+                number = new SkinnableSpriteText(new OsuSkinComponent(OsuSkinComponents.HitCircleText), _ => new OsuSpriteText
                 {
                     Font = OsuFont.Numeric.With(size: 40),
                     UseFullGlyphHeight = false,

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

@@ -6,7 +6,6 @@ using osu.Framework.Graphics.Containers;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -19,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            InternalChild = new SkinnableDrawable("Play/osu/hitcircleoverlay", _ => new Container
+            InternalChild = new Container
             {
                 Masking = true,
                 CornerRadius = Size.X / 2,
@@ -35,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                         RelativeSizeAxes = Axes.Both
                     }
                 }
-            });
+            };
         }
     }
 }

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

@@ -11,6 +11,7 @@ using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Skinning;
 using osuTK.Graphics;
 using osu.Game.Skinning;
 using osuTK;
@@ -43,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     Anchor = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
                     Alpha = 0,
-                    Child = new SkinnableDrawable("Play/osu/sliderfollowcircle", _ => new DefaultFollowCircle()),
+                    Child = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderFollowCircle), _ => new DefaultFollowCircle()),
                 },
                 new CircularContainer
                 {
@@ -55,7 +56,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     Child = new Container
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Child = new SkinnableDrawable("Play/osu/sliderball", _ => new DefaultSliderBall()),
+                        Child = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderBall), _ => new DefaultSliderBall()),
                     }
                 }
             };
@@ -218,7 +219,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             {
                 RelativeSizeAxes = Axes.Both;
 
-                float radius = skin.GetValue<SkinConfiguration, float?>(s => s.SliderPathRadius) ?? OsuHitObject.OBJECT_RADIUS;
+                float radius = skin.GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.SliderPathRadius)?.Value ?? OsuHitObject.OBJECT_RADIUS;
 
                 InternalChild = new CircularContainer
                 {

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

@@ -7,6 +7,8 @@ using osu.Game.Rulesets.Objects;
 using osuTK;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {

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

@@ -1,29 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Osu.Objects
-{
-    public class OsuHitWindows : HitWindows
-    {
-        private static readonly IReadOnlyDictionary<HitResult, (double od0, double od5, double od10)> base_ranges = new Dictionary<HitResult, (double, double, double)>
-        {
-            { HitResult.Great, (160, 100, 40) },
-            { HitResult.Good, (280, 200, 120) },
-            { HitResult.Meh, (400, 300, 200) },
-            { HitResult.Miss, (400, 400, 400) },
-        };
-
-        public override void SetDifficulty(double difficulty)
-        {
-            Great = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Great]);
-            Good = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Good]);
-            Meh = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Meh]);
-            Miss = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Miss]);
-        }
-    }
-}

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

@@ -6,6 +6,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -28,5 +29,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         }
 
         public override Judgement CreateJudgement() => new OsuJudgement();
+
+        protected override HitWindows CreateHitWindows() => null;
     }
 }

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

@@ -13,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -229,5 +230,7 @@ namespace osu.Game.Rulesets.Osu.Objects
             nodeIndex < NodeSamples.Count ? NodeSamples[nodeIndex] : Samples;
 
         public override Judgement CreateJudgement() => new OsuJudgement();
+
+        protected override HitWindows CreateHitWindows() => null;
     }
 }

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

@@ -5,6 +5,7 @@ using osu.Framework.Bindables;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -23,5 +24,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         }
 
         public override Judgement CreateJudgement() => new OsuSliderTailJudgement();
+
+        protected override HitWindows CreateHitWindows() => null;
     }
 }

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

@@ -5,6 +5,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -30,5 +31,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         }
 
         public override Judgement CreateJudgement() => new OsuJudgement();
+
+        protected override HitWindows CreateHitWindows() => null;
     }
 }

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

@@ -7,6 +7,7 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -31,5 +32,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         }
 
         public override Judgement CreateJudgement() => new OsuJudgement();
+
+        protected override HitWindows CreateHitWindows() => null;
     }
 }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -35,6 +35,8 @@ namespace osu.Game.Rulesets.Osu
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new OsuBeatmapConverter(beatmap);
         public override IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => new OsuBeatmapProcessor(beatmap);
 
+        public const string SHORT_NAME = "osu";
+
         public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
         {
             new KeyBinding(InputKey.Z, OsuAction.LeftButton),
@@ -161,11 +163,11 @@ namespace osu.Game.Rulesets.Osu
 
         public override string Description => "osu!";
 
-        public override string ShortName => "osu";
+        public override string ShortName => SHORT_NAME;
 
         public override RulesetSettingsSubsection CreateSettings() => new OsuSettingsSubsection(this);
 
-        public override ISkin CreateLegacySkinProvider(ISkinSource source) => new OsuLegacySkin(source);
+        public override ISkin CreateLegacySkinProvider(ISkinSource source) => new OsuLegacySkinTransformer(source);
 
         public override int? LegacyID => 0;
 

osu.Game.Rulesets.Osu/OsuSkinComponent.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Osu
+{
+    public class OsuSkinComponent : GameplaySkinComponent<OsuSkinComponents>
+    {
+        public OsuSkinComponent(OsuSkinComponents component)
+            : base(component)
+        {
+        }
+
+        protected override string RulesetPrefix => OsuRuleset.SHORT_NAME;
+
+        protected override string ComponentName => Component.ToString().ToLower();
+    }
+}

osu.Game.Rulesets.Osu/OsuSkinComponents.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Osu
+{
+    public enum OsuSkinComponents
+    {
+        HitCircle,
+        FollowPoint,
+        Cursor,
+        CursorTrail,
+        SliderScorePoint,
+        ApproachCircle,
+        ReverseArrow,
+        HitCircleText,
+        SliderFollowCircle,
+        SliderBall
+    }
+}

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

@@ -6,11 +6,13 @@ using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using System;
+using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Replays
@@ -36,6 +38,8 @@ namespace osu.Game.Rulesets.Osu.Replays
         /// </summary>
         private readonly double reactionTime;
 
+        private readonly HitWindows defaultHitWindows;
+
         /// <summary>
         /// What easing to use when moving between hitobjects
         /// </summary>
@@ -50,6 +54,9 @@ namespace osu.Game.Rulesets.Osu.Replays
         {
             // Already superhuman, but still somewhat realistic
             reactionTime = ApplyModsToRate(100);
+
+            defaultHitWindows = new OsuHitWindows();
+            defaultHitWindows.SetDifficulty(Beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
         }
 
         #endregion
@@ -91,21 +98,49 @@ namespace osu.Game.Rulesets.Osu.Replays
         {
             double endTime = (prev as IHasEndTime)?.EndTime ?? prev.StartTime;
 
+            HitWindows hitWindows = null;
+
+            switch (h)
+            {
+                case HitCircle hitCircle:
+                    hitWindows = hitCircle.HitWindows;
+                    break;
+
+                case Slider slider:
+                    hitWindows = slider.TailCircle.HitWindows;
+                    break;
+
+                case Spinner _:
+                    hitWindows = defaultHitWindows;
+                    break;
+            }
+
+            Debug.Assert(hitWindows != null);
+
             // Make the cursor stay at a hitObject as long as possible (mainly for autopilot).
-            if (h.StartTime - h.HitWindows.HalfWindowFor(HitResult.Miss) > endTime + h.HitWindows.HalfWindowFor(HitResult.Meh) + 50)
+            if (h.StartTime - hitWindows.WindowFor(HitResult.Miss) > endTime + hitWindows.WindowFor(HitResult.Meh) + 50)
             {
-                if (!(prev is Spinner) && h.StartTime - endTime < 1000) AddFrameToReplay(new OsuReplayFrame(endTime + h.HitWindows.HalfWindowFor(HitResult.Meh), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+                if (!(prev is Spinner) && h.StartTime - endTime < 1000)
-                if (!(h is Spinner)) AddFrameToReplay(new OsuReplayFrame(h.StartTime - h.HitWindows.HalfWindowFor(HitResult.Miss), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.WindowFor(HitResult.Meh), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+
+                if (!(h is Spinner))
+                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.WindowFor(HitResult.Miss), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
             }
-            else if (h.StartTime - h.HitWindows.HalfWindowFor(HitResult.Meh) > endTime + h.HitWindows.HalfWindowFor(HitResult.Meh) + 50)
+            else if (h.StartTime - hitWindows.WindowFor(HitResult.Meh) > endTime + hitWindows.WindowFor(HitResult.Meh) + 50)
             {
-                if (!(prev is Spinner) && h.StartTime - endTime < 1000) AddFrameToReplay(new OsuReplayFrame(endTime + h.HitWindows.HalfWindowFor(HitResult.Meh), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+                if (!(prev is Spinner) && h.StartTime - endTime < 1000)
-                if (!(h is Spinner)) AddFrameToReplay(new OsuReplayFrame(h.StartTime - h.HitWindows.HalfWindowFor(HitResult.Meh), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.WindowFor(HitResult.Meh), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+
+                if (!(h is Spinner))
+                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.WindowFor(HitResult.Meh), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
             }
-            else if (h.StartTime - h.HitWindows.HalfWindowFor(HitResult.Good) > endTime + h.HitWindows.HalfWindowFor(HitResult.Good) + 50)
+            else if (h.StartTime - hitWindows.WindowFor(HitResult.Good) > endTime + hitWindows.WindowFor(HitResult.Good) + 50)
             {
-                if (!(prev is Spinner) && h.StartTime - endTime < 1000) AddFrameToReplay(new OsuReplayFrame(endTime + h.HitWindows.HalfWindowFor(HitResult.Good), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+                if (!(prev is Spinner) && h.StartTime - endTime < 1000)
-                if (!(h is Spinner)) AddFrameToReplay(new OsuReplayFrame(h.StartTime - h.HitWindows.HalfWindowFor(HitResult.Good), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.WindowFor(HitResult.Good), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+
+                if (!(h is Spinner))
+                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.WindowFor(HitResult.Good), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
             }
         }