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>();

osu.Game.Rulesets.Catch/MathUtils/FastRandom.cs

@@ -61,6 +61,14 @@ namespace osu.Game.Rulesets.Catch.MathUtils
         /// <returns>The random value.</returns>
         public int Next(int lowerBound, int upperBound) => (int)(lowerBound + NextDouble() * (upperBound - lowerBound));
 
+        /// <summary>
+        /// Generates a random integer value within the range [<paramref name="lowerBound"/>, <paramref name="upperBound"/>).
+        /// </summary>
+        /// <param name="lowerBound">The lower bound of the range.</param>
+        /// <param name="upperBound">The upper bound of the range.</param>
+        /// <returns>The random value.</returns>
+        public int Next(double lowerBound, double upperBound) => (int)(lowerBound + NextDouble() * (upperBound - lowerBound));
+
         /// <summary>
         /// Generates a random double value within the range [0, 1).
         /// </summary>

osu.Game.Rulesets.Catch/Mods/CatchModHardRock.cs

@@ -1,121 +1,17 @@
 // 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.MathUtils;
-using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
-using System;
+using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Catch.Beatmaps;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModHardRock : ModHardRock, IApplicableToHitObject
+    public class CatchModHardRock : ModHardRock, IApplicableToBeatmap
     {
         public override double ScoreMultiplier => 1.12;
         public override bool Ranked => true;
 
-        private float? lastPosition;
+        public void ApplyToBeatmap(IBeatmap beatmap) => CatchBeatmapProcessor.ApplyPositionOffsets(beatmap, this);
-        private double lastStartTime;
-
-        public void ApplyToHitObject(HitObject hitObject)
-        {
-            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);
-                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>
-        private void applyRandomOffset(ref float position, double maxOffset)
-        {
-            bool right = RNG.NextBool();
-            float rand = Math.Min(20, (float)RNG.NextDouble(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 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;
-            }
-        }
     }
 }