Merge pull request #27 from winnerspiros/autopilot-cursor-logic-improvement-10698393220144712166

Improve Autopilot cursor movement logic

Author: winnerspiros

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

@@ -10,9 +10,11 @@
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -43,12 +45,79 @@ public class OsuModAutopilot : Mod, IUpdatableByPlayfield, IApplicableToDrawable
 
         public void Update(Playfield playfield)
         {
-            if (currentFrame == replayFrames.Count - 1) return;
+            if (replayFrames.Count == 0 || currentFrame == replayFrames.Count - 1) return;
 
             double time = playfield.Clock.CurrentTime;
 
-            // Very naive implementation of autopilot based on proximity to replay frames.
+            // Interpolate the cursor position using the replay frames.
             // Special case for the first frame is required to ensure the mouse is in a sane position until the actual time of the first frame is hit.
+            while (currentFrame > 0 && Math.Abs(replayFrames[currentFrame - 1].Time - time) <= Math.Abs(replayFrames[currentFrame].Time - time))
+            {
+                currentFrame--;
+            }
+
+            while (currentFrame < replayFrames.Count - 1 && Math.Abs(replayFrames[currentFrame + 1].Time - time) <= Math.Abs(replayFrames[currentFrame < 0 ? 0 : currentFrame].Time - time))
+            {
+                currentFrame++;
+            }
+
+            if (currentFrame < 0)
+                return;
+
+            Vector2 newPosition = playfield.ToScreenSpace(replayFrames[currentFrame].Position);
+
+            var osuPlayfield = (OsuPlayfield)playfield;
+
+            DrawableOsuHitObject? nextObject = null;
+
+            foreach (var h in osuPlayfield.HitObjectContainer.AliveObjects)
+            {
+                if (h is not DrawableOsuHitObject osuHitObject || osuHitObject.Result.HasResult)
+                    continue;
+
+                if (nextObject == null || osuHitObject.HitObject.StartTime < nextObject.HitObject.StartTime)
+                {
+                    nextObject = osuHitObject;
+                }
+            }
+
+            if (nextObject != null)
+            {
+                // If we are currently "on" an object (in terms of time), we should check if it has been judged.
+                // If it hasn't been judged, and we are still within the valid hit window, maybe we should clamp the cursor position to that object's position, effectively "pausing" the cursor movement along the path until the user clicks or it's too late.
+
+                bool shouldStay = false;
+                Vector2 stayPosition = Vector2.Zero;
+
+                if (nextObject is DrawableSlider slider)
+                {
+                    if (!slider.HeadCircle.Result.HasResult)
+                    {
+                        if (time >= slider.HitObject.StartTime)
+                        {
+                            shouldStay = true;
+                            stayPosition = slider.HitObject.StackedPosition;
+                        }
+                    }
+                }
+                else if (nextObject is DrawableHitCircle hitCircle)
+                {
+                    if (time >= hitCircle.HitObject.StartTime)
+                    {
+                        shouldStay = true;
+                        stayPosition = hitCircle.HitObject.StackedPosition;
+                    }
+                }
+
+                if (shouldStay)
+                {
+                    newPosition = playfield.ToScreenSpace(stayPosition);
+                }
+            }
+
+            new MousePositionAbsoluteInput { Position = newPosition }.Apply(inputManager.CurrentState, inputManager);
+
+            // TODO: Implement the functionality to automatically spin spinners
             // TODO: this needs to be based on user interactions to better match stable (pausing until judgement is registered).
             while (currentFrame < replayFrames.Count - 1)
             {
@@ -74,6 +143,7 @@ public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset
 
             // Generate the replay frames the cursor should follow
             replayFrames = new OsuAutoGenerator(drawableRuleset.Beatmap, drawableRuleset.Mods).Generate().Frames.Cast<OsuReplayFrame>().ToList();
+            currentFrame = -1;
         }
     }
 }

osu.Game/Database/BackgroundDataStoreProcessor.cs

@@ -96,7 +96,7 @@ protected override void LoadComplete()
                 convertLegacyTotalScoreToStandardised();
                 upgradeScoreRanks();
                 backpopulateMissingSubmissionAndRankDates();
-                backpopulateUserTags();
+                BackpopulateUserTags();
             }, TaskCreationOptions.LongRunning).ContinueWith(t =>
             {
                 if (t.Exception?.InnerException is ObjectDisposedException)