Use new mod-related object types for Strict Tracking

osu.Game.Rulesets.Osu/Mods/Objects/StrictTrackingDrawableSliderTail.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.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Mods.Objects
+{
+    public class StrictTrackingDrawableSliderTail : DrawableSliderTail
+    {
+        public override bool DisplayResult => true;
+    }
+}

osu.Game.Rulesets.Osu/Mods/Objects/StrictTrackingSlider.cs

@@ -0,0 +1,70 @@
+// 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.Threading;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Mods.Objects
+{
+    public class StrictTrackingSlider : Slider
+    {
+        public StrictTrackingSlider(Slider original)
+        {
+            StartTime = original.StartTime;
+            Samples = original.Samples;
+            Path = original.Path;
+            NodeSamples = original.NodeSamples;
+            RepeatCount = original.RepeatCount;
+            Position = original.Position;
+            NewCombo = original.NewCombo;
+            ComboOffset = original.ComboOffset;
+            LegacyLastTickOffset = original.LegacyLastTickOffset;
+            TickDistanceMultiplier = original.TickDistanceMultiplier;
+        }
+
+        protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
+        {
+            var sliderEvents = SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken);
+
+            foreach (var e in sliderEvents)
+            {
+                switch (e.Type)
+                {
+                    case SliderEventType.Head:
+                        AddNested(HeadCircle = new SliderHeadCircle
+                        {
+                            StartTime = e.Time,
+                            Position = Position,
+                            StackHeight = StackHeight,
+                        });
+                        break;
+
+                    case SliderEventType.LegacyLastTick:
+                        AddNested(TailCircle = new StrictTrackingSliderTailCircle(this)
+                        {
+                            RepeatIndex = e.SpanIndex,
+                            StartTime = e.Time,
+                            Position = EndPosition,
+                            StackHeight = StackHeight
+                        });
+                        break;
+
+                    case SliderEventType.Repeat:
+                        AddNested(new SliderRepeat(this)
+                        {
+                            RepeatIndex = e.SpanIndex,
+                            StartTime = StartTime + (e.SpanIndex + 1) * SpanDuration,
+                            Position = Position + Path.PositionAt(e.PathProgress),
+                            StackHeight = StackHeight,
+                            Scale = Scale,
+                        });
+                        break;
+                }
+            }
+
+            UpdateNestedSamples();
+        }
+    }
+}

osu.Game.Rulesets.Osu/Mods/Objects/StrictTrackingSliderTailCircle.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Mods.Objects
+{
+    public class StrictTrackingSliderTailCircle : SliderTailCircle
+    {
+        public StrictTrackingSliderTailCircle(Slider slider)
+            : base(slider)
+        {
+        }
+
+        public override Judgement CreateJudgement() => new OsuJudgement();
+    }
+}

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

@@ -2,17 +2,20 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using osu.Framework.Graphics.Sprites;
 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.Beatmaps;
+using osu.Game.Rulesets.Osu.Mods.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModStrictTracking : Mod, IApplicableToDifficulty, IApplicableToDrawableHitObject, IApplicableToHitObject
+    public class OsuModStrictTracking : Mod, IApplicableAfterBeatmapConversion, IApplicableToDrawableHitObject, IApplicableToDrawableRuleset<OsuHitObject>
     {
         public override string Name => @"Strict Tracking";
         public override string Acronym => @"ST";
@@ -22,11 +25,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override double ScoreMultiplier => 1.0;
         public override Type[] IncompatibleMods => new[] { typeof(ModClassic) };
 
-        public void ApplyToDifficulty(BeatmapDifficulty difficulty)
-        {
-            difficulty.SliderTickRate = 0.0;
-        }
-
         public void ApplyToDrawableHitObject(DrawableHitObject drawable)
         {
             if (drawable is DrawableSlider slider)
@@ -46,14 +44,30 @@ namespace osu.Game.Rulesets.Osu.Mods
             }
         }
 
-        public void ApplyToHitObject(HitObject hitObject)
+        public void ApplyToBeatmap(IBeatmap beatmap)
         {
-            switch (hitObject)
+            var osuBeatmap = (OsuBeatmap)beatmap;
+
+            if (osuBeatmap.HitObjects.Count == 0) return;
+
+            var hitObjects = osuBeatmap.HitObjects.Select(ho =>
             {
-                case Slider slider:
+                if (ho is Slider slider)
-                    slider.TailCircle.JudgeAsSliderTick = true;
+                {
-                    break;
+                    var newSlider = new StrictTrackingSlider(slider);
-            }
+                    return newSlider;
+                }
+
+                return ho;
+            }).ToList();
+
+            osuBeatmap.HitObjects = hitObjects;
+        }
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            drawableRuleset.Playfield.RegisterPool<StrictTrackingSlider, DrawableSlider>(10, 100);
+            drawableRuleset.Playfield.RegisterPool<StrictTrackingSliderTailCircle, StrictTrackingDrawableSliderTail>(10, 100);
         }
     }
 }

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

@@ -137,7 +137,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public Slider()
         {
-            SamplesBindable.CollectionChanged += (_, __) => updateNestedSamples();
+            SamplesBindable.CollectionChanged += (_, __) => UpdateNestedSamples();
             Path.Version.ValueChanged += _ => updateNestedPositions();
         }
 
@@ -210,7 +210,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                 }
             }
 
-            updateNestedSamples();
+            UpdateNestedSamples();
         }
 
         private void updateNestedPositions()
@@ -224,7 +224,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                 TailCircle.Position = EndPosition;
         }
 
-        private void updateNestedSamples()
+        protected void UpdateNestedSamples()
         {
             var firstSample = Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_NORMAL)
                               ?? Samples.FirstOrDefault(); // TODO: remove this when guaranteed sort is present for samples (https://github.com/ppy/osu/issues/1933)

osu.Game/Rulesets/UI/Playfield.cs

@@ -308,7 +308,7 @@ namespace osu.Game.Rulesets.UI
         /// </param>
         /// <typeparam name="TObject">The <see cref="HitObject"/> type.</typeparam>
         /// <typeparam name="TDrawable">The <see cref="DrawableHitObject"/> receiver for <typeparamref name="TObject"/>s.</typeparam>
-        protected void RegisterPool<TObject, TDrawable>(int initialSize, int? maximumSize = null)
+        public void RegisterPool<TObject, TDrawable>(int initialSize, int? maximumSize = null)
             where TObject : HitObject
             where TDrawable : DrawableHitObject, new()
             => RegisterPool<TObject, TDrawable>(new DrawablePool<TDrawable>(initialSize, maximumSize));