Merge pull request #18607 from ggliv/osu-mod-repel

Add repel mod to the osu ruleset

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModRepel.cs

@@ -0,0 +1,27 @@
+// 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 NUnit.Framework;
+using osu.Game.Rulesets.Osu.Mods;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModRepel : OsuModTestScene
+    {
+        [TestCase(0.1f)]
+        [TestCase(0.5f)]
+        [TestCase(1)]
+        public void TestRepel(float strength)
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new OsuModRepel
+                {
+                    RepulsionStrength = { Value = strength },
+                },
+                PassCondition = () => true,
+                Autoplay = false,
+            });
+        }
+    }
+}

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         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(ModFailCondition), typeof(ModNoFail), typeof(ModAutoplay), typeof(OsuModMagnetised) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModSpunOut), typeof(ModRelax), typeof(ModFailCondition), typeof(ModNoFail), typeof(ModAutoplay), typeof(OsuModMagnetised), typeof(OsuModRepel) };
 
         public bool PerformFail() => false;
 

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

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModAutoplay : ModAutoplay
     {
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModMagnetised), typeof(OsuModAutopilot), typeof(OsuModSpunOut), typeof(OsuModAlternate) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModAutopilot), typeof(OsuModSpunOut), typeof(OsuModAlternate) }).ToArray();
 
         public override ModReplayData CreateReplayData(IBeatmap beatmap, IReadOnlyList<Mod> mods)
             => new ModReplayData(new OsuAutoGenerator(beatmap, mods).Generate(), new ModCreatedUser { Username = "Autoplay" });

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override string Description => "No need to chase the circles – your cursor is a magnet!";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel) };
 
         private IFrameStableClock gameplayClock;
 

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

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     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.Concat(new[] { typeof(OsuModAutopilot), typeof(OsuModMagnetised), typeof(OsuModAlternate) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAutopilot), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModAlternate) }).ToArray();
 
         /// <summary>
         /// How early before a hitobject's start time to trigger a hit.

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

@@ -0,0 +1,98 @@
+// 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.Diagnostics;
+using osu.Framework.Bindables;
+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.Osu.UI;
+using osu.Game.Rulesets.Osu.Utils;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    internal class OsuModRepel : Mod, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
+    {
+        public override string Name => "Repel";
+        public override string Acronym => "RP";
+        public override ModType Type => ModType.Fun;
+        public override string Description => "Hit objects run away!";
+        public override double ScoreMultiplier => 1;
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModMagnetised) };
+
+        private IFrameStableClock? gameplayClock;
+
+        [SettingSource("Repulsion strength", "How strong the repulsion is.", 0)]
+        public BindableFloat RepulsionStrength { get; } = new BindableFloat(0.5f)
+        {
+            Precision = 0.05f,
+            MinValue = 0.05f,
+            MaxValue = 1.0f,
+        };
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            gameplayClock = drawableRuleset.FrameStableClock;
+
+            // Hide judgment displays and follow points as they won't make any sense.
+            // Judgements can potentially be turned on in a future where they display at a position relative to their drawable counterpart.
+            drawableRuleset.Playfield.DisplayJudgements.Value = false;
+            (drawableRuleset.Playfield as OsuPlayfield)?.FollowPoints.Hide();
+        }
+
+        public void Update(Playfield playfield)
+        {
+            var cursorPos = playfield.Cursor.ActiveCursor.DrawPosition;
+
+            foreach (var drawable in playfield.HitObjectContainer.AliveObjects)
+            {
+                var destination = Vector2.Clamp(2 * drawable.Position - cursorPos, Vector2.Zero, OsuPlayfield.BASE_SIZE);
+
+                if (drawable.HitObject is Slider thisSlider)
+                {
+                    var possibleMovementBounds = OsuHitObjectGenerationUtils.CalculatePossibleMovementBounds(thisSlider);
+
+                    destination = Vector2.Clamp(
+                        destination,
+                        new Vector2(possibleMovementBounds.Left, possibleMovementBounds.Top),
+                        new Vector2(possibleMovementBounds.Right, possibleMovementBounds.Bottom)
+                    );
+                }
+
+                switch (drawable)
+                {
+                    case DrawableHitCircle circle:
+                        easeTo(circle, destination, cursorPos);
+                        break;
+
+                    case DrawableSlider slider:
+
+                        if (!slider.HeadCircle.Result.HasResult)
+                            easeTo(slider, destination, cursorPos);
+                        else
+                            easeTo(slider, destination - slider.Ball.DrawPosition, cursorPos);
+
+                        break;
+                }
+            }
+        }
+
+        private void easeTo(DrawableHitObject hitObject, Vector2 destination, Vector2 cursorPos)
+        {
+            Debug.Assert(gameplayClock != null);
+
+            double dampLength = Vector2.Distance(hitObject.Position, cursorPos) / (0.04 * RepulsionStrength.Value + 0.04);
+
+            float x = (float)Interpolation.DampContinuously(hitObject.X, destination.X, dampLength, gameplayClock.ElapsedFrameTime);
+            float y = (float)Interpolation.DampContinuously(hitObject.Y, destination.Y, dampLength, gameplayClock.ElapsedFrameTime);
+
+            hitObject.Position = new Vector2(x, y);
+        }
+    }
+}

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override string Description => "Everything rotates. EVERYTHING.";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModWiggle), typeof(OsuModMagnetised) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModWiggle), typeof(OsuModMagnetised), typeof(OsuModRepel) };
 
         private float theta;
 

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override string Description => "They just won't stay still...";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform), typeof(OsuModMagnetised) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform), typeof(OsuModMagnetised), typeof(OsuModRepel) };
 
         private const int wiggle_duration = 90; // (ms) Higher = fewer wiggles
         private const int wiggle_strength = 10; // Higher = stronger wiggles

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -197,7 +197,7 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModApproachDifferent(),
                         new OsuModMuted(),
                         new OsuModNoScope(),
-                        new OsuModMagnetised(),
+                        new MultiMod(new OsuModMagnetised(), new OsuModRepel()),
                         new ModAdaptiveSpeed()
                     };
 

osu.Game.Rulesets.Osu/Utils/OsuHitObjectGenerationUtils_Reposition.cs

@@ -194,7 +194,7 @@ namespace osu.Game.Rulesets.Osu.Utils
         private static Vector2 clampSliderToPlayfield(WorkingObject workingObject)
         {
             var slider = (Slider)workingObject.HitObject;
-            var possibleMovementBounds = calculatePossibleMovementBounds(slider);
+            var possibleMovementBounds = CalculatePossibleMovementBounds(slider);
 
             // The slider rotation applied in computeModifiedPosition might make it impossible to fit the slider into the playfield
             // For example, a long horizontal slider will be off-screen when rotated by 90 degrees
@@ -214,7 +214,7 @@ namespace osu.Game.Rulesets.Osu.Utils
                     RotateSlider(slider, workingObject.RotationOriginal + MathF.PI - getSliderRotation(slider));
                 }
 
-                possibleMovementBounds = calculatePossibleMovementBounds(slider);
+                possibleMovementBounds = CalculatePossibleMovementBounds(slider);
             }
 
             var previousPosition = workingObject.PositionModified;
@@ -260,10 +260,12 @@ namespace osu.Game.Rulesets.Osu.Utils
         /// 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>
+        /// <param name="slider">The <see cref="Slider"/> for which to calculate a movement bounding box.</param>
+        /// <returns>A <see cref="RectangleF"/> which contains all of the possible movements of the slider such that the entire slider is inside the playfield.</returns>
         /// <remarks>
         /// If the slider is larger than the playfield, the returned <see cref="RectangleF"/> may have negative width/height.
         /// </remarks>
-        private static RectangleF calculatePossibleMovementBounds(Slider slider)
+        public static RectangleF CalculatePossibleMovementBounds(Slider slider)
         {
             var pathPositions = new List<Vector2>();
             slider.Path.GetPathToProgress(pathPositions, 0, 1);