Make catch HR properly utilise the RNG

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

@@ -10,6 +10,8 @@ using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects.Types;
 using osuTK;
 using osu.Game.Rulesets.Catch.MathUtils;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
@@ -26,7 +28,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
         {
             base.PostProcess();
 
-            applyPositionOffsets();
+            ApplyPositionOffsets(Beatmap);
 
             initialiseHyperDash((List<CatchHitObject>)Beatmap.HitObjects);
 
@@ -40,15 +42,23 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             }
         }
 
-        private void applyPositionOffsets()
+        public static void ApplyPositionOffsets(IBeatmap beatmap, params Mod[] mods)
         {
             var rng = new FastRandom(RNG_SEED);
-            // todo: HardRock displacement should be applied here
 
-            foreach (var obj in Beatmap.HitObjects)
+            bool shouldApplyHardRockOffset = mods.Any(m => m is ModHardRock);
+            float? lastPosition = null;
+            double lastStartTime = 0;
+
+            foreach (var obj in beatmap.HitObjects)
             {
                 switch (obj)
                 {
+                    case Fruit fruit:
+                        if (shouldApplyHardRockOffset)
+                            applyHardRockOffset(fruit, ref lastPosition, ref lastStartTime, rng);
+                        break;
+
                     case BananaShower bananaShower:
                         foreach (var banana in bananaShower.NestedHitObjects.OfType<Banana>())
                         {
@@ -76,6 +86,107 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             }
         }
 
+        private static void applyHardRockOffset(HitObject hitObject, ref float? lastPosition, ref double lastStartTime, FastRandom rng)
+        {
+            if (hitObject is JuiceStream stream)
+            {
+                lastPosition = stream.EndX;
+                lastStartTime = stream.EndTime;
+                return;
+            }
+
+            if (!(hitObject is Fruit))
+                return;
+
+            var catchObject = (CatchHitObject)hitObject;
+
+            float position = catchObject.X;
+            double startTime = hitObject.StartTime;
+
+            if (lastPosition == null)
+            {
+                lastPosition = position;
+                lastStartTime = startTime;
+
+                return;
+            }
+
+            float positionDiff = position - lastPosition.Value;
+            double timeDiff = startTime - lastStartTime;
+
+            if (timeDiff > 1000)
+            {
+                lastPosition = position;
+                lastStartTime = startTime;
+                return;
+            }
+
+            if (positionDiff == 0)
+            {
+                applyRandomOffset(ref position, timeDiff / 4d, rng);
+                catchObject.X = position;
+                return;
+            }
+
+            if (Math.Abs(positionDiff * CatchPlayfield.BASE_WIDTH) < timeDiff / 3d)
+                applyOffset(ref position, positionDiff);
+
+            catchObject.X = position;
+
+            lastPosition = position;
+            lastStartTime = startTime;
+        }
+
+        /// <summary>
+        /// Applies a random offset in a random direction to a position, ensuring that the final position remains within the boundary of the playfield.
+        /// </summary>
+        /// <param name="position">The position which the offset should be applied to.</param>
+        /// <param name="maxOffset">The maximum offset, cannot exceed 20px.</param>
+        /// <param name="rng">The random number generator.</param>
+        private static void applyRandomOffset(ref float position, double maxOffset, FastRandom rng)
+        {
+            bool right = rng.NextBool();
+            float rand = Math.Min(20, (float)rng.Next(0, Math.Max(0, maxOffset))) / CatchPlayfield.BASE_WIDTH;
+
+            if (right)
+            {
+                // Clamp to the right bound
+                if (position + rand <= 1)
+                    position += rand;
+                else
+                    position -= rand;
+            }
+            else
+            {
+                // Clamp to the left bound
+                if (position - rand >= 0)
+                    position -= rand;
+                else
+                    position += rand;
+            }
+        }
+
+        /// <summary>
+        /// Applies an offset to a position, ensuring that the final position remains within the boundary of the playfield.
+        /// </summary>
+        /// <param name="position">The position which the offset should be applied to.</param>
+        /// <param name="amount">The amount to offset by.</param>
+        private static void applyOffset(ref float position, float amount)
+        {
+            if (amount > 0)
+            {
+                // Clamp to the right bound
+                if (position + amount < 1)
+                    position += amount;
+            }
+            else
+            {
+                // Clamp to the left bound
+                if (position + amount > 0)
+                    position += amount;
+            }
+        }
+
         private void initialiseHyperDash(List<CatchHitObject> objects)
         {
             List<CatchHitObject> objectWithDroplets = new List<CatchHitObject>();