merged upstream

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs

@@ -3,7 +3,6 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 
@@ -23,19 +22,19 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 {
                     Name = @"Circle Count",
                     Content = circles.ToString(),
-                    Icon = FontAwesome.Regular.Circle
+                    CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Slider Count",
                     Content = sliders.ToString(),
-                    Icon = FontAwesome.Regular.Circle
+                    CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                 },
                 new BeatmapStatistic
                 {
                     Name = @"Spinner Count",
                     Content = spinners.ToString(),
-                    Icon = FontAwesome.Regular.Circle
+                    CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
                 }
             };
         }

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs

@@ -7,68 +7,67 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using System.Collections.Generic;
 using osu.Game.Rulesets.Objects.Types;
-using System;
+using System.Linq;
+using System.Threading;
 using osu.Game.Rulesets.Osu.UI;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps.Legacy;
 
 namespace osu.Game.Rulesets.Osu.Beatmaps
 {
     public class OsuBeatmapConverter : BeatmapConverter<OsuHitObject>
     {
-        public OsuBeatmapConverter(IBeatmap beatmap)
-            : base(beatmap)
+        public OsuBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
+            : base(beatmap, ruleset)
         {
         }
 
-        protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(IHasPosition) };
+        public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasPosition);
 
-        protected override IEnumerable<OsuHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap)
+        protected override IEnumerable<OsuHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
         {
-            var curveData = original as IHasCurve;
-            var endTimeData = original as IHasEndTime;
             var positionData = original as IHasPosition;
             var comboData = original as IHasCombo;
-            var legacyOffset = original as IHasLegacyLastTickOffset;
 
-            if (curveData != null)
+            switch (original)
             {
-                yield return new Slider
-                {
-                    StartTime = original.StartTime,
-                    Samples = original.Samples,
-                    Path = curveData.Path,
-                    NodeSamples = curveData.NodeSamples,
-                    RepeatCount = curveData.RepeatCount,
-                    Position = positionData?.Position ?? Vector2.Zero,
-                    NewCombo = comboData?.NewCombo ?? false,
-                    ComboOffset = comboData?.ComboOffset ?? 0,
-                    LegacyLastTickOffset = legacyOffset?.LegacyLastTickOffset,
-                    // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
-                    // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                    TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / beatmap.ControlPointInfo.DifficultyPointAt(original.StartTime).SpeedMultiplier : 1
-                };
-            }
-            else if (endTimeData != null)
-            {
-                yield return new Spinner
-                {
-                    StartTime = original.StartTime,
-                    Samples = original.Samples,
-                    EndTime = endTimeData.EndTime,
-                    Position = positionData?.Position ?? OsuPlayfield.BASE_SIZE / 2,
-                    NewCombo = comboData?.NewCombo ?? false,
-                    ComboOffset = comboData?.ComboOffset ?? 0,
-                };
-            }
-            else
-            {
-                yield return new HitCircle
-                {
-                    StartTime = original.StartTime,
-                    Samples = original.Samples,
-                    Position = positionData?.Position ?? Vector2.Zero,
-                    NewCombo = comboData?.NewCombo ?? false,
-                    ComboOffset = comboData?.ComboOffset ?? 0,
-                };
+                case IHasPathWithRepeats curveData:
+                    return new Slider
+                    {
+                        StartTime = original.StartTime,
+                        Samples = original.Samples,
+                        Path = curveData.Path,
+                        NodeSamples = curveData.NodeSamples,
+                        RepeatCount = curveData.RepeatCount,
+                        Position = positionData?.Position ?? Vector2.Zero,
+                        NewCombo = comboData?.NewCombo ?? false,
+                        ComboOffset = comboData?.ComboOffset ?? 0,
+                        LegacyLastTickOffset = (original as IHasLegacyLastTickOffset)?.LegacyLastTickOffset,
+                        // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
+                        // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
+                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1
+                    }.Yield();
+
+                case IHasDuration endTimeData:
+                    return new Spinner
+                    {
+                        StartTime = original.StartTime,
+                        Samples = original.Samples,
+                        EndTime = endTimeData.EndTime,
+                        Position = positionData?.Position ?? OsuPlayfield.BASE_SIZE / 2,
+                        NewCombo = comboData?.NewCombo ?? false,
+                        ComboOffset = comboData?.ComboOffset ?? 0,
+                    }.Yield();
+
+                default:
+                    return new HitCircle
+                    {
+                        StartTime = original.StartTime,
+                        Samples = original.Samples,
+                        Position = positionData?.Position ?? Vector2.Zero,
+                        NewCombo = comboData?.NewCombo ?? false,
+                        ComboOffset = comboData?.ComboOffset ?? 0,
+                    }.Yield();
             }
         }
 

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs

@@ -4,7 +4,7 @@
 using System;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
 
@@ -62,11 +62,11 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         if (objectN is Spinner)
                             continue;
 
-                        double endTime = (stackBaseObject as IHasEndTime)?.EndTime ?? stackBaseObject.StartTime;
+                        double endTime = stackBaseObject.GetEndTime();
                         double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
 
                         if (objectN.StartTime - endTime > stackThreshold)
-                            //We are no longer within stacking range of the next object.
+                            // We are no longer within stacking range of the next object.
                             break;
 
                         if (Vector2Extensions.Distance(stackBaseObject.Position, objectN.Position) < stack_distance
@@ -88,7 +88,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 }
             }
 
-            //Reverse pass for stack calculation.
+            // Reverse pass for stack calculation.
             int extendedStartIndex = startIndex;
 
             for (int i = extendedEndIndex; i > startIndex; i--)
@@ -121,10 +121,10 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         OsuHitObject objectN = beatmap.HitObjects[n];
                         if (objectN is Spinner) continue;
 
-                        double endTime = (objectN as IHasEndTime)?.EndTime ?? objectN.StartTime;
+                        double endTime = objectN.GetEndTime();
 
                         if (objectI.StartTime - endTime > stackThreshold)
-                            //We are no longer within stacking range of the previous object.
+                            // We are no longer within stacking range of the previous object.
                             break;
 
                         // HitObjects before the specified update range haven't been reset yet
@@ -145,20 +145,20 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 
                             for (int j = n + 1; j <= i; j++)
                             {
-                                //For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
+                                // For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
                                 OsuHitObject objectJ = beatmap.HitObjects[j];
                                 if (Vector2Extensions.Distance(objectN.EndPosition, objectJ.Position) < stack_distance)
                                     objectJ.StackHeight -= offset;
                             }
 
-                            //We have hit a slider.  We should restart calculation using this as the new base.
-                            //Breaking here will mean that the slider still has StackCount of 0, so will be handled in the i-outer-loop.
+                            // We have hit a slider.  We should restart calculation using this as the new base.
+                            // Breaking here will mean that the slider still has StackCount of 0, so will be handled in the i-outer-loop.
                             break;
                         }
 
                         if (Vector2Extensions.Distance(objectN.Position, objectI.Position) < stack_distance)
                         {
-                            //Keep processing as if there are no sliders.  If we come across a slider, this gets cancelled out.
+                            // Keep processing as if there are no sliders.  If we come across a slider, this gets cancelled out.
                             //NOTE: Sliders with start positions stacking are a special case that is also handled here.
 
                             objectN.StackHeight = objectI.StackHeight + 1;
@@ -177,7 +177,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         if (objectN is Spinner) continue;
 
                         if (objectI.StartTime - objectN.StartTime > stackThreshold)
-                            //We are no longer within stacking range of the previous object.
+                            // We are no longer within stacking range of the previous object.
                             break;
 
                         if (Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < stack_distance)
@@ -199,7 +199,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 if (currHitObject.StackHeight != 0 && !(currHitObject is Slider))
                     continue;
 
-                double startTime = (currHitObject as IHasEndTime)?.EndTime ?? currHitObject.StartTime;
+                double startTime = currHitObject.GetEndTime();
                 int sliderStack = 0;
 
                 for (int j = i + 1; j < beatmap.HitObjects.Count; j++)
@@ -217,14 +217,14 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, currHitObject.Position) < stack_distance)
                     {
                         currHitObject.StackHeight++;
-                        startTime = (beatmap.HitObjects[j] as IHasEndTime)?.EndTime ?? beatmap.HitObjects[j].StartTime;
+                        startTime = beatmap.HitObjects[j].GetEndTime();
                     }
                     else if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, position2) < stack_distance)
                     {
-                        //Case for sliders - bump notes down and right, rather than up and left.
+                        // Case for sliders - bump notes down and right, rather than up and left.
                         sliderStack++;
                         beatmap.HitObjects[j].StackHeight -= sliderStack;
-                        startTime = (beatmap.HitObjects[j] as IHasEndTime)?.EndTime ?? beatmap.HitObjects[j].StartTime;
+                        startTime = beatmap.HitObjects[j].GetEndTime();
                     }
                 }
             }

osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs

@@ -3,6 +3,7 @@
 
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Configuration;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu.Configuration
 {
@@ -16,9 +17,10 @@ namespace osu.Game.Rulesets.Osu.Configuration
         protected override void InitialiseDefaults()
         {
             base.InitialiseDefaults();
-            Set(OsuRulesetSetting.SnakingInSliders, true);
-            Set(OsuRulesetSetting.SnakingOutSliders, true);
-            Set(OsuRulesetSetting.ShowCursorTrail, true);
+            SetDefault(OsuRulesetSetting.SnakingInSliders, true);
+            SetDefault(OsuRulesetSetting.SnakingOutSliders, true);
+            SetDefault(OsuRulesetSetting.ShowCursorTrail, true);
+            SetDefault(OsuRulesetSetting.PlayfieldBorderStyle, PlayfieldBorderStyle.None);
         }
     }
 
@@ -26,6 +28,7 @@ namespace osu.Game.Rulesets.Osu.Configuration
     {
         SnakingInSliders,
         SnakingOutSliders,
-        ShowCursorTrail
+        ShowCursorTrail,
+        PlayfieldBorderStyle,
     }
 }

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

@@ -1,16 +1,84 @@
 // 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 JetBrains.Annotations;
+using Newtonsoft.Json;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
     public class OsuDifficultyAttributes : DifficultyAttributes
     {
-        public double AimStrain;
-        public double SpeedStrain;
-        public double ApproachRate;
-        public double OverallDifficulty;
-        public int MaxCombo;
+        [JsonProperty("aim_difficulty")]
+        public double AimDifficulty { get; set; }
+
+        [JsonProperty("speed_difficulty")]
+        public double SpeedDifficulty { get; set; }
+
+        [JsonProperty("flashlight_difficulty")]
+        public double FlashlightDifficulty { get; set; }
+
+        [JsonProperty("slider_factor")]
+        public double SliderFactor { get; set; }
+
+        [JsonProperty("approach_rate")]
+        public double ApproachRate { get; set; }
+
+        [JsonProperty("overall_difficulty")]
+        public double OverallDifficulty { get; set; }
+
+        public double DrainRate { get; set; }
+
+        public int HitCircleCount { get; set; }
+
+        public int SliderCount { get; set; }
+
+        public int SpinnerCount { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            yield return (ATTRIB_ID_AIM, AimDifficulty);
+            yield return (ATTRIB_ID_SPEED, SpeedDifficulty);
+            yield return (ATTRIB_ID_OVERALL_DIFFICULTY, OverallDifficulty);
+            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
+            yield return (ATTRIB_ID_MAX_COMBO, MaxCombo);
+            yield return (ATTRIB_ID_DIFFICULTY, StarRating);
+
+            if (ShouldSerializeFlashlightRating())
+                yield return (ATTRIB_ID_FLASHLIGHT, FlashlightDifficulty);
+
+            yield return (ATTRIB_ID_SLIDER_FACTOR, SliderFactor);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            AimDifficulty = values[ATTRIB_ID_AIM];
+            SpeedDifficulty = values[ATTRIB_ID_SPEED];
+            OverallDifficulty = values[ATTRIB_ID_OVERALL_DIFFICULTY];
+            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
+            MaxCombo = (int)values[ATTRIB_ID_MAX_COMBO];
+            StarRating = values[ATTRIB_ID_DIFFICULTY];
+            FlashlightDifficulty = values.GetValueOrDefault(ATTRIB_ID_FLASHLIGHT);
+            SliderFactor = values[ATTRIB_ID_SLIDER_FACTOR];
+        }
+
+        #region Newtonsoft.Json implicit ShouldSerialize() methods
+
+        // The properties in this region are used implicitly by Newtonsoft.Json to not serialise certain fields in some cases.
+        // They rely on being named exactly the same as the corresponding fields (casing included) and as such should NOT be renamed
+        // unless the fields are also renamed.
+
+        [UsedImplicitly]
+        public bool ShouldSerializeFlashlightRating() => Mods.Any(m => m is ModFlashlight);
+
+        #endregion
     }
 }

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

@@ -13,14 +13,17 @@ 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
 {
     public class OsuDifficultyCalculator : DifficultyCalculator
     {
         private const double difficulty_multiplier = 0.0675;
+        private double hitWindowGreat;
 
-        public OsuDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }
@@ -28,30 +31,60 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
         {
             if (beatmap.HitObjects.Count == 0)
-                return new OsuDifficultyAttributes { Mods = mods, Skills = skills };
+                return new OsuDifficultyAttributes { Mods = mods };
 
             double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier;
-            double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
-            double starRating = aimRating + speedRating + Math.Abs(aimRating - speedRating) / 2;
+            double aimRatingNoSliders = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
+            double speedRating = Math.Sqrt(skills[2].DifficultyValue()) * difficulty_multiplier;
+            double flashlightRating = Math.Sqrt(skills[3].DifficultyValue()) * difficulty_multiplier;
 
-            // 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 preempt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+            double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
+
+            if (mods.Any(h => h is OsuModRelax))
+                speedRating = 0.0;
+
+            double baseAimPerformance = Math.Pow(5 * Math.Max(1, aimRating / 0.0675) - 4, 3) / 100000;
+            double baseSpeedPerformance = Math.Pow(5 * Math.Max(1, speedRating / 0.0675) - 4, 3) / 100000;
+            double baseFlashlightPerformance = 0.0;
+
+            if (mods.Any(h => h is OsuModFlashlight))
+                baseFlashlightPerformance = Math.Pow(flashlightRating, 2.0) * 25.0;
+
+            double basePerformance =
+                Math.Pow(
+                    Math.Pow(baseAimPerformance, 1.1) +
+                    Math.Pow(baseSpeedPerformance, 1.1) +
+                    Math.Pow(baseFlashlightPerformance, 1.1), 1.0 / 1.1
+                );
+
+            double starRating = basePerformance > 0.00001 ? Math.Cbrt(1.12) * 0.027 * (Math.Cbrt(100000 / Math.Pow(2, 1 / 1.1) * basePerformance) + 4) : 0;
+
+            double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+            double drainRate = beatmap.Difficulty.DrainRate;
 
             int maxCombo = beatmap.HitObjects.Count;
             // Add the ticks + tail of the slider. 1 is subtracted because the head circle would be counted twice (once for the slider itself in the line above)
             maxCombo += beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
 
+            int hitCirclesCount = beatmap.HitObjects.Count(h => h is HitCircle);
+            int sliderCount = beatmap.HitObjects.Count(h => h is Slider);
+            int spinnerCount = beatmap.HitObjects.Count(h => h is Spinner);
+
             return new OsuDifficultyAttributes
             {
                 StarRating = starRating,
                 Mods = mods,
-                AimStrain = aimRating,
-                SpeedStrain = speedRating,
+                AimDifficulty = aimRating,
+                SpeedDifficulty = speedRating,
+                FlashlightDifficulty = flashlightRating,
+                SliderFactor = sliderFactor,
                 ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
                 OverallDifficulty = (80 - hitWindowGreat) / 6,
+                DrainRate = drainRate,
                 MaxCombo = maxCombo,
-                Skills = skills
+                HitCircleCount = hitCirclesCount,
+                SliderCount = sliderCount,
+                SpinnerCount = spinnerCount,
             };
         }
 
@@ -69,11 +102,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             }
         }
 
-        protected override Skill[] CreateSkills(IBeatmap beatmap) => new Skill[]
+        protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clockRate)
         {
-            new Aim(),
-            new Speed()
-        };
+            HitWindows hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
+
+            hitWindowGreat = hitWindows.WindowFor(HitResult.Great) / clockRate;
+
+            return new Skill[]
+            {
+                new Aim(mods, true),
+                new Aim(mods, false),
+                new Speed(mods, hitWindowGreat),
+                new Flashlight(mods)
+            };
+        }
 
         protected override Mod[] DifficultyAdjustmentMods => new Mod[]
         {
@@ -81,6 +124,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             new OsuModHalfTime(),
             new OsuModEasy(),
             new OsuModHardRock(),
+            new OsuModFlashlight(),
         };
     }
 }

osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceAttributes.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 Newtonsoft.Json;
+using osu.Game.Rulesets.Difficulty;
+
+namespace osu.Game.Rulesets.Osu.Difficulty
+{
+    public class OsuPerformanceAttributes : PerformanceAttributes
+    {
+        [JsonProperty("aim")]
+        public double Aim { get; set; }
+
+        [JsonProperty("speed")]
+        public double Speed { get; set; }
+
+        [JsonProperty("accuracy")]
+        public double Accuracy { get; set; }
+
+        [JsonProperty("flashlight")]
+        public double Flashlight { get; set; }
+
+        [JsonProperty("effective_miss_count")]
+        public double EffectiveMissCount { get; set; }
+    }
+}

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

@@ -4,11 +4,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 
@@ -18,192 +16,254 @@ namespace osu.Game.Rulesets.Osu.Difficulty
     {
         public new OsuDifficultyAttributes Attributes => (OsuDifficultyAttributes)base.Attributes;
 
-        private readonly int countHitCircles;
-        private readonly int beatmapMaxCombo;
-
         private Mod[] mods;
 
         private double accuracy;
         private int scoreMaxCombo;
         private int countGreat;
-        private int countGood;
+        private int countOk;
         private int countMeh;
         private int countMiss;
 
-        public OsuPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
-            : base(ruleset, beatmap, score)
-        {
-            countHitCircles = Beatmap.HitObjects.Count(h => h is HitCircle);
+        private int effectiveMissCount;
 
-            beatmapMaxCombo = Beatmap.HitObjects.Count;
-            // Add the ticks + tail of the slider. 1 is subtracted because the "headcircle" would be counted twice (once for the slider itself in the line above)
-            beatmapMaxCombo += Beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
+        public OsuPerformanceCalculator(Ruleset ruleset, DifficultyAttributes attributes, ScoreInfo score)
+            : base(ruleset, attributes, score)
+        {
         }
 
-        public override double Calculate(Dictionary<string, double> categoryRatings = null)
+        public override PerformanceAttributes Calculate()
         {
             mods = Score.Mods;
             accuracy = Score.Accuracy;
             scoreMaxCombo = Score.MaxCombo;
-            countGreat = Convert.ToInt32(Score.Statistics[HitResult.Great]);
-            countGood = Convert.ToInt32(Score.Statistics[HitResult.Good]);
-            countMeh = Convert.ToInt32(Score.Statistics[HitResult.Meh]);
-            countMiss = Convert.ToInt32(Score.Statistics[HitResult.Miss]);
+            countGreat = Score.Statistics.GetValueOrDefault(HitResult.Great);
+            countOk = Score.Statistics.GetValueOrDefault(HitResult.Ok);
+            countMeh = Score.Statistics.GetValueOrDefault(HitResult.Meh);
+            countMiss = Score.Statistics.GetValueOrDefault(HitResult.Miss);
+            effectiveMissCount = calculateEffectiveMissCount();
 
-            // Don't count scores made with supposedly unranked mods
-            if (mods.Any(m => !m.Ranked))
-                return 0;
-
-            // Custom multipliers for NoFail and SpunOut.
-            double multiplier = 1.12f; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things
+            double multiplier = 1.12; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
 
             if (mods.Any(m => m is OsuModNoFail))
-                multiplier *= 0.90f;
+                multiplier *= Math.Max(0.90, 1.0 - 0.02 * effectiveMissCount);
 
             if (mods.Any(m => m is OsuModSpunOut))
-                multiplier *= 0.95f;
+                multiplier *= 1.0 - Math.Pow((double)Attributes.SpinnerCount / totalHits, 0.85);
+
+            if (mods.Any(h => h is OsuModRelax))
+            {
+                // As we're adding Oks and Mehs to an approximated number of combo breaks the result can be higher than total hits in specific scenarios (which breaks some calculations) so we need to clamp it.
+                effectiveMissCount = Math.Min(effectiveMissCount + countOk + countMeh, totalHits);
+
+                multiplier *= 0.6;
+            }
 
             double aimValue = computeAimValue();
             double speedValue = computeSpeedValue();
             double accuracyValue = computeAccuracyValue();
+            double flashlightValue = computeFlashlightValue();
             double totalValue =
                 Math.Pow(
-                    Math.Pow(aimValue, 1.1f) +
-                    Math.Pow(speedValue, 1.1f) +
-                    Math.Pow(accuracyValue, 1.1f), 1.0f / 1.1f
+                    Math.Pow(aimValue, 1.1) +
+                    Math.Pow(speedValue, 1.1) +
+                    Math.Pow(accuracyValue, 1.1) +
+                    Math.Pow(flashlightValue, 1.1), 1.0 / 1.1
                 ) * multiplier;
 
-            if (categoryRatings != null)
+            return new OsuPerformanceAttributes
             {
-                categoryRatings.Add("Aim", aimValue);
-                categoryRatings.Add("Speed", speedValue);
-                categoryRatings.Add("Accuracy", accuracyValue);
-                categoryRatings.Add("OD", Attributes.OverallDifficulty);
-                categoryRatings.Add("AR", Attributes.ApproachRate);
-                categoryRatings.Add("Max Combo", beatmapMaxCombo);
-            }
-
-            return totalValue;
+                Aim = aimValue,
+                Speed = speedValue,
+                Accuracy = accuracyValue,
+                Flashlight = flashlightValue,
+                EffectiveMissCount = effectiveMissCount,
+                Total = totalValue
+            };
         }
 
         private double computeAimValue()
         {
-            double rawAim = Attributes.AimStrain;
+            double rawAim = Attributes.AimDifficulty;
 
             if (mods.Any(m => m is OsuModTouchDevice))
                 rawAim = Math.Pow(rawAim, 0.8);
 
-            double aimValue = Math.Pow(5.0f * Math.Max(1.0f, rawAim / 0.0675f) - 4.0f, 3.0f) / 100000.0f;
-
-            // Longer maps are worth more
-            double lengthBonus = 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
-                                 (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
+            double aimValue = Math.Pow(5.0 * Math.Max(1.0, rawAim / 0.0675) - 4.0, 3.0) / 100000.0;
 
+            double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
+                                 (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
             aimValue *= lengthBonus;
 
-            // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
-            aimValue *= Math.Pow(0.97f, countMiss);
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            if (effectiveMissCount > 0)
+                aimValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), effectiveMissCount);
 
-            // Combo scaling
-            if (beatmapMaxCombo > 0)
-                aimValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8f) / Math.Pow(beatmapMaxCombo, 0.8f), 1.0f);
+            aimValue *= getComboScalingFactor();
 
-            double approachRateFactor = 1.0f;
+            double approachRateFactor = 0.0;
+            if (Attributes.ApproachRate > 10.33)
+                approachRateFactor = 0.3 * (Attributes.ApproachRate - 10.33);
+            else if (Attributes.ApproachRate < 8.0)
+                approachRateFactor = 0.1 * (8.0 - Attributes.ApproachRate);
 
-            if (Attributes.ApproachRate > 10.33f)
-                approachRateFactor += 0.3f * (Attributes.ApproachRate - 10.33f);
-            else if (Attributes.ApproachRate < 8.0f)
+            aimValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.
+
+            if (mods.Any(m => m is OsuModBlinds))
+                aimValue *= 1.3 + (totalHits * (0.0016 / (1 + 2 * effectiveMissCount)) * Math.Pow(accuracy, 16)) * (1 - 0.003 * Attributes.DrainRate * Attributes.DrainRate);
+            else if (mods.Any(h => h is OsuModHidden))
             {
-                approachRateFactor += 0.01f * (8.0f - Attributes.ApproachRate);
+                // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
+                aimValue *= 1.0 + 0.04 * (12.0 - Attributes.ApproachRate);
             }
 
-            aimValue *= approachRateFactor;
+            // We assume 15% of sliders in a map are difficult since there's no way to tell from the performance calculator.
+            double estimateDifficultSliders = Attributes.SliderCount * 0.15;
 
-            // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-            if (mods.Any(h => h is OsuModHidden))
-                aimValue *= 1.0f + 0.04f * (12.0f - Attributes.ApproachRate);
-
-            if (mods.Any(h => h is OsuModFlashlight))
+            if (Attributes.SliderCount > 0)
             {
-                // Apply object-based bonus for flashlight.
-                aimValue *= 1.0f + 0.35f * Math.Min(1.0f, totalHits / 200.0f) +
-                            (totalHits > 200
-                                ? 0.3f * Math.Min(1.0f, (totalHits - 200) / 300.0f) +
-                                  (totalHits > 500 ? (totalHits - 500) / 1200.0f : 0.0f)
-                                : 0.0f);
+                double estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, Attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
+                double sliderNerfFactor = (1 - Attributes.SliderFactor) * Math.Pow(1 - estimateSliderEndsDropped / estimateDifficultSliders, 3) + Attributes.SliderFactor;
+                aimValue *= sliderNerfFactor;
             }
 
-            // Scale the aim value with accuracy _slightly_
-            aimValue *= 0.5f + accuracy / 2.0f;
-            // It is important to also consider accuracy difficulty when doing that
-            aimValue *= 0.98f + Math.Pow(Attributes.OverallDifficulty, 2) / 2500;
+            aimValue *= accuracy;
+            // It is important to consider accuracy difficulty when scaling with accuracy.
+            aimValue *= 0.98 + Math.Pow(Attributes.OverallDifficulty, 2) / 2500;
 
             return aimValue;
         }
 
         private double computeSpeedValue()
         {
-            double speedValue = Math.Pow(5.0f * Math.Max(1.0f, Attributes.SpeedStrain / 0.0675f) - 4.0f, 3.0f) / 100000.0f;
+            double speedValue = Math.Pow(5.0 * Math.Max(1.0, Attributes.SpeedDifficulty / 0.0675) - 4.0, 3.0) / 100000.0;
 
-            // Longer maps are worth more
-            speedValue *= 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
-                          (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
+            double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
+                                 (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
+            speedValue *= lengthBonus;
 
-            // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
-            speedValue *= Math.Pow(0.97f, countMiss);
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            if (effectiveMissCount > 0)
+                speedValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
 
-            // Combo scaling
-            if (beatmapMaxCombo > 0)
-                speedValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8f) / Math.Pow(beatmapMaxCombo, 0.8f), 1.0f);
+            speedValue *= getComboScalingFactor();
 
-            double approachRateFactor = 1.0f;
-            if (Attributes.ApproachRate > 10.33f)
-                approachRateFactor += 0.3f * (Attributes.ApproachRate - 10.33f);
+            double approachRateFactor = 0.0;
+            if (Attributes.ApproachRate > 10.33)
+                approachRateFactor = 0.3 * (Attributes.ApproachRate - 10.33);
 
-            speedValue *= approachRateFactor;
+            speedValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.
 
-            if (mods.Any(m => m is OsuModHidden))
-                speedValue *= 1.0f + 0.04f * (12.0f - Attributes.ApproachRate);
+            if (mods.Any(m => m is OsuModBlinds))
+            {
+                // Increasing the speed value by object count for Blinds isn't ideal, so the minimum buff is given.
+                speedValue *= 1.12;
+            }
+            else if (mods.Any(m => m is OsuModHidden))
+            {
+                // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
+                speedValue *= 1.0 + 0.04 * (12.0 - Attributes.ApproachRate);
+            }
 
-            // Scale the speed value with accuracy _slightly_
-            speedValue *= 0.02f + accuracy;
-            // It is important to also consider accuracy difficulty when doing that
-            speedValue *= 0.96f + Math.Pow(Attributes.OverallDifficulty, 2) / 1600;
+            // Scale the speed value with accuracy and OD.
+            speedValue *= (0.95 + Math.Pow(Attributes.OverallDifficulty, 2) / 750) * Math.Pow(accuracy, (14.5 - Math.Max(Attributes.OverallDifficulty, 8)) / 2);
+
+            // Scale the speed value with # of 50s to punish doubletapping.
+            speedValue *= Math.Pow(0.98, countMeh < totalHits / 500.0 ? 0 : countMeh - totalHits / 500.0);
 
             return speedValue;
         }
 
         private double computeAccuracyValue()
         {
-            // This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window
+            if (mods.Any(h => h is OsuModRelax))
+                return 0.0;
+
+            // This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window.
             double betterAccuracyPercentage;
-            int amountHitObjectsWithAccuracy = countHitCircles;
+            int amountHitObjectsWithAccuracy = Attributes.HitCircleCount;
 
             if (amountHitObjectsWithAccuracy > 0)
-                betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countGood * 2 + countMeh) / (amountHitObjectsWithAccuracy * 6);
+                betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
             else
                 betterAccuracyPercentage = 0;
 
-            // It is possible to reach a negative accuracy with this formula. Cap it at zero - zero points
+            // It is possible to reach a negative accuracy with this formula. Cap it at zero - zero points.
             if (betterAccuracyPercentage < 0)
                 betterAccuracyPercentage = 0;
 
             // Lots of arbitrary values from testing.
-            // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
-            double accuracyValue = Math.Pow(1.52163f, Attributes.OverallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83f;
+            // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution.
+            double accuracyValue = Math.Pow(1.52163, Attributes.OverallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83;
 
-            // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
-            accuracyValue *= Math.Min(1.15f, Math.Pow(amountHitObjectsWithAccuracy / 1000.0f, 0.3f));
+            // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
+            accuracyValue *= Math.Min(1.15, Math.Pow(amountHitObjectsWithAccuracy / 1000.0, 0.3));
+
+            // Increasing the accuracy value by object count for Blinds isn't ideal, so the minimum buff is given.
+            if (mods.Any(m => m is OsuModBlinds))
+                accuracyValue *= 1.14;
+            else if (mods.Any(m => m is OsuModHidden))
+                accuracyValue *= 1.08;
 
-            if (mods.Any(m => m is OsuModHidden))
-                accuracyValue *= 1.08f;
             if (mods.Any(m => m is OsuModFlashlight))
-                accuracyValue *= 1.02f;
+                accuracyValue *= 1.02;
 
             return accuracyValue;
         }
 
-        private double totalHits => countGreat + countGood + countMeh + countMiss;
-        private double totalSuccessfulHits => countGreat + countGood + countMeh;
+        private double computeFlashlightValue()
+        {
+            if (!mods.Any(h => h is OsuModFlashlight))
+                return 0.0;
+
+            double rawFlashlight = Attributes.FlashlightDifficulty;
+
+            if (mods.Any(m => m is OsuModTouchDevice))
+                rawFlashlight = Math.Pow(rawFlashlight, 0.8);
+
+            double flashlightValue = Math.Pow(rawFlashlight, 2.0) * 25.0;
+
+            if (mods.Any(h => h is OsuModHidden))
+                flashlightValue *= 1.3;
+
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            if (effectiveMissCount > 0)
+                flashlightValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
+
+            flashlightValue *= getComboScalingFactor();
+
+            // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
+            flashlightValue *= 0.7 + 0.1 * Math.Min(1.0, totalHits / 200.0) +
+                               (totalHits > 200 ? 0.2 * Math.Min(1.0, (totalHits - 200) / 200.0) : 0.0);
+
+            // Scale the flashlight value with accuracy _slightly_.
+            flashlightValue *= 0.5 + accuracy / 2.0;
+            // It is important to also consider accuracy difficulty when doing that.
+            flashlightValue *= 0.98 + Math.Pow(Attributes.OverallDifficulty, 2) / 2500;
+
+            return flashlightValue;
+        }
+
+        private int calculateEffectiveMissCount()
+        {
+            // Guess the number of misses + slider breaks from combo
+            double comboBasedMissCount = 0.0;
+
+            if (Attributes.SliderCount > 0)
+            {
+                double fullComboThreshold = Attributes.MaxCombo - 0.1 * Attributes.SliderCount;
+                if (scoreMaxCombo < fullComboThreshold)
+                    comboBasedMissCount = fullComboThreshold / Math.Max(1.0, scoreMaxCombo);
+            }
+
+            // Clamp misscount since it's derived from combo and can be higher than total hits and that breaks some calculations
+            comboBasedMissCount = Math.Min(comboBasedMissCount, totalHits);
+
+            return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
+        }
+
+        private double getComboScalingFactor() => Attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
+        private int totalHits => countGreat + countOk + countMeh + countMiss;
+        private int totalSuccessfulHits => countGreat + countOk + countMeh;
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
@@ -12,31 +11,65 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 {
     public class OsuDifficultyHitObject : DifficultyHitObject
     {
-        private const int normalized_radius = 52;
+        private const int normalised_radius = 50; // Change radius to 50 to make 100 the diameter. Easier for mental maths.
+        private const int min_delta_time = 25;
+        private const float maximum_slider_radius = normalised_radius * 2.4f;
+        private const float assumed_slider_radius = normalised_radius * 1.8f;
 
         protected new OsuHitObject BaseObject => (OsuHitObject)base.BaseObject;
 
         /// <summary>
-        /// Normalized distance from the end position of the previous <see cref="OsuDifficultyHitObject"/> to the start position of this <see cref="OsuDifficultyHitObject"/>.
+        /// Milliseconds elapsed since the start time of the previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms.
         /// </summary>
-        public double JumpDistance { get; private set; }
+        public readonly double StrainTime;
 
         /// <summary>
-        /// Normalized distance between the start and end position of the previous <see cref="OsuDifficultyHitObject"/>.
+        /// Normalised distance from the "lazy" end position of the previous <see cref="OsuDifficultyHitObject"/> to the start position of this <see cref="OsuDifficultyHitObject"/>.
+        /// <para>
+        /// The "lazy" end position is the position at which the cursor ends up if the previous hitobject is followed with as minimal movement as possible (i.e. on the edge of slider follow circles).
+        /// </para>
+        /// </summary>
+        public double LazyJumpDistance { get; private set; }
+
+        /// <summary>
+        /// Normalised shortest distance to consider for a jump between the previous <see cref="OsuDifficultyHitObject"/> and this <see cref="OsuDifficultyHitObject"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is bounded from above by <see cref="LazyJumpDistance"/>, and is smaller than the former if a more natural path is able to be taken through the previous <see cref="OsuDifficultyHitObject"/>.
+        /// </remarks>
+        /// <example>
+        /// Suppose a linear slider - circle pattern.
+        /// <br />
+        /// Following the slider lazily (see: <see cref="LazyJumpDistance"/>) will result in underestimating the true end position of the slider as being closer towards the start position.
+        /// As a result, <see cref="LazyJumpDistance"/> overestimates the jump distance because the player is able to take a more natural path by following through the slider to its end,
+        /// such that the jump is felt as only starting from the slider's true end position.
+        /// <br />
+        /// Now consider a slider - circle pattern where the circle is stacked along the path inside the slider.
+        /// In this case, the lazy end position correctly estimates the true end position of the slider and provides the more natural movement path.
+        /// </example>
+        public double MinimumJumpDistance { get; private set; }
+
+        /// <summary>
+        /// The time taken to travel through <see cref="MinimumJumpDistance"/>, with a minimum value of 25ms.
+        /// </summary>
+        public double MinimumJumpTime { get; private set; }
+
+        /// <summary>
+        /// Normalised distance between the start and end position of this <see cref="OsuDifficultyHitObject"/>.
         /// </summary>
         public double TravelDistance { get; private set; }
 
+        /// <summary>
+        /// The time taken to travel through <see cref="TravelDistance"/>, with a minimum value of 25ms for a non-zero distance.
+        /// </summary>
+        public double TravelTime { get; private set; }
+
         /// <summary>
         /// Angle the player has to take to hit this <see cref="OsuDifficultyHitObject"/>.
         /// Calculated as the angle between the circles (current-2, current-1, current).
         /// </summary>
         public double? Angle { get; private set; }
 
-        /// <summary>
-        /// Milliseconds elapsed since the start time of the previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 50ms.
-        /// </summary>
-        public readonly double StrainTime;
-
         private readonly OsuHitObject lastLastObject;
         private readonly OsuHitObject lastObject;
 
@@ -46,16 +79,27 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
             this.lastLastObject = (OsuHitObject)lastLastObject;
             this.lastObject = (OsuHitObject)lastObject;
 
-            setDistances();
+            // Capped to 25ms to prevent difficulty calculation breaking from simultaneous objects.
+            StrainTime = Math.Max(DeltaTime, min_delta_time);
 
-            // Every strain interval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure
-            StrainTime = Math.Max(50, DeltaTime);
+            setDistances(clockRate);
         }
 
-        private void setDistances()
+        private void setDistances(double clockRate)
         {
+            if (BaseObject is Slider currentSlider)
+            {
+                computeSliderCursorPosition(currentSlider);
+                TravelDistance = currentSlider.LazyTravelDistance;
+                TravelTime = Math.Max(currentSlider.LazyTravelTime / clockRate, min_delta_time);
+            }
+
+            // We don't need to calculate either angle or distance when one of the last->curr objects is a spinner
+            if (BaseObject is Spinner || lastObject is Spinner)
+                return;
+
             // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-            float scalingFactor = normalized_radius / (float)BaseObject.Radius;
+            float scalingFactor = normalised_radius / (float)BaseObject.Radius;
 
             if (BaseObject.Radius < 30)
             {
@@ -63,19 +107,44 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
                 scalingFactor *= 1 + smallCircleBonus;
             }
 
-            if (lastObject is Slider lastSlider)
-            {
-                computeSliderCursorPosition(lastSlider);
-                TravelDistance = lastSlider.LazyTravelDistance * scalingFactor;
-            }
-
             Vector2 lastCursorPosition = getEndCursorPosition(lastObject);
 
-            // Don't need to jump to reach spinners
-            if (!(BaseObject is Spinner))
-                JumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;
+            LazyJumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;
+            MinimumJumpTime = StrainTime;
+            MinimumJumpDistance = LazyJumpDistance;
 
-            if (lastLastObject != null)
+            if (lastObject is Slider lastSlider)
+            {
+                double lastTravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, min_delta_time);
+                MinimumJumpTime = Math.Max(StrainTime - lastTravelTime, min_delta_time);
+
+                //
+                // There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.
+                //
+                // 1. The anti-flow pattern, where players cut the slider short in order to move to the next hitobject.
+                //
+                //      <======o==>  ← slider
+                //             |     ← most natural jump path
+                //             o     ← a follow-up hitcircle
+                //
+                // In this case the most natural jump path is approximated by LazyJumpDistance.
+                //
+                // 2. The flow pattern, where players follow through the slider to its visual extent into the next hitobject.
+                //
+                //      <======o==>---o
+                //                  ↑
+                //        most natural jump path
+                //
+                // In this case the most natural jump path is better approximated by a new distance called "tailJumpDistance" - the distance between the slider's tail and the next hitobject.
+                //
+                // Thus, the player is assumed to jump the minimum of these two distances in all cases.
+                //
+
+                float tailJumpDistance = Vector2.Subtract(lastSlider.TailCircle.StackedPosition, BaseObject.StackedPosition).Length * scalingFactor;
+                MinimumJumpDistance = Math.Max(0, Math.Min(LazyJumpDistance - (maximum_slider_radius - assumed_slider_radius), tailJumpDistance - maximum_slider_radius));
+            }
+
+            if (lastLastObject != null && !(lastLastObject is Spinner))
             {
                 Vector2 lastLastCursorPosition = getEndCursorPosition(lastLastObject);
 
@@ -94,35 +163,60 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
             if (slider.LazyEndPosition != null)
                 return;
 
-            slider.LazyEndPosition = slider.StackedPosition;
+            slider.LazyTravelTime = slider.NestedHitObjects[^1].StartTime - slider.StartTime;
 
-            float approxFollowCircleRadius = (float)(slider.Radius * 3);
-            var computeVertex = new Action<double>(t =>
+            double endTimeMin = slider.LazyTravelTime / slider.SpanDuration;
+            if (endTimeMin % 2 >= 1)
+                endTimeMin = 1 - endTimeMin % 1;
+            else
+                endTimeMin %= 1;
+
+            slider.LazyEndPosition = slider.StackedPosition + slider.Path.PositionAt(endTimeMin); // temporary lazy end position until a real result can be derived.
+            var currCursorPosition = slider.StackedPosition;
+            double scalingFactor = normalised_radius / slider.Radius; // lazySliderDistance is coded to be sensitive to scaling, this makes the maths easier with the thresholds being used.
+
+            for (int i = 1; i < slider.NestedHitObjects.Count; i++)
             {
-                double progress = (t - slider.StartTime) / slider.SpanDuration;
-                if (progress % 2 >= 1)
-                    progress = 1 - progress % 1;
-                else
-                    progress = progress % 1;
+                var currMovementObj = (OsuHitObject)slider.NestedHitObjects[i];
 
-                // ReSharper disable once PossibleInvalidOperationException (bugged in current r# version)
-                var diff = slider.StackedPosition + slider.Path.PositionAt(progress) - slider.LazyEndPosition.Value;
-                float dist = diff.Length;
+                Vector2 currMovement = Vector2.Subtract(currMovementObj.StackedPosition, currCursorPosition);
+                double currMovementLength = scalingFactor * currMovement.Length;
 
-                if (dist > approxFollowCircleRadius)
+                // Amount of movement required so that the cursor position needs to be updated.
+                double requiredMovement = assumed_slider_radius;
+
+                if (i == slider.NestedHitObjects.Count - 1)
                 {
-                    // The cursor would be outside the follow circle, we need to move it
-                    diff.Normalize(); // Obtain direction of diff
-                    dist -= approxFollowCircleRadius;
-                    slider.LazyEndPosition += diff * dist;
-                    slider.LazyTravelDistance += dist;
-                }
-            });
+                    // The end of a slider has special aim rules due to the relaxed time constraint on position.
+                    // There is both a lazy end position as well as the actual end slider position. We assume the player takes the simpler movement.
+                    // For sliders that are circular, the lazy end position may actually be farther away than the sliders true end.
+                    // This code is designed to prevent buffing situations where lazy end is actually a less efficient movement.
+                    Vector2 lazyMovement = Vector2.Subtract((Vector2)slider.LazyEndPosition, currCursorPosition);
 
-            // Skip the head circle
-            var scoringTimes = slider.NestedHitObjects.Skip(1).Select(t => t.StartTime);
-            foreach (var time in scoringTimes)
-                computeVertex(time);
+                    if (lazyMovement.Length < currMovement.Length)
+                        currMovement = lazyMovement;
+
+                    currMovementLength = scalingFactor * currMovement.Length;
+                }
+                else if (currMovementObj is SliderRepeat)
+                {
+                    // For a slider repeat, assume a tighter movement threshold to better assess repeat sliders.
+                    requiredMovement = normalised_radius;
+                }
+
+                if (currMovementLength > requiredMovement)
+                {
+                    // this finds the positional delta from the required radius and the current position, and updates the currCursorPosition accordingly, as well as rewarding distance.
+                    currCursorPosition = Vector2.Add(currCursorPosition, Vector2.Multiply(currMovement, (float)((currMovementLength - requiredMovement) / currMovementLength)));
+                    currMovementLength *= (currMovementLength - requiredMovement) / currMovementLength;
+                    slider.LazyTravelDistance += (float)currMovementLength;
+                }
+
+                if (i == slider.NestedHitObjects.Count - 1)
+                    slider.LazyEndPosition = currCursorPosition;
+            }
+
+            slider.LazyTravelDistance *= (float)Math.Pow(1 + slider.RepeatCount / 2.5, 1.0 / 2.5); // Bonus for repeat sliders until a better per nested object strain system can be achieved.
         }
 
         private Vector2 getEndCursorPosition(OsuHitObject hitObject)

osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs

@@ -3,7 +3,7 @@
 
 using System;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Objects;
 
@@ -12,48 +12,154 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// <summary>
     /// Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
     /// </summary>
-    public class Aim : Skill
+    public class Aim : OsuStrainSkill
     {
-        private const double angle_bonus_begin = Math.PI / 3;
-        private const double timing_threshold = 107;
-
-        protected override double SkillMultiplier => 26.25;
-        protected override double StrainDecayBase => 0.15;
-
-        protected override double StrainValueOf(DifficultyHitObject current)
+        public Aim(Mod[] mods, bool withSliders)
+            : base(mods)
         {
-            if (current.BaseObject is Spinner)
+            this.withSliders = withSliders;
+        }
+
+        private readonly bool withSliders;
+
+        protected override int HistoryLength => 2;
+
+        private const double wide_angle_multiplier = 1.5;
+        private const double acute_angle_multiplier = 2.0;
+        private const double slider_multiplier = 1.5;
+        private const double velocity_change_multiplier = 0.75;
+
+        private double currentStrain;
+
+        private double skillMultiplier => 23.25;
+        private double strainDecayBase => 0.15;
+
+        private double strainValueOf(DifficultyHitObject current)
+        {
+            if (current.BaseObject is Spinner || Previous.Count <= 1 || Previous[0].BaseObject is Spinner)
                 return 0;
 
-            var osuCurrent = (OsuDifficultyHitObject)current;
+            var osuCurrObj = (OsuDifficultyHitObject)current;
+            var osuLastObj = (OsuDifficultyHitObject)Previous[0];
+            var osuLastLastObj = (OsuDifficultyHitObject)Previous[1];
 
-            double result = 0;
+            // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
+            double currVelocity = osuCurrObj.LazyJumpDistance / osuCurrObj.StrainTime;
 
-            if (Previous.Count > 0)
+            // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
+            if (osuLastObj.BaseObject is Slider && withSliders)
             {
-                var osuPrevious = (OsuDifficultyHitObject)Previous[0];
+                double travelVelocity = osuLastObj.TravelDistance / osuLastObj.TravelTime; // calculate the slider velocity from slider head to slider end.
+                double movementVelocity = osuCurrObj.MinimumJumpDistance / osuCurrObj.MinimumJumpTime; // calculate the movement velocity from slider end to current object
 
-                if (osuCurrent.Angle != null && osuCurrent.Angle.Value > angle_bonus_begin)
+                currVelocity = Math.Max(currVelocity, movementVelocity + travelVelocity); // take the larger total combined velocity.
+            }
+
+            // As above, do the same for the previous hitobject.
+            double prevVelocity = osuLastObj.LazyJumpDistance / osuLastObj.StrainTime;
+
+            if (osuLastLastObj.BaseObject is Slider && withSliders)
+            {
+                double travelVelocity = osuLastLastObj.TravelDistance / osuLastLastObj.TravelTime;
+                double movementVelocity = osuLastObj.MinimumJumpDistance / osuLastObj.MinimumJumpTime;
+
+                prevVelocity = Math.Max(prevVelocity, movementVelocity + travelVelocity);
+            }
+
+            double wideAngleBonus = 0;
+            double acuteAngleBonus = 0;
+            double sliderBonus = 0;
+            double velocityChangeBonus = 0;
+
+            double aimStrain = currVelocity; // Start strain with regular velocity.
+
+            if (Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime) < 1.25 * Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime)) // If rhythms are the same.
+            {
+                if (osuCurrObj.Angle != null && osuLastObj.Angle != null && osuLastLastObj.Angle != null)
                 {
-                    const double scale = 90;
+                    double currAngle = osuCurrObj.Angle.Value;
+                    double lastAngle = osuLastObj.Angle.Value;
+                    double lastLastAngle = osuLastLastObj.Angle.Value;
 
-                    var angleBonus = Math.Sqrt(
-                        Math.Max(osuPrevious.JumpDistance - scale, 0)
-                        * Math.Pow(Math.Sin(osuCurrent.Angle.Value - angle_bonus_begin), 2)
-                        * Math.Max(osuCurrent.JumpDistance - scale, 0));
-                    result = 1.5 * applyDiminishingExp(Math.Max(0, angleBonus)) / Math.Max(timing_threshold, osuPrevious.StrainTime);
+                    // Rewarding angles, take the smaller velocity as base.
+                    double angleBonus = Math.Min(currVelocity, prevVelocity);
+
+                    wideAngleBonus = calcWideAngleBonus(currAngle);
+                    acuteAngleBonus = calcAcuteAngleBonus(currAngle);
+
+                    if (osuCurrObj.StrainTime > 100) // Only buff deltaTime exceeding 300 bpm 1/2.
+                        acuteAngleBonus = 0;
+                    else
+                    {
+                        acuteAngleBonus *= calcAcuteAngleBonus(lastAngle) // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
+                                           * Math.Min(angleBonus, 125 / osuCurrObj.StrainTime) // The maximum velocity we buff is equal to 125 / strainTime
+                                           * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, (100 - osuCurrObj.StrainTime) / 25)), 2) // scale buff from 150 bpm 1/4 to 200 bpm 1/4
+                                           * Math.Pow(Math.Sin(Math.PI / 2 * (Math.Clamp(osuCurrObj.LazyJumpDistance, 50, 100) - 50) / 50), 2); // Buff distance exceeding 50 (radius) up to 100 (diameter).
+                    }
+
+                    // Penalize wide angles if they're repeated, reducing the penalty as the lastAngle gets more acute.
+                    wideAngleBonus *= angleBonus * (1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3)));
+                    // Penalize acute angles if they're repeated, reducing the penalty as the lastLastAngle gets more obtuse.
+                    acuteAngleBonus *= 0.5 + 0.5 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastLastAngle), 3)));
                 }
             }
 
-            double jumpDistanceExp = applyDiminishingExp(osuCurrent.JumpDistance);
-            double travelDistanceExp = applyDiminishingExp(osuCurrent.TravelDistance);
+            if (Math.Max(prevVelocity, currVelocity) != 0)
+            {
+                // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
+                prevVelocity = (osuLastObj.LazyJumpDistance + osuLastLastObj.TravelDistance) / osuLastObj.StrainTime;
+                currVelocity = (osuCurrObj.LazyJumpDistance + osuLastObj.TravelDistance) / osuCurrObj.StrainTime;
 
-            return Math.Max(
-                result + (jumpDistanceExp + travelDistanceExp + Math.Sqrt(travelDistanceExp * jumpDistanceExp)) / Math.Max(osuCurrent.StrainTime, timing_threshold),
-                (Math.Sqrt(travelDistanceExp * jumpDistanceExp) + jumpDistanceExp + travelDistanceExp) / osuCurrent.StrainTime
-            );
+                // Scale with ratio of difference compared to 0.5 * max dist.
+                double distRatio = Math.Pow(Math.Sin(Math.PI / 2 * Math.Abs(prevVelocity - currVelocity) / Math.Max(prevVelocity, currVelocity)), 2);
+
+                // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
+                double overlapVelocityBuff = Math.Min(125 / Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime), Math.Abs(prevVelocity - currVelocity));
+
+                // Reward for % distance slowed down compared to previous, paying attention to not award overlap
+                double nonOverlapVelocityBuff = Math.Abs(prevVelocity - currVelocity)
+                                                // do not award overlap
+                                                * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, Math.Min(osuCurrObj.LazyJumpDistance, osuLastObj.LazyJumpDistance) / 100)), 2);
+
+                // Choose the largest bonus, multiplied by ratio.
+                velocityChangeBonus = Math.Max(overlapVelocityBuff, nonOverlapVelocityBuff) * distRatio;
+
+                // Penalize for rhythm changes.
+                velocityChangeBonus *= Math.Pow(Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime) / Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime), 2);
+            }
+
+            if (osuLastObj.TravelTime != 0)
+            {
+                // Reward sliders based on velocity.
+                sliderBonus = osuLastObj.TravelDistance / osuLastObj.TravelTime;
+            }
+
+            // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
+            aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier + velocityChangeBonus * velocity_change_multiplier);
+
+            // Add in additional slider velocity bonus.
+            if (withSliders)
+                aimStrain += sliderBonus * slider_multiplier;
+
+            return aimStrain;
         }
 
+        private double calcWideAngleBonus(double angle) => Math.Pow(Math.Sin(3.0 / 4 * (Math.Min(5.0 / 6 * Math.PI, Math.Max(Math.PI / 6, angle)) - Math.PI / 6)), 2);
+
+        private double calcAcuteAngleBonus(double angle) => 1 - calcWideAngleBonus(angle);
+
         private double applyDiminishingExp(double val) => Math.Pow(val, 0.99);
+
+        private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
+
+        protected override double CalculateInitialStrain(double time) => currentStrain * strainDecay(time - Previous[0].StartTime);
+
+        protected override double StrainValueAt(DifficultyHitObject current)
+        {
+            currentStrain *= strainDecay(current.DeltaTime);
+            currentStrain += strainValueOf(current) * skillMultiplier;
+
+            return currentStrain;
+        }
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs

@@ -0,0 +1,85 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Skills
+{
+    /// <summary>
+    /// Represents the skill required to memorise and hit every object in a map with the Flashlight mod enabled.
+    /// </summary>
+    public class Flashlight : OsuStrainSkill
+    {
+        public Flashlight(Mod[] mods)
+            : base(mods)
+        {
+        }
+
+        private double skillMultiplier => 0.07;
+        private double strainDecayBase => 0.15;
+        protected override double DecayWeight => 1.0;
+        protected override int HistoryLength => 10; // Look back for 10 notes is added for the sake of flashlight calculations.
+
+        private double currentStrain;
+
+        private double strainValueOf(DifficultyHitObject current)
+        {
+            if (current.BaseObject is Spinner)
+                return 0;
+
+            var osuCurrent = (OsuDifficultyHitObject)current;
+            var osuHitObject = (OsuHitObject)(osuCurrent.BaseObject);
+
+            double scalingFactor = 52.0 / osuHitObject.Radius;
+            double smallDistNerf = 1.0;
+            double cumulativeStrainTime = 0.0;
+
+            double result = 0.0;
+
+            OsuDifficultyHitObject lastObj = osuCurrent;
+
+            // This is iterating backwards in time from the current object.
+            for (int i = 0; i < Previous.Count; i++)
+            {
+                var currentObj = (OsuDifficultyHitObject)Previous[i];
+                var currentHitObject = (OsuHitObject)(currentObj.BaseObject);
+
+                if (!(currentObj.BaseObject is Spinner))
+                {
+                    double jumpDistance = (osuHitObject.StackedPosition - currentHitObject.EndPosition).Length;
+
+                    cumulativeStrainTime += lastObj.StrainTime;
+
+                    // We want to nerf objects that can be easily seen within the Flashlight circle radius.
+                    if (i == 0)
+                        smallDistNerf = Math.Min(1.0, jumpDistance / 75.0);
+
+                    // We also want to nerf stacks so that only the first object of the stack is accounted for.
+                    double stackNerf = Math.Min(1.0, (currentObj.LazyJumpDistance / scalingFactor) / 25.0);
+
+                    result += stackNerf * scalingFactor * jumpDistance / cumulativeStrainTime;
+                }
+
+                lastObj = currentObj;
+            }
+
+            return Math.Pow(smallDistNerf * result, 2.0);
+        }
+
+        private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
+
+        protected override double CalculateInitialStrain(double time) => currentStrain * strainDecay(time - Previous[0].StartTime);
+
+        protected override double StrainValueAt(DifficultyHitObject current)
+        {
+            currentStrain *= strainDecay(current.DeltaTime);
+            currentStrain += strainValueOf(current) * skillMultiplier;
+
+            return currentStrain;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Mods;
+using System.Linq;
+using osu.Framework.Utils;
+
+namespace osu.Game.Rulesets.Osu.Difficulty.Skills
+{
+    public abstract class OsuStrainSkill : StrainSkill
+    {
+        /// <summary>
+        /// The number of sections with the highest strains, which the peak strain reductions will apply to.
+        /// This is done in order to decrease their impact on the overall difficulty of the map for this skill.
+        /// </summary>
+        protected virtual int ReducedSectionCount => 10;
+
+        /// <summary>
+        /// The baseline multiplier applied to the section with the biggest strain.
+        /// </summary>
+        protected virtual double ReducedStrainBaseline => 0.75;
+
+        /// <summary>
+        /// The final multiplier to be applied to <see cref="DifficultyValue"/> after all other calculations.
+        /// </summary>
+        protected virtual double DifficultyMultiplier => 1.06;
+
+        protected OsuStrainSkill(Mod[] mods)
+            : base(mods)
+        {
+        }
+
+        public override double DifficultyValue()
+        {
+            double difficulty = 0;
+            double weight = 1;
+
+            List<double> strains = GetCurrentStrainPeaks().OrderByDescending(d => d).ToList();
+
+            // We are reducing the highest strains first to account for extreme difficulty spikes
+            for (int i = 0; i < Math.Min(strains.Count, ReducedSectionCount); i++)
+            {
+                double scale = Math.Log10(Interpolation.Lerp(1, 10, Math.Clamp((float)i / ReducedSectionCount, 0, 1)));
+                strains[i] *= Interpolation.Lerp(ReducedStrainBaseline, 1.0, scale);
+            }
+
+            // Difficulty is the weighted sum of the highest strains from every section.
+            // We're sorting from highest to lowest strain.
+            foreach (double strain in strains.OrderByDescending(d => d))
+            {
+                difficulty += strain * weight;
+                weight *= DecayWeight;
+            }
+
+            return difficulty * DifficultyMultiplier;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs

@@ -3,61 +3,177 @@
 
 using System;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Framework.Utils;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 {
     /// <summary>
     /// Represents the skill required to press keys with regards to keeping up with the speed at which objects need to be hit.
     /// </summary>
-    public class Speed : Skill
+    public class Speed : OsuStrainSkill
     {
         private const double single_spacing_threshold = 125;
-
-        private const double angle_bonus_begin = 5 * Math.PI / 6;
-        private const double pi_over_4 = Math.PI / 4;
-        private const double pi_over_2 = Math.PI / 2;
-
-        protected override double SkillMultiplier => 1400;
-        protected override double StrainDecayBase => 0.3;
-
+        private const double rhythm_multiplier = 0.75;
+        private const int history_time_max = 5000; // 5 seconds of calculatingRhythmBonus max.
         private const double min_speed_bonus = 75; // ~200BPM
-        private const double max_speed_bonus = 45; // ~330BPM
         private const double speed_balancing_factor = 40;
 
-        protected override double StrainValueOf(DifficultyHitObject current)
+        private double skillMultiplier => 1375;
+        private double strainDecayBase => 0.3;
+
+        private double currentStrain;
+        private double currentRhythm;
+
+        protected override int ReducedSectionCount => 5;
+        protected override double DifficultyMultiplier => 1.04;
+        protected override int HistoryLength => 32;
+
+        private readonly double greatWindow;
+
+        public Speed(Mod[] mods, double hitWindowGreat)
+            : base(mods)
+        {
+            greatWindow = hitWindowGreat;
+        }
+
+        /// <summary>
+        /// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current <see cref="OsuDifficultyHitObject"/>.
+        /// </summary>
+        private double calculateRhythmBonus(DifficultyHitObject current)
         {
             if (current.BaseObject is Spinner)
                 return 0;
 
-            var osuCurrent = (OsuDifficultyHitObject)current;
+            int previousIslandSize = 0;
 
-            double distance = Math.Min(single_spacing_threshold, osuCurrent.TravelDistance + osuCurrent.JumpDistance);
-            double deltaTime = Math.Max(max_speed_bonus, current.DeltaTime);
+            double rhythmComplexitySum = 0;
+            int islandSize = 1;
+            double startRatio = 0; // store the ratio of the current start of an island to buff for tighter rhythms
 
-            double speedBonus = 1.0;
-            if (deltaTime < min_speed_bonus)
-                speedBonus = 1 + Math.Pow((min_speed_bonus - deltaTime) / speed_balancing_factor, 2);
+            bool firstDeltaSwitch = false;
 
-            double angleBonus = 1.0;
+            int rhythmStart = 0;
 
-            if (osuCurrent.Angle != null && osuCurrent.Angle.Value < angle_bonus_begin)
+            while (rhythmStart < Previous.Count - 2 && current.StartTime - Previous[rhythmStart].StartTime < history_time_max)
+                rhythmStart++;
+
+            for (int i = rhythmStart; i > 0; i--)
             {
-                angleBonus = 1 + Math.Pow(Math.Sin(1.5 * (angle_bonus_begin - osuCurrent.Angle.Value)), 2) / 3.57;
+                OsuDifficultyHitObject currObj = (OsuDifficultyHitObject)Previous[i - 1];
+                OsuDifficultyHitObject prevObj = (OsuDifficultyHitObject)Previous[i];
+                OsuDifficultyHitObject lastObj = (OsuDifficultyHitObject)Previous[i + 1];
 
-                if (osuCurrent.Angle.Value < pi_over_2)
+                double currHistoricalDecay = (history_time_max - (current.StartTime - currObj.StartTime)) / history_time_max; // scales note 0 to 1 from history to now
+
+                currHistoricalDecay = Math.Min((double)(Previous.Count - i) / Previous.Count, currHistoricalDecay); // either we're limited by time or limited by object count.
+
+                double currDelta = currObj.StrainTime;
+                double prevDelta = prevObj.StrainTime;
+                double lastDelta = lastObj.StrainTime;
+                double currRatio = 1.0 + 6.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
+
+                double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - greatWindow * 0.6) / (greatWindow * 0.6));
+
+                windowPenalty = Math.Min(1, windowPenalty);
+
+                double effectiveRatio = windowPenalty * currRatio;
+
+                if (firstDeltaSwitch)
                 {
-                    angleBonus = 1.28;
-                    if (distance < 90 && osuCurrent.Angle.Value < pi_over_4)
-                        angleBonus += (1 - angleBonus) * Math.Min((90 - distance) / 10, 1);
-                    else if (distance < 90)
-                        angleBonus += (1 - angleBonus) * Math.Min((90 - distance) / 10, 1) * Math.Sin((pi_over_2 - osuCurrent.Angle.Value) / pi_over_4);
+                    if (!(prevDelta > 1.25 * currDelta || prevDelta * 1.25 < currDelta))
+                    {
+                        if (islandSize < 7)
+                            islandSize++; // island is still progressing, count size.
+                    }
+                    else
+                    {
+                        if (Previous[i - 1].BaseObject is Slider) // bpm change is into slider, this is easy acc window
+                            effectiveRatio *= 0.125;
+
+                        if (Previous[i].BaseObject is Slider) // bpm change was from a slider, this is easier typically than circle -> circle
+                            effectiveRatio *= 0.25;
+
+                        if (previousIslandSize == islandSize) // repeated island size (ex: triplet -> triplet)
+                            effectiveRatio *= 0.25;
+
+                        if (previousIslandSize % 2 == islandSize % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
+                            effectiveRatio *= 0.50;
+
+                        if (lastDelta > prevDelta + 10 && prevDelta > currDelta + 10) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
+                            effectiveRatio *= 0.125;
+
+                        rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay * Math.Sqrt(4 + islandSize) / 2 * Math.Sqrt(4 + previousIslandSize) / 2;
+
+                        startRatio = effectiveRatio;
+
+                        previousIslandSize = islandSize; // log the last island size.
+
+                        if (prevDelta * 1.25 < currDelta) // we're slowing down, stop counting
+                            firstDeltaSwitch = false; // if we're speeding up, this stays true and  we keep counting island size.
+
+                        islandSize = 1;
+                    }
+                }
+                else if (prevDelta > 1.25 * currDelta) // we want to be speeding up.
+                {
+                    // Begin counting island until we change speed again.
+                    firstDeltaSwitch = true;
+                    startRatio = effectiveRatio;
+                    islandSize = 1;
                 }
             }
 
-            return (1 + (speedBonus - 1) * 0.75) * angleBonus * (0.95 + speedBonus * Math.Pow(distance / single_spacing_threshold, 3.5)) / osuCurrent.StrainTime;
+            return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
+        }
+
+        private double strainValueOf(DifficultyHitObject current)
+        {
+            if (current.BaseObject is Spinner)
+                return 0;
+
+            // derive strainTime for calculation
+            var osuCurrObj = (OsuDifficultyHitObject)current;
+            var osuPrevObj = Previous.Count > 0 ? (OsuDifficultyHitObject)Previous[0] : null;
+
+            double strainTime = osuCurrObj.StrainTime;
+            double greatWindowFull = greatWindow * 2;
+            double speedWindowRatio = strainTime / greatWindowFull;
+
+            // Aim to nerf cheesy rhythms (Very fast consecutive doubles with large deltatimes between)
+            if (osuPrevObj != null && strainTime < greatWindowFull && osuPrevObj.StrainTime > strainTime)
+                strainTime = Interpolation.Lerp(osuPrevObj.StrainTime, strainTime, speedWindowRatio);
+
+            // Cap deltatime to the OD 300 hitwindow.
+            // 0.93 is derived from making sure 260bpm OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
+            strainTime /= Math.Clamp((strainTime / greatWindowFull) / 0.93, 0.92, 1);
+
+            // derive speedBonus for calculation
+            double speedBonus = 1.0;
+
+            if (strainTime < min_speed_bonus)
+                speedBonus = 1 + 0.75 * Math.Pow((min_speed_bonus - strainTime) / speed_balancing_factor, 2);
+
+            double travelDistance = osuPrevObj?.TravelDistance ?? 0;
+            double distance = Math.Min(single_spacing_threshold, travelDistance + osuCurrObj.MinimumJumpDistance);
+
+            return (speedBonus + speedBonus * Math.Pow(distance / single_spacing_threshold, 3.5)) / strainTime;
+        }
+
+        private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
+
+        protected override double CalculateInitialStrain(double time) => (currentStrain * currentRhythm) * strainDecay(time - Previous[0].StartTime);
+
+        protected override double StrainValueAt(DifficultyHitObject current)
+        {
+            currentStrain *= strainDecay(current.DeltaTime);
+            currentStrain += strainValueOf(current) * skillMultiplier;
+
+            currentRhythm = calculateRhythmBonus(current);
+
+            return currentStrain * currentRhythm;
         }
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/BlueprintPiece.cs

@@ -0,0 +1,25 @@
+// 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.Containers;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints
+{
+    /// <summary>
+    /// A piece of a selection or placement blueprint which visualises an <see cref="OsuHitObject"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of <see cref="OsuHitObject"/> which this <see cref="BlueprintPiece{T}"/> visualises.</typeparam>
+    public abstract class BlueprintPiece<T> : CompositeDrawable
+        where T : OsuHitObject
+    {
+        /// <summary>
+        /// Updates this <see cref="BlueprintPiece{T}"/> using the properties of a <see cref="OsuHitObject"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="OsuHitObject"/> to reference properties from.</param>
+        public virtual void UpdateFrom(T hitObject)
+        {
+            Position = hitObject.StackedPosition;
+        }
+    }
+}

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

@@ -5,24 +5,21 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
 {
-    public class HitCirclePiece : HitObjectPiece
+    public class HitCirclePiece : BlueprintPiece<HitCircle>
     {
-        private readonly HitCircle hitCircle;
-
-        public HitCirclePiece(HitCircle hitCircle)
-            : base(hitCircle)
+        public HitCirclePiece()
         {
-            this.hitCircle = hitCircle;
             Origin = Anchor.Centre;
 
             Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
-            Scale = new Vector2(hitCircle.Scale);
+
             CornerRadius = Size.X / 2;
+            CornerExponent = 2;
 
             InternalChild = new RingPiece();
         }
@@ -31,12 +28,13 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
         private void load(OsuColour colours)
         {
             Colour = colours.Yellow;
-
-            PositionBindable.BindValueChanged(_ => UpdatePosition(), true);
-            StackHeightBindable.BindValueChanged(_ => UpdatePosition());
-            ScaleBindable.BindValueChanged(scale => Scale = new Vector2(scale.NewValue), true);
         }
 
-        protected virtual void UpdatePosition() => Position = hitCircle.StackedPosition;
+        public override void UpdateFrom(HitCircle hitObject)
+        {
+            base.UpdateFrom(hitObject);
+
+            Scale = new Vector2(hitObject.Scale);
+        }
     }
 }

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

@@ -5,7 +5,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
-using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 {
@@ -13,31 +13,42 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
     {
         public new HitCircle HitObject => (HitCircle)base.HitObject;
 
+        private readonly HitCirclePiece circlePiece;
+
         public HitCirclePlacementBlueprint()
             : base(new HitCircle())
         {
-            InternalChild = new HitCirclePiece(HitObject);
+            InternalChild = circlePiece = new HitCirclePiece();
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
-
-            // Fixes a 1-frame position discrepancy due to the first mouse move event happening in the next frame
-            HitObject.Position = Parent?.ToLocalSpace(GetContainingInputManager().CurrentState.Mouse.Position) ?? Vector2.Zero;
+            BeginPlacement();
         }
 
-        protected override bool OnClick(ClickEvent e)
+        protected override void Update()
         {
-            HitObject.StartTime = EditorClock.CurrentTime;
-            EndPlacement();
-            return true;
+            base.Update();
+
+            circlePiece.UpdateFrom(HitObject);
         }
 
-        protected override bool OnMouseMove(MouseMoveEvent e)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
-            HitObject.Position = e.MousePosition;
-            return true;
+            if (e.Button == MouseButton.Left)
+            {
+                EndPlacement(true);
+                return true;
+            }
+
+            return base.OnMouseDown(e);
+        }
+
+        public override void UpdateTimeAndPosition(SnapResult result)
+        {
+            base.UpdateTimeAndPosition(result);
+            HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
         }
     }
 }

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

@@ -1,18 +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 osu.Framework.Graphics.Primitives;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 {
-    public class HitCircleSelectionBlueprint : OsuSelectionBlueprint
+    public class HitCircleSelectionBlueprint : OsuSelectionBlueprint<HitCircle>
     {
-        public HitCircleSelectionBlueprint(DrawableHitCircle hitCircle)
-            : base(hitCircle)
+        protected new DrawableHitCircle DrawableObject => (DrawableHitCircle)base.DrawableObject;
+
+        protected readonly HitCirclePiece CirclePiece;
+
+        public HitCircleSelectionBlueprint(HitCircle circle)
+            : base(circle)
         {
-            InternalChild = new HitCirclePiece((HitCircle)hitCircle.HitObject);
+            InternalChild = CirclePiece = new HitCirclePiece();
         }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            CirclePiece.UpdateFrom(HitObject);
+        }
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => DrawableObject.HitArea.ReceivePositionalInputAt(screenSpacePos);
+
+        public override Quad SelectionQuad => CirclePiece.ScreenSpaceDrawQuad;
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/HitObjectPiece.cs

@@ -1,36 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Osu.Objects;
-using osuTK;
-
-namespace osu.Game.Rulesets.Osu.Edit.Blueprints
-{
-    /// <summary>
-    /// A piece of a blueprint which responds to changes in the state of a <see cref="OsuHitObject"/>.
-    /// </summary>
-    public abstract class HitObjectPiece : CompositeDrawable
-    {
-        protected readonly IBindable<Vector2> PositionBindable = new Bindable<Vector2>();
-        protected readonly IBindable<int> StackHeightBindable = new Bindable<int>();
-        protected readonly IBindable<float> ScaleBindable = new Bindable<float>();
-
-        private readonly OsuHitObject hitObject;
-
-        protected HitObjectPiece(OsuHitObject hitObject)
-        {
-            this.hitObject = hitObject;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            PositionBindable.BindTo(hitObject.PositionBindable);
-            StackHeightBindable.BindTo(hitObject.StackHeightBindable);
-            ScaleBindable.BindTo(hitObject.ScaleBindable);
-        }
-    }
-}

osu.Game.Rulesets.Osu/Edit/Blueprints/OsuSelectionBlueprint.cs

@@ -2,16 +2,19 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints
 {
-    public class OsuSelectionBlueprint : SelectionBlueprint
+    public abstract class OsuSelectionBlueprint<T> : HitObjectSelectionBlueprint<T>
+        where T : OsuHitObject
     {
-        protected OsuHitObject OsuObject => (OsuHitObject)HitObject.HitObject;
+        protected new DrawableOsuHitObject DrawableObject => (DrawableOsuHitObject)base.DrawableObject;
 
-        public OsuSelectionBlueprint(DrawableHitObject hitObject)
+        protected override bool AlwaysShowWhenSelected => true;
+
+        protected OsuSelectionBlueprint(T hitObject)
             : base(hitObject)
         {
         }

osu.Game.Rulesets.Osu/Edit/Blueprints/SliderPiece.cs

@@ -1,32 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Osu.Objects;
-
-namespace osu.Game.Rulesets.Osu.Edit.Blueprints
-{
-    /// <summary>
-    /// A piece of a blueprint which responds to changes in the state of a <see cref="Slider"/>.
-    /// </summary>
-    public abstract class SliderPiece : HitObjectPiece
-    {
-        protected readonly IBindable<SliderPath> PathBindable = new Bindable<SliderPath>();
-
-        private readonly Slider slider;
-
-        protected SliderPiece(Slider slider)
-            : base(slider)
-        {
-            this.slider = slider;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            PathBindable.BindTo(slider.PathBindable);
-        }
-    }
-}

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

@@ -0,0 +1,77 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Lines;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
+{
+    /// <summary>
+    /// A visualisation of the line between two <see cref="PathControlPointPiece"/>s.
+    /// </summary>
+    public class PathControlPointConnectionPiece : CompositeDrawable
+    {
+        public readonly PathControlPoint ControlPoint;
+
+        private readonly Path path;
+        private readonly Slider slider;
+        public int ControlPointIndex { get; set; }
+
+        private IBindable<Vector2> sliderPosition;
+        private IBindable<int> pathVersion;
+
+        public PathControlPointConnectionPiece(Slider slider, int controlPointIndex)
+        {
+            this.slider = slider;
+            ControlPointIndex = controlPointIndex;
+
+            Origin = Anchor.Centre;
+            AutoSizeAxes = Axes.Both;
+
+            ControlPoint = slider.Path.ControlPoints[controlPointIndex];
+
+            InternalChild = path = new SmoothPath
+            {
+                Anchor = Anchor.Centre,
+                PathRadius = 1
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            sliderPosition = slider.PositionBindable.GetBoundCopy();
+            sliderPosition.BindValueChanged(_ => updateConnectingPath());
+
+            pathVersion = slider.Path.Version.GetBoundCopy();
+            pathVersion.BindValueChanged(_ => updateConnectingPath());
+
+            updateConnectingPath();
+        }
+
+        /// <summary>
+        /// Updates the path connecting this control point to the next one.
+        /// </summary>
+        private void updateConnectingPath()
+        {
+            Position = slider.StackedPosition + ControlPoint.Position;
+
+            path.ClearVertices();
+
+            int nextIndex = ControlPointIndex + 1;
+            if (nextIndex == 0 || nextIndex >= slider.Path.ControlPoints.Count)
+                return;
+
+            path.AddVertex(Vector2.Zero);
+            path.AddVertex(slider.Path.ControlPoints[nextIndex].Position - ControlPoint.Position);
+
+            path.OriginPosition = path.PositionInBoundingBox(Vector2.Zero);
+        }
+    }
+}

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

@@ -1,112 +1,268 @@
 // 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 osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Lines;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
-    public class PathControlPointPiece : CompositeDrawable
+    /// <summary>
+    /// A visualisation of a single <see cref="PathControlPoint"/> in a <see cref="Slider"/>.
+    /// </summary>
+    public class PathControlPointPiece : BlueprintPiece<Slider>, IHasTooltip
     {
-        private readonly Slider slider;
-        private readonly int index;
+        public Action<PathControlPointPiece, MouseButtonEvent> RequestSelection;
 
-        private readonly Path path;
-        private readonly CircularContainer marker;
+        public Action<PathControlPoint> DragStarted;
+        public Action<DragEvent> DragInProgress;
+        public Action DragEnded;
+
+        public List<PathControlPoint> PointsInSegment;
+
+        public readonly BindableBool IsSelected = new BindableBool();
+        public readonly PathControlPoint ControlPoint;
+
+        private readonly Slider slider;
+        private readonly Container marker;
+        private readonly Drawable markerRing;
 
         [Resolved]
         private OsuColour colours { get; set; }
 
-        public PathControlPointPiece(Slider slider, int index)
+        private IBindable<Vector2> sliderPosition;
+        private IBindable<float> sliderScale;
+
+        public PathControlPointPiece(Slider slider, PathControlPoint controlPoint)
         {
             this.slider = slider;
-            this.index = index;
+            ControlPoint = controlPoint;
+
+            // we don't want to run the path type update on construction as it may inadvertently change the slider.
+            cachePoints(slider);
+
+            slider.Path.Version.BindValueChanged(_ =>
+            {
+                cachePoints(slider);
+                updatePathType();
+            });
+
+            controlPoint.Changed += updateMarkerDisplay;
 
             Origin = Anchor.Centre;
             AutoSizeAxes = Axes.Both;
 
             InternalChildren = new Drawable[]
             {
-                path = new SmoothPath
-                {
-                    Anchor = Anchor.Centre,
-                    PathRadius = 1
-                },
-                marker = new CircularContainer
+                marker = new Container
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(10),
-                    Masking = true,
-                    Child = new Box { RelativeSizeAxes = Axes.Both }
+                    AutoSizeAxes = Axes.Both,
+                    Children = new[]
+                    {
+                        new Circle
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(20),
+                        },
+                        markerRing = new CircularContainer
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(28),
+                            Masking = true,
+                            BorderThickness = 2,
+                            BorderColour = Color4.White,
+                            Alpha = 0,
+                            Child = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0,
+                                AlwaysPresent = true
+                            }
+                        }
+                    }
                 }
             };
         }
 
-        protected override void Update()
+        protected override void LoadComplete()
         {
-            base.Update();
+            base.LoadComplete();
 
-            Position = slider.StackedPosition + slider.Path.ControlPoints[index];
+            sliderPosition = slider.PositionBindable.GetBoundCopy();
+            sliderPosition.BindValueChanged(_ => updateMarkerDisplay());
 
-            marker.Colour = isSegmentSeparator ? colours.Red : colours.Yellow;
+            sliderScale = slider.ScaleBindable.GetBoundCopy();
+            sliderScale.BindValueChanged(_ => updateMarkerDisplay());
 
-            path.ClearVertices();
+            IsSelected.BindValueChanged(_ => updateMarkerDisplay());
 
-            if (index != slider.Path.ControlPoints.Length - 1)
-            {
-                path.AddVertex(Vector2.Zero);
-                path.AddVertex(slider.Path.ControlPoints[index + 1] - slider.Path.ControlPoints[index]);
-            }
-
-            path.OriginPosition = path.PositionInBoundingBox(Vector2.Zero);
+            updateMarkerDisplay();
         }
 
+        // The connecting path is excluded from positional input
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => marker.ReceivePositionalInputAt(screenSpacePos);
 
-        protected override bool OnDragStart(DragStartEvent e) => true;
-
-        protected override bool OnDrag(DragEvent e)
+        protected override bool OnHover(HoverEvent e)
         {
-            var newControlPoints = slider.Path.ControlPoints.ToArray();
-
-            if (index == 0)
-            {
-                // Special handling for the head - only the position of the slider changes
-                slider.Position += e.Delta;
-
-                // Since control points are relative to the position of the slider, they all need to be offset backwards by the delta
-                for (int i = 1; i < newControlPoints.Length; i++)
-                    newControlPoints[i] -= e.Delta;
-            }
-            else
-                newControlPoints[index] += e.Delta;
-
-            if (isSegmentSeparatorWithNext)
-                newControlPoints[index + 1] = newControlPoints[index];
-
-            if (isSegmentSeparatorWithPrevious)
-                newControlPoints[index - 1] = newControlPoints[index];
-
-            slider.Path = new SliderPath(slider.Path.Type, newControlPoints);
-
-            return true;
+            updateMarkerDisplay();
+            return false;
         }
 
-        protected override bool OnDragEnd(DragEndEvent e) => true;
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            updateMarkerDisplay();
+        }
 
-        private bool isSegmentSeparator => isSegmentSeparatorWithNext || isSegmentSeparatorWithPrevious;
+        // Used to pair up mouse down/drag events with their corresponding mouse up events,
+        // to avoid deselecting the piece by accident when the mouse up corresponding to the mouse down/drag fires.
+        private bool keepSelection;
 
-        private bool isSegmentSeparatorWithNext => index < slider.Path.ControlPoints.Length - 1 && slider.Path.ControlPoints[index + 1] == slider.Path.ControlPoints[index];
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            if (RequestSelection == null)
+                return false;
 
-        private bool isSegmentSeparatorWithPrevious => index > 0 && slider.Path.ControlPoints[index - 1] == slider.Path.ControlPoints[index];
+            switch (e.Button)
+            {
+                case MouseButton.Left:
+                    // if control is pressed, do not do anything as the user may be adding to current selection
+                    // or dragging all currently selected control points.
+                    // if it isn't and the user's intent is to deselect, deselection will happen on mouse up.
+                    if (e.ControlPressed && IsSelected.Value)
+                        return true;
+
+                    RequestSelection.Invoke(this, e);
+                    keepSelection = true;
+
+                    return true;
+
+                case MouseButton.Right:
+                    if (!IsSelected.Value)
+                        RequestSelection.Invoke(this, e);
+
+                    keepSelection = true;
+                    return false; // Allow context menu to show
+            }
+
+            return false;
+        }
+
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            base.OnMouseUp(e);
+
+            // ctrl+click deselects this piece, but only if this event
+            // wasn't immediately preceded by a matching mouse down or drag.
+            if (IsSelected.Value && e.ControlPressed && !keepSelection)
+                IsSelected.Value = false;
+
+            keepSelection = false;
+        }
+
+        protected override bool OnClick(ClickEvent e) => RequestSelection != null;
+
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            if (RequestSelection == null)
+                return false;
+
+            if (e.Button == MouseButton.Left)
+            {
+                DragStarted?.Invoke(ControlPoint);
+                keepSelection = true;
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override void OnDrag(DragEvent e) => DragInProgress?.Invoke(e);
+
+        protected override void OnDragEnd(DragEndEvent e) => DragEnded?.Invoke();
+
+        private void cachePoints(Slider slider) => PointsInSegment = slider.Path.PointsInSegment(ControlPoint);
+
+        /// <summary>
+        /// Handles correction of invalid path types.
+        /// </summary>
+        private void updatePathType()
+        {
+            if (ControlPoint.Type != PathType.PerfectCurve)
+                return;
+
+            if (PointsInSegment.Count > 3)
+                ControlPoint.Type = PathType.Bezier;
+
+            if (PointsInSegment.Count != 3)
+                return;
+
+            ReadOnlySpan<Vector2> points = PointsInSegment.Select(p => p.Position).ToArray();
+            RectangleF boundingBox = PathApproximator.CircularArcBoundingBox(points);
+            if (boundingBox.Width >= 640 || boundingBox.Height >= 480)
+                ControlPoint.Type = PathType.Bezier;
+        }
+
+        /// <summary>
+        /// Updates the state of the circular control point marker.
+        /// </summary>
+        private void updateMarkerDisplay()
+        {
+            Position = slider.StackedPosition + ControlPoint.Position;
+
+            markerRing.Alpha = IsSelected.Value ? 1 : 0;
+
+            Color4 colour = getColourFromNodeType();
+
+            if (IsHovered || IsSelected.Value)
+                colour = colour.Lighten(1);
+
+            marker.Colour = colour;
+            marker.Scale = new Vector2(slider.Scale);
+        }
+
+        private Color4 getColourFromNodeType()
+        {
+            if (!(ControlPoint.Type is PathType pathType))
+                return colours.Yellow;
+
+            switch (pathType)
+            {
+                case PathType.Catmull:
+                    return colours.SeaFoam;
+
+                case PathType.Bezier:
+                    return colours.Pink;
+
+                case PathType.PerfectCurve:
+                    return colours.PurpleDark;
+
+                default:
+                    return colours.Red;
+            }
+        }
+
+        public LocalisableString TooltipText => ControlPoint.Type.ToString() ?? string.Empty;
     }
 }

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

@@ -1,39 +1,361 @@
 // 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.Collections.Specialized;
+using System.Diagnostics;
+using System.Linq;
+using Humanizer;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
+using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
-    public class PathControlPointVisualiser : SliderPiece
+    public class PathControlPointVisualiser : CompositeDrawable, IKeyBindingHandler<PlatformAction>, IHasContextMenu
     {
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true; // allow context menu to appear outside of the playfield.
+
+        internal readonly Container<PathControlPointPiece> Pieces;
+        internal readonly Container<PathControlPointConnectionPiece> Connections;
+
+        private readonly IBindableList<PathControlPoint> controlPoints = new BindableList<PathControlPoint>();
         private readonly Slider slider;
+        private readonly bool allowSelection;
 
-        private readonly Container<PathControlPointPiece> pieces;
+        private InputManager inputManager;
 
-        public PathControlPointVisualiser(Slider slider)
-            : base(slider)
+        public Action<List<PathControlPoint>> RemoveControlPointsRequested;
+
+        [Resolved(CanBeNull = true)]
+        private IPositionSnapProvider snapProvider { get; set; }
+
+        public PathControlPointVisualiser(Slider slider, bool allowSelection)
         {
             this.slider = slider;
+            this.allowSelection = allowSelection;
 
-            InternalChild = pieces = new Container<PathControlPointPiece> { RelativeSizeAxes = Axes.Both };
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                Connections = new Container<PathControlPointConnectionPiece> { RelativeSizeAxes = Axes.Both },
+                Pieces = new Container<PathControlPointPiece> { RelativeSizeAxes = Axes.Both }
+            };
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
+        protected override void LoadComplete()
         {
-            PathBindable.BindValueChanged(_ => updatePathControlPoints(), true);
+            base.LoadComplete();
+
+            inputManager = GetContainingInputManager();
+
+            controlPoints.CollectionChanged += onControlPointsChanged;
+            controlPoints.BindTo(slider.Path.ControlPoints);
         }
 
-        private void updatePathControlPoints()
+        /// <summary>
+        /// Selects the <see cref="PathControlPointPiece"/> corresponding to the given <paramref name="pathControlPoint"/>,
+        /// and deselects all other <see cref="PathControlPointPiece"/>s.
+        /// </summary>
+        public void SetSelectionTo(PathControlPoint pathControlPoint)
         {
-            while (slider.Path.ControlPoints.Length > pieces.Count)
-                pieces.Add(new PathControlPointPiece(slider, pieces.Count));
-            while (slider.Path.ControlPoints.Length < pieces.Count)
-                pieces.Remove(pieces[pieces.Count - 1]);
+            foreach (var p in Pieces)
+                p.IsSelected.Value = p.ControlPoint == pathControlPoint;
+        }
+
+        /// <summary>
+        /// Delete all visually selected <see cref="PathControlPoint"/>s.
+        /// </summary>
+        /// <returns></returns>
+        public bool DeleteSelected()
+        {
+            List<PathControlPoint> toRemove = Pieces.Where(p => p.IsSelected.Value).Select(p => p.ControlPoint).ToList();
+
+            // Ensure that there are any points to be deleted
+            if (toRemove.Count == 0)
+                return false;
+
+            changeHandler?.BeginChange();
+            RemoveControlPointsRequested?.Invoke(toRemove);
+            changeHandler?.EndChange();
+
+            // Since pieces are re-used, they will not point to the deleted control points while remaining selected
+            foreach (var piece in Pieces)
+                piece.IsSelected.Value = false;
+
+            return true;
+        }
+
+        private void onControlPointsChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            switch (e.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                    // If inserting in the path (not appending),
+                    // update indices of existing connections after insert location
+                    if (e.NewStartingIndex < Pieces.Count)
+                    {
+                        foreach (var connection in Connections)
+                        {
+                            if (connection.ControlPointIndex >= e.NewStartingIndex)
+                                connection.ControlPointIndex += e.NewItems.Count;
+                        }
+                    }
+
+                    for (int i = 0; i < e.NewItems.Count; i++)
+                    {
+                        var point = (PathControlPoint)e.NewItems[i];
+
+                        Pieces.Add(new PathControlPointPiece(slider, point).With(d =>
+                        {
+                            if (allowSelection)
+                                d.RequestSelection = selectionRequested;
+
+                            d.DragStarted = dragStarted;
+                            d.DragInProgress = dragInProgress;
+                            d.DragEnded = dragEnded;
+                        }));
+
+                        Connections.Add(new PathControlPointConnectionPiece(slider, e.NewStartingIndex + i));
+                    }
+
+                    break;
+
+                case NotifyCollectionChangedAction.Remove:
+                    foreach (var point in e.OldItems.Cast<PathControlPoint>())
+                    {
+                        Pieces.RemoveAll(p => p.ControlPoint == point);
+                        Connections.RemoveAll(c => c.ControlPoint == point);
+                    }
+
+                    // If removing before the end of the path,
+                    // update indices of connections after remove location
+                    if (e.OldStartingIndex < Pieces.Count)
+                    {
+                        foreach (var connection in Connections)
+                        {
+                            if (connection.ControlPointIndex >= e.OldStartingIndex)
+                                connection.ControlPointIndex -= e.OldItems.Count;
+                        }
+                    }
+
+                    break;
+            }
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            if (Pieces.Any(piece => piece.IsHovered))
+                return false;
+
+            foreach (var piece in Pieces)
+            {
+                piece.IsSelected.Value = false;
+            }
+
+            return false;
+        }
+
+        public bool OnPressed(KeyBindingPressEvent<PlatformAction> e)
+        {
+            switch (e.Action)
+            {
+                case PlatformAction.Delete:
+                    return DeleteSelected();
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<PlatformAction> e)
+        {
+        }
+
+        private void selectionRequested(PathControlPointPiece piece, MouseButtonEvent e)
+        {
+            if (e.Button == MouseButton.Left && inputManager.CurrentState.Keyboard.ControlPressed)
+                piece.IsSelected.Toggle();
+            else
+                SetSelectionTo(piece.ControlPoint);
+        }
+
+        /// <summary>
+        /// Attempts to set the given control point piece to the given path type.
+        /// If that would fail, try to change the path such that it instead succeeds
+        /// in a UX-friendly way.
+        /// </summary>
+        /// <param name="piece">The control point piece that we want to change the path type of.</param>
+        /// <param name="type">The path type we want to assign to the given control point piece.</param>
+        private void updatePathType(PathControlPointPiece piece, PathType? type)
+        {
+            int indexInSegment = piece.PointsInSegment.IndexOf(piece.ControlPoint);
+
+            switch (type)
+            {
+                case PathType.PerfectCurve:
+                    // Can't always create a circular arc out of 4 or more points,
+                    // so we split the segment into one 3-point circular arc segment
+                    // and one segment of the previous type.
+                    int thirdPointIndex = indexInSegment + 2;
+
+                    if (piece.PointsInSegment.Count > thirdPointIndex + 1)
+                        piece.PointsInSegment[thirdPointIndex].Type = piece.PointsInSegment[0].Type;
+
+                    break;
+            }
+
+            piece.ControlPoint.Type = type;
+        }
+
+        [Resolved(CanBeNull = true)]
+        private IEditorChangeHandler changeHandler { get; set; }
+
+        #region Drag handling
+
+        private Vector2[] dragStartPositions;
+        private PathType?[] dragPathTypes;
+        private int draggedControlPointIndex;
+        private HashSet<PathControlPoint> selectedControlPoints;
+
+        private void dragStarted(PathControlPoint controlPoint)
+        {
+            dragStartPositions = slider.Path.ControlPoints.Select(point => point.Position).ToArray();
+            dragPathTypes = slider.Path.ControlPoints.Select(point => point.Type).ToArray();
+            draggedControlPointIndex = slider.Path.ControlPoints.IndexOf(controlPoint);
+            selectedControlPoints = new HashSet<PathControlPoint>(Pieces.Where(piece => piece.IsSelected.Value).Select(piece => piece.ControlPoint));
+
+            Debug.Assert(draggedControlPointIndex >= 0);
+
+            changeHandler?.BeginChange();
+        }
+
+        private void dragInProgress(DragEvent e)
+        {
+            Vector2[] oldControlPoints = slider.Path.ControlPoints.Select(cp => cp.Position).ToArray();
+            var oldPosition = slider.Position;
+            double oldStartTime = slider.StartTime;
+
+            if (selectedControlPoints.Contains(slider.Path.ControlPoints[0]))
+            {
+                // Special handling for selections containing head control point - the position of the slider changes which means the snapped position and time have to be taken into account
+                Vector2 newHeadPosition = Parent.ToScreenSpace(e.MousePosition + (dragStartPositions[0] - dragStartPositions[draggedControlPointIndex]));
+                var result = snapProvider?.SnapScreenSpacePositionToValidTime(newHeadPosition);
+
+                Vector2 movementDelta = Parent.ToLocalSpace(result?.ScreenSpacePosition ?? newHeadPosition) - slider.Position;
+
+                slider.Position += movementDelta;
+                slider.StartTime = result?.Time ?? slider.StartTime;
+
+                for (int i = 1; i < slider.Path.ControlPoints.Count; i++)
+                {
+                    var controlPoint = slider.Path.ControlPoints[i];
+                    // Since control points are relative to the position of the slider, all points that are _not_ selected
+                    // need to be offset _back_ by the delta corresponding to the movement of the head point.
+                    // All other selected control points (if any) will move together with the head point
+                    // (and so they will not move at all, relative to each other).
+                    if (!selectedControlPoints.Contains(controlPoint))
+                        controlPoint.Position -= movementDelta;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < controlPoints.Count; ++i)
+                {
+                    var controlPoint = controlPoints[i];
+                    if (selectedControlPoints.Contains(controlPoint))
+                        controlPoint.Position = dragStartPositions[i] + (e.MousePosition - e.MouseDownPosition);
+                }
+            }
+
+            if (!slider.Path.HasValidLength)
+            {
+                for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
+                    slider.Path.ControlPoints[i].Position = oldControlPoints[i];
+
+                slider.Position = oldPosition;
+                slider.StartTime = oldStartTime;
+                return;
+            }
+
+            // Maintain the path types in case they got defaulted to bezier at some point during the drag.
+            for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
+                slider.Path.ControlPoints[i].Type = dragPathTypes[i];
+        }
+
+        private void dragEnded() => changeHandler?.EndChange();
+
+        #endregion
+
+        public MenuItem[] ContextMenuItems
+        {
+            get
+            {
+                if (!Pieces.Any(p => p.IsHovered))
+                    return null;
+
+                var selectedPieces = Pieces.Where(p => p.IsSelected.Value).ToList();
+                int count = selectedPieces.Count;
+
+                if (count == 0)
+                    return null;
+
+                List<MenuItem> items = new List<MenuItem>();
+
+                if (!selectedPieces.Contains(Pieces[0]))
+                    items.Add(createMenuItemForPathType(null));
+
+                // todo: hide/disable items which aren't valid for selected points
+                items.Add(createMenuItemForPathType(PathType.Linear));
+                items.Add(createMenuItemForPathType(PathType.PerfectCurve));
+                items.Add(createMenuItemForPathType(PathType.Bezier));
+                items.Add(createMenuItemForPathType(PathType.Catmull));
+
+                return new MenuItem[]
+                {
+                    new OsuMenuItem($"Delete {"control point".ToQuantity(count, count > 1 ? ShowQuantityAs.Numeric : ShowQuantityAs.None)}", MenuItemType.Destructive, () => DeleteSelected()),
+                    new OsuMenuItem("Curve type")
+                    {
+                        Items = items
+                    }
+                };
+            }
+        }
+
+        private MenuItem createMenuItemForPathType(PathType? type)
+        {
+            int totalCount = Pieces.Count(p => p.IsSelected.Value);
+            int countOfState = Pieces.Where(p => p.IsSelected.Value).Count(p => p.ControlPoint.Type == type);
+
+            var item = new TernaryStateRadioMenuItem(type == null ? "Inherit" : type.ToString().Humanize(), MenuItemType.Standard, _ =>
+            {
+                foreach (var p in Pieces.Where(p => p.IsSelected.Value))
+                    updatePathType(p, type);
+            });
+
+            if (countOfState == totalCount)
+                item.State.Value = TernaryState.True;
+            else if (countOfState > 0)
+                item.State.Value = TernaryState.Indeterminate;
+            else
+                item.State.Value = TernaryState.False;
+
+            return item;
         }
     }
 }

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

@@ -5,50 +5,56 @@ using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
-    public class SliderBodyPiece : SliderPiece
+    public class SliderBodyPiece : BlueprintPiece<Slider>
     {
-        private readonly Slider slider;
         private readonly ManualSliderBody body;
 
-        public SliderBodyPiece(Slider slider)
-            : base(slider)
-        {
-            this.slider = slider;
+        /// <summary>
+        /// Offset in absolute (local) coordinates from the start of the curve.
+        /// </summary>
+        public Vector2 PathStartLocation => body.PathOffset;
 
+        public SliderBodyPiece()
+        {
             InternalChild = body = new ManualSliderBody
             {
-                AccentColour = Color4.Transparent,
+                AccentColour = Color4.Transparent
             };
+
+            // SliderSelectionBlueprint relies on calling ReceivePositionalInputAt on this drawable to determine whether selection should occur.
+            // Without AlwaysPresent, a movement in a parent container (ie. the editor composer area resizing) could cause incorrect input handling.
+            AlwaysPresent = true;
         }
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
             body.BorderColour = colours.Yellow;
-
-            PositionBindable.BindValueChanged(_ => updatePosition(), true);
-            ScaleBindable.BindValueChanged(scale => body.PathRadius = scale.NewValue * OsuHitObject.OBJECT_RADIUS, true);
         }
 
-        private void updatePosition() => Position = slider.StackedPosition;
-
-        protected override void Update()
+        public override void UpdateFrom(Slider hitObject)
         {
-            base.Update();
+            base.UpdateFrom(hitObject);
+
+            body.PathRadius = hitObject.Scale * OsuHitObject.OBJECT_RADIUS;
 
             var vertices = new List<Vector2>();
-            slider.Path.GetPathToProgress(vertices, 0, 1);
+            hitObject.Path.GetPathToProgress(vertices, 0, 1);
 
             body.SetVertices(vertices);
 
             Size = body.Size;
             OriginPosition = body.PathOffset;
         }
+
+        public void RecyclePath() => body.RecyclePath();
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => body.ReceivePositionalInputAt(screenSpacePos);
     }
 }

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

@@ -1,47 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
-using osu.Game.Rulesets.Osu.Objects;
-
-namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
-{
-    public class SliderCirclePiece : HitCirclePiece
-    {
-        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
-
-        private readonly Slider slider;
-        private readonly SliderPosition position;
-
-        public SliderCirclePiece(Slider slider, SliderPosition position)
-            : base(slider.HeadCircle)
-        {
-            this.slider = slider;
-            this.position = position;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            pathBindable.BindTo(slider.PathBindable);
-            pathBindable.BindValueChanged(_ => UpdatePosition(), true);
-        }
-
-        protected override void UpdatePosition()
-        {
-            switch (position)
-            {
-                case SliderPosition.Start:
-                    Position = slider.StackedPosition + slider.Path.PositionAt(0);
-                    break;
-
-                case SliderPosition.End:
-                    Position = slider.StackedPosition + slider.Path.PositionAt(1);
-                    break;
-            }
-        }
-    }
-}

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

@@ -0,0 +1,32 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
+{
+    public class SliderCircleOverlay : CompositeDrawable
+    {
+        protected readonly HitCirclePiece CirclePiece;
+
+        private readonly Slider slider;
+        private readonly SliderPosition position;
+
+        public SliderCircleOverlay(Slider slider, SliderPosition position)
+        {
+            this.slider = slider;
+            this.position = position;
+
+            InternalChild = CirclePiece = new HitCirclePiece();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            CirclePiece.UpdateFrom(position == SliderPosition.Start ? (HitCircle)slider.HeadCircle : slider.TailCircle);
+        }
+    }
+}

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

@@ -1,23 +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.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-
-namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
-{
-    public class SliderCircleSelectionBlueprint : OsuSelectionBlueprint
-    {
-        public SliderCircleSelectionBlueprint(DrawableOsuHitObject hitObject, Slider slider, SliderPosition position)
-            : base(hitObject)
-        {
-            InternalChild = new SliderCirclePiece(slider, position);
-
-            Select();
-        }
-
-        // Todo: This is temporary, since the slider circle masks don't do anything special yet. In the future they will handle input.
-        public override bool HandlePositionalInput => false;
-    }
-}

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

@@ -1,17 +1,21 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osu.Game.Screens.Edit;
 using osuTK;
 using osuTK.Input;
 
@@ -21,16 +25,28 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
     {
         public new Objects.Slider HitObject => (Objects.Slider)base.HitObject;
 
-        private readonly List<Segment> segments = new List<Segment>();
-        private Vector2 cursor;
+        private SliderBodyPiece bodyPiece;
+        private HitCirclePiece headCirclePiece;
+        private HitCirclePiece tailCirclePiece;
+        private PathControlPointVisualiser controlPointVisualiser;
 
-        private PlacementState state;
+        private InputManager inputManager;
+
+        private SliderPlacementState state;
+        private PathControlPoint segmentStart;
+        private PathControlPoint cursor;
+        private int currentSegmentLength;
+
+        [Resolved(CanBeNull = true)]
+        private HitObjectComposer composer { get; set; }
 
         public SliderPlacementBlueprint()
             : base(new Objects.Slider())
         {
             RelativeSizeAxes = Axes.Both;
-            segments.Add(new Segment(Vector2.Zero));
+
+            HitObject.Path.ControlPoints.Add(segmentStart = new PathControlPoint(Vector2.Zero, PathType.Linear));
+            currentSegmentLength = 1;
         }
 
         [BackgroundDependencyLoader]
@@ -38,53 +54,72 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         {
             InternalChildren = new Drawable[]
             {
-                new SliderBodyPiece(HitObject),
-                new SliderCirclePiece(HitObject, SliderPosition.Start),
-                new SliderCirclePiece(HitObject, SliderPosition.End),
-                new PathControlPointVisualiser(HitObject),
+                bodyPiece = new SliderBodyPiece(),
+                headCirclePiece = new HitCirclePiece(),
+                tailCirclePiece = new HitCirclePiece(),
+                controlPointVisualiser = new PathControlPointVisualiser(HitObject, false)
             };
 
-            setState(PlacementState.Initial);
+            setState(SliderPlacementState.Initial);
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
-
-            // Fixes a 1-frame position discrepancy due to the first mouse move event happening in the next frame
-            HitObject.Position = Parent?.ToLocalSpace(GetContainingInputManager().CurrentState.Mouse.Position) ?? Vector2.Zero;
+            inputManager = GetContainingInputManager();
         }
 
-        protected override bool OnMouseMove(MouseMoveEvent e)
+        [Resolved]
+        private EditorBeatmap editorBeatmap { get; set; }
+
+        public override void UpdateTimeAndPosition(SnapResult result)
         {
+            base.UpdateTimeAndPosition(result);
+
             switch (state)
             {
-                case PlacementState.Initial:
-                    HitObject.Position = e.MousePosition;
-                    return true;
+                case SliderPlacementState.Initial:
+                    BeginPlacement();
 
-                case PlacementState.Body:
-                    cursor = e.MousePosition - HitObject.Position;
-                    return true;
+                    var nearestDifficultyPoint = editorBeatmap.HitObjects.LastOrDefault(h => h.GetEndTime() < HitObject.StartTime)?.DifficultyControlPoint?.DeepClone() as DifficultyControlPoint;
+
+                    HitObject.DifficultyControlPoint = nearestDifficultyPoint ?? new DifficultyControlPoint();
+                    HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
+                    break;
+
+                case SliderPlacementState.Body:
+                    updateCursor();
+                    break;
             }
-
-            return false;
         }
 
-        protected override bool OnClick(ClickEvent e)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
+            if (e.Button != MouseButton.Left)
+                return base.OnMouseDown(e);
+
             switch (state)
             {
-                case PlacementState.Initial:
+                case SliderPlacementState.Initial:
                     beginCurve();
                     break;
 
-                case PlacementState.Body:
-                    switch (e.Button)
+                case SliderPlacementState.Body:
+                    if (canPlaceNewControlPoint(out var lastPoint))
                     {
-                        case MouseButton.Left:
-                            segments.Last().ControlPoints.Add(cursor);
-                            break;
+                        // Place a new point by detatching the current cursor.
+                        updateCursor();
+                        cursor = null;
+                    }
+                    else
+                    {
+                        // Transform the last point into a new segment.
+                        Debug.Assert(lastPoint != null);
+
+                        segmentStart = lastPoint;
+                        segmentStart.Type = PathType.Linear;
+
+                        currentSegmentLength = 1;
                     }
 
                     break;
@@ -93,64 +128,115 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             return true;
         }
 
-        protected override bool OnMouseUp(MouseUpEvent e)
+        protected override void OnMouseUp(MouseUpEvent e)
         {
-            if (state == PlacementState.Body && e.Button == MouseButton.Right)
+            if (state == SliderPlacementState.Body && e.Button == MouseButton.Right)
                 endCurve();
-            return base.OnMouseUp(e);
-        }
-
-        protected override bool OnDoubleClick(DoubleClickEvent e)
-        {
-            segments.Add(new Segment(segments[segments.Count - 1].ControlPoints.Last()));
-            return true;
+            base.OnMouseUp(e);
         }
 
         private void beginCurve()
         {
-            BeginPlacement();
-
-            HitObject.StartTime = EditorClock.CurrentTime;
-            setState(PlacementState.Body);
+            BeginPlacement(commitStart: true);
+            setState(SliderPlacementState.Body);
         }
 
         private void endCurve()
         {
             updateSlider();
-            EndPlacement();
+            EndPlacement(HitObject.Path.HasValidLength);
         }
 
         protected override void Update()
         {
             base.Update();
             updateSlider();
+
+            // Maintain the path type in case it got defaulted to bezier at some point during the drag.
+            updatePathType();
+        }
+
+        private void updatePathType()
+        {
+            switch (currentSegmentLength)
+            {
+                case 1:
+                case 2:
+                    segmentStart.Type = PathType.Linear;
+                    break;
+
+                case 3:
+                    segmentStart.Type = PathType.PerfectCurve;
+                    break;
+
+                default:
+                    segmentStart.Type = PathType.Bezier;
+                    break;
+            }
+        }
+
+        private void updateCursor()
+        {
+            if (canPlaceNewControlPoint(out _))
+            {
+                // The cursor does not overlap a previous control point, so it can be added if not already existing.
+                if (cursor == null)
+                {
+                    HitObject.Path.ControlPoints.Add(cursor = new PathControlPoint { Position = Vector2.Zero });
+
+                    // The path type should be adjusted in the progression of updatePathType() (Linear -> PC -> Bezier).
+                    currentSegmentLength++;
+                    updatePathType();
+                }
+
+                // Update the cursor position.
+                cursor.Position = ToLocalSpace(inputManager.CurrentState.Mouse.Position) - HitObject.Position;
+            }
+            else if (cursor != null)
+            {
+                // The cursor overlaps a previous control point, so it's removed.
+                HitObject.Path.ControlPoints.Remove(cursor);
+                cursor = null;
+
+                // The path type should be adjusted in the reverse progression of updatePathType() (Bezier -> PC -> Linear).
+                currentSegmentLength--;
+                updatePathType();
+            }
+        }
+
+        /// <summary>
+        /// Whether a new control point can be placed at the current mouse position.
+        /// </summary>
+        /// <param name="lastPoint">The last-placed control point. May be null, but is not null if <c>false</c> is returned.</param>
+        /// <returns>Whether a new control point can be placed at the current position.</returns>
+        private bool canPlaceNewControlPoint([CanBeNull] out PathControlPoint lastPoint)
+        {
+            // We cannot rely on the ordering of drawable pieces, so find the respective drawable piece by searching for the last non-cursor control point.
+            var last = HitObject.Path.ControlPoints.LastOrDefault(p => p != cursor);
+            var lastPiece = controlPointVisualiser.Pieces.Single(p => p.ControlPoint == last);
+
+            lastPoint = last;
+            return lastPiece.IsHovered != true;
         }
 
         private void updateSlider()
         {
-            var newControlPoints = segments.SelectMany(s => s.ControlPoints).Concat(cursor.Yield()).ToArray();
-            HitObject.Path = new SliderPath(newControlPoints.Length > 2 ? PathType.Bezier : PathType.Linear, newControlPoints);
+            HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
+
+            bodyPiece.UpdateFrom(HitObject);
+            headCirclePiece.UpdateFrom(HitObject.HeadCircle);
+            tailCirclePiece.UpdateFrom(HitObject.TailCircle);
         }
 
-        private void setState(PlacementState newState)
+        private void setState(SliderPlacementState newState)
         {
             state = newState;
         }
 
-        private enum PlacementState
+        private enum SliderPlacementState
         {
             Initial,
             Body,
         }
-
-        private class Segment
-        {
-            public readonly List<Vector2> ControlPoints = new List<Vector2>();
-
-            public Segment(Vector2 offset)
-            {
-                ControlPoints.Add(offset);
-            }
-        }
     }
 }

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

@@ -1,32 +1,312 @@
 // 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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
-    public class SliderSelectionBlueprint : OsuSelectionBlueprint
+    public class SliderSelectionBlueprint : OsuSelectionBlueprint<Slider>
     {
-        private readonly SliderCircleSelectionBlueprint headBlueprint;
+        protected new DrawableSlider DrawableObject => (DrawableSlider)base.DrawableObject;
 
-        public SliderSelectionBlueprint(DrawableSlider slider)
+        protected SliderBodyPiece BodyPiece { get; private set; }
+        protected SliderCircleOverlay HeadOverlay { get; private set; }
+        protected SliderCircleOverlay TailOverlay { get; private set; }
+
+        [CanBeNull]
+        protected PathControlPointVisualiser ControlPointVisualiser { get; private set; }
+
+        [Resolved(CanBeNull = true)]
+        private HitObjectComposer composer { get; set; }
+
+        [Resolved(CanBeNull = true)]
+        private IPlacementHandler placementHandler { get; set; }
+
+        [Resolved(CanBeNull = true)]
+        private EditorBeatmap editorBeatmap { get; set; }
+
+        [Resolved(CanBeNull = true)]
+        private IEditorChangeHandler changeHandler { get; set; }
+
+        [Resolved(CanBeNull = true)]
+        private BindableBeatDivisor beatDivisor { get; set; }
+
+        public override Quad SelectionQuad => BodyPiece.ScreenSpaceDrawQuad;
+
+        private readonly BindableList<PathControlPoint> controlPoints = new BindableList<PathControlPoint>();
+        private readonly IBindable<int> pathVersion = new Bindable<int>();
+
+        public SliderSelectionBlueprint(Slider slider)
             : base(slider)
         {
-            var sliderObject = (Slider)slider.HitObject;
+        }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
             InternalChildren = new Drawable[]
             {
-                new SliderBodyPiece(sliderObject),
-                headBlueprint = new SliderCircleSelectionBlueprint(slider.HeadCircle, sliderObject, SliderPosition.Start),
-                new SliderCircleSelectionBlueprint(slider.TailCircle, sliderObject, SliderPosition.End),
-                new PathControlPointVisualiser(sliderObject),
+                BodyPiece = new SliderBodyPiece(),
+                HeadOverlay = CreateCircleOverlay(HitObject, SliderPosition.Start),
+                TailOverlay = CreateCircleOverlay(HitObject, SliderPosition.End),
             };
         }
 
-        public override Vector2 SelectionPoint => headBlueprint.SelectionPoint;
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            controlPoints.BindTo(HitObject.Path.ControlPoints);
+
+            pathVersion.BindTo(HitObject.Path.Version);
+            pathVersion.BindValueChanged(_ => updatePath());
+
+            BodyPiece.UpdateFrom(HitObject);
+        }
+
+        public override bool HandleQuickDeletion()
+        {
+            var hoveredControlPoint = ControlPointVisualiser?.Pieces.FirstOrDefault(p => p.IsHovered);
+
+            if (hoveredControlPoint == null)
+                return false;
+
+            hoveredControlPoint.IsSelected.Value = true;
+            ControlPointVisualiser.DeleteSelected();
+            return true;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (IsSelected)
+                BodyPiece.UpdateFrom(HitObject);
+        }
+
+        protected override void OnSelected()
+        {
+            AddInternal(ControlPointVisualiser = new PathControlPointVisualiser(HitObject, true)
+            {
+                RemoveControlPointsRequested = removeControlPoints
+            });
+
+            base.OnSelected();
+        }
+
+        protected override void OnDeselected()
+        {
+            base.OnDeselected();
+
+            // throw away frame buffers on deselection.
+            ControlPointVisualiser?.Expire();
+            ControlPointVisualiser = null;
+
+            BodyPiece.RecyclePath();
+        }
+
+        private Vector2 rightClickPosition;
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            switch (e.Button)
+            {
+                case MouseButton.Right:
+                    rightClickPosition = e.MouseDownPosition;
+                    return false; // Allow right click to be handled by context menu
+
+                case MouseButton.Left:
+                    if (e.ControlPressed && IsSelected)
+                    {
+                        changeHandler?.BeginChange();
+                        placementControlPoint = addControlPoint(e.MousePosition);
+                        ControlPointVisualiser?.SetSelectionTo(placementControlPoint);
+                        return true; // Stop input from being handled and modifying the selection
+                    }
+
+                    break;
+            }
+
+            return false;
+        }
+
+        [CanBeNull]
+        private PathControlPoint placementControlPoint;
+
+        protected override bool OnDragStart(DragStartEvent e) => placementControlPoint != null;
+
+        protected override void OnDrag(DragEvent e)
+        {
+            if (placementControlPoint != null)
+                placementControlPoint.Position = e.MousePosition - HitObject.Position;
+        }
+
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            if (placementControlPoint != null)
+            {
+                placementControlPoint = null;
+                changeHandler?.EndChange();
+            }
+        }
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (!IsSelected)
+                return false;
+
+            if (e.Key == Key.F && e.ControlPressed && e.ShiftPressed)
+            {
+                convertToStream();
+                return true;
+            }
+
+            return false;
+        }
+
+        private PathControlPoint addControlPoint(Vector2 position)
+        {
+            position -= HitObject.Position;
+
+            int insertionIndex = 0;
+            float minDistance = float.MaxValue;
+
+            for (int i = 0; i < controlPoints.Count - 1; i++)
+            {
+                float dist = new Line(controlPoints[i].Position, controlPoints[i + 1].Position).DistanceToPoint(position);
+
+                if (dist < minDistance)
+                {
+                    insertionIndex = i + 1;
+                    minDistance = dist;
+                }
+            }
+
+            var pathControlPoint = new PathControlPoint { Position = position };
+
+            // Move the control points from the insertion index onwards to make room for the insertion
+            controlPoints.Insert(insertionIndex, pathControlPoint);
+
+            return pathControlPoint;
+        }
+
+        private void removeControlPoints(List<PathControlPoint> toRemove)
+        {
+            // Ensure that there are any points to be deleted
+            if (toRemove.Count == 0)
+                return;
+
+            foreach (var c in toRemove)
+            {
+                // The first control point in the slider must have a type, so take it from the previous "first" one
+                // Todo: Should be handled within SliderPath itself
+                if (c == controlPoints[0] && controlPoints.Count > 1 && controlPoints[1].Type == null)
+                    controlPoints[1].Type = controlPoints[0].Type;
+
+                controlPoints.Remove(c);
+            }
+
+            // If there are 0 or 1 remaining control points, the slider is in a degenerate (single point) form and should be deleted
+            if (controlPoints.Count <= 1 || !HitObject.Path.HasValidLength)
+            {
+                placementHandler?.Delete(HitObject);
+                return;
+            }
+
+            // The path will have a non-zero offset if the head is removed, but sliders don't support this behaviour since the head is positioned at the slider's position
+            // So the slider needs to be offset by this amount instead, and all control points offset backwards such that the path is re-positioned at (0, 0)
+            Vector2 first = controlPoints[0].Position;
+            foreach (var c in controlPoints)
+                c.Position -= first;
+            HitObject.Position += first;
+        }
+
+        private void updatePath()
+        {
+            HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
+            editorBeatmap?.Update(HitObject);
+        }
+
+        private void convertToStream()
+        {
+            if (editorBeatmap == null || changeHandler == null || beatDivisor == null)
+                return;
+
+            var timingPoint = editorBeatmap.ControlPointInfo.TimingPointAt(HitObject.StartTime);
+            double streamSpacing = timingPoint.BeatLength / beatDivisor.Value;
+
+            changeHandler.BeginChange();
+
+            int i = 0;
+            double time = HitObject.StartTime;
+
+            while (!Precision.DefinitelyBigger(time, HitObject.GetEndTime(), 1))
+            {
+                // positionWithRepeats is a fractional number in the range of [0, HitObject.SpanCount()]
+                // and indicates how many fractional spans of a slider have passed up to time.
+                double positionWithRepeats = (time - HitObject.StartTime) / HitObject.Duration * HitObject.SpanCount();
+                double pathPosition = positionWithRepeats - (int)positionWithRepeats;
+                // every second span is in the reverse direction - need to reverse the path position.
+                if (Precision.AlmostBigger(positionWithRepeats % 2, 1))
+                    pathPosition = 1 - pathPosition;
+
+                Vector2 position = HitObject.Position + HitObject.Path.PositionAt(pathPosition);
+
+                var samplePoint = (SampleControlPoint)HitObject.SampleControlPoint.DeepClone();
+                samplePoint.Time = time;
+
+                editorBeatmap.Add(new HitCircle
+                {
+                    StartTime = time,
+                    Position = position,
+                    NewCombo = i == 0 && HitObject.NewCombo,
+                    SampleControlPoint = samplePoint,
+                    Samples = HitObject.HeadCircle.Samples.Select(s => s.With()).ToList()
+                });
+
+                i += 1;
+                time = HitObject.StartTime + i * streamSpacing;
+            }
+
+            editorBeatmap.Remove(HitObject);
+
+            changeHandler.EndChange();
+        }
+
+        public override MenuItem[] ContextMenuItems => new MenuItem[]
+        {
+            new OsuMenuItem("Add control point", MenuItemType.Standard, () => addControlPoint(rightClickPosition)),
+            new OsuMenuItem("Convert to stream", MenuItemType.Destructive, convertToStream),
+        };
+
+        // Always refer to the drawable object's slider body so subsequent movement deltas are calculated with updated positions.
+        public override Vector2 ScreenSpaceSelectionPoint => DrawableObject.SliderBody?.ToScreenSpace(DrawableObject.SliderBody.PathOffset)
+                                                             ?? BodyPiece.ToScreenSpace(BodyPiece.PathStartLocation);
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) =>
+            BodyPiece.ReceivePositionalInputAt(screenSpacePos) || ControlPointVisualiser?.Pieces.Any(p => p.ReceivePositionalInputAt(screenSpacePos)) == true;
+
+        protected virtual SliderCircleOverlay CreateCircleOverlay(Slider slider, SliderPosition position) => new SliderCircleOverlay(slider, position);
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/Components/SpinnerPiece.cs

@@ -7,22 +7,18 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
 {
-    public class SpinnerPiece : HitObjectPiece
+    public class SpinnerPiece : BlueprintPiece<Spinner>
     {
-        private readonly Spinner spinner;
         private readonly CircularContainer circle;
         private readonly RingPiece ring;
 
-        public SpinnerPiece(Spinner spinner)
-            : base(spinner)
+        public SpinnerPiece()
         {
-            this.spinner = spinner;
-
             Origin = Anchor.Centre;
 
             RelativeSizeAxes = Axes.Both;
@@ -38,27 +34,22 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
                     Alpha = 0.5f,
                     Child = new Box { RelativeSizeAxes = Axes.Both }
                 },
-                ring = new RingPiece
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre
-                }
+                ring = new RingPiece()
             };
-
-            ring.Scale = new Vector2(spinner.Scale);
         }
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
             Colour = colours.Yellow;
-
-            PositionBindable.BindValueChanged(_ => updatePosition(), true);
-            StackHeightBindable.BindValueChanged(_ => updatePosition());
-            ScaleBindable.BindValueChanged(scale => ring.Scale = new Vector2(scale.NewValue), true);
         }
 
-        private void updatePosition() => Position = spinner.Position;
+        public override void UpdateFrom(Spinner hitObject)
+        {
+            base.UpdateFrom(hitObject);
+
+            ring.Scale = new Vector2(hitObject.Scale);
+        }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => circle.ReceivePositionalInputAt(screenSpacePos);
     }

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

@@ -1,12 +1,14 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {
@@ -21,24 +23,38 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
         public SpinnerPlacementBlueprint()
             : base(new Spinner { Position = OsuPlayfield.BASE_SIZE / 2 })
         {
-            InternalChild = piece = new SpinnerPiece(HitObject) { Alpha = 0.5f };
+            InternalChild = piece = new SpinnerPiece { Alpha = 0.5f };
         }
 
-        protected override bool OnClick(ClickEvent e)
+        protected override void Update()
+        {
+            base.Update();
+
+            if (isPlacingEnd)
+                HitObject.EndTime = Math.Max(HitObject.StartTime, EditorClock.CurrentTime);
+
+            piece.UpdateFrom(HitObject);
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             if (isPlacingEnd)
             {
+                if (e.Button != MouseButton.Right)
+                    return false;
+
                 HitObject.EndTime = EditorClock.CurrentTime;
-                EndPlacement();
+                EndPlacement(true);
             }
             else
             {
-                HitObject.StartTime = EditorClock.CurrentTime;
+                if (e.Button != MouseButton.Left)
+                    return false;
 
-                isPlacingEnd = true;
+                BeginPlacement(commitStart: true);
                 piece.FadeTo(1f, 150, Easing.OutQuint);
 
-                BeginPlacement();
+                isPlacingEnd = true;
             }
 
             return true;

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

@@ -3,19 +3,25 @@
 
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {
-    public class SpinnerSelectionBlueprint : OsuSelectionBlueprint
+    public class SpinnerSelectionBlueprint : OsuSelectionBlueprint<Spinner>
     {
         private readonly SpinnerPiece piece;
 
-        public SpinnerSelectionBlueprint(DrawableSpinner spinner)
+        public SpinnerSelectionBlueprint(Spinner spinner)
             : base(spinner)
         {
-            InternalChild = piece = new SpinnerPiece((Spinner)spinner.HitObject);
+            InternalChild = piece = new SpinnerPiece();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            piece.UpdateFrom(HitObject);
         }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => piece.ReceivePositionalInputAt(screenSpacePos);

osu.Game.Rulesets.Osu/Edit/Checks/CheckLowDiffOverlaps.cs

@@ -0,0 +1,109 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Checks
+{
+    public class CheckLowDiffOverlaps : ICheck
+    {
+        // For the lowest difficulties, the osu! Ranking Criteria encourages overlapping ~180 BPM 1/2, but discourages ~180 BPM 1/1.
+        private const double should_overlap_threshold = 150; // 200 BPM 1/2
+        private const double should_probably_overlap_threshold = 175; // 170 BPM 1/2
+        private const double should_not_overlap_threshold = 250; // 120 BPM 1/2 = 240 BPM 1/1
+
+        /// <summary>
+        /// Objects need to overlap this much before being treated as an overlap, else it may just be the borders slightly touching.
+        /// </summary>
+        private const double overlap_leniency = 5;
+
+        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Spread, "Missing or unexpected overlaps");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateShouldOverlap(this),
+            new IssueTemplateShouldProbablyOverlap(this),
+            new IssueTemplateShouldNotOverlap(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            // TODO: This should also apply to *lowest difficulty* Normals - they are skipped for now.
+            if (context.InterpretedDifficulty > DifficultyRating.Easy)
+                yield break;
+
+            var hitObjects = context.Beatmap.HitObjects;
+
+            for (int i = 0; i < hitObjects.Count - 1; ++i)
+            {
+                if (!(hitObjects[i] is OsuHitObject hitObject) || hitObject is Spinner)
+                    continue;
+
+                if (!(hitObjects[i + 1] is OsuHitObject nextHitObject) || nextHitObject is Spinner)
+                    continue;
+
+                double deltaTime = nextHitObject.StartTime - hitObject.GetEndTime();
+                if (deltaTime >= hitObject.TimeFadeIn + hitObject.TimePreempt)
+                    // The objects are not visible at the same time (without mods), hence skipping.
+                    continue;
+
+                float distanceSq = (hitObject.StackedEndPosition - nextHitObject.StackedPosition).LengthSquared;
+                double diameter = (hitObject.Radius - overlap_leniency) * 2;
+                double diameterSq = diameter * diameter;
+
+                bool areOverlapping = distanceSq < diameterSq;
+
+                // Slider ends do not need to be overlapped because of slider leniency.
+                if (!areOverlapping && !(hitObject is Slider))
+                {
+                    if (deltaTime < should_overlap_threshold)
+                        yield return new IssueTemplateShouldOverlap(this).Create(deltaTime, hitObject, nextHitObject);
+                    else if (deltaTime < should_probably_overlap_threshold)
+                        yield return new IssueTemplateShouldProbablyOverlap(this).Create(deltaTime, hitObject, nextHitObject);
+                }
+
+                if (areOverlapping && deltaTime > should_not_overlap_threshold)
+                    yield return new IssueTemplateShouldNotOverlap(this).Create(deltaTime, hitObject, nextHitObject);
+            }
+        }
+
+        public abstract class IssueTemplateOverlap : IssueTemplate
+        {
+            protected IssueTemplateOverlap(ICheck check, IssueType issueType, string unformattedMessage)
+                : base(check, issueType, unformattedMessage)
+            {
+            }
+
+            public Issue Create(double deltaTime, params HitObject[] hitObjects) => new Issue(hitObjects, this, deltaTime);
+        }
+
+        public class IssueTemplateShouldOverlap : IssueTemplateOverlap
+        {
+            public IssueTemplateShouldOverlap(ICheck check)
+                : base(check, IssueType.Problem, "These are {0} ms apart and so should be overlapping.")
+            {
+            }
+        }
+
+        public class IssueTemplateShouldProbablyOverlap : IssueTemplateOverlap
+        {
+            public IssueTemplateShouldProbablyOverlap(ICheck check)
+                : base(check, IssueType.Warning, "These are {0} ms apart and so should probably be overlapping.")
+            {
+            }
+        }
+
+        public class IssueTemplateShouldNotOverlap : IssueTemplateOverlap
+        {
+            public IssueTemplateShouldNotOverlap(ICheck check)
+                : base(check, IssueType.Problem, "These are {0} ms apart and so should NOT be overlapping.")
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Checks/CheckOffscreenObjects.cs

@@ -0,0 +1,115 @@
+// 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.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Checks
+{
+    public class CheckOffscreenObjects : ICheck
+    {
+        // A close approximation for the bounding box of the screen in gameplay on 4:3 aspect ratio.
+        // Uses gameplay space coordinates (512 x 384 playfield / 640 x 480 screen area).
+        // See https://github.com/ppy/osu/pull/12361#discussion_r612199777 for reference.
+        private const int min_x = -67;
+        private const int min_y = -60;
+        private const int max_x = 579;
+        private const int max_y = 428;
+
+        // The amount of milliseconds to step through a slider path at a time
+        // (higher = more performant, but higher false-negative chance).
+        private const int path_step_size = 5;
+
+        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Compose, "Offscreen hitobjects");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateOffscreenCircle(this),
+            new IssueTemplateOffscreenSlider(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            foreach (var hitobject in context.Beatmap.HitObjects)
+            {
+                switch (hitobject)
+                {
+                    case Slider slider:
+                    {
+                        foreach (var issue in sliderIssues(slider))
+                            yield return issue;
+
+                        break;
+                    }
+
+                    case HitCircle circle:
+                    {
+                        if (isOffscreen(circle.StackedPosition, circle.Radius))
+                            yield return new IssueTemplateOffscreenCircle(this).Create(circle);
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Steps through points on the slider to ensure the entire path is on-screen.
+        /// Returns at most one issue.
+        /// </summary>
+        /// <param name="slider">The slider whose path to check.</param>
+        /// <returns></returns>
+        private IEnumerable<Issue> sliderIssues(Slider slider)
+        {
+            for (int i = 0; i < slider.Distance; i += path_step_size)
+            {
+                double progress = i / slider.Distance;
+                Vector2 position = slider.StackedPositionAt(progress);
+
+                if (!isOffscreen(position, slider.Radius))
+                    continue;
+
+                // `SpanDuration` ensures we don't include reverses.
+                double time = slider.StartTime + progress * slider.SpanDuration;
+                yield return new IssueTemplateOffscreenSlider(this).Create(slider, time);
+
+                yield break;
+            }
+
+            // Above loop may skip the last position in the slider due to step size.
+            if (!isOffscreen(slider.StackedEndPosition, slider.Radius))
+                yield break;
+
+            yield return new IssueTemplateOffscreenSlider(this).Create(slider, slider.EndTime);
+        }
+
+        private bool isOffscreen(Vector2 position, double radius)
+        {
+            return position.X - radius < min_x || position.X + radius > max_x ||
+                   position.Y - radius < min_y || position.Y + radius > max_y;
+        }
+
+        public class IssueTemplateOffscreenCircle : IssueTemplate
+        {
+            public IssueTemplateOffscreenCircle(ICheck check)
+                : base(check, IssueType.Problem, "This circle goes offscreen on a 4:3 aspect ratio.")
+            {
+            }
+
+            public Issue Create(HitCircle circle) => new Issue(circle, this);
+        }
+
+        public class IssueTemplateOffscreenSlider : IssueTemplate
+        {
+            public IssueTemplateOffscreenSlider(ICheck check)
+                : base(check, IssueType.Problem, "This slider goes offscreen here on a 4:3 aspect ratio.")
+            {
+            }
+
+            public Issue Create(Slider slider, double offscreenTime) => new Issue(slider, this) { Time = offscreenTime };
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Checks/CheckTimeDistanceEquality.cs

@@ -0,0 +1,179 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Checks
+{
+    public class CheckTimeDistanceEquality : ICheck
+    {
+        /// <summary>
+        /// Two objects this many ms apart or more are skipped. (200 BPM 2/1)
+        /// </summary>
+        private const double pattern_lifetime = 600;
+
+        /// <summary>
+        /// Two objects this distance apart or less are skipped.
+        /// </summary>
+        private const double stack_leniency = 12;
+
+        /// <summary>
+        /// How long an observation is relevant for comparison. (120 BPM 8/1)
+        /// </summary>
+        private const double observation_lifetime = 4000;
+
+        /// <summary>
+        /// How different two delta times can be to still be compared. (240 BPM 1/16)
+        /// </summary>
+        private const double similar_time_leniency = 16;
+
+        /// <summary>
+        /// How many pixels are subtracted from the difference between current and expected distance.
+        /// </summary>
+        private const double distance_leniency_absolute_warning = 10;
+
+        /// <summary>
+        /// How much of the current distance that the difference can make out.
+        /// </summary>
+        private const double distance_leniency_percent_warning = 0.15;
+
+        private const double distance_leniency_absolute_problem = 20;
+        private const double distance_leniency_percent_problem = 0.3;
+
+        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Spread, "Object too close or far away from previous");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateIrregularSpacingProblem(this),
+            new IssueTemplateIrregularSpacingWarning(this)
+        };
+
+        /// <summary>
+        /// Represents an observation of the time and distance between two objects.
+        /// </summary>
+        private readonly struct ObservedTimeDistance
+        {
+            public readonly double ObservationTime;
+            public readonly double DeltaTime;
+            public readonly double Distance;
+
+            public ObservedTimeDistance(double observationTime, double deltaTime, double distance)
+            {
+                ObservationTime = observationTime;
+                DeltaTime = deltaTime;
+                Distance = distance;
+            }
+        }
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            if (context.InterpretedDifficulty > DifficultyRating.Normal)
+                yield break;
+
+            var prevObservedTimeDistances = new List<ObservedTimeDistance>();
+            var hitObjects = context.Beatmap.HitObjects;
+
+            for (int i = 0; i < hitObjects.Count - 1; ++i)
+            {
+                if (!(hitObjects[i] is OsuHitObject hitObject) || hitObject is Spinner)
+                    continue;
+
+                if (!(hitObjects[i + 1] is OsuHitObject nextHitObject) || nextHitObject is Spinner)
+                    continue;
+
+                double deltaTime = nextHitObject.StartTime - hitObject.GetEndTime();
+
+                // Ignore objects that are far enough apart in time to not be considered the same pattern.
+                if (deltaTime > pattern_lifetime)
+                    continue;
+
+                // Relying on FastInvSqrt is probably good enough here. We'll be taking the difference between distances later, hence square not being sufficient.
+                float distance = (hitObject.StackedEndPosition - nextHitObject.StackedPosition).LengthFast;
+
+                // Ignore stacks and half-stacks, as these are close enough to where they can't be confused for being time-distanced.
+                if (distance < stack_leniency)
+                    continue;
+
+                var observedTimeDistance = new ObservedTimeDistance(nextHitObject.StartTime, deltaTime, distance);
+                double expectedDistance = getExpectedDistance(prevObservedTimeDistances, observedTimeDistance);
+
+                if (expectedDistance == 0)
+                {
+                    // There was nothing relevant to compare to.
+                    prevObservedTimeDistances.Add(observedTimeDistance);
+                    continue;
+                }
+
+                if ((Math.Abs(expectedDistance - distance) - distance_leniency_absolute_problem) / distance > distance_leniency_percent_problem)
+                    yield return new IssueTemplateIrregularSpacingProblem(this).Create(expectedDistance, distance, hitObject, nextHitObject);
+                else if ((Math.Abs(expectedDistance - distance) - distance_leniency_absolute_warning) / distance > distance_leniency_percent_warning)
+                    yield return new IssueTemplateIrregularSpacingWarning(this).Create(expectedDistance, distance, hitObject, nextHitObject);
+                else
+                {
+                    // We use `else` here to prevent issues from cascading; an object spaced too far could cause regular spacing to be considered "too short" otherwise.
+                    prevObservedTimeDistances.Add(observedTimeDistance);
+                }
+            }
+        }
+
+        private double getExpectedDistance(IEnumerable<ObservedTimeDistance> prevObservedTimeDistances, ObservedTimeDistance observedTimeDistance)
+        {
+            int observations = prevObservedTimeDistances.Count();
+
+            int count = 0;
+            double sum = 0;
+
+            // Looping this in reverse allows us to break before going through all elements, as we're only interested in the most recent ones.
+            for (int i = observations - 1; i >= 0; --i)
+            {
+                var prevObservedTimeDistance = prevObservedTimeDistances.ElementAt(i);
+
+                // Only consider observations within the last few seconds - this allows the map to build spacing up/down over time, but prevents it from being too sudden.
+                if (observedTimeDistance.ObservationTime - prevObservedTimeDistance.ObservationTime > observation_lifetime)
+                    break;
+
+                // Only consider observations which have a similar time difference - this leniency allows handling of multi-BPM maps which speed up/down slowly.
+                if (Math.Abs(observedTimeDistance.DeltaTime - prevObservedTimeDistance.DeltaTime) > similar_time_leniency)
+                    break;
+
+                count += 1;
+                sum += prevObservedTimeDistance.Distance / Math.Max(prevObservedTimeDistance.DeltaTime, 1);
+            }
+
+            return sum / Math.Max(count, 1) * observedTimeDistance.DeltaTime;
+        }
+
+        public abstract class IssueTemplateIrregularSpacing : IssueTemplate
+        {
+            protected IssueTemplateIrregularSpacing(ICheck check, IssueType issueType)
+                : base(check, issueType, "Expected {0:0} px spacing like previous objects, currently {1:0}.")
+            {
+            }
+
+            public Issue Create(double expected, double actual, params HitObject[] hitObjects) => new Issue(hitObjects, this, expected, actual);
+        }
+
+        public class IssueTemplateIrregularSpacingProblem : IssueTemplateIrregularSpacing
+        {
+            public IssueTemplateIrregularSpacingProblem(ICheck check)
+                : base(check, IssueType.Problem)
+            {
+            }
+        }
+
+        public class IssueTemplateIrregularSpacingWarning : IssueTemplateIrregularSpacing
+        {
+            public IssueTemplateIrregularSpacingWarning(ICheck check)
+                : base(check, IssueType.Warning)
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSliders.cs

@@ -0,0 +1,48 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Checks
+{
+    public class CheckTooShortSliders : ICheck
+    {
+        /// <summary>
+        /// The shortest acceptable duration between the head and tail of the slider (so ignoring repeats).
+        /// </summary>
+        private const double span_duration_threshold = 125; // 240 BPM 1/2
+
+        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Spread, "Too short sliders");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateTooShort(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            if (context.InterpretedDifficulty > DifficultyRating.Easy)
+                yield break;
+
+            foreach (var hitObject in context.Beatmap.HitObjects)
+            {
+                if (hitObject is Slider slider && slider.SpanDuration < span_duration_threshold)
+                    yield return new IssueTemplateTooShort(this).Create(slider);
+            }
+        }
+
+        public class IssueTemplateTooShort : IssueTemplate
+        {
+            public IssueTemplateTooShort(ICheck check)
+                : base(check, IssueType.Problem, "This slider is too short ({0:0} ms), expected at least {1:0} ms.")
+            {
+            }
+
+            public Issue Create(Slider slider) => new Issue(slider, this, slider.SpanDuration, span_duration_threshold);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Checks/CheckTooShortSpinners.cs

@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Checks
+{
+    public class CheckTooShortSpinners : ICheck
+    {
+        public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Spread, "Too short spinners");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateTooShort(this)
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            double od = context.Beatmap.Difficulty.OverallDifficulty;
+
+            // These are meant to reflect the duration necessary for auto to score at least 1000 points on the spinner.
+            // It's difficult to eliminate warnings here, as auto achieving 1000 points depends on the approach angle on some spinners.
+            double warningThreshold = 500 + (od < 5 ? (5 - od) * -21.8 : (od - 5) * 20); // Anything above this is always ok.
+            double problemThreshold = 450 + (od < 5 ? (5 - od) * -17 : (od - 5) * 17); // Anything below this is never ok.
+
+            foreach (var hitObject in context.Beatmap.HitObjects)
+            {
+                if (!(hitObject is Spinner spinner))
+                    continue;
+
+                if (spinner.Duration < problemThreshold)
+                    yield return new IssueTemplateTooShort(this).Create(spinner);
+                else if (spinner.Duration < warningThreshold)
+                    yield return new IssueTemplateVeryShort(this).Create(spinner);
+            }
+        }
+
+        public class IssueTemplateTooShort : IssueTemplate
+        {
+            public IssueTemplateTooShort(ICheck check)
+                : base(check, IssueType.Problem, "This spinner is too short. Auto cannot achieve 1000 points on this.")
+            {
+            }
+
+            public Issue Create(Spinner spinner) => new Issue(spinner, this);
+        }
+
+        public class IssueTemplateVeryShort : IssueTemplate
+        {
+            public IssueTemplateVeryShort(ICheck check)
+                : base(check, IssueType.Warning, "This spinner may be too short. Ensure auto can achieve 1000 points on this.")
+            {
+            }
+
+            public Issue Create(Spinner spinner) => new Issue(spinner, this);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/DrawableOsuEditRuleset.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.Mods;
-using osu.Game.Rulesets.Osu.UI;
-using osu.Game.Rulesets.UI;
-using osuTK;
-
-namespace osu.Game.Rulesets.Osu.Edit
-{
-    public class DrawableOsuEditRuleset : DrawableOsuRuleset
-    {
-        public DrawableOsuEditRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            : base(ruleset, beatmap, mods)
-        {
-        }
-
-        protected override Playfield CreatePlayfield() => new OsuPlayfieldNoCursor();
-
-        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new OsuPlayfieldAdjustmentContainer { Size = Vector2.One };
-
-        private class OsuPlayfieldNoCursor : OsuPlayfield
-        {
-            protected override GameplayCursorContainer CreateCursor() => null;
-        }
-    }
-}

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

@@ -0,0 +1,116 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Skinning.Default;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class DrawableOsuEditorRuleset : DrawableOsuRuleset
+    {
+        /// <summary>
+        /// Hit objects are intentionally made to fade out at a constant slower rate than in gameplay.
+        /// This allows a mapper to gain better historical context and use recent hitobjects as reference / snap points.
+        /// </summary>
+        public const double EDITOR_HIT_OBJECT_FADE_OUT_EXTENSION = 700;
+
+        public DrawableOsuEditorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
+            : base(ruleset, beatmap, mods)
+        {
+        }
+
+        protected override Playfield CreatePlayfield() => new OsuEditorPlayfield();
+
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new OsuPlayfieldAdjustmentContainer { Size = Vector2.One };
+
+        private class OsuEditorPlayfield : OsuPlayfield
+        {
+            private Bindable<bool> hitAnimations;
+
+            protected override GameplayCursorContainer CreateCursor() => null;
+
+            public OsuEditorPlayfield()
+            {
+                HitPolicy = new AnyOrderHitPolicy();
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuConfigManager config)
+            {
+                hitAnimations = config.GetBindable<bool>(OsuSetting.EditorHitAnimations);
+            }
+
+            protected override void OnNewDrawableHitObject(DrawableHitObject d)
+            {
+                d.ApplyCustomUpdateState += updateState;
+            }
+
+            private void updateState(DrawableHitObject hitObject, ArmedState state)
+            {
+                if (state == ArmedState.Idle || hitAnimations.Value)
+                    return;
+
+                if (hitObject is DrawableHitCircle circle)
+                {
+                    using (circle.BeginAbsoluteSequence(circle.HitStateUpdateTime))
+                    {
+                        circle.ApproachCircle
+                              .FadeOutFromOne(EDITOR_HIT_OBJECT_FADE_OUT_EXTENSION * 4)
+                              .Expire();
+
+                        circle.ApproachCircle.ScaleTo(1.1f, 300, Easing.OutQuint);
+                    }
+                }
+
+                if (hitObject is IHasMainCirclePiece mainPieceContainer)
+                {
+                    // clear any explode animation logic.
+                    // this is scheduled after children to ensure that the clear happens after invocations of ApplyCustomUpdateState on the circle piece's nested skinnables.
+                    ScheduleAfterChildren(() =>
+                    {
+                        if (hitObject.HitObject == null) return;
+
+                        mainPieceContainer.CirclePiece.ApplyTransformsAt(hitObject.StateUpdateTime, true);
+                        mainPieceContainer.CirclePiece.ClearTransformsAfter(hitObject.StateUpdateTime, true);
+                    });
+                }
+
+                if (hitObject is DrawableSliderRepeat repeat)
+                {
+                    repeat.Arrow.ApplyTransformsAt(hitObject.StateUpdateTime, true);
+                    repeat.Arrow.ClearTransformsAfter(hitObject.StateUpdateTime, true);
+                }
+
+                // adjust the visuals of top-level object types to make them stay on screen for longer than usual.
+                switch (hitObject)
+                {
+                    case DrawableSlider _:
+                    case DrawableHitCircle _:
+                        // Get the existing fade out transform
+                        var existing = hitObject.Transforms.LastOrDefault(t => t.TargetMember == nameof(Alpha));
+
+                        if (existing == null)
+                            return;
+
+                        hitObject.RemoveTransform(existing);
+
+                        using (hitObject.BeginAbsoluteSequence(hitObject.HitStateUpdateTime))
+                            hitObject.FadeOut(EDITOR_HIT_OBJECT_FADE_OUT_EXTENSION).Expire();
+                        break;
+                }
+            }
+        }
+    }
+}

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

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
@@ -15,6 +17,8 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
+        public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles);
+
         public override PlacementBlueprint CreatePlacementBlueprint() => new HitCirclePlacementBlueprint();
     }
 }

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

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Osu.Edit.Checks;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuBeatmapVerifier : IBeatmapVerifier
+    {
+        private readonly List<ICheck> checks = new List<ICheck>
+        {
+            // Compose
+            new CheckOffscreenObjects(),
+            new CheckTooShortSpinners(),
+
+            // Spread
+            new CheckTimeDistanceEquality(),
+            new CheckLowDiffOverlaps(),
+            new CheckTooShortSliders(),
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            return checks.SelectMany(check => check.Run(context));
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuBlueprintContainer : ComposeBlueprintContainer
+    {
+        public OsuBlueprintContainer(HitObjectComposer composer)
+            : base(composer)
+        {
+        }
+
+        protected override SelectionHandler<HitObject> CreateSelectionHandler() => new OsuSelectionHandler();
+
+        public override HitObjectSelectionBlueprint CreateHitObjectBlueprintFor(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case HitCircle circle:
+                    return new HitCircleSelectionBlueprint(circle);
+
+                case Slider slider:
+                    return new SliderSelectionBlueprint(slider);
+
+                case Spinner spinner:
+                    return new SpinnerSelectionBlueprint(spinner);
+            }
+
+            return base.CreateHitObjectBlueprintFor(hitObject);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapGrid.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 JetBrains.Annotations;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuDistanceSnapGrid : CircularDistanceSnapGrid
+    {
+        public OsuDistanceSnapGrid(OsuHitObject hitObject, [CanBeNull] OsuHitObject nextHitObject = null)
+            : base(hitObject, hitObject.StackedEndPosition, hitObject.GetEndTime(), nextHitObject?.StartTime)
+        {
+            Masking = true;
+        }
+    }
+}

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

@@ -1,19 +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;
 using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
-using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
-using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
@@ -24,8 +31,8 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
-            => new DrawableOsuEditRuleset(ruleset, beatmap, mods);
+        protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
+            => new DrawableOsuEditorRuleset(ruleset, beatmap, mods);
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {
@@ -34,23 +41,262 @@ namespace osu.Game.Rulesets.Osu.Edit
             new SpinnerCompositionTool()
         };
 
-        public override SelectionHandler CreateSelectionHandler() => new OsuSelectionHandler();
+        private readonly Bindable<TernaryState> distanceSnapToggle = new Bindable<TernaryState>();
+        private readonly Bindable<TernaryState> rectangularGridSnapToggle = new Bindable<TernaryState>();
 
-        public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
+        protected override IEnumerable<TernaryButton> CreateTernaryButtons() => base.CreateTernaryButtons().Concat(new[]
         {
-            switch (hitObject)
+            new TernaryButton(distanceSnapToggle, "Distance Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Ruler }),
+            new TernaryButton(rectangularGridSnapToggle, "Grid Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Th })
+        });
+
+        private BindableList<HitObject> selectedHitObjects;
+
+        private Bindable<HitObject> placementObject;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            LayerBelowRuleset.AddRange(new Drawable[]
             {
-                case DrawableHitCircle circle:
-                    return new HitCircleSelectionBlueprint(circle);
+                new PlayfieldBorder
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    PlayfieldBorderStyle = { Value = PlayfieldBorderStyle.Corners }
+                },
+                distanceSnapGridContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
+                rectangularPositionSnapGrid = new OsuRectangularPositionSnapGrid
+                {
+                    RelativeSizeAxes = Axes.Both
+                }
+            });
 
-                case DrawableSlider slider:
-                    return new SliderSelectionBlueprint(slider);
+            selectedHitObjects = EditorBeatmap.SelectedHitObjects.GetBoundCopy();
+            selectedHitObjects.CollectionChanged += (_, __) => updateDistanceSnapGrid();
 
-                case DrawableSpinner spinner:
-                    return new SpinnerSelectionBlueprint(spinner);
+            placementObject = EditorBeatmap.PlacementObject.GetBoundCopy();
+            placementObject.ValueChanged += _ => updateDistanceSnapGrid();
+            distanceSnapToggle.ValueChanged += _ =>
+            {
+                updateDistanceSnapGrid();
+
+                if (distanceSnapToggle.Value == TernaryState.True)
+                    rectangularGridSnapToggle.Value = TernaryState.False;
+            };
+
+            rectangularGridSnapToggle.ValueChanged += _ =>
+            {
+                if (rectangularGridSnapToggle.Value == TernaryState.True)
+                    distanceSnapToggle.Value = TernaryState.False;
+            };
+
+            // we may be entering the screen with a selection already active
+            updateDistanceSnapGrid();
+        }
+
+        protected override ComposeBlueprintContainer CreateBlueprintContainer()
+            => new OsuBlueprintContainer(this);
+
+        public override string ConvertSelectionToString()
+            => string.Join(',', selectedHitObjects.Cast<OsuHitObject>().OrderBy(h => h.StartTime).Select(h => (h.IndexInCurrentCombo + 1).ToString()));
+
+        private DistanceSnapGrid distanceSnapGrid;
+        private Container distanceSnapGridContainer;
+
+        private readonly Cached distanceSnapGridCache = new Cached();
+        private double? lastDistanceSnapGridTime;
+
+        private RectangularPositionSnapGrid rectangularPositionSnapGrid;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!(BlueprintContainer.CurrentTool is SelectTool))
+            {
+                if (EditorClock.CurrentTime != lastDistanceSnapGridTime)
+                {
+                    distanceSnapGridCache.Invalidate();
+                    lastDistanceSnapGridTime = EditorClock.CurrentTime;
+                }
+
+                if (!distanceSnapGridCache.IsValid)
+                    updateDistanceSnapGrid();
+            }
+        }
+
+        public override SnapResult SnapScreenSpacePositionToValidPosition(Vector2 screenSpacePosition)
+        {
+            if (snapToVisibleBlueprints(screenSpacePosition, out var snapResult))
+                return snapResult;
+
+            return new SnapResult(screenSpacePosition, null);
+        }
+
+        public override SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition)
+        {
+            var positionSnap = SnapScreenSpacePositionToValidPosition(screenSpacePosition);
+            if (positionSnap.ScreenSpacePosition != screenSpacePosition)
+                return positionSnap;
+
+            if (distanceSnapToggle.Value == TernaryState.True && distanceSnapGrid != null)
+            {
+                (Vector2 pos, double time) = distanceSnapGrid.GetSnappedPosition(distanceSnapGrid.ToLocalSpace(screenSpacePosition));
+                return new SnapResult(distanceSnapGrid.ToScreenSpace(pos), time, PlayfieldAtScreenSpacePosition(screenSpacePosition));
             }
 
-            return base.CreateBlueprintFor(hitObject);
+            if (rectangularGridSnapToggle.Value == TernaryState.True)
+            {
+                Vector2 pos = rectangularPositionSnapGrid.GetSnappedPosition(rectangularPositionSnapGrid.ToLocalSpace(screenSpacePosition));
+                return new SnapResult(rectangularPositionSnapGrid.ToScreenSpace(pos), null, PlayfieldAtScreenSpacePosition(screenSpacePosition));
+            }
+
+            return base.SnapScreenSpacePositionToValidTime(screenSpacePosition);
+        }
+
+        private bool snapToVisibleBlueprints(Vector2 screenSpacePosition, out SnapResult snapResult)
+        {
+            // check other on-screen objects for snapping/stacking
+            var blueprints = BlueprintContainer.SelectionBlueprints.AliveChildren;
+
+            var playfield = PlayfieldAtScreenSpacePosition(screenSpacePosition);
+
+            float snapRadius =
+                playfield.GamefieldToScreenSpace(new Vector2(OsuHitObject.OBJECT_RADIUS / 5)).X -
+                playfield.GamefieldToScreenSpace(Vector2.Zero).X;
+
+            foreach (var b in blueprints)
+            {
+                if (b.IsSelected)
+                    continue;
+
+                var hitObject = (OsuHitObject)b.Item;
+
+                Vector2? snap = checkSnap(hitObject.Position);
+                if (snap == null && hitObject.Position != hitObject.EndPosition)
+                    snap = checkSnap(hitObject.EndPosition);
+
+                if (snap != null)
+                {
+                    // only return distance portion, since time is not really valid
+                    snapResult = new SnapResult(snap.Value, null, playfield);
+                    return true;
+                }
+
+                Vector2? checkSnap(Vector2 checkPos)
+                {
+                    Vector2 checkScreenPos = playfield.GamefieldToScreenSpace(checkPos);
+
+                    if (Vector2.Distance(checkScreenPos, screenSpacePosition) < snapRadius)
+                        return checkScreenPos;
+
+                    return null;
+                }
+            }
+
+            snapResult = null;
+            return false;
+        }
+
+        private void updateDistanceSnapGrid()
+        {
+            distanceSnapGridContainer.Clear();
+            distanceSnapGridCache.Invalidate();
+            distanceSnapGrid = null;
+
+            if (distanceSnapToggle.Value != TernaryState.True)
+                return;
+
+            switch (BlueprintContainer.CurrentTool)
+            {
+                case SelectTool _:
+                    if (!EditorBeatmap.SelectedHitObjects.Any())
+                        return;
+
+                    distanceSnapGrid = createDistanceSnapGrid(EditorBeatmap.SelectedHitObjects);
+                    break;
+
+                default:
+                    if (!CursorInPlacementArea)
+                        return;
+
+                    distanceSnapGrid = createDistanceSnapGrid(Enumerable.Empty<HitObject>());
+                    break;
+            }
+
+            if (distanceSnapGrid != null)
+            {
+                distanceSnapGridContainer.Add(distanceSnapGrid);
+                distanceSnapGridCache.Validate();
+            }
+        }
+
+        private DistanceSnapGrid createDistanceSnapGrid(IEnumerable<HitObject> selectedHitObjects)
+        {
+            if (BlueprintContainer.CurrentTool is SpinnerCompositionTool)
+                return null;
+
+            var objects = selectedHitObjects.ToList();
+
+            if (objects.Count == 0)
+                // use accurate time value to give more instantaneous feedback to the user.
+                return createGrid(h => h.StartTime <= EditorClock.CurrentTimeAccurate);
+
+            double minTime = objects.Min(h => h.StartTime);
+            return createGrid(h => h.StartTime < minTime, objects.Count + 1);
+        }
+
+        /// <summary>
+        /// Creates a grid from the last <see cref="HitObject"/> matching a predicate to a target <see cref="HitObject"/>.
+        /// </summary>
+        /// <param name="sourceSelector">A predicate that matches <see cref="HitObject"/>s where the grid can start from.
+        /// Only the last <see cref="HitObject"/> matching the predicate is used.</param>
+        /// <param name="targetOffset">An offset from the <see cref="HitObject"/> selected via <paramref name="sourceSelector"/> at which the grid should stop.</param>
+        /// <returns>The <see cref="OsuDistanceSnapGrid"/> from a selected <see cref="HitObject"/> to a target <see cref="HitObject"/>.</returns>
+        private OsuDistanceSnapGrid createGrid(Func<HitObject, bool> sourceSelector, int targetOffset = 1)
+        {
+            if (targetOffset < 1) throw new ArgumentOutOfRangeException(nameof(targetOffset));
+
+            int sourceIndex = -1;
+
+            for (int i = 0; i < EditorBeatmap.HitObjects.Count; i++)
+            {
+                if (!sourceSelector(EditorBeatmap.HitObjects[i]))
+                    break;
+
+                sourceIndex = i;
+            }
+
+            if (sourceIndex == -1)
+                return null;
+
+            HitObject sourceObject = EditorBeatmap.HitObjects[sourceIndex];
+
+            int targetIndex = sourceIndex + targetOffset;
+            HitObject targetObject = null;
+
+            // Keep advancing the target object while its start time falls before the end time of the source object
+            while (true)
+            {
+                if (targetIndex >= EditorBeatmap.HitObjects.Count)
+                    break;
+
+                if (EditorBeatmap.HitObjects[targetIndex].StartTime >= sourceObject.GetEndTime())
+                {
+                    targetObject = EditorBeatmap.HitObjects[targetIndex];
+                    break;
+                }
+
+                targetIndex++;
+            }
+
+            if (sourceObject is Spinner)
+                return null;
+
+            return new OsuDistanceSnapGrid((OsuHitObject)sourceObject, (OsuHitObject)targetObject);
         }
     }
 }

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

@@ -0,0 +1,69 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Input.Bindings;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuRectangularPositionSnapGrid : RectangularPositionSnapGrid, IKeyBindingHandler<GlobalAction>
+    {
+        private static readonly int[] grid_sizes = { 4, 8, 16, 32 };
+
+        private int currentGridSizeIndex = grid_sizes.Length - 1;
+
+        [Resolved]
+        private EditorBeatmap editorBeatmap { get; set; }
+
+        public OsuRectangularPositionSnapGrid()
+            : base(OsuPlayfield.BASE_SIZE / 2)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            int gridSizeIndex = Array.IndexOf(grid_sizes, editorBeatmap.BeatmapInfo.GridSize);
+            if (gridSizeIndex >= 0)
+                currentGridSizeIndex = gridSizeIndex;
+            updateSpacing();
+        }
+
+        private void nextGridSize()
+        {
+            currentGridSizeIndex = (currentGridSizeIndex + 1) % grid_sizes.Length;
+            updateSpacing();
+        }
+
+        private void updateSpacing()
+        {
+            int gridSize = grid_sizes[currentGridSizeIndex];
+
+            editorBeatmap.BeatmapInfo.GridSize = gridSize;
+            Spacing = new Vector2(gridSize);
+        }
+
+        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+        {
+            switch (e.Action)
+            {
+                case GlobalAction.EditorCycleGridDisplayMode:
+                    nextGridSize();
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+        {
+        }
+    }
+}

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

@@ -1,30 +1,303 @@
 // 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 osu.Framework.Input.Events;
-using osu.Game.Rulesets.Edit;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Utils;
+using osu.Game.Extensions;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class OsuSelectionHandler : SelectionHandler
+    public class OsuSelectionHandler : EditorSelectionHandler
     {
-        public override void HandleDrag(SelectionBlueprint blueprint, DragEvent dragEvent)
-        {
-            foreach (var h in SelectedHitObjects.OfType<OsuHitObject>())
-            {
-                if (h is Spinner)
-                {
-                    // Spinners don't support position adjustments
-                    continue;
-                }
+        /// <summary>
+        /// During a transform, the initial origin is stored so it can be used throughout the operation.
+        /// </summary>
+        private Vector2? referenceOrigin;
 
-                h.Position += dragEvent.Delta;
+        /// <summary>
+        /// During a transform, the initial path types of a single selected slider are stored so they
+        /// can be maintained throughout the operation.
+        /// </summary>
+        private List<PathType?> referencePathTypes;
+
+        protected override void OnSelectionChanged()
+        {
+            base.OnSelectionChanged();
+
+            Quad quad = selectedMovableObjects.Length > 0 ? getSurroundingQuad(selectedMovableObjects) : new Quad();
+
+            SelectionBox.CanRotate = quad.Width > 0 || quad.Height > 0;
+            SelectionBox.CanFlipX = SelectionBox.CanScaleX = quad.Width > 0;
+            SelectionBox.CanFlipY = SelectionBox.CanScaleY = quad.Height > 0;
+            SelectionBox.CanReverse = EditorBeatmap.SelectedHitObjects.Count > 1 || EditorBeatmap.SelectedHitObjects.Any(s => s is Slider);
+        }
+
+        protected override void OnOperationEnded()
+        {
+            base.OnOperationEnded();
+            referenceOrigin = null;
+            referencePathTypes = null;
+        }
+
+        public override bool HandleMovement(MoveSelectionEvent<HitObject> moveEvent)
+        {
+            var hitObjects = selectedMovableObjects;
+
+            // this will potentially move the selection out of bounds...
+            foreach (var h in hitObjects)
+                h.Position += this.ScreenSpaceDeltaToParentSpace(moveEvent.ScreenSpaceDelta);
+
+            // but this will be corrected.
+            moveSelectionInBounds();
+            return true;
+        }
+
+        public override bool HandleReverse()
+        {
+            var hitObjects = EditorBeatmap.SelectedHitObjects;
+
+            double endTime = hitObjects.Max(h => h.GetEndTime());
+            double startTime = hitObjects.Min(h => h.StartTime);
+
+            bool moreThanOneObject = hitObjects.Count > 1;
+
+            foreach (var h in hitObjects)
+            {
+                if (moreThanOneObject)
+                    h.StartTime = endTime - (h.GetEndTime() - startTime);
+
+                if (h is Slider slider)
+                {
+                    slider.Path.Reverse(out Vector2 offset);
+                    slider.Position += offset;
+                }
             }
 
-            base.HandleDrag(blueprint, dragEvent);
+            return true;
         }
+
+        public override bool HandleFlip(Direction direction)
+        {
+            var hitObjects = selectedMovableObjects;
+
+            var selectedObjectsQuad = getSurroundingQuad(hitObjects);
+
+            foreach (var h in hitObjects)
+            {
+                h.Position = GetFlippedPosition(direction, selectedObjectsQuad, h.Position);
+
+                if (h is Slider slider)
+                {
+                    foreach (var point in slider.Path.ControlPoints)
+                    {
+                        point.Position = new Vector2(
+                            (direction == Direction.Horizontal ? -1 : 1) * point.Position.X,
+                            (direction == Direction.Vertical ? -1 : 1) * point.Position.Y
+                        );
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        public override bool HandleScale(Vector2 scale, Anchor reference)
+        {
+            adjustScaleFromAnchor(ref scale, reference);
+
+            var hitObjects = selectedMovableObjects;
+
+            // for the time being, allow resizing of slider paths only if the slider is
+            // the only hit object selected. with a group selection, it's likely the user
+            // is not looking to change the duration of the slider but expand the whole pattern.
+            if (hitObjects.Length == 1 && hitObjects.First() is Slider slider)
+                scaleSlider(slider, scale);
+            else
+                scaleHitObjects(hitObjects, reference, scale);
+
+            moveSelectionInBounds();
+            return true;
+        }
+
+        private static void adjustScaleFromAnchor(ref Vector2 scale, Anchor reference)
+        {
+            // cancel out scale in axes we don't care about (based on which drag handle was used).
+            if ((reference & Anchor.x1) > 0) scale.X = 0;
+            if ((reference & Anchor.y1) > 0) scale.Y = 0;
+
+            // reverse the scale direction if dragging from top or left.
+            if ((reference & Anchor.x0) > 0) scale.X = -scale.X;
+            if ((reference & Anchor.y0) > 0) scale.Y = -scale.Y;
+        }
+
+        public override bool HandleRotation(float delta)
+        {
+            var hitObjects = selectedMovableObjects;
+
+            Quad quad = getSurroundingQuad(hitObjects);
+
+            referenceOrigin ??= quad.Centre;
+
+            foreach (var h in hitObjects)
+            {
+                h.Position = RotatePointAroundOrigin(h.Position, referenceOrigin.Value, delta);
+
+                if (h is IHasPath path)
+                {
+                    foreach (var point in path.Path.ControlPoints)
+                        point.Position = RotatePointAroundOrigin(point.Position, Vector2.Zero, delta);
+                }
+            }
+
+            // this isn't always the case but let's be lenient for now.
+            return true;
+        }
+
+        private void scaleSlider(Slider slider, Vector2 scale)
+        {
+            referencePathTypes ??= slider.Path.ControlPoints.Select(p => p.Type).ToList();
+
+            Quad sliderQuad = GetSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position));
+
+            // Limit minimum distance between control points after scaling to almost 0. Less than 0 causes the slider to flip, exactly 0 causes a crash through division by 0.
+            scale = Vector2.ComponentMax(new Vector2(Precision.FLOAT_EPSILON), sliderQuad.Size + scale) - sliderQuad.Size;
+
+            Vector2 pathRelativeDeltaScale = new Vector2(
+                sliderQuad.Width == 0 ? 0 : 1 + scale.X / sliderQuad.Width,
+                sliderQuad.Height == 0 ? 0 : 1 + scale.Y / sliderQuad.Height);
+
+            Queue<Vector2> oldControlPoints = new Queue<Vector2>();
+
+            foreach (var point in slider.Path.ControlPoints)
+            {
+                oldControlPoints.Enqueue(point.Position);
+                point.Position *= pathRelativeDeltaScale;
+            }
+
+            // Maintain the path types in case they were defaulted to bezier at some point during scaling
+            for (int i = 0; i < slider.Path.ControlPoints.Count; ++i)
+                slider.Path.ControlPoints[i].Type = referencePathTypes[i];
+
+            //if sliderhead or sliderend end up outside playfield, revert scaling.
+            Quad scaledQuad = getSurroundingQuad(new OsuHitObject[] { slider });
+            (bool xInBounds, bool yInBounds) = isQuadInBounds(scaledQuad);
+
+            if (xInBounds && yInBounds && slider.Path.HasValidLength)
+                return;
+
+            foreach (var point in slider.Path.ControlPoints)
+                point.Position = oldControlPoints.Dequeue();
+        }
+
+        private void scaleHitObjects(OsuHitObject[] hitObjects, Anchor reference, Vector2 scale)
+        {
+            scale = getClampedScale(hitObjects, reference, scale);
+            Quad selectionQuad = getSurroundingQuad(hitObjects);
+
+            foreach (var h in hitObjects)
+                h.Position = GetScaledPosition(reference, scale, selectionQuad, h.Position);
+        }
+
+        private (bool X, bool Y) isQuadInBounds(Quad quad)
+        {
+            bool xInBounds = (quad.TopLeft.X >= 0) && (quad.BottomRight.X <= DrawWidth);
+            bool yInBounds = (quad.TopLeft.Y >= 0) && (quad.BottomRight.Y <= DrawHeight);
+
+            return (xInBounds, yInBounds);
+        }
+
+        private void moveSelectionInBounds()
+        {
+            var hitObjects = selectedMovableObjects;
+
+            Quad quad = getSurroundingQuad(hitObjects);
+
+            Vector2 delta = Vector2.Zero;
+
+            if (quad.TopLeft.X < 0)
+                delta.X -= quad.TopLeft.X;
+            if (quad.TopLeft.Y < 0)
+                delta.Y -= quad.TopLeft.Y;
+
+            if (quad.BottomRight.X > DrawWidth)
+                delta.X -= quad.BottomRight.X - DrawWidth;
+            if (quad.BottomRight.Y > DrawHeight)
+                delta.Y -= quad.BottomRight.Y - DrawHeight;
+
+            foreach (var h in hitObjects)
+                h.Position += delta;
+        }
+
+        /// <summary>
+        /// Clamp scale for multi-object-scaling where selection does not exceed playfield bounds or flip.
+        /// </summary>
+        /// <param name="hitObjects">The hitobjects to be scaled</param>
+        /// <param name="reference">The anchor from which the scale operation is performed</param>
+        /// <param name="scale">The scale to be clamped</param>
+        /// <returns>The clamped scale vector</returns>
+        private Vector2 getClampedScale(OsuHitObject[] hitObjects, Anchor reference, Vector2 scale)
+        {
+            float xOffset = ((reference & Anchor.x0) > 0) ? -scale.X : 0;
+            float yOffset = ((reference & Anchor.y0) > 0) ? -scale.Y : 0;
+
+            Quad selectionQuad = getSurroundingQuad(hitObjects);
+
+            //todo: this is not always correct for selections involving sliders. This approximation assumes each point is scaled independently, but sliderends move with the sliderhead.
+            Quad scaledQuad = new Quad(selectionQuad.TopLeft.X + xOffset, selectionQuad.TopLeft.Y + yOffset, selectionQuad.Width + scale.X, selectionQuad.Height + scale.Y);
+
+            //max Size -> playfield bounds
+            if (scaledQuad.TopLeft.X < 0)
+                scale.X += scaledQuad.TopLeft.X;
+            if (scaledQuad.TopLeft.Y < 0)
+                scale.Y += scaledQuad.TopLeft.Y;
+
+            if (scaledQuad.BottomRight.X > DrawWidth)
+                scale.X -= scaledQuad.BottomRight.X - DrawWidth;
+            if (scaledQuad.BottomRight.Y > DrawHeight)
+                scale.Y -= scaledQuad.BottomRight.Y - DrawHeight;
+
+            //min Size -> almost 0. Less than 0 causes the quad to flip, exactly 0 causes scaling to get stuck at minimum scale.
+            Vector2 scaledSize = selectionQuad.Size + scale;
+            Vector2 minSize = new Vector2(Precision.FLOAT_EPSILON);
+
+            scale = Vector2.ComponentMax(minSize, scaledSize) - selectionQuad.Size;
+
+            return scale;
+        }
+
+        /// <summary>
+        /// Returns a gamefield-space quad surrounding the provided hit objects.
+        /// </summary>
+        /// <param name="hitObjects">The hit objects to calculate a quad for.</param>
+        private Quad getSurroundingQuad(OsuHitObject[] hitObjects) =>
+            GetSurroundingQuad(hitObjects.SelectMany(h =>
+            {
+                if (h is IHasPath path)
+                {
+                    return new[]
+                    {
+                        h.Position,
+                        // can't use EndPosition for reverse slider cases.
+                        h.Position + path.Path.PositionAt(1)
+                    };
+                }
+
+                return new[] { h.Position };
+            }));
+
+        /// <summary>
+        /// All osu! hitobjects which can be moved/rotated/scaled.
+        /// </summary>
+        private OsuHitObject[] selectedMovableObjects => SelectedItems.OfType<OsuHitObject>()
+                                                                      .Where(h => !(h is Spinner))
+                                                                      .ToArray();
     }
 }

osu.Game.Rulesets.Osu/Edit/Setup/OsuSetupSection.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 osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Screens.Edit.Setup;
+
+namespace osu.Game.Rulesets.Osu.Edit.Setup
+{
+    public class OsuSetupSection : RulesetSetupSection
+    {
+        private LabelledSliderBar<float> stackLeniency;
+
+        public OsuSetupSection()
+            : base(new OsuRuleset().RulesetInfo)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new[]
+            {
+                stackLeniency = new LabelledSliderBar<float>
+                {
+                    Label = "Stack Leniency",
+                    Description = "In play mode, osu! automatically stacks notes which occur at the same location. Increasing this value means it is more likely to snap notes of further time-distance.",
+                    Current = new BindableFloat(Beatmap.BeatmapInfo.StackLeniency)
+                    {
+                        Default = 0.7f,
+                        MinValue = 0,
+                        MaxValue = 1,
+                        Precision = 0.1f
+                    }
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            stackLeniency.Current.BindValueChanged(_ => updateBeatmap());
+        }
+
+        private void updateBeatmap()
+        {
+            Beatmap.BeatmapInfo.StackLeniency = stackLeniency.Current.Value;
+        }
+    }
+}

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

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
@@ -15,6 +17,8 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
+        public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders);
+
         public override PlacementBlueprint CreatePlacementBlueprint() => new SliderPlacementBlueprint();
     }
 }

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

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
@@ -15,6 +17,8 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
+        public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners);
+
         public override PlacementBlueprint CreatePlacementBlueprint() => new SpinnerPlacementBlueprint();
     }
 }

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

@@ -0,0 +1,28 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Judgements
+{
+    public class OsuHitCircleJudgementResult : OsuJudgementResult
+    {
+        /// <summary>
+        /// The <see cref="HitCircle"/>.
+        /// </summary>
+        public HitCircle HitCircle => (HitCircle)HitObject;
+
+        /// <summary>
+        /// The position of the player's cursor when <see cref="HitCircle"/> was hit.
+        /// </summary>
+        public Vector2? CursorPositionAtHit;
+
+        public OsuHitCircleJudgementResult(HitObject hitObject, Judgement judgement)
+            : base(hitObject, judgement)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Osu/Judgements/OsuIgnoreJudgement.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.
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Judgements
+{
+    public class OsuIgnoreJudgement : OsuJudgement
+    {
+        public override HitResult MaxResult => HitResult.IgnoreHit;
+    }
+}

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

@@ -9,40 +9,5 @@ namespace osu.Game.Rulesets.Osu.Judgements
     public class OsuJudgement : Judgement
     {
         public override HitResult MaxResult => HitResult.Great;
-
-        protected override int NumericResultFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Meh:
-                    return 50;
-
-                case HitResult.Good:
-                    return 100;
-
-                case HitResult.Great:
-                    return 300;
-            }
-        }
-
-        protected override double HealthIncreaseFor(HitResult result)
-        {
-            switch (result)
-            {
-                case HitResult.Miss:
-                    return -0.02;
-
-                case HitResult.Meh:
-                case HitResult.Good:
-                case HitResult.Great:
-                    return 0.01;
-
-                default:
-                    return 0;
-            }
-        }
     }
 }

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)
-            : base(judgement)
+        public OsuJudgementResult(HitObject hitObject, Judgement judgement)
+            : base(hitObject, judgement)
         {
         }
     }

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

@@ -1,14 +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.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Osu.Judgements
-{
-    public class OsuSliderTailJudgement : OsuJudgement
-    {
-        public override bool AffectsCombo => false;
-
-        protected override int NumericResultFor(HitResult result) => 0;
-    }
-}

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

@@ -0,0 +1,57 @@
+// 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.Judgements;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Judgements
+{
+    public class OsuSpinnerJudgementResult : OsuJudgementResult
+    {
+        /// <summary>
+        /// The <see cref="Spinner"/>.
+        /// </summary>
+        public Spinner Spinner => (Spinner)HitObject;
+
+        /// <summary>
+        /// The total rotation performed on the spinner disc, disregarding the spin direction,
+        /// adjusted for the track's playback rate.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// This value is always non-negative and is monotonically increasing with time
+        /// (i.e. will only increase if time is passing forward, but can decrease during rewind).
+        /// </para>
+        /// <para>
+        /// The rotation from each frame is multiplied by the clock's current playback rate.
+        /// The reason this is done is to ensure that spinners give the same score and require the same number of spins
+        /// regardless of whether speed-modifying mods are applied.
+        /// </para>
+        /// </remarks>
+        /// <example>
+        /// Assuming no speed-modifying mods are active,
+        /// if the spinner is spun 360 degrees clockwise and then 360 degrees counter-clockwise,
+        /// this property will return the value of 720 (as opposed to 0).
+        /// If Double Time is active instead (with a speed multiplier of 1.5x),
+        /// in the same scenario the property will return 720 * 1.5 = 1080.
+        /// </example>
+        public float RateAdjustedRotation;
+
+        /// <summary>
+        /// Time instant at which the spin was started (the first user input which caused an increase in spin).
+        /// </summary>
+        public double? TimeStarted;
+
+        /// <summary>
+        /// Time instant at which the spinner has been completed (the user has executed all required spins).
+        /// Will be null if all required spins haven't been completed.
+        /// </summary>
+        public double? TimeCompleted;
+
+        public OsuSpinnerJudgementResult(HitObject hitObject, Judgement judgement)
+            : base(hitObject, judgement)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Osu/Judgements/SliderTickJudgement.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.
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Judgements
+{
+    public class SliderTickJudgement : OsuJudgement
+    {
+        public override HitResult MaxResult => HitResult.LargeTickHit;
+    }
+}

osu.Game.Rulesets.Osu/Mods/IHidesApproachCircles.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.
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    /// <summary>
+    /// Marker interface for any mod which completely hides the approach circles.
+    /// Used for incompatibility with <see cref="IRequiresApproachCircles"/>.
+    /// </summary>
+    /// <remarks>
+    /// Note that this is only a marker interface for incompatibility purposes, it does not change any gameplay behaviour.
+    /// </remarks>
+    public interface IHidesApproachCircles
+    {
+    }
+}

osu.Game.Rulesets.Osu/Mods/IRequiresApproachCircles.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.
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    /// <summary>
+    /// Marker interface for any mod which requires the approach circles to be visible.
+    /// Used for incompatibility with <see cref="IHidesApproachCircles"/>.
+    /// </summary>
+    /// <remarks>
+    /// Note that this is only a marker interface for incompatibility purposes, it does not change any gameplay behaviour.
+    /// </remarks>
+    public interface IRequiresApproachCircles
+    {
+    }
+}

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

@@ -0,0 +1,104 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModApproachDifferent : Mod, IApplicableToDrawableHitObject, IRequiresApproachCircles
+    {
+        public override string Name => "Approach Different";
+        public override string Acronym => "AD";
+        public override string Description => "Never trust the approach circles...";
+        public override double ScoreMultiplier => 1;
+        public override IconUsage? Icon { get; } = FontAwesome.Regular.Circle;
+
+        public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles) };
+
+        [SettingSource("Initial size", "Change the initial size of the approach circle, relative to hit circles.", 0)]
+        public BindableFloat Scale { get; } = new BindableFloat(4)
+        {
+            Precision = 0.1f,
+            MinValue = 1.5f,
+            MaxValue = 10,
+        };
+
+        [SettingSource("Style", "Change the animation style of the approach circles.", 1)]
+        public Bindable<AnimationStyle> Style { get; } = new Bindable<AnimationStyle>(AnimationStyle.Gravity);
+
+        public void ApplyToDrawableHitObject(DrawableHitObject drawable)
+        {
+            drawable.ApplyCustomUpdateState += (drawableObject, state) =>
+            {
+                if (!(drawableObject is DrawableHitCircle drawableHitCircle)) return;
+
+                var hitCircle = drawableHitCircle.HitObject;
+
+                drawableHitCircle.ApproachCircle.ClearTransforms(targetMember: nameof(Scale));
+
+                using (drawableHitCircle.BeginAbsoluteSequence(hitCircle.StartTime - hitCircle.TimePreempt))
+                    drawableHitCircle.ApproachCircle.ScaleTo(Scale.Value).ScaleTo(1f, hitCircle.TimePreempt, getEasing(Style.Value));
+            };
+        }
+
+        private Easing getEasing(AnimationStyle style)
+        {
+            switch (style)
+            {
+                case AnimationStyle.Linear:
+                    return Easing.None;
+
+                case AnimationStyle.Gravity:
+                    return Easing.InBack;
+
+                case AnimationStyle.InOut1:
+                    return Easing.InOutCubic;
+
+                case AnimationStyle.InOut2:
+                    return Easing.InOutQuint;
+
+                case AnimationStyle.Accelerate1:
+                    return Easing.In;
+
+                case AnimationStyle.Accelerate2:
+                    return Easing.InCubic;
+
+                case AnimationStyle.Accelerate3:
+                    return Easing.InQuint;
+
+                case AnimationStyle.Decelerate1:
+                    return Easing.Out;
+
+                case AnimationStyle.Decelerate2:
+                    return Easing.OutCubic;
+
+                case AnimationStyle.Decelerate3:
+                    return Easing.OutQuint;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(style), style, @"Unsupported animation style");
+            }
+        }
+
+        public enum AnimationStyle
+        {
+            Linear,
+            Gravity,
+            InOut1,
+            InOut2,
+            Accelerate1,
+            Accelerate2,
+            Accelerate3,
+            Decelerate1,
+            Decelerate2,
+            Decelerate3,
+        }
+    }
+}

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

@@ -18,16 +18,20 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Autopilot";
         public override string Acronym => "AP";
-        public override IconUsage Icon => OsuIcon.ModAutopilot;
+        public override IconUsage? Icon => OsuIcon.ModAutopilot;
         public override ModType Type => ModType.Automation;
         public override string Description => @"Automatic cursor movement - just follow the rhythm.";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModSpunOut), typeof(ModRelax), typeof(ModSuddenDeath), typeof(ModNoFail), typeof(ModAutoplay), typeof(OsuModAimAssist) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModSpunOut), typeof(ModRelax), typeof(ModFailCondition), typeof(ModNoFail), typeof(ModAutoplay), typeof(OsuModAimAssist) };
 
-        public bool AllowFail => false;
+        public bool PerformFail() => false;
+
+        public bool RestartOnFail => false;
 
         private OsuInputManager inputManager;
 
+        private IFrameStableClock gameplayClock;
+
         private List<OsuReplayFrame> replayFrames;
 
         private int currentFrame;
@@ -36,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             if (currentFrame == replayFrames.Count - 1) return;
 
-            double time = playfield.Time.Current;
+            double time = gameplayClock.CurrentTime;
 
             // Very naive implementation of autopilot based on proximity to replay frames.
             // TODO: this needs to be based on user interactions to better match stable (pausing until judgement is registered).
@@ -51,12 +55,14 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
+            gameplayClock = drawableRuleset.FrameStableClock;
+
             // Grab the input manager to disable the user's cursor, and for future use
             inputManager = (OsuInputManager)drawableRuleset.KeyBindingInputManager;
             inputManager.AllowUserCursorMovement = false;
 
             // Generate the replay frames the cursor should follow
-            replayFrames = new OsuAutoGenerator(drawableRuleset.Beatmap).Generate().Frames.Cast<OsuReplayFrame>().ToList();
+            replayFrames = new OsuAutoGenerator(drawableRuleset.Beatmap, drawableRuleset.Mods).Generate().Frames.Cast<OsuReplayFrame>().ToList();
         }
     }
 }

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

@@ -2,24 +2,24 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Scoring;
-using osu.Game.Users;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModAutoplay : ModAutoplay<OsuHitObject>
+    public class OsuModAutoplay : ModAutoplay
     {
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).Append(typeof(OsuModSpunOut)).ToArray();
 
-        public override Score CreateReplayScore(IBeatmap beatmap) => new Score
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
         {
-            ScoreInfo = new ScoreInfo { User = new User { Username = "Autoplay" } },
-            Replay = new OsuAutoGenerator(beatmap).Generate()
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "Autoplay" } },
+            Replay = new OsuAutoGenerator(beatmap, mods).Generate()
         };
     }
 }

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

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModBarrelRoll : ModBarrelRoll<OsuHitObject>, IApplicableToDrawableHitObject
+    {
+        public void ApplyToDrawableHitObject(DrawableHitObject d)
+        {
+            d.OnUpdate += _ =>
+            {
+                switch (d)
+                {
+                    case DrawableHitCircle circle:
+                        circle.CirclePiece.Rotation = -CurrentRotation;
+                        break;
+                }
+            };
+        }
+    }
+}

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

@@ -1,45 +1,44 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
-using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModBlinds : Mod, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToScoreProcessor
+    public class OsuModBlinds : Mod, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToHealthProcessor
     {
         public override string Name => "Blinds";
         public override string Description => "Play with blinds on your screen.";
         public override string Acronym => "BL";
 
-        public override IconUsage Icon => FontAwesome.Solid.Adjust;
+        public override IconUsage? Icon => FontAwesome.Solid.Adjust;
         public override ModType Type => ModType.DifficultyIncrease;
 
-        public override bool Ranked => false;
-
         public override double ScoreMultiplier => 1.12;
         private DrawableOsuBlinds blinds;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
         {
-            drawableRuleset.Overlays.Add(blinds = new DrawableOsuBlinds(drawableRuleset.Playfield.HitObjectContainer, drawableRuleset.Beatmap));
+            drawableRuleset.Overlays.Add(blinds = new DrawableOsuBlinds(drawableRuleset.Playfield, drawableRuleset.Beatmap));
         }
 
-        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+        public void ApplyToHealthProcessor(HealthProcessor healthProcessor)
         {
-            scoreProcessor.Health.ValueChanged += health => { blinds.AnimateClosedness((float)health.NewValue); };
+            healthProcessor.Health.ValueChanged += health => { blinds.AnimateClosedness((float)health.NewValue); };
         }
 
         public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
@@ -64,8 +63,8 @@ namespace osu.Game.Rulesets.Osu.Mods
             /// </summary>
             private const float target_clamp = 1;
 
-            private readonly float targetBreakMultiplier = 0;
-            private readonly float easing = 1;
+            private readonly float targetBreakMultiplier;
+            private readonly float easing;
 
             private readonly CompositeDrawable restrictTo;
 
@@ -86,6 +85,9 @@ namespace osu.Game.Rulesets.Osu.Mods
             {
                 this.restrictTo = restrictTo;
                 this.beatmap = beatmap;
+
+                targetBreakMultiplier = 0;
+                easing = 1;
             }
 
             [BackgroundDependencyLoader]
@@ -120,15 +122,28 @@ namespace osu.Game.Rulesets.Osu.Mods
                 };
             }
 
-            private float calculateGap(float value) => MathHelper.Clamp(value, 0, target_clamp) * targetBreakMultiplier;
+            private float calculateGap(float value) => Math.Clamp(value, 0, target_clamp) * targetBreakMultiplier;
 
             // lagrange polinominal for (0,0) (0.6,0.4) (1,1) should make a good curve
             private static float applyAdjustmentCurve(float value) => 0.6f * value * value + 0.4f * value;
 
             protected override void Update()
             {
-                float start = Parent.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopLeft).X;
-                float end = Parent.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopRight).X;
+                float start, end;
+
+                if (Precision.AlmostEquals(restrictTo.Rotation, 0))
+                {
+                    start = Parent.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopLeft).X;
+                    end = Parent.ToLocalSpace(restrictTo.ScreenSpaceDrawQuad.TopRight).X;
+                }
+                else
+                {
+                    float center = restrictTo.ToSpaceOfOtherDrawable(restrictTo.OriginPosition, Parent).X;
+                    float halfDiagonal = (restrictTo.DrawSize / 2).LengthFast;
+
+                    start = center - halfDiagonal;
+                    end = center + halfDiagonal;
+                }
 
                 float rawWidth = end - start;
 
@@ -155,19 +170,19 @@ namespace osu.Game.Rulesets.Osu.Mods
                 base.LoadComplete();
 
                 var firstObj = beatmap.HitObjects[0];
-                var startDelay = firstObj.StartTime - firstObj.TimePreempt;
+                double startDelay = firstObj.StartTime - firstObj.TimePreempt;
 
-                using (BeginAbsoluteSequence(startDelay + break_close_late, true))
+                using (BeginAbsoluteSequence(startDelay + break_close_late))
                     leaveBreak();
 
                 foreach (var breakInfo in beatmap.Breaks)
                 {
                     if (breakInfo.HasEffect)
                     {
-                        using (BeginAbsoluteSequence(breakInfo.StartTime - break_open_early, true))
+                        using (BeginAbsoluteSequence(breakInfo.StartTime - break_open_early))
                         {
                             enterBreak();
-                            using (BeginDelayedSequence(breakInfo.Duration + break_open_early + break_close_late, true))
+                            using (BeginDelayedSequence(breakInfo.Duration + break_open_early + break_close_late))
                                 leaveBreak();
                         }
                     }
@@ -188,7 +203,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/OsuModCinema.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;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModCinema : ModCinema<OsuHitObject>
+    {
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).Append(typeof(OsuModSpunOut)).ToArray();
+
+        public override Score CreateReplayScore(IBeatmap beatmap, IReadOnlyList<Mod> mods) => new Score
+        {
+            ScoreInfo = new ScoreInfo { User = new APIUser { Username = "Autoplay" } },
+            Replay = new OsuAutoGenerator(beatmap, mods).Generate()
+        };
+    }
+}

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

@@ -0,0 +1,74 @@
+// 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 osu.Framework.Bindables;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModClassic : ModClassic, IApplicableToHitObject, IApplicableToDrawableHitObject, IApplicableToDrawableRuleset<OsuHitObject>
+    {
+        [SettingSource("No slider head accuracy requirement", "Scores sliders proportionally to the number of ticks hit.")]
+        public Bindable<bool> NoSliderHeadAccuracy { get; } = new BindableBool(true);
+
+        [SettingSource("No slider head movement", "Pins slider heads at their starting position, regardless of time.")]
+        public Bindable<bool> NoSliderHeadMovement { get; } = new BindableBool(true);
+
+        [SettingSource("Apply classic note lock", "Applies note lock to the full hit window.")]
+        public Bindable<bool> ClassicNoteLock { get; } = new BindableBool(true);
+
+        [SettingSource("Use fixed slider follow circle hit area", "Makes the slider follow circle track its final size at all times.")]
+        public Bindable<bool> FixedFollowCircleHitArea { get; } = new BindableBool(true);
+
+        [SettingSource("Always play a slider's tail sample", "Always plays a slider's tail sample regardless of whether it was hit or not.")]
+        public Bindable<bool> AlwaysPlayTailSample { get; } = new BindableBool(true);
+
+        public void ApplyToHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Slider slider:
+                    slider.OnlyJudgeNestedObjects = !NoSliderHeadAccuracy.Value;
+
+                    foreach (var head in slider.NestedHitObjects.OfType<SliderHeadCircle>())
+                        head.JudgeAsNormalHitCircle = !NoSliderHeadAccuracy.Value;
+
+                    break;
+            }
+        }
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            var osuRuleset = (DrawableOsuRuleset)drawableRuleset;
+
+            if (ClassicNoteLock.Value)
+                osuRuleset.Playfield.HitPolicy = new ObjectOrderedHitPolicy();
+        }
+
+        public void ApplyToDrawableHitObject(DrawableHitObject obj)
+        {
+            switch (obj)
+            {
+                case DrawableSlider slider:
+                    slider.Ball.InputTracksVisualSize = !FixedFollowCircleHitArea.Value;
+                    break;
+
+                case DrawableSliderHead head:
+                    head.TrackFollowCircle = !NoSliderHeadMovement.Value;
+                    break;
+
+                case DrawableSliderTail tail:
+                    tail.SamplePlaysOnlyOnHit = !AlwaysPlayTailSample.Value;
+                    break;
+            }
+        }
+    }
+}

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

@@ -1,20 +1,30 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModDeflate : OsuModeObjectScaleTween
+    public class OsuModDeflate : OsuModObjectScaleTween
     {
         public override string Name => "Deflate";
 
         public override string Acronym => "DF";
 
-        public override IconUsage Icon => FontAwesome.Solid.CompressArrowsAlt;
+        public override IconUsage? Icon => FontAwesome.Solid.CompressArrowsAlt;
 
         public override string Description => "Hit them at the right size!";
 
-        protected override float StartScale => 2f;
+        [SettingSource("Starting Size", "The initial size multiplier applied to all objects.")]
+        public override BindableNumber<float> StartScale { get; } = new BindableFloat
+        {
+            MinValue = 1f,
+            MaxValue = 25f,
+            Default = 2f,
+            Value = 2f,
+            Precision = 0.1f,
+        };
     }
 }

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

@@ -0,0 +1,57 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModDifficultyAdjust : ModDifficultyAdjust
+    {
+        [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable CircleSize { get; } = new DifficultyBindable
+        {
+            Precision = 0.1f,
+            MinValue = 0,
+            MaxValue = 10,
+            ExtendedMaxValue = 11,
+            ReadCurrentFromDifficulty = diff => diff.CircleSize,
+        };
+
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        public DifficultyBindable ApproachRate { get; } = new DifficultyBindable
+        {
+            Precision = 0.1f,
+            MinValue = 0,
+            MaxValue = 10,
+            ExtendedMaxValue = 11,
+            ReadCurrentFromDifficulty = diff => diff.ApproachRate,
+        };
+
+        public override string SettingDescription
+        {
+            get
+            {
+                string circleSize = CircleSize.IsDefault ? string.Empty : $"CS {CircleSize.Value:N1}";
+                string approachRate = ApproachRate.IsDefault ? string.Empty : $"AR {ApproachRate.Value:N1}";
+
+                return string.Join(", ", new[]
+                {
+                    circleSize,
+                    base.SettingDescription,
+                    approachRate
+                }.Where(s => !string.IsNullOrEmpty(s)));
+            }
+        }
+
+        protected override void ApplySettings(BeatmapDifficulty difficulty)
+        {
+            base.ApplySettings(difficulty);
+
+            if (CircleSize.Value != null) difficulty.CircleSize = CircleSize.Value.Value;
+            if (ApproachRate.Value != null) difficulty.ApproachRate = ApproachRate.Value.Value;
+        }
+    }
+}

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

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

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

@@ -1,41 +1,59 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
-using System.Linq;
+using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
-using osu.Framework.MathUtils;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.UI;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModFlashlight : ModFlashlight<OsuHitObject>, IApplicableToDrawableHitObjects
+    public class OsuModFlashlight : ModFlashlight<OsuHitObject>, IApplicableToDrawableHitObject
     {
         public override double ScoreMultiplier => 1.12;
 
         private const float default_flashlight_size = 180;
 
+        private const double default_follow_delay = 120;
+
         private OsuFlashlight flashlight;
 
         public override Flashlight CreateFlashlight() => flashlight = new OsuFlashlight();
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        public void ApplyToDrawableHitObject(DrawableHitObject drawable)
         {
-            foreach (var s in drawables.OfType<DrawableSlider>())
-            {
+            if (drawable is DrawableSlider s)
                 s.Tracking.ValueChanged += flashlight.OnSliderTrackingChange;
-            }
         }
 
+        public override void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            base.ApplyToDrawableRuleset(drawableRuleset);
+
+            flashlight.FollowDelay = FollowDelay.Value;
+        }
+
+        [SettingSource("Follow delay", "Milliseconds until the flashlight reaches the cursor")]
+        public BindableNumber<double> FollowDelay { get; } = new BindableDouble(default_follow_delay)
+        {
+            MinValue = default_follow_delay,
+            MaxValue = default_follow_delay * 10,
+            Precision = default_follow_delay,
+        };
+
         private class OsuFlashlight : Flashlight, IRequireHighFrequencyMousePosition
         {
+            public double FollowDelay { private get; set; }
+
             public OsuFlashlight()
             {
                 FlashlightSize = new Vector2(0, getSizeFor(0));
@@ -49,13 +67,11 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             protected override bool OnMouseMove(MouseMoveEvent e)
             {
-                const double follow_delay = 120;
-
                 var position = FlashlightPosition;
                 var destination = e.MousePosition;
 
                 FlashlightPosition = Interpolation.ValueAt(
-                    MathHelper.Clamp(Clock.ElapsedFrameTime, 0, follow_delay), position, destination, 0, follow_delay, Easing.Out);
+                    Math.Min(Math.Abs(Clock.ElapsedFrameTime), FollowDelay), position, destination, 0, FollowDelay, Easing.Out);
 
                 return base.OnMouseMove(e);
             }

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

@@ -1,20 +1,30 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModGrow : OsuModeObjectScaleTween
+    internal class OsuModGrow : OsuModObjectScaleTween
     {
         public override string Name => "Grow";
 
         public override string Acronym => "GR";
 
-        public override IconUsage Icon => FontAwesome.Solid.ArrowsAltV;
+        public override IconUsage? Icon => FontAwesome.Solid.ArrowsAltV;
 
         public override string Description => "Hit them at the right size!";
 
-        protected override float StartScale => 0.5f;
+        [SettingSource("Starting Size", "The initial size multiplier applied to all objects.")]
+        public override BindableNumber<float> StartScale { get; } = new BindableFloat
+        {
+            MinValue = 0f,
+            MaxValue = 0.99f,
+            Default = 0.5f,
+            Value = 0.5f,
+            Precision = 0.01f,
+        };
     }
 }

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

@@ -1,39 +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;
 using System.Linq;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.UI;
-using osuTK;
+using osu.Game.Rulesets.Osu.Utils;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModHardRock : ModHardRock, IApplicableToHitObject
     {
         public override double ScoreMultiplier => 1.06;
-        public override bool Ranked => true;
+
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModMirror)).ToArray();
 
         public void ApplyToHitObject(HitObject hitObject)
         {
             var osuObject = (OsuHitObject)hitObject;
 
-            osuObject.Position = new Vector2(osuObject.Position.X, OsuPlayfield.BASE_SIZE.Y - osuObject.Y);
-
-            var slider = hitObject as Slider;
-            if (slider == null)
-                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));
-
-            var newControlPoints = new Vector2[slider.Path.ControlPoints.Length];
-            for (int i = 0; i < slider.Path.ControlPoints.Length; i++)
-                newControlPoints[i] = new Vector2(slider.Path.ControlPoints[i].X, -slider.Path.ControlPoints[i].Y);
-
-            slider.Path = new SliderPath(slider.Path.Type, newControlPoints, slider.Path.ExpectedDistance);
+            OsuHitObjectGenerationUtils.ReflectVertically(osuObject);
         }
     }
 }

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

@@ -2,91 +2,191 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Bindables;
+using osu.Game.Configuration;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModHidden : ModHidden
+    public class OsuModHidden : ModHidden, IHidesApproachCircles
     {
+        [SettingSource("Only fade approach circles", "The main object body will not fade when enabled.")]
+        public Bindable<bool> OnlyFadeApproachCircles { get; } = new BindableBool();
+
         public override string Description => @"Play with no approach circles and fading circles/sliders.";
         public override double ScoreMultiplier => 1.06;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModSpinIn) };
+
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn) };
+
         private const double fade_in_duration_multiplier = 0.4;
         private const double fade_out_duration_multiplier = 0.3;
 
-        public override void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        protected override bool IsFirstAdjustableObject(HitObject hitObject) => !(hitObject is Spinner || hitObject is SpinnerTick);
+
+        public override void ApplyToBeatmap(IBeatmap beatmap)
         {
-            void adjustFadeIn(OsuHitObject h) => h.TimeFadeIn = h.TimePreempt * fade_in_duration_multiplier;
+            base.ApplyToBeatmap(beatmap);
 
-            foreach (var d in drawables.OfType<DrawableOsuHitObject>())
+            foreach (var obj in beatmap.HitObjects.OfType<OsuHitObject>())
+                applyFadeInAdjustment(obj);
+
+            static void applyFadeInAdjustment(OsuHitObject osuObject)
             {
-                adjustFadeIn(d.HitObject);
-                foreach (var h in d.HitObject.NestedHitObjects.OfType<OsuHitObject>())
-                    adjustFadeIn(h);
+                osuObject.TimeFadeIn = osuObject.TimePreempt * fade_in_duration_multiplier;
+                foreach (var nested in osuObject.NestedHitObjects.OfType<OsuHitObject>())
+                    applyFadeInAdjustment(nested);
             }
-
-            base.ApplyToDrawableHitObjects(drawables);
         }
 
-        protected override void ApplyHiddenState(DrawableHitObject drawable, ArmedState state)
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            if (!(drawable is DrawableOsuHitObject d))
+            applyHiddenState(hitObject, true);
+        }
+
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
+        {
+            applyHiddenState(hitObject, false);
+        }
+
+        private void applyHiddenState(DrawableHitObject drawableObject, bool increaseVisibility)
+        {
+            if (!(drawableObject is DrawableOsuHitObject drawableOsuObject))
                 return;
 
-            var h = d.HitObject;
+            OsuHitObject hitObject = drawableOsuObject.HitObject;
 
-            var fadeOutStartTime = h.StartTime - h.TimePreempt + h.TimeFadeIn;
-            var fadeOutDuration = h.TimePreempt * fade_out_duration_multiplier;
+            (double fadeStartTime, double fadeDuration) = getFadeOutParameters(drawableOsuObject);
 
-            // new duration from completed fade in to end (before fading out)
-            var longFadeDuration = ((h as IHasEndTime)?.EndTime ?? h.StartTime) - fadeOutStartTime;
-
-            switch (drawable)
+            // process approach circle hiding first (to allow for early return below).
+            if (!increaseVisibility)
             {
-                case DrawableHitCircle circle:
-                    // we don't want to see the approach circle
-                    using (circle.BeginAbsoluteSequence(h.StartTime - h.TimePreempt, true))
+                if (drawableObject is DrawableHitCircle circle)
+                {
+                    using (circle.BeginAbsoluteSequence(hitObject.StartTime - hitObject.TimePreempt))
                         circle.ApproachCircle.Hide();
+                }
+                else if (drawableObject is DrawableSpinner spinner)
+                {
+                    spinner.Body.OnSkinChanged += () => hideSpinnerApproachCircle(spinner);
+                    hideSpinnerApproachCircle(spinner);
+                }
+            }
 
-                    // fade out immediately after fade in.
-                    using (drawable.BeginAbsoluteSequence(fadeOutStartTime, true))
-                        circle.FadeOut(fadeOutDuration);
+            if (OnlyFadeApproachCircles.Value)
+                return;
+
+            switch (drawableObject)
+            {
+                case DrawableSliderTail _:
+                    using (drawableObject.BeginAbsoluteSequence(fadeStartTime))
+                        drawableObject.FadeOut(fadeDuration);
 
                     break;
 
+                case DrawableSliderRepeat sliderRepeat:
+                    using (drawableObject.BeginAbsoluteSequence(fadeStartTime))
+                        // only apply to circle piece – reverse arrow is not affected by hidden.
+                        sliderRepeat.CirclePiece.FadeOut(fadeDuration);
+
+                    break;
+
+                case DrawableHitCircle circle:
+                    Drawable fadeTarget = circle;
+
+                    if (increaseVisibility)
+                    {
+                        // only fade the circle piece (not the approach circle) for the increased visibility object.
+                        fadeTarget = circle.CirclePiece;
+                    }
+
+                    using (drawableObject.BeginAbsoluteSequence(fadeStartTime))
+                        fadeTarget.FadeOut(fadeDuration);
+                    break;
+
                 case DrawableSlider slider:
-                    using (slider.BeginAbsoluteSequence(fadeOutStartTime, true))
-                        slider.Body.FadeOut(longFadeDuration, Easing.Out);
+                    using (slider.BeginAbsoluteSequence(fadeStartTime))
+                        slider.Body.FadeOut(fadeDuration, Easing.Out);
 
                     break;
 
                 case DrawableSliderTick sliderTick:
-                    // slider ticks fade out over up to one second
-                    var tickFadeOutDuration = Math.Min(sliderTick.HitObject.TimePreempt - DrawableSliderTick.ANIM_DURATION, 1000);
-
-                    using (sliderTick.BeginAbsoluteSequence(sliderTick.HitObject.StartTime - tickFadeOutDuration, true))
-                        sliderTick.FadeOut(tickFadeOutDuration);
+                    using (sliderTick.BeginAbsoluteSequence(fadeStartTime))
+                        sliderTick.FadeOut(fadeDuration);
 
                     break;
 
                 case DrawableSpinner spinner:
                     // hide elements we don't care about.
-                    spinner.Disc.Hide();
-                    spinner.Ticks.Hide();
-                    spinner.Background.Hide();
+                    // todo: hide background
 
-                    using (spinner.BeginAbsoluteSequence(fadeOutStartTime + longFadeDuration, true))
-                        spinner.FadeOut(fadeOutDuration);
+                    using (spinner.BeginAbsoluteSequence(fadeStartTime))
+                        spinner.FadeOut(fadeDuration);
 
                     break;
             }
         }
+
+        private (double fadeStartTime, double fadeDuration) getFadeOutParameters(DrawableOsuHitObject drawableObject)
+        {
+            switch (drawableObject)
+            {
+                case DrawableSliderTail tail:
+                    // Use the same fade sequence as the slider head.
+                    Debug.Assert(tail.Slider != null);
+                    return getParameters(tail.Slider.HeadCircle);
+
+                case DrawableSliderRepeat repeat:
+                    // Use the same fade sequence as the slider head.
+                    Debug.Assert(repeat.Slider != null);
+                    return getParameters(repeat.Slider.HeadCircle);
+
+                default:
+                    return getParameters(drawableObject.HitObject);
+            }
+
+            static (double fadeStartTime, double fadeDuration) getParameters(OsuHitObject hitObject)
+            {
+                double fadeOutStartTime = hitObject.StartTime - hitObject.TimePreempt + hitObject.TimeFadeIn;
+                double fadeOutDuration = hitObject.TimePreempt * fade_out_duration_multiplier;
+
+                // new duration from completed fade in to end (before fading out)
+                double longFadeDuration = hitObject.GetEndTime() - fadeOutStartTime;
+
+                switch (hitObject)
+                {
+                    case Slider _:
+                        return (fadeOutStartTime, longFadeDuration);
+
+                    case SliderTick _:
+                        double tickFadeOutDuration = Math.Min(hitObject.TimePreempt - DrawableSliderTick.ANIM_DURATION, 1000);
+                        return (hitObject.StartTime - tickFadeOutDuration, tickFadeOutDuration);
+
+                    case Spinner _:
+                        return (fadeOutStartTime + longFadeDuration, fadeOutDuration);
+
+                    default:
+                        return (fadeOutStartTime, fadeOutDuration);
+                }
+            }
+        }
+
+        private static void hideSpinnerApproachCircle(DrawableSpinner spinner)
+        {
+            var approachCircle = (spinner.Body.Drawable as IHasApproachCircle)?.ApproachCircle;
+            if (approachCircle == null)
+                return;
+
+            using (spinner.BeginAbsoluteSequence(spinner.HitObject.StartTime - spinner.HitObject.TimePreempt))
+                approachCircle.Hide();
+        }
     }
 }

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

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Bindables;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Utils;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModMirror : ModMirror, IApplicableToHitObject
+    {
+        public override string Description => "Flip objects on the chosen axes.";
+        public override Type[] IncompatibleMods => new[] { typeof(ModHardRock) };
+
+        [SettingSource("Mirrored axes", "Choose which axes objects are mirrored over.")]
+        public Bindable<MirrorType> Reflection { get; } = new Bindable<MirrorType>();
+
+        public void ApplyToHitObject(HitObject hitObject)
+        {
+            var osuObject = (OsuHitObject)hitObject;
+
+            switch (Reflection.Value)
+            {
+                case MirrorType.Horizontal:
+                    OsuHitObjectGenerationUtils.ReflectHorizontally(osuObject);
+                    break;
+
+                case MirrorType.Vertical:
+                    OsuHitObjectGenerationUtils.ReflectVertically(osuObject);
+                    break;
+
+                case MirrorType.Both:
+                    OsuHitObjectGenerationUtils.ReflectHorizontally(osuObject);
+                    OsuHitObjectGenerationUtils.ReflectVertically(osuObject);
+                    break;
+            }
+        }
+
+        public enum MirrorType
+        {
+            Horizontal,
+            Vertical,
+            Both
+        }
+    }
+}

osu.Game.Rulesets.Osu/Mods/OsuModMuted.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.
+
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModMuted : ModMuted<OsuHitObject>
+    {
+    }
+}

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

@@ -2,10 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModNightcore : ModNightcore
+    public class OsuModNightcore : ModNightcore<OsuHitObject>
     {
         public override double ScoreMultiplier => 1.12;
     }

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

@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.UI;
+using osu.Game.Utils;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModNoScope : ModNoScope, IUpdatableByPlayfield, IApplicableToBeatmap
+    {
+        public override string Description => "Where's the cursor?";
+
+        private PeriodTracker spinnerPeriods;
+
+        [SettingSource(
+            "Hidden at combo",
+            "The combo count at which the cursor becomes completely hidden",
+            SettingControlType = typeof(SettingsSlider<int, HiddenComboSlider>)
+        )]
+        public override BindableInt HiddenComboCount { get; } = new BindableInt
+        {
+            Default = 10,
+            Value = 10,
+            MinValue = 0,
+            MaxValue = 50,
+        };
+
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            spinnerPeriods = new PeriodTracker(beatmap.HitObjects.OfType<Spinner>().Select(b => new Period(b.StartTime - TRANSITION_DURATION, b.EndTime)));
+        }
+
+        public void Update(Playfield playfield)
+        {
+            bool shouldAlwaysShowCursor = IsBreakTime.Value || spinnerPeriods.IsInAny(playfield.Clock.CurrentTime);
+            float targetAlpha = shouldAlwaysShowCursor ? 1 : ComboBasedAlpha;
+            playfield.Cursor.Alpha = (float)Interpolation.Lerp(playfield.Cursor.Alpha, targetAlpha, Math.Clamp(playfield.Time.Elapsed / TRANSITION_DURATION, 0, 1));
+        }
+    }
+}

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

@@ -2,11 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -17,43 +14,29 @@ namespace osu.Game.Rulesets.Osu.Mods
     /// <summary>
     /// Adjusts the size of hit objects during their fade in animation.
     /// </summary>
-    public abstract class OsuModeObjectScaleTween : Mod, IReadFromConfig, IApplicableToDrawableHitObjects
+    public abstract class OsuModObjectScaleTween : ModWithVisibilityAdjustment, IHidesApproachCircles
     {
         public override ModType Type => ModType.Fun;
 
         public override double ScoreMultiplier => 1;
 
-        protected virtual float StartScale => 1;
+        public abstract BindableNumber<float> StartScale { get; }
 
         protected virtual float EndScale => 1;
 
-        private Bindable<bool> increaseFirstObjectVisibility = new Bindable<bool>();
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn) };
 
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModSpinIn) };
-
-        public void ReadFromConfig(OsuConfigManager config)
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            increaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
         }
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
-        {
-            foreach (var drawable in drawables.Skip(increaseFirstObjectVisibility.Value ? 1 : 0))
-            {
-                switch (drawable)
-                {
-                    case DrawableSpinner _:
-                        continue;
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyCustomState(hitObject, state);
 
-                    default:
-                        drawable.ApplyCustomUpdateState += ApplyCustomState;
-                        break;
-                }
-            }
-        }
-
-        protected virtual void ApplyCustomState(DrawableHitObject drawable, ArmedState state)
+        private void applyCustomState(DrawableHitObject drawable, ArmedState state)
         {
+            if (drawable is DrawableSpinner)
+                return;
+
             var h = (OsuHitObject)drawable.HitObject;
 
             // apply grow effect
@@ -68,7 +51,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 case DrawableHitCircle _:
                 {
                     using (drawable.BeginAbsoluteSequence(h.StartTime - h.TimePreempt))
-                        drawable.ScaleTo(StartScale).Then().ScaleTo(EndScale, h.TimePreempt, Easing.OutSine);
+                        drawable.ScaleTo(StartScale.Value).Then().ScaleTo(EndScale, h.TimePreempt, Easing.OutSine);
                     break;
                 }
             }

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

@@ -0,0 +1,306 @@
+// 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 osu.Framework.Graphics.Primitives;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Osu.Utils;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    /// <summary>
+    /// Mod that randomises the positions of the <see cref="HitObject"/>s
+    /// </summary>
+    public class OsuModRandom : ModRandom, IApplicableToBeatmap
+    {
+        public override string Description => "It never gets boring!";
+
+        private static readonly float playfield_diagonal = OsuPlayfield.BASE_SIZE.LengthFast;
+
+        /// <summary>
+        /// Number of previous hitobjects to be shifted together when another object is being moved.
+        /// </summary>
+        private const int preceding_hitobjects_to_shift = 10;
+
+        private Random rng;
+
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            if (!(beatmap is OsuBeatmap osuBeatmap))
+                return;
+
+            var hitObjects = osuBeatmap.HitObjects;
+
+            Seed.Value ??= RNG.Next();
+
+            rng = new Random((int)Seed.Value);
+
+            RandomObjectInfo previous = null;
+
+            float rateOfChangeMultiplier = 0;
+
+            for (int i = 0; i < hitObjects.Count; i++)
+            {
+                var hitObject = hitObjects[i];
+
+                var current = new RandomObjectInfo(hitObject);
+
+                // rateOfChangeMultiplier only changes every 5 iterations in a combo
+                // to prevent shaky-line-shaped streams
+                if (hitObject.IndexInCurrentCombo % 5 == 0)
+                    rateOfChangeMultiplier = (float)rng.NextDouble() * 2 - 1;
+
+                if (hitObject is Spinner)
+                {
+                    previous = null;
+                    continue;
+                }
+
+                applyRandomisation(rateOfChangeMultiplier, previous, current);
+
+                // Move hit objects back into the playfield if they are outside of it
+                Vector2 shift = Vector2.Zero;
+
+                switch (hitObject)
+                {
+                    case HitCircle circle:
+                        shift = clampHitCircleToPlayfield(circle, current);
+                        break;
+
+                    case Slider slider:
+                        shift = clampSliderToPlayfield(slider, current);
+                        break;
+                }
+
+                if (shift != Vector2.Zero)
+                {
+                    var toBeShifted = new List<OsuHitObject>();
+
+                    for (int j = i - 1; j >= i - preceding_hitobjects_to_shift && j >= 0; j--)
+                    {
+                        // only shift hit circles
+                        if (!(hitObjects[j] is HitCircle)) break;
+
+                        toBeShifted.Add(hitObjects[j]);
+                    }
+
+                    if (toBeShifted.Count > 0)
+                        applyDecreasingShift(toBeShifted, shift);
+                }
+
+                previous = current;
+            }
+        }
+
+        /// <summary>
+        /// Returns the final position of the hit object
+        /// </summary>
+        /// <returns>Final position of the hit object</returns>
+        private void applyRandomisation(float rateOfChangeMultiplier, RandomObjectInfo previous, RandomObjectInfo current)
+        {
+            if (previous == null)
+            {
+                var playfieldSize = OsuPlayfield.BASE_SIZE;
+
+                current.AngleRad = (float)(rng.NextDouble() * 2 * Math.PI - Math.PI);
+                current.PositionRandomised = new Vector2((float)rng.NextDouble() * playfieldSize.X, (float)rng.NextDouble() * playfieldSize.Y);
+
+                return;
+            }
+
+            float distanceToPrev = Vector2.Distance(previous.EndPositionOriginal, current.PositionOriginal);
+
+            // The max. angle (relative to the angle of the vector pointing from the 2nd last to the last hit object)
+            // is proportional to the distance between the last and the current hit object
+            // to allow jumps and prevent too sharp turns during streams.
+
+            // Allow maximum jump angle when jump distance is more than half of playfield diagonal length
+            double randomAngleRad = rateOfChangeMultiplier * 2 * Math.PI * Math.Min(1f, distanceToPrev / (playfield_diagonal * 0.5f));
+
+            current.AngleRad = (float)randomAngleRad + previous.AngleRad;
+            if (current.AngleRad < 0)
+                current.AngleRad += 2 * (float)Math.PI;
+
+            var posRelativeToPrev = new Vector2(
+                distanceToPrev * (float)Math.Cos(current.AngleRad),
+                distanceToPrev * (float)Math.Sin(current.AngleRad)
+            );
+
+            posRelativeToPrev = OsuHitObjectGenerationUtils.RotateAwayFromEdge(previous.EndPositionRandomised, posRelativeToPrev);
+
+            current.AngleRad = (float)Math.Atan2(posRelativeToPrev.Y, posRelativeToPrev.X);
+
+            current.PositionRandomised = previous.EndPositionRandomised + posRelativeToPrev;
+        }
+
+        /// <summary>
+        /// Move the randomised position of a hit circle so that it fits inside the playfield.
+        /// </summary>
+        /// <returns>The deviation from the original randomised position in order to fit within the playfield.</returns>
+        private Vector2 clampHitCircleToPlayfield(HitCircle circle, RandomObjectInfo objectInfo)
+        {
+            var previousPosition = objectInfo.PositionRandomised;
+            objectInfo.EndPositionRandomised = objectInfo.PositionRandomised = clampToPlayfieldWithPadding(
+                objectInfo.PositionRandomised,
+                (float)circle.Radius
+            );
+
+            circle.Position = objectInfo.PositionRandomised;
+
+            return objectInfo.PositionRandomised - previousPosition;
+        }
+
+        /// <summary>
+        /// Moves the <see cref="Slider"/> and all necessary nested <see cref="OsuHitObject"/>s into the <see cref="OsuPlayfield"/> if they aren't already.
+        /// </summary>
+        /// <returns>The deviation from the original randomised position in order to fit within the playfield.</returns>
+        private Vector2 clampSliderToPlayfield(Slider slider, RandomObjectInfo objectInfo)
+        {
+            var possibleMovementBounds = calculatePossibleMovementBounds(slider);
+
+            var previousPosition = objectInfo.PositionRandomised;
+
+            // Clamp slider position to the placement area
+            // If the slider is larger than the playfield, force it to stay at the original position
+            float newX = possibleMovementBounds.Width < 0
+                ? objectInfo.PositionOriginal.X
+                : Math.Clamp(previousPosition.X, possibleMovementBounds.Left, possibleMovementBounds.Right);
+
+            float newY = possibleMovementBounds.Height < 0
+                ? objectInfo.PositionOriginal.Y
+                : Math.Clamp(previousPosition.Y, possibleMovementBounds.Top, possibleMovementBounds.Bottom);
+
+            slider.Position = objectInfo.PositionRandomised = new Vector2(newX, newY);
+            objectInfo.EndPositionRandomised = slider.EndPosition;
+
+            shiftNestedObjects(slider, objectInfo.PositionRandomised - objectInfo.PositionOriginal);
+
+            return objectInfo.PositionRandomised - previousPosition;
+        }
+
+        /// <summary>
+        /// Decreasingly shift a list of <see cref="OsuHitObject"/>s by a specified amount.
+        /// The first item in the list is shifted by the largest amount, while the last item is shifted by the smallest amount.
+        /// </summary>
+        /// <param name="hitObjects">The list of hit objects to be shifted.</param>
+        /// <param name="shift">The amount to be shifted.</param>
+        private void applyDecreasingShift(IList<OsuHitObject> hitObjects, Vector2 shift)
+        {
+            for (int i = 0; i < hitObjects.Count; i++)
+            {
+                var hitObject = hitObjects[i];
+                // The first object is shifted by a vector slightly smaller than shift
+                // The last object is shifted by a vector slightly larger than zero
+                Vector2 position = hitObject.Position + shift * ((hitObjects.Count - i) / (float)(hitObjects.Count + 1));
+
+                hitObject.Position = clampToPlayfieldWithPadding(position, (float)hitObject.Radius);
+            }
+        }
+
+        /// <summary>
+        /// Calculates a <see cref="RectangleF"/> which contains all of the possible movements of the slider (in relative X/Y coordinates)
+        /// such that the entire slider is inside the playfield.
+        /// </summary>
+        /// <remarks>
+        /// If the slider is larger than the playfield, the returned <see cref="RectangleF"/> may have negative width/height.
+        /// </remarks>
+        private RectangleF calculatePossibleMovementBounds(Slider slider)
+        {
+            var pathPositions = new List<Vector2>();
+            slider.Path.GetPathToProgress(pathPositions, 0, 1);
+
+            float minX = float.PositiveInfinity;
+            float maxX = float.NegativeInfinity;
+
+            float minY = float.PositiveInfinity;
+            float maxY = float.NegativeInfinity;
+
+            // Compute the bounding box of the slider.
+            foreach (var pos in pathPositions)
+            {
+                minX = MathF.Min(minX, pos.X);
+                maxX = MathF.Max(maxX, pos.X);
+
+                minY = MathF.Min(minY, pos.Y);
+                maxY = MathF.Max(maxY, pos.Y);
+            }
+
+            // Take the circle radius into account.
+            float radius = (float)slider.Radius;
+
+            minX -= radius;
+            minY -= radius;
+
+            maxX += radius;
+            maxY += radius;
+
+            // Given the bounding box of the slider (via min/max X/Y),
+            // the amount that the slider can move to the left is minX (with the sign flipped, since positive X is to the right),
+            // and the amount that it can move to the right is WIDTH - maxX.
+            // Same calculation applies for the Y axis.
+            float left = -minX;
+            float right = OsuPlayfield.BASE_SIZE.X - maxX;
+            float top = -minY;
+            float bottom = OsuPlayfield.BASE_SIZE.Y - maxY;
+
+            return new RectangleF(left, top, right - left, bottom - top);
+        }
+
+        /// <summary>
+        /// Shifts all nested <see cref="SliderTick"/>s and <see cref="SliderRepeat"/>s by the specified shift.
+        /// </summary>
+        /// <param name="slider"><see cref="Slider"/> whose nested <see cref="SliderTick"/>s and <see cref="SliderRepeat"/>s should be shifted</param>
+        /// <param name="shift">The <see cref="Vector2"/> the <see cref="Slider"/>'s nested <see cref="SliderTick"/>s and <see cref="SliderRepeat"/>s should be shifted by</param>
+        private void shiftNestedObjects(Slider slider, Vector2 shift)
+        {
+            foreach (var hitObject in slider.NestedHitObjects.Where(o => o is SliderTick || o is SliderRepeat))
+            {
+                if (!(hitObject is OsuHitObject osuHitObject))
+                    continue;
+
+                osuHitObject.Position += shift;
+            }
+        }
+
+        /// <summary>
+        /// Clamp a position to playfield, keeping a specified distance from the edges.
+        /// </summary>
+        /// <param name="position">The position to be clamped.</param>
+        /// <param name="padding">The minimum distance allowed from playfield edges.</param>
+        /// <returns>The clamped position.</returns>
+        private Vector2 clampToPlayfieldWithPadding(Vector2 position, float padding)
+        {
+            return new Vector2(
+                Math.Clamp(position.X, padding, OsuPlayfield.BASE_SIZE.X - padding),
+                Math.Clamp(position.Y, padding, OsuPlayfield.BASE_SIZE.Y - padding)
+            );
+        }
+
+        private class RandomObjectInfo
+        {
+            public float AngleRad { get; set; }
+
+            public Vector2 PositionOriginal { get; }
+            public Vector2 PositionRandomised { get; set; }
+
+            public Vector2 EndPositionOriginal { get; }
+            public Vector2 EndPositionRandomised { get; set; }
+
+            public RandomObjectInfo(OsuHitObject hitObject)
+            {
+                PositionRandomised = PositionOriginal = hitObject.Position;
+                EndPositionRandomised = EndPositionOriginal = hitObject.EndPosition;
+                AngleRad = 0;
+            }
+        }
+    }
+}

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

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

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

@@ -2,12 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -16,52 +12,39 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModSpinIn : Mod, IApplicableToDrawableHitObjects, IReadFromConfig
+    public class OsuModSpinIn : ModWithVisibilityAdjustment, IHidesApproachCircles
     {
         public override string Name => "Spin In";
         public override string Acronym => "SI";
-        public override IconUsage Icon => FontAwesome.Solid.Undo;
+        public override IconUsage? Icon => FontAwesome.Solid.Undo;
         public override ModType Type => ModType.Fun;
         public override string Description => "Circles spin in. No approach circles.";
         public override double ScoreMultiplier => 1;
 
-        // todo: this mod should be able to be compatible with hidden with a bit of further implementation.
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModeObjectScaleTween), typeof(OsuModHidden) };
+        // todo: this mod needs to be incompatible with "hidden" due to forcing the circle to remain opaque,
+        // further implementation will be required for supporting that.
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModObjectScaleTween), typeof(OsuModHidden) };
 
         private const int rotate_offset = 360;
         private const float rotate_starting_width = 2;
 
-        private Bindable<bool> increaseFirstObjectVisibility = new Bindable<bool>();
-
-        public void ReadFromConfig(OsuConfigManager config)
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            increaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
         }
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
-        {
-            foreach (var drawable in drawables.Skip(increaseFirstObjectVisibility.Value ? 1 : 0))
-            {
-                switch (drawable)
-                {
-                    case DrawableSpinner _:
-                        continue;
-
-                    default:
-                        drawable.ApplyCustomUpdateState += applyZoomState;
-                        break;
-                }
-            }
-        }
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyZoomState(hitObject, state);
 
         private void applyZoomState(DrawableHitObject drawable, ArmedState state)
         {
+            if (drawable is DrawableSpinner)
+                return;
+
             var h = (OsuHitObject)drawable.HitObject;
 
             switch (drawable)
             {
                 case DrawableHitCircle circle:
-                    using (circle.BeginAbsoluteSequence(h.StartTime - h.TimePreempt, true))
+                    using (circle.BeginAbsoluteSequence(h.StartTime - h.TimePreempt))
                     {
                         circle.ApproachCircle.Hide();
 

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

@@ -2,21 +2,50 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModSpunOut : Mod
+    public class OsuModSpunOut : Mod, IApplicableToDrawableHitObject
     {
         public override string Name => "Spun Out";
         public override string Acronym => "SO";
-        public override IconUsage Icon => OsuIcon.ModSpunout;
-        public override ModType Type => ModType.DifficultyReduction;
+        public override IconUsage? Icon => OsuIcon.ModSpunOut;
+        public override ModType Type => ModType.Automation;
         public override string Description => @"Spinners will be automatically completed.";
         public override double ScoreMultiplier => 0.9;
-        public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(OsuModAutopilot) };
+
+        public void ApplyToDrawableHitObject(DrawableHitObject hitObject)
+        {
+            if (hitObject is DrawableSpinner spinner)
+            {
+                spinner.HandleUserInput = false;
+                spinner.OnUpdate += onSpinnerUpdate;
+            }
+        }
+
+        private void onSpinnerUpdate(Drawable drawable)
+        {
+            var spinner = (DrawableSpinner)drawable;
+
+            spinner.RotationTracker.Tracking = true;
+
+            // early-return if we were paused to avoid division-by-zero in the subsequent calculations.
+            if (Precision.AlmostEquals(spinner.Clock.Rate, 0))
+                return;
+
+            // because the spinner is under the gameplay clock, it is affected by rate adjustments on the track;
+            // for that reason using ElapsedFrameTime directly leads to fewer SPM with Half Time and more SPM with Double Time.
+            // for spinners we want the real (wall clock) elapsed time; to achieve that, unapply the clock rate locally here.
+            double rateIndependentElapsedTime = spinner.Clock.ElapsedFrameTime / spinner.Clock.Rate;
+            spinner.RotationTracker.AddRotation(MathUtils.RadiansToDegrees((float)rateIndependentElapsedTime * 0.03f));
+        }
     }
 }

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

@@ -1,19 +1,506 @@
 // 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 osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
+using osu.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
+using osu.Game.Overlays.Settings;
 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.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Osu.Utils;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModTarget : Mod
+    public class OsuModTarget : ModWithVisibilityAdjustment, IApplicableToDrawableRuleset<OsuHitObject>,
+                                IApplicableToHealthProcessor, IApplicableToDifficulty, IApplicableFailOverride,
+                                IHasSeed, IHidesApproachCircles
     {
         public override string Name => "Target";
         public override string Acronym => "TP";
         public override ModType Type => ModType.Conversion;
-        public override IconUsage Icon => OsuIcon.ModTarget;
+        public override IconUsage? Icon => OsuIcon.ModTarget;
         public override string Description => @"Practice keeping up with the beat of the song.";
         public override double ScoreMultiplier => 1;
+
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles) };
+
+        [SettingSource("Seed", "Use a custom seed instead of a random one", SettingControlType = typeof(SettingsNumberBox))]
+        public Bindable<int?> Seed { get; } = new Bindable<int?>
+        {
+            Default = null,
+            Value = null
+        };
+
+        #region Constants
+
+        /// <summary>
+        /// Jump distance for circles in the last combo
+        /// </summary>
+        private const float max_base_distance = 333f;
+
+        /// <summary>
+        /// The maximum allowed jump distance after multipliers are applied
+        /// </summary>
+        private const float distance_cap = 380f;
+
+        /// <summary>
+        /// The extent of rotation towards playfield centre when a circle is near the edge
+        /// </summary>
+        private const float edge_rotation_multiplier = 0.75f;
+
+        /// <summary>
+        /// Number of recent circles to check for overlap
+        /// </summary>
+        private const int overlap_check_count = 5;
+
+        /// <summary>
+        /// Duration of the undimming animation
+        /// </summary>
+        private const double undim_duration = 96;
+
+        /// <summary>
+        /// Acceptable difference for timing comparisons
+        /// </summary>
+        private const double timing_precision = 1;
+
+        #endregion
+
+        #region Private Fields
+
+        private ControlPointInfo controlPointInfo;
+
+        private List<OsuHitObject> originalHitObjects;
+
+        private Random rng;
+
+        #endregion
+
+        #region Sudden Death (IApplicableFailOverride)
+
+        public bool PerformFail() => true;
+
+        public bool RestartOnFail => false;
+
+        public void ApplyToHealthProcessor(HealthProcessor healthProcessor)
+        {
+            // Sudden death
+            healthProcessor.FailConditions += (_, result)
+                => result.Type.AffectsCombo()
+                   && !result.IsHit;
+        }
+
+        #endregion
+
+        #region Reduce AR (IApplicableToDifficulty)
+
+        public void ReadFromDifficulty(IBeatmapDifficultyInfo difficulty)
+        {
+        }
+
+        public void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            // Decrease AR to increase preempt time
+            difficulty.ApproachRate *= 0.5f;
+        }
+
+        #endregion
+
+        #region Circle Transforms (ModWithVisibilityAdjustment)
+
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject drawable, ArmedState state)
+        {
+        }
+
+        protected override void ApplyNormalVisibilityState(DrawableHitObject drawable, ArmedState state)
+        {
+            if (!(drawable is DrawableHitCircle circle)) return;
+
+            double startTime = circle.HitObject.StartTime;
+            double preempt = circle.HitObject.TimePreempt;
+
+            using (circle.BeginAbsoluteSequence(startTime - preempt))
+            {
+                // initial state
+                circle.ScaleTo(0.5f)
+                      .FadeColour(OsuColour.Gray(0.5f));
+
+                // scale to final size
+                circle.ScaleTo(1f, preempt);
+
+                // Remove approach circles
+                circle.ApproachCircle.Hide();
+            }
+
+            using (circle.BeginAbsoluteSequence(startTime - controlPointInfo.TimingPointAt(startTime).BeatLength - undim_duration))
+                circle.FadeColour(Color4.White, undim_duration);
+        }
+
+        #endregion
+
+        #region Beatmap Generation (IApplicableToBeatmap)
+
+        public override void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            Seed.Value ??= RNG.Next();
+            rng = new Random(Seed.Value.Value);
+
+            var osuBeatmap = (OsuBeatmap)beatmap;
+
+            if (osuBeatmap.HitObjects.Count == 0) return;
+
+            controlPointInfo = osuBeatmap.ControlPointInfo;
+            originalHitObjects = osuBeatmap.HitObjects.OrderBy(x => x.StartTime).ToList();
+
+            var hitObjects = generateBeats(osuBeatmap)
+                             .Select(beat =>
+                             {
+                                 var newCircle = new HitCircle();
+                                 newCircle.ApplyDefaults(controlPointInfo, osuBeatmap.Difficulty);
+                                 newCircle.StartTime = beat;
+                                 return (OsuHitObject)newCircle;
+                             }).ToList();
+
+            addHitSamples(hitObjects);
+
+            fixComboInfo(hitObjects);
+
+            randomizeCirclePos(hitObjects);
+
+            osuBeatmap.HitObjects = hitObjects;
+
+            base.ApplyToBeatmap(beatmap);
+        }
+
+        private IEnumerable<double> generateBeats(IBeatmap beatmap)
+        {
+            double startTime = originalHitObjects.First().StartTime;
+            double endTime = originalHitObjects.Last().GetEndTime();
+
+            var beats = beatmap.ControlPointInfo.TimingPoints
+                               // Ignore timing points after endTime
+                               .Where(timingPoint => !definitelyBigger(timingPoint.Time, endTime))
+                               // Generate the beats
+                               .SelectMany(timingPoint => getBeatsForTimingPoint(timingPoint, endTime))
+                               // Remove beats before startTime
+                               .Where(beat => almostBigger(beat, startTime))
+                               // Remove beats during breaks
+                               .Where(beat => !isInsideBreakPeriod(beatmap.Breaks, beat))
+                               .ToList();
+
+            // Remove beats that are too close to the next one (e.g. due to timing point changes)
+            for (int i = beats.Count - 2; i >= 0; i--)
+            {
+                double beat = beats[i];
+
+                if (!definitelyBigger(beats[i + 1] - beat, beatmap.ControlPointInfo.TimingPointAt(beat).BeatLength / 2))
+                    beats.RemoveAt(i);
+            }
+
+            return beats;
+        }
+
+        private void addHitSamples(IEnumerable<OsuHitObject> hitObjects)
+        {
+            foreach (var obj in hitObjects)
+            {
+                var samples = getSamplesAtTime(originalHitObjects, obj.StartTime);
+
+                // If samples aren't available at the exact start time of the object,
+                // use samples (without additions) in the closest original hit object instead
+                obj.Samples = samples ?? getClosestHitObject(originalHitObjects, obj.StartTime).Samples.Where(s => !HitSampleInfo.AllAdditions.Contains(s.Name)).ToList();
+            }
+        }
+
+        private void fixComboInfo(List<OsuHitObject> hitObjects)
+        {
+            // Copy combo indices from an original object at the same time or from the closest preceding object
+            // (Objects lying between two combos are assumed to belong to the preceding combo)
+            hitObjects.ForEach(newObj =>
+            {
+                var closestOrigObj = originalHitObjects.FindLast(y => almostBigger(newObj.StartTime, y.StartTime));
+
+                // It shouldn't be possible for closestOrigObj to be null
+                // But if it is, obj should be in the first combo
+                newObj.ComboIndex = closestOrigObj?.ComboIndex ?? 0;
+            });
+
+            // The copied combo indices may not be continuous if the original map starts and ends a combo in between beats
+            // e.g. A stream with each object starting a new combo
+            // So combo indices need to be reprocessed to ensure continuity
+            // Other kinds of combo info are also added in the process
+            var combos = hitObjects.GroupBy(x => x.ComboIndex).ToList();
+
+            for (int i = 0; i < combos.Count; i++)
+            {
+                var group = combos[i].ToList();
+                group.First().NewCombo = true;
+                group.Last().LastInCombo = true;
+
+                for (int j = 0; j < group.Count; j++)
+                {
+                    var x = group[j];
+                    x.ComboIndex = i;
+                    x.IndexInCurrentCombo = j;
+                }
+            }
+        }
+
+        private void randomizeCirclePos(IReadOnlyList<OsuHitObject> hitObjects)
+        {
+            if (hitObjects.Count == 0) return;
+
+            float nextSingle(float max = 1f) => (float)(rng.NextDouble() * max);
+
+            const float two_pi = MathF.PI * 2;
+
+            float direction = two_pi * nextSingle();
+            int maxComboIndex = hitObjects.Last().ComboIndex;
+
+            for (int i = 0; i < hitObjects.Count; i++)
+            {
+                var obj = hitObjects[i];
+                var lastPos = i == 0
+                    ? Vector2.Divide(OsuPlayfield.BASE_SIZE, 2)
+                    : hitObjects[i - 1].Position;
+
+                float distance = maxComboIndex == 0
+                    ? (float)obj.Radius
+                    : mapRange(obj.ComboIndex, 0, maxComboIndex, (float)obj.Radius, max_base_distance);
+                if (obj.NewCombo) distance *= 1.5f;
+                if (obj.Kiai) distance *= 1.2f;
+                distance = Math.Min(distance_cap, distance);
+
+                // Attempt to place the circle at a place that does not overlap with previous ones
+
+                int tryCount = 0;
+
+                // for checking overlap
+                var precedingObjects = hitObjects.SkipLast(hitObjects.Count - i).TakeLast(overlap_check_count).ToList();
+
+                do
+                {
+                    if (tryCount > 0) direction = two_pi * nextSingle();
+
+                    var relativePos = new Vector2(
+                        distance * MathF.Cos(direction),
+                        distance * MathF.Sin(direction)
+                    );
+                    // Rotate the new circle away from playfield border
+                    relativePos = OsuHitObjectGenerationUtils.RotateAwayFromEdge(lastPos, relativePos, edge_rotation_multiplier);
+                    direction = MathF.Atan2(relativePos.Y, relativePos.X);
+
+                    var newPosition = Vector2.Add(lastPos, relativePos);
+
+                    obj.Position = newPosition;
+
+                    clampToPlayfield(obj);
+
+                    tryCount++;
+                    if (tryCount % 10 == 0) distance *= 0.9f;
+                } while (distance >= obj.Radius * 2 && checkForOverlap(precedingObjects, obj));
+
+                if (obj.LastInCombo)
+                    direction = two_pi * nextSingle();
+                else
+                    direction += distance / distance_cap * (nextSingle() * two_pi - MathF.PI);
+            }
+        }
+
+        #endregion
+
+        #region Metronome (IApplicableToDrawableRuleset)
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            drawableRuleset.Overlays.Add(new Metronome(drawableRuleset.Beatmap.HitObjects.First().StartTime));
+        }
+
+        #endregion
+
+        #region Helper Subroutines
+
+        /// <summary>
+        /// Check if a given time is inside a <see cref="BreakPeriod"/>.
+        /// </summary>
+        /// <remarks>
+        /// The given time is also considered to be inside a break if it is earlier than the
+        /// start time of the first original hit object after the break.
+        /// </remarks>
+        /// <param name="breaks">The breaks of the beatmap.</param>
+        /// <param name="time">The time to be checked.</param>=
+        private bool isInsideBreakPeriod(IEnumerable<BreakPeriod> breaks, double time)
+        {
+            return breaks.Any(breakPeriod =>
+            {
+                var firstObjAfterBreak = originalHitObjects.First(obj => almostBigger(obj.StartTime, breakPeriod.EndTime));
+
+                return almostBigger(time, breakPeriod.StartTime)
+                       && definitelyBigger(firstObjAfterBreak.StartTime, time);
+            });
+        }
+
+        private IEnumerable<double> getBeatsForTimingPoint(TimingControlPoint timingPoint, double mapEndTime)
+        {
+            var beats = new List<double>();
+            int i = 0;
+            double currentTime = timingPoint.Time;
+
+            while (!definitelyBigger(currentTime, mapEndTime) && controlPointInfo.TimingPointAt(currentTime) == timingPoint)
+            {
+                beats.Add(Math.Floor(currentTime));
+                i++;
+                currentTime = timingPoint.Time + i * timingPoint.BeatLength;
+            }
+
+            return beats;
+        }
+
+        private OsuHitObject getClosestHitObject(List<OsuHitObject> hitObjects, double time)
+        {
+            int precedingIndex = hitObjects.FindLastIndex(h => h.StartTime < time);
+
+            if (precedingIndex == hitObjects.Count - 1) return hitObjects[precedingIndex];
+
+            // return the closest preceding/succeeding hit object, whoever is closer in time
+            return hitObjects[precedingIndex + 1].StartTime - time < time - hitObjects[precedingIndex].StartTime
+                ? hitObjects[precedingIndex + 1]
+                : hitObjects[precedingIndex];
+        }
+
+        /// <summary>
+        /// Get samples (if any) for a specific point in time.
+        /// </summary>
+        /// <remarks>
+        /// Samples will be returned if a hit circle or a slider node exists at that point of time.
+        /// </remarks>
+        /// <param name="hitObjects">The list of hit objects in a beatmap, ordered by StartTime</param>
+        /// <param name="time">The point in time to get samples for</param>
+        /// <returns>Hit samples</returns>
+        private IList<HitSampleInfo> getSamplesAtTime(IEnumerable<OsuHitObject> hitObjects, double time)
+        {
+            // Get a hit object that
+            //   either has StartTime equal to the target time
+            //   or has a repeat node at the target time
+            var sampleObj = hitObjects.FirstOrDefault(hitObject =>
+            {
+                if (almostEquals(time, hitObject.StartTime))
+                    return true;
+
+                if (!(hitObject is IHasRepeats s))
+                    return false;
+                // If time is outside the duration of the IHasRepeats,
+                // then this hitObject isn't the one we want
+                if (!almostBigger(time, hitObject.StartTime)
+                    || !almostBigger(s.EndTime, time))
+                    return false;
+
+                return nodeIndexFromTime(s, time - hitObject.StartTime) != -1;
+            });
+            if (sampleObj == null) return null;
+
+            IList<HitSampleInfo> samples;
+
+            if (sampleObj is IHasRepeats slider)
+                samples = slider.NodeSamples[nodeIndexFromTime(slider, time - sampleObj.StartTime)];
+            else
+                samples = sampleObj.Samples;
+
+            return samples;
+        }
+
+        /// <summary>
+        /// Get the repeat node at a point in time.
+        /// </summary>
+        /// <param name="curve">The slider.</param>
+        /// <param name="timeSinceStart">The time since the start time of the slider.</param>
+        /// <returns>Index of the node. -1 if there isn't a node at the specific time.</returns>
+        private int nodeIndexFromTime(IHasRepeats curve, double timeSinceStart)
+        {
+            double spanDuration = curve.Duration / curve.SpanCount();
+            double nodeIndex = timeSinceStart / spanDuration;
+
+            if (almostEquals(nodeIndex, Math.Round(nodeIndex)))
+                return (int)Math.Round(nodeIndex);
+
+            return -1;
+        }
+
+        private bool checkForOverlap(IEnumerable<OsuHitObject> objectsToCheck, OsuHitObject target)
+        {
+            return objectsToCheck.Any(h => Vector2.Distance(h.Position, target.Position) < target.Radius * 2);
+        }
+
+        /// <summary>
+        /// Move the hit object into playfield, taking its radius into account.
+        /// </summary>
+        /// <param name="obj">The hit object to be clamped.</param>
+        private void clampToPlayfield(OsuHitObject obj)
+        {
+            var position = obj.Position;
+            float radius = (float)obj.Radius;
+
+            if (position.Y < radius)
+                position.Y = radius;
+            else if (position.Y > OsuPlayfield.BASE_SIZE.Y - radius)
+                position.Y = OsuPlayfield.BASE_SIZE.Y - radius;
+
+            if (position.X < radius)
+                position.X = radius;
+            else if (position.X > OsuPlayfield.BASE_SIZE.X - radius)
+                position.X = OsuPlayfield.BASE_SIZE.X - radius;
+
+            obj.Position = position;
+        }
+
+        /// <summary>
+        /// Re-maps a number from one range to another.
+        /// </summary>
+        /// <param name="value">The number to be re-mapped.</param>
+        /// <param name="fromLow">Beginning of the original range.</param>
+        /// <param name="fromHigh">End of the original range.</param>
+        /// <param name="toLow">Beginning of the new range.</param>
+        /// <param name="toHigh">End of the new range.</param>
+        /// <returns>The re-mapped number.</returns>
+        private static float mapRange(float value, float fromLow, float fromHigh, float toLow, float toHigh)
+        {
+            return (value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow;
+        }
+
+        private static bool almostBigger(double value1, double value2)
+        {
+            return Precision.AlmostBigger(value1, value2, timing_precision);
+        }
+
+        private static bool definitelyBigger(double value1, double value2)
+        {
+            return Precision.DefinitelyBigger(value1, value2, timing_precision);
+        }
+
+        private static bool almostEquals(double value1, double value2)
+        {
+            return Precision.AlmostEquals(value1, value2, timing_precision);
+        }
+
+        #endregion
     }
 }

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

@@ -9,10 +9,9 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override string Name => "Touch Device";
         public override string Acronym => "TD";
+        public override string Description => "Automatically applied to plays on devices with a touchscreen.";
         public override double ScoreMultiplier => 1;
 
         public override ModType Type => ModType.System;
-
-        public override bool Ranked => true;
     }
 }

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

@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Skinning.Default;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModTraceable : ModWithVisibilityAdjustment, IRequiresApproachCircles
+    {
+        public override string Name => "Traceable";
+        public override string Acronym => "TC";
+        public override ModType Type => ModType.Fun;
+        public override string Description => "Put your faith in the approach circles...";
+        public override double ScoreMultiplier => 1;
+
+        public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles) };
+
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
+        {
+        }
+
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTraceableState(hitObject, state);
+
+        private void applyTraceableState(DrawableHitObject drawable, ArmedState state)
+        {
+            if (!(drawable is DrawableOsuHitObject))
+                return;
+
+            //todo: expose and hide spinner background somehow
+
+            switch (drawable)
+            {
+                case DrawableHitCircle circle:
+                    // we only want to see the approach circle
+                    applyCirclePieceState(circle, circle.CirclePiece);
+                    break;
+
+                case DrawableSliderTail sliderTail:
+                    applyCirclePieceState(sliderTail);
+                    break;
+
+                case DrawableSliderRepeat sliderRepeat:
+                    // show only the repeat arrow
+                    applyCirclePieceState(sliderRepeat, sliderRepeat.CirclePiece);
+                    break;
+
+                case DrawableSlider slider:
+                    slider.Body.OnSkinChanged += () => applySliderState(slider);
+                    applySliderState(slider);
+                    break;
+            }
+        }
+
+        private void applyCirclePieceState(DrawableOsuHitObject hitObject, IDrawable hitCircle = null)
+        {
+            var h = hitObject.HitObject;
+            using (hitObject.BeginAbsoluteSequence(h.StartTime - h.TimePreempt))
+                (hitCircle ?? hitObject).Hide();
+        }
+
+        private void applySliderState(DrawableSlider slider)
+        {
+            ((PlaySliderBody)slider.Body.Drawable).AccentColour = slider.AccentColour.Value.Opacity(0);
+            ((PlaySliderBody)slider.Body.Drawable).BorderColour = slider.AccentColour.Value;
+        }
+    }
+}

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

@@ -2,21 +2,21 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModTransform : Mod, IApplicableToDrawableHitObjects
+    internal class OsuModTransform : ModWithVisibilityAdjustment
     {
         public override string Name => "Transform";
         public override string Acronym => "TR";
-        public override IconUsage Icon => FontAwesome.Solid.ArrowsAlt;
+        public override IconUsage? Icon => FontAwesome.Solid.ArrowsAlt;
         public override ModType Type => ModType.Fun;
         public override string Description => "Everything rotates. EVERYTHING.";
         public override double ScoreMultiplier => 1;
@@ -24,29 +24,41 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         private float theta;
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
+
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
+
+        private void applyTransform(DrawableHitObject drawable, ArmedState state)
         {
-            foreach (var drawable in drawables)
+            switch (drawable)
             {
-                var hitObject = (OsuHitObject)drawable.HitObject;
+                case DrawableSliderHead _:
+                case DrawableSliderTail _:
+                case DrawableSliderTick _:
+                case DrawableSliderRepeat _:
+                    return;
 
-                float appearDistance = (float)(hitObject.TimePreempt - hitObject.TimeFadeIn) / 2;
+                default:
+                    var hitObject = (OsuHitObject)drawable.HitObject;
 
-                Vector2 originalPosition = drawable.Position;
-                Vector2 appearOffset = new Vector2((float)Math.Cos(theta), (float)Math.Sin(theta)) * appearDistance;
+                    float appearDistance = (float)(hitObject.TimePreempt - hitObject.TimeFadeIn) / 2;
 
-                //the - 1 and + 1 prevents the hit objects to appear in the wrong position.
-                double appearTime = hitObject.StartTime - hitObject.TimePreempt - 1;
-                double moveDuration = hitObject.TimePreempt + 1;
+                    Vector2 originalPosition = drawable.Position;
+                    Vector2 appearOffset = new Vector2(MathF.Cos(theta), MathF.Sin(theta)) * appearDistance;
 
-                using (drawable.BeginAbsoluteSequence(appearTime, true))
-                {
-                    drawable
-                        .MoveToOffset(appearOffset)
-                        .MoveTo(originalPosition, moveDuration, Easing.InOutSine);
-                }
+                    // the - 1 and + 1 prevents the hit objects to appear in the wrong position.
+                    double appearTime = hitObject.StartTime - hitObject.TimePreempt - 1;
+                    double moveDuration = hitObject.TimePreempt + 1;
 
-                theta += (float)hitObject.TimeFadeIn / 1000;
+                    using (drawable.BeginAbsoluteSequence(appearTime))
+                    {
+                        drawable
+                            .MoveToOffset(appearOffset)
+                            .MoveTo(originalPosition, moveDuration, Easing.InOutSine);
+                    }
+
+                    theta += (float)hitObject.TimeFadeIn / 1000;
+                    break;
             }
         }
     }

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

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
@@ -13,11 +12,11 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModWiggle : Mod, IApplicableToDrawableHitObjects
+    internal class OsuModWiggle : ModWithVisibilityAdjustment
     {
         public override string Name => "Wiggle";
         public override string Acronym => "WG";
-        public override IconUsage Icon => FontAwesome.Solid.Certificate;
+        public override IconUsage? Icon => FontAwesome.Solid.Certificate;
         public override ModType Type => ModType.Fun;
         public override string Description => "They just won't stay still...";
         public override double ScoreMultiplier => 1;
@@ -26,20 +25,18 @@ namespace osu.Game.Rulesets.Osu.Mods
         private const int wiggle_duration = 90; // (ms) Higher = fewer wiggles
         private const int wiggle_strength = 10; // Higher = stronger wiggles
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
-        {
-            foreach (var drawable in drawables)
-                drawable.ApplyCustomUpdateState += drawableOnApplyCustomUpdateState;
-        }
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) => drawableOnApplyCustomUpdateState(hitObject, state);
+
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => drawableOnApplyCustomUpdateState(hitObject, state);
 
         private void drawableOnApplyCustomUpdateState(DrawableHitObject drawable, ArmedState state)
         {
             var osuObject = (OsuHitObject)drawable.HitObject;
             Vector2 origin = drawable.Position;
 
-            // Wiggle the repeat points with the slider instead of independently.
+            // Wiggle the repeat points and the tail with the slider instead of independently.
             // Also fixes an issue with repeat points being positioned incorrectly.
-            if (osuObject is RepeatPoint)
+            if (osuObject is SliderRepeat || osuObject is SliderTailCircle)
                 return;
 
             Random objRand = new Random((int)osuObject.StartTime);
@@ -55,18 +52,22 @@ namespace osu.Game.Rulesets.Osu.Mods
             }
 
             for (int i = 0; i < amountWiggles; i++)
-                using (drawable.BeginAbsoluteSequence(osuObject.StartTime - osuObject.TimePreempt + i * wiggle_duration, true))
+            {
+                using (drawable.BeginAbsoluteSequence(osuObject.StartTime - osuObject.TimePreempt + i * wiggle_duration))
                     wiggle();
+            }
 
             // Keep wiggling sliders and spinners for their duration
-            if (!(osuObject is IHasEndTime endTime))
+            if (!(osuObject is IHasDuration endTime))
                 return;
 
             amountWiggles = (int)(endTime.Duration / wiggle_duration);
 
             for (int i = 0; i < amountWiggles; i++)
-                using (drawable.BeginAbsoluteSequence(osuObject.StartTime + i * wiggle_duration, true))
+            {
+                using (drawable.BeginAbsoluteSequence(osuObject.StartTime + i * wiggle_duration))
                     wiggle();
+            }
         }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/ConnectionRenderer.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.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Objects;
-using System.Collections.Generic;
-
-namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
-{
-    /// <summary>
-    /// Connects hit objects visually, for example with follow points.
-    /// </summary>
-    public abstract class ConnectionRenderer<T> : LifetimeManagementContainer
-        where T : HitObject
-    {
-        /// <summary>
-        /// Hit objects to create connections for
-        /// </summary>
-        public abstract IEnumerable<T> HitObjects { get; set; }
-    }
-}

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

@@ -1,18 +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 osu.Framework.Bindables;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 {
-    public class FollowPoint : Container
+    /// <summary>
+    /// A single follow point positioned between two adjacent <see cref="DrawableOsuHitObject"/>s.
+    /// </summary>
+    public class FollowPoint : PoolableDrawable, IAnimationTimeReference
     {
         private const float width = 8;
 
@@ -22,11 +27,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
         {
             Origin = Anchor.Centre;
 
-            Child = new SkinnableDrawable("Play/osu/followpoint", _ => new Container
+            InternalChild = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.FollowPoint), _ => new CircularContainer
             {
                 Masking = true,
                 AutoSizeAxes = Axes.Both,
-                CornerRadius = width / 2,
                 EdgeEffect = new EdgeEffectParameters
                 {
                     Type = EdgeEffectType.Glow,
@@ -36,12 +40,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                 Child = new Box
                 {
                     Size = new Vector2(width),
-                    Blending = BlendingMode.Additive,
+                    Blending = BlendingParameters.Additive,
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
                     Alpha = 0.5f,
                 }
-            }, confineMode: ConfineMode.NoScaling);
+            });
         }
+
+        public Bindable<double> AnimationStartTime { get; } = new BindableDouble();
     }
 }

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

@@ -0,0 +1,120 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Pooling;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Pooling;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
+{
+    /// <summary>
+    /// Visualises the <see cref="FollowPoint"/>s between two <see cref="DrawableOsuHitObject"/>s.
+    /// </summary>
+    public class FollowPointConnection : PoolableDrawableWithLifetime<FollowPointLifetimeEntry>
+    {
+        // Todo: These shouldn't be constants
+        public const int SPACING = 32;
+        public const double PREEMPT = 800;
+
+        public DrawablePool<FollowPoint> Pool;
+
+        protected override void OnApply(FollowPointLifetimeEntry entry)
+        {
+            base.OnApply(entry);
+
+            entry.Invalidated += onEntryInvalidated;
+            refreshPoints();
+        }
+
+        protected override void OnFree(FollowPointLifetimeEntry entry)
+        {
+            base.OnFree(entry);
+
+            entry.Invalidated -= onEntryInvalidated;
+            // Return points to the pool.
+            ClearInternal(false);
+        }
+
+        private void onEntryInvalidated() => Scheduler.AddOnce(refreshPoints);
+
+        private void refreshPoints()
+        {
+            ClearInternal(false);
+
+            var entry = Entry;
+            if (entry?.End == null) return;
+
+            OsuHitObject start = entry.Start;
+            OsuHitObject end = entry.End;
+
+            double startTime = start.GetEndTime();
+
+            Vector2 startPosition = start.StackedEndPosition;
+            Vector2 endPosition = end.StackedPosition;
+
+            Vector2 distanceVector = endPosition - startPosition;
+            int distance = (int)distanceVector.Length;
+            float rotation = (float)(Math.Atan2(distanceVector.Y, distanceVector.X) * (180 / Math.PI));
+
+            double finalTransformEndTime = startTime;
+
+            for (int d = (int)(SPACING * 1.5); d < distance - SPACING; d += SPACING)
+            {
+                float fraction = (float)d / distance;
+                Vector2 pointStartPosition = startPosition + (fraction - 0.1f) * distanceVector;
+                Vector2 pointEndPosition = startPosition + fraction * distanceVector;
+
+                GetFadeTimes(start, end, (float)d / distance, out double fadeInTime, out double fadeOutTime);
+
+                FollowPoint fp;
+
+                AddInternal(fp = Pool.Get());
+
+                fp.ClearTransforms();
+                fp.Position = pointStartPosition;
+                fp.Rotation = rotation;
+                fp.Alpha = 0;
+                fp.Scale = new Vector2(1.5f * end.Scale);
+
+                fp.AnimationStartTime.Value = fadeInTime;
+
+                using (fp.BeginAbsoluteSequence(fadeInTime))
+                {
+                    fp.FadeIn(end.TimeFadeIn);
+                    fp.ScaleTo(end.Scale, end.TimeFadeIn, Easing.Out);
+                    fp.MoveTo(pointEndPosition, end.TimeFadeIn, Easing.Out);
+                    fp.Delay(fadeOutTime - fadeInTime).FadeOut(end.TimeFadeIn).Expire();
+
+                    finalTransformEndTime = fp.LifetimeEnd;
+                }
+            }
+
+            entry.LifetimeEnd = finalTransformEndTime;
+        }
+
+        /// <summary>
+        /// Computes the fade time of follow point positioned between two hitobjects.
+        /// </summary>
+        /// <param name="start">The first <see cref="OsuHitObject"/>, where follow points should originate from.</param>
+        /// <param name="end">The second <see cref="OsuHitObject"/>, which follow points should target.</param>
+        /// <param name="fraction">The fractional distance along <paramref name="start"/> and <paramref name="end"/> at which the follow point is to be located.</param>
+        /// <param name="fadeInTime">The fade-in time of the follow point/</param>
+        /// <param name="fadeOutTime">The fade-out time of the follow point.</param>
+        public static void GetFadeTimes(OsuHitObject start, OsuHitObject end, float fraction, out double fadeInTime, out double fadeOutTime)
+        {
+            double startTime = start.GetEndTime();
+            double duration = end.StartTime - startTime;
+
+            // Preempt time can go below 800ms. Normally, this is achieved via the DT mod which uniformly speeds up all animations game wide regardless of AR.
+            // This uniform speedup is hard to match 1:1, however we can at least make AR>10 (via mods) feel good by extending the upper linear preempt function (see: OsuHitObject).
+            // Note that this doesn't exactly match the AR>10 visuals as they're classically known, but it feels good.
+            double preempt = PREEMPT * Math.Min(1, start.TimePreempt / OsuHitObject.PREEMPT_MIN);
+
+            fadeOutTime = startTime + fraction * duration;
+            fadeInTime = fadeOutTime - preempt;
+        }
+    }
+}

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

@@ -0,0 +1,104 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System;
+using System.Diagnostics;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Performance;
+using osu.Game.Rulesets.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
+{
+    public class FollowPointLifetimeEntry : LifetimeEntry
+    {
+        public event Action? Invalidated;
+        public readonly OsuHitObject Start;
+
+        public FollowPointLifetimeEntry(OsuHitObject start)
+        {
+            Start = start;
+            LifetimeStart = Start.StartTime;
+        }
+
+        private OsuHitObject? end;
+
+        public OsuHitObject? End
+        {
+            get => end;
+            set
+            {
+                UnbindEvents();
+
+                end = value;
+
+                bindEvents();
+
+                refreshLifetimes();
+            }
+        }
+
+        private bool wasBound;
+
+        private void bindEvents()
+        {
+            UnbindEvents();
+
+            if (End == null)
+                return;
+
+            // Note: Positions are bound for instantaneous feedback from positional changes from the editor, before ApplyDefaults() is called on hitobjects.
+            Start.DefaultsApplied += onDefaultsApplied;
+            Start.PositionBindable.ValueChanged += onPositionChanged;
+
+            End.DefaultsApplied += onDefaultsApplied;
+            End.PositionBindable.ValueChanged += onPositionChanged;
+
+            wasBound = true;
+        }
+
+        public void UnbindEvents()
+        {
+            if (!wasBound)
+                return;
+
+            Debug.Assert(End != null);
+
+            Start.DefaultsApplied -= onDefaultsApplied;
+            Start.PositionBindable.ValueChanged -= onPositionChanged;
+
+            End.DefaultsApplied -= onDefaultsApplied;
+            End.PositionBindable.ValueChanged -= onPositionChanged;
+
+            wasBound = false;
+        }
+
+        private void onDefaultsApplied(HitObject obj) => refreshLifetimes();
+
+        private void onPositionChanged(ValueChangedEvent<Vector2> obj) => refreshLifetimes();
+
+        private void refreshLifetimes()
+        {
+            if (End == null || End.NewCombo || Start is Spinner || End is Spinner)
+            {
+                LifetimeEnd = LifetimeStart;
+                return;
+            }
+
+            Vector2 startPosition = Start.StackedEndPosition;
+            Vector2 endPosition = End.StackedPosition;
+            Vector2 distanceVector = endPosition - startPosition;
+
+            // The lifetime start will match the fade-in time of the first follow point.
+            float fraction = (int)(FollowPointConnection.SPACING * 1.5) / distanceVector.Length;
+            FollowPointConnection.GetFadeTimes(Start, End, fraction, out double fadeInTime, out _);
+
+            LifetimeStart = fadeInTime;
+            LifetimeEnd = double.MaxValue; // This will be set by the connection.
+
+            Invalidated?.Invoke();
+        }
+    }
+}

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

@@ -1,121 +1,146 @@
 // 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 osuTK;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Objects.Types;
+using osu.Framework.Graphics.Pooling;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Pooling;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 {
-    public class FollowPointRenderer : ConnectionRenderer<OsuHitObject>
+    /// <summary>
+    /// Visualises connections between <see cref="DrawableOsuHitObject"/>s.
+    /// </summary>
+    public class FollowPointRenderer : PooledDrawableWithLifetimeContainer<FollowPointLifetimeEntry, FollowPointConnection>
     {
-        private int pointDistance = 32;
+        public new IReadOnlyList<FollowPointLifetimeEntry> Entries => lifetimeEntries;
 
-        /// <summary>
-        /// Determines how much space there is between points.
-        /// </summary>
-        public int PointDistance
+        private DrawablePool<FollowPointConnection> connectionPool;
+        private DrawablePool<FollowPoint> pointPool;
+
+        private readonly List<FollowPointLifetimeEntry> lifetimeEntries = new List<FollowPointLifetimeEntry>();
+        private readonly Dictionary<HitObject, IBindable> startTimeMap = new Dictionary<HitObject, IBindable>();
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            get => pointDistance;
-            set
+            InternalChildren = new Drawable[]
             {
-                if (pointDistance == value) return;
+                connectionPool = new DrawablePool<FollowPointConnection>(1, 200),
+                pointPool = new DrawablePool<FollowPoint>(50, 1000)
+            };
+        }
 
-                pointDistance = value;
-                update();
+        public void AddFollowPoints(OsuHitObject hitObject)
+        {
+            addEntry(hitObject);
+
+            var startTimeBindable = hitObject.StartTimeBindable.GetBoundCopy();
+            startTimeBindable.ValueChanged += _ => onStartTimeChanged(hitObject);
+            startTimeMap[hitObject] = startTimeBindable;
+        }
+
+        public void RemoveFollowPoints(OsuHitObject hitObject)
+        {
+            removeEntry(hitObject);
+
+            startTimeMap[hitObject].UnbindAll();
+            startTimeMap.Remove(hitObject);
+        }
+
+        private void addEntry(OsuHitObject hitObject)
+        {
+            var newEntry = new FollowPointLifetimeEntry(hitObject);
+
+            int index = lifetimeEntries.AddInPlace(newEntry, Comparer<FollowPointLifetimeEntry>.Create((e1, e2) =>
+            {
+                int comp = e1.Start.StartTime.CompareTo(e2.Start.StartTime);
+
+                if (comp != 0)
+                    return comp;
+
+                // we always want to insert the new item after equal ones.
+                // this is important for beatmaps with multiple hitobjects at the same point in time.
+                // if we use standard comparison insert order, there will be a churn of connections getting re-updated to
+                // the next object at the point-in-time, adding a construction/disposal overhead (see FollowPointConnection.End implementation's ClearInternal).
+                // this is easily visible on https://osu.ppy.sh/beatmapsets/150945#osu/372245
+                return -1;
+            }));
+
+            if (index < lifetimeEntries.Count - 1)
+            {
+                // Update the connection's end point to the next connection's start point
+                //     h1 -> -> -> h2
+                //    connection    nextGroup
+
+                FollowPointLifetimeEntry nextEntry = lifetimeEntries[index + 1];
+                newEntry.End = nextEntry.Start;
+            }
+            else
+            {
+                // The end point may be non-null during re-ordering
+                newEntry.End = null;
+            }
+
+            if (index > 0)
+            {
+                // Update the previous connection's end point to the current connection's start point
+                //     h1 -> -> -> h2
+                //  prevGroup    connection
+
+                FollowPointLifetimeEntry previousEntry = lifetimeEntries[index - 1];
+                previousEntry.End = newEntry.Start;
+            }
+
+            Add(newEntry);
+        }
+
+        private void removeEntry(OsuHitObject hitObject)
+        {
+            int index = lifetimeEntries.FindIndex(e => e.Start == hitObject);
+
+            var entry = lifetimeEntries[index];
+            entry.UnbindEvents();
+
+            lifetimeEntries.RemoveAt(index);
+            Remove(entry);
+
+            if (index > 0)
+            {
+                // Update the previous connection's end point to the next connection's start point
+                //     h1 -> -> -> h2 -> -> -> h3
+                //  prevGroup    connection       nextGroup
+                // The current connection's end point is used since there may not be a next connection
+                FollowPointLifetimeEntry previousEntry = lifetimeEntries[index - 1];
+                previousEntry.End = entry.End;
             }
         }
 
-        private int preEmpt = 800;
-
-        /// <summary>
-        /// Follow points to the next hitobject start appearing for this many milliseconds before an hitobject's end time.
-        /// </summary>
-        public int PreEmpt
+        protected override FollowPointConnection GetDrawable(FollowPointLifetimeEntry entry)
         {
-            get => preEmpt;
-            set
-            {
-                if (preEmpt == value) return;
-
-                preEmpt = value;
-                update();
-            }
+            var connection = connectionPool.Get();
+            connection.Pool = pointPool;
+            connection.Apply(entry);
+            return connection;
         }
 
-        private IEnumerable<OsuHitObject> hitObjects;
-
-        public override IEnumerable<OsuHitObject> HitObjects
+        private void onStartTimeChanged(OsuHitObject hitObject)
         {
-            get => hitObjects;
-            set
-            {
-                hitObjects = value;
-                update();
-            }
+            removeEntry(hitObject);
+            addEntry(hitObject);
         }
 
-        public override bool RemoveCompletedTransforms => false;
-
-        private void update()
+        protected override void Dispose(bool isDisposing)
         {
-            ClearInternal();
+            base.Dispose(isDisposing);
 
-            if (hitObjects == null)
-                return;
-
-            OsuHitObject prevHitObject = null;
-
-            foreach (var currHitObject in hitObjects)
-            {
-                if (prevHitObject != null && !currHitObject.NewCombo && !(prevHitObject is Spinner) && !(currHitObject is Spinner))
-                {
-                    Vector2 startPosition = prevHitObject.EndPosition;
-                    Vector2 endPosition = currHitObject.Position;
-                    double startTime = (prevHitObject as IHasEndTime)?.EndTime ?? prevHitObject.StartTime;
-                    double endTime = currHitObject.StartTime;
-
-                    Vector2 distanceVector = endPosition - startPosition;
-                    int distance = (int)distanceVector.Length;
-                    float rotation = (float)(Math.Atan2(distanceVector.Y, distanceVector.X) * (180 / Math.PI));
-                    double duration = endTime - startTime;
-
-                    for (int d = (int)(PointDistance * 1.5); d < distance - PointDistance; d += PointDistance)
-                    {
-                        float fraction = (float)d / distance;
-                        Vector2 pointStartPosition = startPosition + (fraction - 0.1f) * distanceVector;
-                        Vector2 pointEndPosition = startPosition + fraction * distanceVector;
-                        double fadeOutTime = startTime + fraction * duration;
-                        double fadeInTime = fadeOutTime - PreEmpt;
-
-                        FollowPoint fp;
-
-                        AddInternal(fp = new FollowPoint
-                        {
-                            Position = pointStartPosition,
-                            Rotation = rotation,
-                            Alpha = 0,
-                            Scale = new Vector2(1.5f * currHitObject.Scale),
-                        });
-
-                        using (fp.BeginAbsoluteSequence(fadeInTime))
-                        {
-                            fp.FadeIn(currHitObject.TimeFadeIn);
-                            fp.ScaleTo(currHitObject.Scale, currHitObject.TimeFadeIn, Easing.Out);
-
-                            fp.MoveTo(pointEndPosition, currHitObject.TimeFadeIn, Easing.Out);
-
-                            fp.Delay(fadeOutTime - fadeInTime).FadeOut(currHitObject.TimeFadeIn);
-                        }
-
-                        fp.Expire(true);
-                    }
-                }
-
-                prevHitObject = currHitObject;
-            }
+            foreach (var entry in lifetimeEntries)
+                entry.UnbindEvents();
+            lifetimeEntries.Clear();
         }
     }
 }

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

@@ -2,39 +2,53 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using osuTK;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Osu.Skinning;
+using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
-    public class DrawableHitCircle : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
+    public class DrawableHitCircle : DrawableOsuHitObject, IHasMainCirclePiece, IHasApproachCircle
     {
-        public ApproachCircle ApproachCircle;
+        public OsuAction? HitAction => HitArea.HitAction;
+        protected virtual OsuSkinComponents CirclePieceComponent => OsuSkinComponents.HitCircle;
 
-        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
-        private readonly IBindable<int> stackHeightBindable = new Bindable<int>();
-        private readonly IBindable<float> scaleBindable = new Bindable<float>();
+        public SkinnableDrawable ApproachCircle { get; private set; }
+        public HitReceptor HitArea { get; private set; }
+        public SkinnableDrawable CirclePiece { get; private set; }
 
-        public OsuAction? HitAction => hitArea.HitAction;
+        Drawable IHasApproachCircle.ApproachCircle => ApproachCircle;
 
-        private readonly Container scaleContainer;
+        private Container scaleContainer;
+        private InputManager inputManager;
 
-        private readonly HitArea hitArea;
+        public DrawableHitCircle()
+            : this(null)
+        {
+        }
 
-        public DrawableHitCircle(HitCircle h)
+        public DrawableHitCircle([CanBeNull] HitCircle h = null)
             : base(h)
         {
-            Origin = Anchor.Centre;
+        }
 
-            Position = HitObject.StackedPosition;
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Origin = Anchor.Centre;
 
             InternalChildren = new Drawable[]
             {
@@ -45,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Anchor = Anchor.Centre,
                     Children = new Drawable[]
                     {
-                        hitArea = new HitArea
+                        HitArea = new HitReceptor
                         {
                             Hit = () =>
                             {
@@ -56,9 +70,16 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                                 return true;
                             },
                         },
-                        new SkinnableDrawable("Play/osu/hitcircle", _ => new MainCirclePiece(HitObject.IndexInCurrentCombo)),
-                        ApproachCircle = new ApproachCircle
+                        CirclePiece = new SkinnableDrawable(new OsuSkinComponent(CirclePieceComponent), _ => new MainCirclePiece())
                         {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                        ApproachCircle = new ProxyableSkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.ApproachCircle), _ => new DefaultApproachCircle())
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
                             Alpha = 0,
                             Scale = new Vector2(4),
                         }
@@ -66,86 +87,131 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 },
             };
 
-            Size = hitArea.DrawSize;
+            Size = HitArea.DrawSize;
+
+            PositionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            StackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue));
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
+        protected override void LoadComplete()
         {
-            positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
-            stackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
-            scaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
+            base.LoadComplete();
 
-            positionBindable.BindTo(HitObject.PositionBindable);
-            stackHeightBindable.BindTo(HitObject.StackHeightBindable);
-            scaleBindable.BindTo(HitObject.ScaleBindable);
+            inputManager = GetContainingInputManager();
+        }
 
-            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))
-                    ApplyResult(r => r.Type = HitResult.Miss);
+                    ApplyResult(r => r.Type = r.Judgement.MinResult);
 
                 return;
             }
 
-            var result = HitObject.HitWindows.ResultFor(timeOffset);
+            var result = ResultFor(timeOffset);
 
-            if (result == HitResult.None)
+            if (result == HitResult.None || CheckHittable?.Invoke(this, Time.Current) == false)
             {
-                Shake(Math.Abs(timeOffset) - HitObject.HitWindows.HalfWindowFor(HitResult.Miss));
+                Shake(Math.Abs(timeOffset) - HitObject.HitWindows.WindowFor(HitResult.Miss));
                 return;
             }
 
-            ApplyResult(r => r.Type = result);
+            ApplyResult(r =>
+            {
+                var circleResult = (OsuHitCircleJudgementResult)r;
+
+                // Todo: This should also consider misses, but they're a little more interesting to handle, since we don't necessarily know the position at the time of a miss.
+                if (result.IsHit())
+                {
+                    var localMousePosition = ToLocalSpace(inputManager.CurrentState.Mouse.Position);
+                    circleResult.CursorPositionAtHit = HitObject.StackedPosition + (localMousePosition - DrawSize / 2);
+                }
+
+                circleResult.Type = result;
+            });
         }
 
+        /// <summary>
+        /// Retrieves the <see cref="HitResult"/> for a time offset.
+        /// </summary>
+        /// <param name="timeOffset">The time offset.</param>
+        /// <returns>The hit result, or <see cref="HitResult.None"/> if <paramref name="timeOffset"/> doesn't result in a judgement.</returns>
+        protected virtual HitResult ResultFor(double timeOffset) => HitObject.HitWindows.ResultFor(timeOffset);
+
         protected override void UpdateInitialTransforms()
         {
             base.UpdateInitialTransforms();
 
+            CirclePiece.FadeInFromZero(HitObject.TimeFadeIn);
+
             ApproachCircle.FadeIn(Math.Min(HitObject.TimeFadeIn * 2, HitObject.TimePreempt));
             ApproachCircle.ScaleTo(1f, HitObject.TimePreempt);
             ApproachCircle.Expire(true);
         }
 
-        protected override void UpdateStateTransforms(ArmedState state)
+        protected override void UpdateStartTimeStateTransforms()
         {
+            base.UpdateStartTimeStateTransforms();
+
+            // always fade out at the circle's start time (to match user expectations).
+            ApproachCircle.FadeOut(50);
+        }
+
+        protected override void UpdateHitStateTransforms(ArmedState state)
+        {
+            Debug.Assert(HitObject.HitWindows != null);
+
+            // todo: temporary / arbitrary, used for lifetime optimisation.
+            this.Delay(800).FadeOut();
+
+            // in the case of an early state change, the fade should be expedited to the current point in time.
+            if (HitStateUpdateTime < HitObject.StartTime)
+                ApproachCircle.FadeOut(50);
+
             switch (state)
             {
                 case ArmedState.Idle:
-                    this.Delay(HitObject.TimePreempt).FadeOut(500);
-
-                    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);
+                    HitArea.HitAction = null;
                     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();
                     break;
             }
+
+            Expire();
         }
 
         public Drawable ProxiedLayer => ApproachCircle;
 
-        private class HitArea : Drawable, IKeyBindingHandler<OsuAction>
+        protected override JudgementResult CreateResult(Judgement judgement) => new OsuHitCircleJudgementResult(HitObject, judgement);
+
+        public class HitReceptor : CompositeDrawable, IKeyBindingHandler<OsuAction>
         {
             // IsHovered is used
             public override bool HandlePositionalInput => true;
@@ -154,23 +220,26 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             public OsuAction? HitAction;
 
-            public HitArea()
+            public HitReceptor()
             {
                 Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
                 Anchor = Anchor.Centre;
                 Origin = Anchor.Centre;
+
+                CornerRadius = OsuHitObject.OBJECT_RADIUS;
+                CornerExponent = 2;
             }
 
-            public bool OnPressed(OsuAction action)
+            public bool OnPressed(KeyBindingPressEvent<OsuAction> e)
             {
-                switch (action)
+                switch (e.Action)
                 {
                     case OsuAction.LeftButton:
                     case OsuAction.RightButton:
                         if (IsHovered && (Hit?.Invoke() ?? false))
                         {
-                            HitAction = action;
+                            HitAction = e.Action;
                             return true;
                         }
 
@@ -180,7 +249,19 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 return false;
             }
 
-            public bool OnReleased(OsuAction action) => false;
+            public void OnReleased(KeyBindingReleaseEvent<OsuAction> e)
+            {
+            }
+        }
+
+        private class ProxyableSkinnableDrawable : SkinnableDrawable
+        {
+            public override bool RemoveWhenNotAlive => false;
+
+            public ProxyableSkinnableDrawable(ISkinComponent component, Func<ISkinComponent, Drawable> defaultImplementation = null, ConfineMode confineMode = ConfineMode.NoScaling)
+                : base(component, defaultImplementation, confineMode)
+            {
+            }
         }
     }
 }

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

@@ -1,31 +1,74 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Graphics.Containers;
+using osu.Game.Rulesets.Osu.UI;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableOsuHitObject : DrawableHitObject<OsuHitObject>
     {
-        private readonly ShakeContainer shakeContainer;
+        public readonly IBindable<Vector2> PositionBindable = new Bindable<Vector2>();
+        public readonly IBindable<int> StackHeightBindable = new Bindable<int>();
+        public readonly IBindable<float> ScaleBindable = new BindableFloat();
+        public readonly IBindable<int> IndexInCurrentComboBindable = new Bindable<int>();
 
         // Must be set to update IsHovered as it's used in relax mdo to detect osu hit objects.
         public override bool HandlePositionalInput => true;
 
+        protected override float SamplePlaybackPosition => HitObject.X / OsuPlayfield.BASE_SIZE.X;
+
+        /// <summary>
+        /// Whether this <see cref="DrawableOsuHitObject"/> can be hit, given a time value.
+        /// If non-null, judgements will be ignored (resulting in a shake) whilst the function returns false.
+        /// </summary>
+        public Func<DrawableHitObject, double, bool> CheckHittable;
+
+        private ShakeContainer shakeContainer;
+
         protected DrawableOsuHitObject(OsuHitObject hitObject)
             : base(hitObject)
         {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Alpha = 0;
+
             base.AddInternal(shakeContainer = new ShakeContainer
             {
                 ShakeDuration = 30,
                 RelativeSizeAxes = Axes.Both
             });
+        }
 
-            Alpha = 0;
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            IndexInCurrentComboBindable.BindTo(HitObject.IndexInCurrentComboBindable);
+            PositionBindable.BindTo(HitObject.PositionBindable);
+            StackHeightBindable.BindTo(HitObject.StackHeightBindable);
+            ScaleBindable.BindTo(HitObject.ScaleBindable);
+        }
+
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            IndexInCurrentComboBindable.UnbindFrom(HitObject.IndexInCurrentComboBindable);
+            PositionBindable.UnbindFrom(HitObject.PositionBindable);
+            StackHeightBindable.UnbindFrom(HitObject.StackHeightBindable);
+            ScaleBindable.UnbindFrom(HitObject.ScaleBindable);
         }
 
         // Forward all internal management to shakeContainer.
@@ -36,13 +79,16 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected sealed override double InitialLifetimeOffset => HitObject.TimePreempt;
 
-        protected override void UpdateInitialTransforms() => this.FadeIn(HitObject.TimeFadeIn);
-
         private OsuInputManager osuActionInputManager;
-        internal OsuInputManager OsuActionInputManager => osuActionInputManager ?? (osuActionInputManager = GetContainingInputManager() as OsuInputManager);
+        internal OsuInputManager OsuActionInputManager => osuActionInputManager ??= GetContainingInputManager() as OsuInputManager;
 
-        protected virtual void Shake(double maximumLength) => shakeContainer.Shake(maximumLength);
+        public virtual void Shake(double maximumLength) => shakeContainer.Shake(maximumLength);
 
-        protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(judgement);
+        /// <summary>
+        /// Causes this <see cref="DrawableOsuHitObject"/> to get missed, disregarding all conditions in implementations of <see cref="DrawableHitObject.CheckForResult"/>.
+        /// </summary>
+        public void MissForcefully() => ApplyResult(r => r.Type = r.Judgement.MinResult);
+
+        protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(HitObject, judgement);
     }
 }

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

@@ -1,24 +1,88 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osuTK;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableOsuJudgement : DrawableJudgement
     {
-        public DrawableOsuJudgement(JudgementResult result, DrawableHitObject judgedObject)
-            : base(result, judgedObject)
+        protected SkinnableLighting Lighting { get; private set; }
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
+            AddInternal(Lighting = new SkinnableLighting
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Blending = BlendingParameters.Additive,
+                Depth = float.MaxValue,
+                Alpha = 0
+            });
+        }
+
+        protected override void PrepareForUse()
+        {
+            base.PrepareForUse();
+
+            Lighting.ResetAnimation();
+            Lighting.SetColourFrom(JudgedObject, Result);
+
+            if (JudgedObject?.HitObject is OsuHitObject osuObject)
+            {
+                Position = osuObject.StackedEndPosition;
+                Scale = new Vector2(osuObject.Scale);
+            }
         }
 
         protected override void ApplyHitAnimations()
         {
-            JudgementText?.TransformSpacingTo(new Vector2(14, 0), 1800, Easing.OutQuint);
+            bool hitLightingEnabled = config.Get<bool>(OsuSetting.HitLighting);
+
+            Lighting.Alpha = 0;
+
+            if (hitLightingEnabled && Lighting.Drawable != null)
+            {
+                // todo: this animation changes slightly based on new/old legacy skin versions.
+                Lighting.ScaleTo(0.8f).ScaleTo(1.2f, 600, Easing.Out);
+                Lighting.FadeIn(200).Then().Delay(200).FadeOut(1000);
+
+                // extend the lifetime to cover lighting fade
+                LifetimeEnd = Lighting.LatestTransformEndTime;
+            }
+
             base.ApplyHitAnimations();
         }
+
+        protected override Drawable CreateDefaultJudgement(HitResult result) => new OsuJudgementPiece(result);
+
+        private class OsuJudgementPiece : DefaultJudgementPiece
+        {
+            public OsuJudgementPiece(HitResult result)
+                : base(result)
+            {
+            }
+
+            public override void PlayAnimation()
+            {
+                if (Result != HitResult.Miss)
+                {
+                    JudgementText
+                        .ScaleTo(new Vector2(0.8f, 1))
+                        .ScaleTo(new Vector2(1.2f, 1), 1800, Easing.OutQuint);
+                }
+
+                base.PlayAnimation();
+            }
+        }
     }
 }

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

@@ -1,137 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-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 osu.Game.Skinning;
-
-namespace osu.Game.Rulesets.Osu.Objects.Drawables
-{
-    public class DrawableRepeatPoint : DrawableOsuHitObject, ITrackSnaking
-    {
-        private readonly RepeatPoint repeatPoint;
-        private readonly DrawableSlider drawableSlider;
-
-        private double animDuration;
-
-        private readonly SkinnableDrawable scaleContainer;
-
-        public DrawableRepeatPoint(RepeatPoint repeatPoint, DrawableSlider drawableSlider)
-            : base(repeatPoint)
-        {
-            this.repeatPoint = repeatPoint;
-            this.drawableSlider = drawableSlider;
-
-            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
-
-            Blending = BlendingMode.Additive;
-            Origin = Anchor.Centre;
-
-            InternalChild = scaleContainer = new SkinnableDrawable("Play/osu/reversearrow", _ => new SpriteIcon
-            {
-                RelativeSizeAxes = Axes.Both,
-                Icon = FontAwesome.Solid.ChevronRight,
-                Size = new Vector2(0.35f)
-            }, confineMode: ConfineMode.NoScaling)
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-            };
-        }
-
-        private readonly IBindable<float> scaleBindable = new Bindable<float>();
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            scaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
-            scaleBindable.BindTo(HitObject.ScaleBindable);
-        }
-
-        protected override void CheckForResult(bool userTriggered, double timeOffset)
-        {
-            if (repeatPoint.StartTime <= Time.Current)
-                ApplyResult(r => r.Type = drawableSlider.Tracking.Value ? HitResult.Great : HitResult.Miss);
-        }
-
-        protected override void UpdateInitialTransforms()
-        {
-            animDuration = Math.Min(150, repeatPoint.SpanDuration / 2);
-
-            this.Animate(
-                d => d.FadeIn(animDuration),
-                d => d.ScaleTo(0.5f).ScaleTo(1f, animDuration * 4, Easing.OutElasticHalf)
-            );
-        }
-
-        protected override void UpdateStateTransforms(ArmedState state)
-        {
-            switch (state)
-            {
-                case ArmedState.Idle:
-                    this.Delay(HitObject.TimePreempt).FadeOut();
-                    break;
-
-                case ArmedState.Miss:
-                    this.FadeOut(animDuration);
-                    break;
-
-                case ArmedState.Hit:
-                    this.FadeOut(animDuration, Easing.OutQuint)
-                        .ScaleTo(Scale * 1.5f, animDuration, Easing.Out);
-                    break;
-            }
-        }
-
-        private bool hasRotation;
-
-        public void UpdateSnakingPosition(Vector2 start, Vector2 end)
-        {
-            bool isRepeatAtEnd = repeatPoint.RepeatIndex % 2 == 0;
-            List<Vector2> curve = drawableSlider.Body.CurrentCurve;
-
-            Position = isRepeatAtEnd ? end : start;
-
-            if (curve.Count < 2)
-                return;
-
-            int searchStart = isRepeatAtEnd ? curve.Count - 1 : 0;
-            int direction = isRepeatAtEnd ? -1 : 1;
-
-            Vector2 aimRotationVector = Vector2.Zero;
-
-            // find the next vector2 in the curve which is not equal to our current position to infer a rotation.
-            for (int i = searchStart; i >= 0 && i < curve.Count; i += direction)
-            {
-                if (Precision.AlmostEquals(curve[i], Position))
-                    continue;
-
-                aimRotationVector = curve[i];
-                break;
-            }
-
-            float aimRotation = MathHelper.RadiansToDegrees((float)Math.Atan2(aimRotationVector.Y - Position.Y, aimRotationVector.X - Position.X));
-            while (Math.Abs(aimRotation - Rotation) > 180)
-                aimRotation += aimRotation < Rotation ? 360 : -360;
-
-            if (!hasRotation)
-            {
-                Rotation = aimRotation;
-                hasRotation = true;
-            }
-            else
-            {
-                // If we're already snaking, interpolate to smooth out sharp curves (linear sliders, mainly).
-                Rotation = Interpolation.ValueAt(MathHelper.Clamp(Clock.ElapsedFrameTime, 0, 100), Rotation, aimRotation, 0, 50, Easing.OutQuint);
-            }
-        }
-    }
-}

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

@@ -1,124 +1,213 @@
 // 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 JetBrains.Annotations;
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Osu.Configuration;
+using osu.Game.Rulesets.Osu.Skinning;
+using osu.Game.Rulesets.Osu.Skinning.Default;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
-    public class DrawableSlider : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
+    public class DrawableSlider : DrawableOsuHitObject
     {
-        private readonly Slider slider;
-        private readonly List<Drawable> components = new List<Drawable>();
+        public new Slider HitObject => (Slider)base.HitObject;
 
-        public readonly DrawableHitCircle HeadCircle;
-        public readonly DrawableSliderTail TailCircle;
+        public DrawableSliderHead HeadCircle => headContainer.Child;
+        public DrawableSliderTail TailCircle => tailContainer.Child;
 
-        public readonly SnakingSliderBody Body;
-        public readonly SliderBall Ball;
+        public SliderBall Ball { get; private set; }
+        public SkinnableDrawable Body { get; private set; }
 
-        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
-        private readonly IBindable<float> scaleBindable = new Bindable<float>();
-        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
+        /// <summary>
+        /// A target container which can be used to add top level elements to the slider's display.
+        /// Intended to be used for proxy purposes only.
+        /// </summary>
+        public Container OverlayElementContainer { get; private set; }
 
-        [Resolved(CanBeNull = true)]
-        private OsuRulesetConfigManager config { get; set; }
+        public override bool DisplayResult => !HitObject.OnlyJudgeNestedObjects;
 
-        public DrawableSlider(Slider s)
+        [CanBeNull]
+        public PlaySliderBody SliderBody => Body.Drawable as PlaySliderBody;
+
+        public IBindable<int> PathVersion => pathVersion;
+        private readonly Bindable<int> pathVersion = new Bindable<int>();
+
+        private Container<DrawableSliderHead> headContainer;
+        private Container<DrawableSliderTail> tailContainer;
+        private Container<DrawableSliderTick> tickContainer;
+        private Container<DrawableSliderRepeat> repeatContainer;
+        private PausableSkinnableSound slidingSample;
+
+        public DrawableSlider()
+            : this(null)
+        {
+        }
+
+        public DrawableSlider([CanBeNull] Slider s = null)
             : base(s)
         {
-            slider = s;
-
-            Position = s.StackedPosition;
-
-            Container<DrawableSliderTick> ticks;
-            Container<DrawableRepeatPoint> repeatPoints;
-
-            InternalChildren = new Drawable[]
-            {
-                Body = new SnakingSliderBody(s),
-                ticks = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both },
-                repeatPoints = new Container<DrawableRepeatPoint> { RelativeSizeAxes = Axes.Both },
-                Ball = new SliderBall(s, this)
-                {
-                    GetInitialHitAction = () => HeadCircle.HitAction,
-                    BypassAutoSizeAxes = Axes.Both,
-                    Scale = new Vector2(s.Scale),
-                    AlwaysPresent = true,
-                    Alpha = 0
-                },
-                HeadCircle = new DrawableSliderHead(s, s.HeadCircle)
-                {
-                    OnShake = Shake
-                },
-                TailCircle = new DrawableSliderTail(s, s.TailCircle)
-            };
-
-            components.Add(Body);
-            components.Add(Ball);
-
-            AddNested(HeadCircle);
-
-            AddNested(TailCircle);
-            components.Add(TailCircle);
-
-            foreach (var tick in s.NestedHitObjects.OfType<SliderTick>())
-            {
-                var drawableTick = new DrawableSliderTick(tick) { Position = tick.Position - s.Position };
-
-                ticks.Add(drawableTick);
-                components.Add(drawableTick);
-                AddNested(drawableTick);
-            }
-
-            foreach (var repeatPoint in s.NestedHitObjects.OfType<RepeatPoint>())
-            {
-                var drawableRepeatPoint = new DrawableRepeatPoint(repeatPoint, this) { Position = repeatPoint.Position - s.Position };
-
-                repeatPoints.Add(drawableRepeatPoint);
-                components.Add(drawableRepeatPoint);
-                AddNested(drawableRepeatPoint);
-            }
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            config?.BindWith(OsuRulesetSetting.SnakingInSliders, Body.SnakingIn);
-            config?.BindWith(OsuRulesetSetting.SnakingOutSliders, Body.SnakingOut);
-
-            positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
-            scaleBindable.BindValueChanged(scale =>
+            InternalChildren = new Drawable[]
             {
-                updatePathRadius();
-                Ball.Scale = new Vector2(scale.NewValue);
-            });
+                Body = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderBody), _ => new DefaultSliderBody(), confineMode: ConfineMode.NoScaling),
+                tailContainer = new Container<DrawableSliderTail> { RelativeSizeAxes = Axes.Both },
+                tickContainer = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both },
+                repeatContainer = new Container<DrawableSliderRepeat> { RelativeSizeAxes = Axes.Both },
+                headContainer = new Container<DrawableSliderHead> { RelativeSizeAxes = Axes.Both },
+                OverlayElementContainer = new Container { RelativeSizeAxes = Axes.Both, },
+                Ball = new SliderBall(this)
+                {
+                    GetInitialHitAction = () => HeadCircle.HitAction,
+                    BypassAutoSizeAxes = Axes.Both,
+                    AlwaysPresent = true,
+                    Alpha = 0
+                },
+                slidingSample = new PausableSkinnableSound { Looping = true }
+            };
 
-            positionBindable.BindTo(HitObject.PositionBindable);
-            scaleBindable.BindTo(HitObject.ScaleBindable);
-            pathBindable.BindTo(slider.PathBindable);
-
-            pathBindable.BindValueChanged(_ => Body.Refresh());
+            PositionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            StackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
+            ScaleBindable.BindValueChanged(scale => Ball.Scale = new Vector2(scale.NewValue));
 
             AccentColour.BindValueChanged(colour =>
             {
-                Body.AccentColour = colour.NewValue;
-
                 foreach (var drawableHitObject in NestedHitObjects)
                     drawableHitObject.AccentColour.Value = colour.NewValue;
+                updateBallTint();
             }, true);
+
+            Tracking.BindValueChanged(updateSlidingSample);
+        }
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            // Ensure that the version will change after the upcoming BindTo().
+            pathVersion.Value = int.MaxValue;
+            PathVersion.BindTo(HitObject.Path.Version);
+        }
+
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            PathVersion.UnbindFrom(HitObject.Path.Version);
+
+            slidingSample.Samples = null;
+        }
+
+        protected override void LoadSamples()
+        {
+            // Note: base.LoadSamples() isn't called since the slider plays the tail's hitsounds for the time being.
+
+            if (HitObject.SampleControlPoint == null)
+            {
+                throw new InvalidOperationException($"{nameof(HitObject)}s must always have an attached {nameof(HitObject.SampleControlPoint)}."
+                                                    + $" This is an indication that {nameof(HitObject.ApplyDefaults)} has not been invoked on {this}.");
+            }
+
+            Samples.Samples = HitObject.TailSamples.Select(s => HitObject.SampleControlPoint.ApplyTo(s)).Cast<ISampleInfo>().ToArray();
+
+            var slidingSamples = new List<ISampleInfo>();
+
+            var normalSample = HitObject.Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_NORMAL);
+            if (normalSample != null)
+                slidingSamples.Add(HitObject.SampleControlPoint.ApplyTo(normalSample).With("sliderslide"));
+
+            var whistleSample = HitObject.Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_WHISTLE);
+            if (whistleSample != null)
+                slidingSamples.Add(HitObject.SampleControlPoint.ApplyTo(whistleSample).With("sliderwhistle"));
+
+            slidingSample.Samples = slidingSamples.ToArray();
+        }
+
+        public override void StopAllSamples()
+        {
+            base.StopAllSamples();
+            slidingSample?.Stop();
+        }
+
+        private void updateSlidingSample(ValueChangedEvent<bool> tracking)
+        {
+            if (tracking.NewValue)
+                slidingSample?.Play();
+            else
+                slidingSample?.Stop();
+        }
+
+        protected override void AddNestedHitObject(DrawableHitObject hitObject)
+        {
+            base.AddNestedHitObject(hitObject);
+
+            switch (hitObject)
+            {
+                case DrawableSliderHead head:
+                    headContainer.Child = head;
+                    break;
+
+                case DrawableSliderTail tail:
+                    tailContainer.Child = tail;
+                    break;
+
+                case DrawableSliderTick tick:
+                    tickContainer.Add(tick);
+                    break;
+
+                case DrawableSliderRepeat repeat:
+                    repeatContainer.Add(repeat);
+                    break;
+            }
+        }
+
+        protected override void ClearNestedHitObjects()
+        {
+            base.ClearNestedHitObjects();
+
+            headContainer.Clear(false);
+            tailContainer.Clear(false);
+            repeatContainer.Clear(false);
+            tickContainer.Clear(false);
+
+            OverlayElementContainer.Clear(false);
+        }
+
+        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case SliderTailCircle tail:
+                    return new DrawableSliderTail(tail);
+
+                case SliderHeadCircle head:
+                    return new DrawableSliderHead(head);
+
+                case SliderTick tick:
+                    return new DrawableSliderTick(tick);
+
+                case SliderRepeat repeat:
+                    return new DrawableSliderRepeat(repeat);
+            }
+
+            return base.CreateNestedHitObject(hitObject);
         }
 
         public readonly Bindable<bool> Tracking = new Bindable<bool>();
@@ -129,14 +218,23 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             Tracking.Value = Ball.Tracking;
 
-            double completionProgress = MathHelper.Clamp((Time.Current - slider.StartTime) / slider.Duration, 0, 1);
+            if (Tracking.Value && slidingSample != null)
+                // keep the sliding sample playing at the current tracking position
+                slidingSample.Balance.Value = CalculateSamplePlaybackBalance(Ball.X / OsuPlayfield.BASE_SIZE.X);
 
-            foreach (var c in components.OfType<ISliderProgress>()) c.UpdateProgress(completionProgress);
-            foreach (var c in components.OfType<ITrackSnaking>()) c.UpdateSnakingPosition(slider.Path.PositionAt(Body.SnakedStart ?? 0), slider.Path.PositionAt(Body.SnakedEnd ?? 0));
-            foreach (var t in components.OfType<IRequireTracking>()) t.Tracking = Ball.Tracking;
+            double completionProgress = Math.Clamp((Time.Current - HitObject.StartTime) / HitObject.Duration, 0, 1);
 
-            Size = Body.Size;
-            OriginPosition = Body.PathOffset;
+            Ball.UpdateProgress(completionProgress);
+            SliderBody?.UpdateProgress(completionProgress);
+
+            foreach (DrawableHitObject hitObject in NestedHitObjects)
+            {
+                if (hitObject is ITrackSnaking s) s.UpdateSnakingPosition(HitObject.Path.PositionAt(SliderBody?.SnakedStart ?? 0), HitObject.Path.PositionAt(SliderBody?.SnakedEnd ?? 0));
+                if (hitObject is IRequireTracking t) t.Tracking = Ball.Tracking;
+            }
+
+            Size = SliderBody?.Size ?? Vector2.Zero;
+            OriginPosition = SliderBody?.PathOffset ?? Vector2.Zero;
 
             if (DrawSize != Vector2.Zero)
             {
@@ -150,75 +248,104 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public override void OnKilled()
         {
             base.OnKilled();
-            Body.RecyclePath();
+            SliderBody?.RecyclePath();
         }
 
-        private float sliderPathRadius;
-
-        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+        protected override void ApplySkin(ISkinSource skin, bool allowFallback)
         {
-            base.SkinChanged(skin, allowFallback);
+            base.ApplySkin(skin, allowFallback);
 
-            Body.BorderSize = skin.GetValue<SkinConfiguration, float?>(s => s.SliderBorderSize) ?? SliderBody.DEFAULT_BORDER_SIZE;
-            sliderPathRadius = skin.GetValue<SkinConfiguration, float?>(s => s.SliderPathRadius) ?? OsuHitObject.OBJECT_RADIUS;
-            updatePathRadius();
-
-            Body.AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderTrackOverride") ? s.CustomColours["SliderTrackOverride"] : (Color4?)null) ?? AccentColour.Value;
-            Body.BorderColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderBorder") ? s.CustomColours["SliderBorder"] : (Color4?)null) ?? Color4.White;
+            updateBallTint();
         }
 
-        private void updatePathRadius() => Body.PathRadius = slider.Scale * sliderPathRadius;
+        private void updateBallTint()
+        {
+            if (CurrentSkin == null)
+                return;
+
+            bool allowBallTint = CurrentSkin.GetConfig<OsuSkinConfiguration, bool>(OsuSkinConfiguration.AllowSliderBallTint)?.Value ?? false;
+            Ball.AccentColour = allowBallTint ? AccentColour.Value : Color4.White;
+        }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
-            if (userTriggered || Time.Current < slider.EndTime)
+            if (userTriggered || Time.Current < HitObject.EndTime)
                 return;
 
+            // If only the nested hitobjects are judged, then the slider's own judgement is ignored for scoring purposes.
+            // But the slider needs to still be judged with a reasonable hit/miss result for visual purposes (hit/miss transforms, etc).
+            if (HitObject.OnlyJudgeNestedObjects)
+            {
+                ApplyResult(r => r.Type = NestedHitObjects.Any(h => h.Result.IsHit) ? r.Judgement.MaxResult : r.Judgement.MinResult);
+                return;
+            }
+
+            // Otherwise, if this slider also needs to be judged, apply judgement proportionally to the number of nested hitobjects hit. This is the classic osu!stable scoring.
             ApplyResult(r =>
             {
-                var judgementsCount = NestedHitObjects.Count();
-                var judgementsHit = NestedHitObjects.Count(h => h.IsHit);
+                int totalTicks = NestedHitObjects.Count;
+                int hitTicks = NestedHitObjects.Count(h => h.IsHit);
 
-                var hitFraction = (double)judgementsHit / judgementsCount;
-
-                if (hitFraction == 1 && HeadCircle.Result.Type == HitResult.Great)
+                if (hitTicks == totalTicks)
                     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
+                else if (hitTicks == 0)
                     r.Type = HitResult.Miss;
+                else
+                {
+                    double hitFraction = (double)hitTicks / totalTicks;
+                    r.Type = hitFraction >= 0.5 ? HitResult.Ok : HitResult.Meh;
+                }
             });
         }
 
-        protected override void UpdateStateTransforms(ArmedState state)
+        public override void PlaySamples()
         {
-            Ball.FadeIn();
-            Ball.ScaleTo(HitObject.Scale);
-
-            using (BeginDelayedSequence(slider.Duration, true))
-            {
-                const float fade_out_time = 450;
-
-                // intentionally pile on an extra FadeOut to make it happen much faster.
-                Ball.FadeOut(fade_out_time / 4, Easing.Out);
-
-                switch (state)
-                {
-                    case ArmedState.Hit:
-                        Ball.ScaleTo(HitObject.Scale * 1.4f, fade_out_time, Easing.Out);
-                        break;
-                }
-
-                this.FadeOut(fade_out_time, Easing.OutQuint).Expire();
-            }
-
-            Expire(true);
+            // rather than doing it this way, we should probably attach the sample to the tail circle.
+            // this can only be done after we stop using LegacyLastTick.
+            if (!TailCircle.SamplePlaysOnlyOnHit || TailCircle.IsHit)
+                base.PlaySamples();
         }
 
-        public Drawable ProxiedLayer => HeadCircle.ApproachCircle;
+        protected override void UpdateInitialTransforms()
+        {
+            base.UpdateInitialTransforms();
 
-        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Body.ReceivePositionalInputAt(screenSpacePos);
+            Body.FadeInFromZero(HitObject.TimeFadeIn);
+        }
+
+        protected override void UpdateStartTimeStateTransforms()
+        {
+            base.UpdateStartTimeStateTransforms();
+
+            Ball.FadeIn();
+            Ball.ScaleTo(HitObject.Scale);
+        }
+
+        protected override void UpdateHitStateTransforms(ArmedState state)
+        {
+            base.UpdateHitStateTransforms(state);
+
+            const float fade_out_time = 450;
+
+            // intentionally pile on an extra FadeOut to make it happen much faster.
+            Ball.FadeOut(fade_out_time / 4, Easing.Out);
+
+            switch (state)
+            {
+                case ArmedState.Hit:
+                    Ball.ScaleTo(HitObject.Scale * 1.4f, fade_out_time, Easing.Out);
+                    if (SliderBody?.SnakingOut.Value == true)
+                        Body.FadeOut(40); // short fade to allow for any body colour to smoothly disappear.
+                    break;
+            }
+
+            this.FadeOut(fade_out_time, Easing.OutQuint).Expire();
+        }
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => SliderBody?.ReceivePositionalInputAt(screenSpacePos) ?? base.ReceivePositionalInputAt(screenSpacePos);
+
+        private class DefaultSliderBody : PlaySliderBody
+        {
+        }
     }
 }

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

@@ -2,52 +2,106 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using osuTK;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableSliderHead : DrawableHitCircle
     {
-        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
-        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
+        public new SliderHeadCircle HitObject => (SliderHeadCircle)base.HitObject;
 
-        private readonly Slider slider;
+        [CanBeNull]
+        public Slider Slider => DrawableSlider?.HitObject;
 
-        public DrawableSliderHead(Slider slider, HitCircle h)
+        public DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
+
+        public override bool DisplayResult => HitObject?.JudgeAsNormalHitCircle ?? base.DisplayResult;
+
+        /// <summary>
+        /// Makes this <see cref="DrawableSliderHead"/> track the follow circle when the start time is reached.
+        /// If <c>false</c>, this <see cref="DrawableSliderHead"/> will be pinned to its initial position in the slider.
+        /// </summary>
+        public bool TrackFollowCircle = true;
+
+        private readonly IBindable<int> pathVersion = new Bindable<int>();
+
+        protected override OsuSkinComponents CirclePieceComponent => OsuSkinComponents.SliderHeadHitCircle;
+
+        public DrawableSliderHead()
+        {
+        }
+
+        public DrawableSliderHead(SliderHeadCircle h)
             : base(h)
         {
-            this.slider = slider;
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            positionBindable.BindTo(HitObject.PositionBindable);
-            pathBindable.BindTo(slider.PathBindable);
+            PositionBindable.BindValueChanged(_ => updatePosition());
+            pathVersion.BindValueChanged(_ => updatePosition());
+        }
 
-            positionBindable.BindValueChanged(_ => updatePosition());
-            pathBindable.BindValueChanged(_ => updatePosition(), true);
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            pathVersion.UnbindFrom(DrawableSlider.PathVersion);
+        }
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            pathVersion.BindTo(DrawableSlider.PathVersion);
+
+            OnShake = DrawableSlider.Shake;
+            CheckHittable = (d, t) => DrawableSlider.CheckHittable?.Invoke(d, t) ?? true;
         }
 
         protected override void Update()
         {
             base.Update();
 
-            double completionProgress = MathHelper.Clamp((Time.Current - slider.StartTime) / slider.Duration, 0, 1);
+            Debug.Assert(Slider != null);
+            Debug.Assert(HitObject != null);
 
-            //todo: we probably want to reconsider this before adding scoring, but it looks and feels nice.
-            if (!IsHit)
-                Position = slider.CurvePositionAt(completionProgress);
+            if (TrackFollowCircle)
+            {
+                double completionProgress = Math.Clamp((Time.Current - Slider.StartTime) / Slider.Duration, 0, 1);
+
+                //todo: we probably want to reconsider this before adding scoring, but it looks and feels nice.
+                if (!IsHit)
+                    Position = Slider.CurvePositionAt(completionProgress);
+            }
+        }
+
+        protected override HitResult ResultFor(double timeOffset)
+        {
+            Debug.Assert(HitObject != null);
+
+            if (HitObject.JudgeAsNormalHitCircle)
+                return base.ResultFor(timeOffset);
+
+            // If not judged as a normal hitcircle, judge as a slider tick instead. This is the classic osu!stable scoring.
+            var result = base.ResultFor(timeOffset);
+            return result.IsHit() ? HitResult.LargeTickHit : HitResult.LargeTickMiss;
         }
 
         public Action<double> OnShake;
 
-        protected override void Shake(double maximumLength) => OnShake?.Invoke(maximumLength);
+        public override void Shake(double maximumLength) => OnShake?.Invoke(maximumLength);
 
-        private void updatePosition() => Position = HitObject.Position - slider.Position;
+        private void updatePosition()
+        {
+            if (Slider != null)
+                Position = HitObject.Position - Slider.Position;
+        }
     }
 }

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

@@ -0,0 +1,168 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Skinning.Default;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableSliderRepeat : DrawableOsuHitObject, ITrackSnaking, IHasMainCirclePiece
+    {
+        public new SliderRepeat HitObject => (SliderRepeat)base.HitObject;
+
+        [CanBeNull]
+        public Slider Slider => DrawableSlider?.HitObject;
+
+        public DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
+
+        private double animDuration;
+
+        public SkinnableDrawable CirclePiece { get; private set; }
+
+        public ReverseArrowPiece Arrow { get; private set; }
+
+        private Drawable scaleContainer;
+
+        public override bool DisplayResult => false;
+
+        public DrawableSliderRepeat()
+            : base(null)
+        {
+        }
+
+        public DrawableSliderRepeat(SliderRepeat sliderRepeat)
+            : base(sliderRepeat)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Origin = Anchor.Centre;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+
+            InternalChild = scaleContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Children = new Drawable[]
+                {
+                    // no default for this; only visible in legacy skins.
+                    CirclePiece = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderTailHitCircle), _ => Empty())
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                    Arrow = new ReverseArrowPiece(),
+                }
+            };
+
+            ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue));
+        }
+
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            Position = HitObject.Position - DrawableSlider.Position;
+        }
+
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
+        {
+            if (HitObject.StartTime <= Time.Current)
+                ApplyResult(r => r.Type = DrawableSlider.Tracking.Value ? r.Judgement.MaxResult : r.Judgement.MinResult);
+        }
+
+        protected override void UpdateInitialTransforms()
+        {
+            animDuration = Math.Min(300, HitObject.SpanDuration);
+
+            this.Animate(
+                d => d.FadeIn(animDuration),
+                d => d.ScaleTo(0.5f).ScaleTo(1f, animDuration * 2, Easing.OutElasticHalf)
+            );
+        }
+
+        protected override void UpdateHitStateTransforms(ArmedState state)
+        {
+            base.UpdateHitStateTransforms(state);
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    this.Delay(HitObject.TimePreempt).FadeOut();
+                    break;
+
+                case ArmedState.Miss:
+                    this.FadeOut(animDuration);
+                    break;
+
+                case ArmedState.Hit:
+                    this.FadeOut(animDuration, Easing.Out);
+
+                    const float final_scale = 1.5f;
+
+                    Arrow.ScaleTo(Scale * final_scale, animDuration, Easing.Out);
+                    CirclePiece.ScaleTo(Scale * final_scale, animDuration, Easing.Out);
+                    break;
+            }
+        }
+
+        private bool hasRotation;
+
+        public void UpdateSnakingPosition(Vector2 start, Vector2 end)
+        {
+            // When the repeat is hit, the arrow should fade out on spot rather than following the slider
+            if (IsHit) return;
+
+            bool isRepeatAtEnd = HitObject.RepeatIndex % 2 == 0;
+            List<Vector2> curve = ((PlaySliderBody)DrawableSlider.Body.Drawable).CurrentCurve;
+
+            Position = isRepeatAtEnd ? end : start;
+
+            if (curve.Count < 2)
+                return;
+
+            int searchStart = isRepeatAtEnd ? curve.Count - 1 : 0;
+            int direction = isRepeatAtEnd ? -1 : 1;
+
+            Vector2 aimRotationVector = Vector2.Zero;
+
+            // find the next vector2 in the curve which is not equal to our current position to infer a rotation.
+            for (int i = searchStart; i >= 0 && i < curve.Count; i += direction)
+            {
+                if (Precision.AlmostEquals(curve[i], Position))
+                    continue;
+
+                aimRotationVector = curve[i];
+                break;
+            }
+
+            float aimRotation = MathUtils.RadiansToDegrees(MathF.Atan2(aimRotationVector.Y - Position.Y, aimRotationVector.X - Position.X));
+            while (Math.Abs(aimRotation - Arrow.Rotation) > 180)
+                aimRotation += aimRotation < Arrow.Rotation ? 360 : -360;
+
+            // The clock may be paused in a scenario like the editor.
+            if (!hasRotation || !Clock.IsRunning)
+            {
+                Arrow.Rotation = aimRotation;
+                hasRotation = true;
+            }
+            else
+            {
+                // If we're already snaking, interpolate to smooth out sharp curves (linear sliders, mainly).
+                Arrow.Rotation = Interpolation.ValueAt(Math.Clamp(Clock.ElapsedFrameTime, 0, 100), Arrow.Rotation, aimRotation, 0, 50, Easing.OutQuint);
+            }
+        }
+    }
+}

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

@@ -1,53 +1,121 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Bindables;
+using System.Diagnostics;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Skinning.Default;
+using osu.Game.Skinning;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
-    public class DrawableSliderTail : DrawableOsuHitObject, IRequireTracking
+    public class DrawableSliderTail : DrawableOsuHitObject, IRequireTracking, IHasMainCirclePiece
     {
-        private readonly Slider slider;
+        public new SliderTailCircle HitObject => (SliderTailCircle)base.HitObject;
+
+        [CanBeNull]
+        public Slider Slider => DrawableSlider?.HitObject;
+
+        protected DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
 
         /// <summary>
         /// The judgement text is provided by the <see cref="DrawableSlider"/>.
         /// </summary>
         public override bool DisplayResult => false;
 
+        /// <summary>
+        /// Whether the hit samples only play on successful hits.
+        /// If <c>false</c>, the hit samples will also play on misses.
+        /// </summary>
+        public bool SamplePlaysOnlyOnHit { get; set; } = true;
+
         public bool Tracking { get; set; }
 
-        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
-        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
+        public SkinnableDrawable CirclePiece { get; private set; }
 
-        public DrawableSliderTail(Slider slider, SliderTailCircle hitCircle)
-            : base(hitCircle)
+        private Container scaleContainer;
+
+        public DrawableSliderTail()
+            : base(null)
         {
-            this.slider = slider;
+        }
 
+        public DrawableSliderTail(SliderTailCircle tailCircle)
+            : base(tailCircle)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
             Origin = Anchor.Centre;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
 
-            RelativeSizeAxes = Axes.Both;
-            FillMode = FillMode.Fit;
+            InternalChildren = new Drawable[]
+            {
+                scaleContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        // no default for this; only visible in legacy skins.
+                        CirclePiece = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderTailHitCircle), _ => Empty())
+                    }
+                },
+            };
 
-            AlwaysPresent = true;
+            ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue));
+        }
 
-            positionBindable.BindTo(hitCircle.PositionBindable);
-            pathBindable.BindTo(slider.PathBindable);
+        protected override void UpdateInitialTransforms()
+        {
+            base.UpdateInitialTransforms();
 
-            positionBindable.BindValueChanged(_ => updatePosition());
-            pathBindable.BindValueChanged(_ => updatePosition(), true);
+            CirclePiece.FadeInFromZero(HitObject.TimeFadeIn);
+        }
+
+        protected override void UpdateHitStateTransforms(ArmedState state)
+        {
+            base.UpdateHitStateTransforms(state);
+
+            Debug.Assert(HitObject.HitWindows != null);
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    this.Delay(HitObject.TimePreempt).FadeOut(500);
+                    break;
+
+                case ArmedState.Miss:
+                    this.FadeOut(100);
+                    break;
+
+                case ArmedState.Hit:
+                    // todo: temporary / arbitrary
+                    this.Delay(800).FadeOut();
+                    break;
+            }
         }
 
         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 : r.Judgement.MinResult);
         }
 
-        private void updatePosition() => Position = HitObject.Position - slider.Position;
+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            if (Slider != null)
+                Position = Slider.CurvePositionAt(HitObject.RepeatIndex % 2 == 0 ? 1 : 0);
+        }
     }
 }

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

@@ -2,13 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.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;
 
@@ -24,15 +22,27 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public override bool DisplayResult => false;
 
-        private readonly SkinnableDrawable scaleContainer;
+        protected DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
+
+        private SkinnableDrawable scaleContainer;
+
+        public DrawableSliderTick()
+            : base(null)
+        {
+        }
 
         public DrawableSliderTick(SliderTick sliderTick)
             : base(sliderTick)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
             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,
@@ -50,21 +60,21 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             };
+
+            ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue));
         }
 
-        private readonly IBindable<float> scaleBindable = new Bindable<float>();
-
-        [BackgroundDependencyLoader]
-        private void load()
+        protected override void OnApply()
         {
-            scaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
-            scaleBindable.BindTo(HitObject.ScaleBindable);
+            base.OnApply();
+
+            Position = HitObject.Position - DrawableSlider.HitObject.Position;
         }
 
         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 : r.Judgement.MinResult);
         }
 
         protected override void UpdateInitialTransforms()
@@ -73,8 +83,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             this.ScaleTo(0.5f).ScaleTo(1f, ANIM_DURATION * 4, Easing.OutElasticHalf);
         }
 
-        protected override void UpdateStateTransforms(ArmedState state)
+        protected override void UpdateHitStateTransforms(ArmedState state)
         {
+            base.UpdateHitStateTransforms(state);
+
             switch (state)
             {
                 case ArmedState.Idle: