Add proper flow aim evaluator

Author: Givikap120

osu.Game.Rulesets.Osu/Difficulty/Evaluators/Aim/AgilityEvaluator.cs

@@ -33,7 +33,7 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
 
             strain *= highBpmBonus(osuCurrObj.AdjustedDeltaTime);
 
-            return strain * DifficultyCalculationUtils.Smootherstep(distance, 0, OsuDifficultyHitObject.NORMALISED_RADIUS);
+            return strain;
         }
 
         private static double highBpmBonus(double ms) => 1 / (1 - Math.Pow(0.3, Math.Pow(ms / 1000, 0.9)));

osu.Game.Rulesets.Osu/Difficulty/Evaluators/Aim/FlowAimEvaluator.cs

@@ -12,87 +12,61 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators.Aim
 {
     public static class FlowAimEvaluator
     {
-        private const double velocity_change_multiplier = 2.0;
+        private const int radius = OsuDifficultyHitObject.NORMALISED_RADIUS;
+        private const int diameter = OsuDifficultyHitObject.NORMALISED_DIAMETER;
 
         /// <summary>
         /// Evaluates difficulty of "flow aim" - aiming pattern where player doesn't stop their cursor on every object and instead "flows" through them.
         /// </summary>
         public static double EvaluateDifficultyOf(DifficultyHitObject current, bool withSliderTravelDistance)
         {
+            const double flow_multiplier = 0.95;
+
             if (current.BaseObject is Spinner || current.Index <= 1 || current.Previous(0).BaseObject is Spinner)
                 return 0;
 
             var osuCurrObj = (OsuDifficultyHitObject)current;
-            var osuLastObj = (OsuDifficultyHitObject)current.Previous(0);
-            var osuLastLastObj = (OsuDifficultyHitObject)current.Previous(1);
-
-            double currDistance = withSliderTravelDistance ? osuCurrObj.LazyJumpDistance : osuCurrObj.JumpDistance;
-            double prevDistance = withSliderTravelDistance ? osuLastObj.LazyJumpDistance : osuLastObj.JumpDistance;
-
-            double currVelocity = currDistance / osuCurrObj.AdjustedDeltaTime;
-
-            if (osuLastObj.BaseObject is Slider && withSliderTravelDistance)
-            {
-                // If the last object is a slider, then we extend the travel velocity through the slider into the current object.
-                double sliderDistance = osuLastObj.LazyTravelDistance + osuCurrObj.LazyJumpDistance;
-                currVelocity = Math.Max(currVelocity, sliderDistance / osuCurrObj.AdjustedDeltaTime);
-            }
-
-            double prevVelocity = prevDistance / osuLastObj.AdjustedDeltaTime;
+            var osuLast0Obj = (OsuDifficultyHitObject)current.Previous(0);
+            var osuLast1Obj = (OsuDifficultyHitObject)current.Previous(1);
 
-            double flowDifficulty = currVelocity;
-
-            // Apply high circle size bonus to the base velocity
-            flowDifficulty *= osuCurrObj.SmallCircleBonus;
-
-            // Rhythm changes are harder to flow
-            flowDifficulty *= 1 + Math.Min(0.25,
-                Math.Pow((Math.Max(osuCurrObj.AdjustedDeltaTime, osuLastObj.AdjustedDeltaTime) - Math.Min(osuCurrObj.AdjustedDeltaTime, osuLastObj.AdjustedDeltaTime)) / 50, 4));
+            double distance = withSliderTravelDistance ? osuCurrObj.LazyJumpDistance : osuCurrObj.JumpDistance;
+            double flowDifficulty = distance / osuCurrObj.AdjustedDeltaTime;
 
             if (osuCurrObj.AngularVelocity != null)
             {
                 // Low angular velocity flow (angles are consistent) is easier to follow than erratic flow
                 flowDifficulty *= 0.8 + Math.Sqrt(osuCurrObj.AngularVelocity.Value / 270.0);
             }
 
-            // If all three notes are overlapping - don't reward bonuses as you don't have to do additional movement
-            double overlappedNotesWeight = 1;
+            double angleBonus = 0;
 
-            if (current.Index > 2)
+            if (osuCurrObj.AngleSigned != null && osuLast0Obj.AngleSigned != null && osuLast1Obj.AngleSigned != null)
             {
-                double o1 = calculateOverlapFactor(osuCurrObj, osuLastObj);
-                double o2 = calculateOverlapFactor(osuCurrObj, osuLastLastObj);
-                double o3 = calculateOverlapFactor(osuLastObj, osuLastLastObj);
+                double acuteAngleBonus = CalculateFlowAcuteAngleBonus(current);
+                double angleChangeBonus = CalculateFlowAngleChangeBonus(current);
 
-                overlappedNotesWeight = 1 - o1 * o2 * o3;
-            }
+                // If all three notes are overlapping - don't reward angle bonuses as you don't have to do additional movement
+                double overlappedNotesWeight = 1;
 
-            if (osuCurrObj.Angle != null && osuLastObj.Angle != null)
-            {
-                // Acute angles are also hard to flow
-                // We square root velocity to make acute angle switches in streams aren't having difficulty higher than snap
-                flowDifficulty += Math.Sqrt(currVelocity) *
-                                  SnapAimEvaluator.CalcAcuteAngleBonus(osuCurrObj.Angle.Value) *
-                                  overlappedNotesWeight;
-            }
-
-            if (Math.Max(prevVelocity, currVelocity) != 0)
-            {
-                if (withSliderTravelDistance)
+                if (current.Index > 2)
                 {
-                    currVelocity = currDistance / osuCurrObj.AdjustedDeltaTime;
-                    prevVelocity = prevDistance / osuLastObj.AdjustedDeltaTime;
+                    double o1 = calculateOverlapFactor(osuCurrObj, osuLast0Obj);
+                    double o2 = calculateOverlapFactor(osuCurrObj, osuLast1Obj);
+                    double o3 = calculateOverlapFactor(osuLast0Obj, osuLast1Obj);
+
+                    overlappedNotesWeight = 1 - o1 * o2 * o3;
                 }
 
-                // Scale with ratio of difference compared to 0.5 * max dist.
-                double distRatio = DifficultyCalculationUtils.Smoothstep(Math.Abs(prevVelocity - currVelocity) / Math.Max(prevVelocity, currVelocity), 0, 1);
+                angleBonus = Math.Max(acuteAngleBonus, angleChangeBonus) * overlappedNotesWeight;
+            }
 
-                // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
-                double overlapVelocityBuff = Math.Min(OsuDifficultyHitObject.NORMALISED_DIAMETER * 1.25 / Math.Min(osuCurrObj.AdjustedDeltaTime, osuLastObj.AdjustedDeltaTime),
-                    Math.Abs(prevVelocity - currVelocity));
+            // Add all bonuses
+            flowDifficulty += angleBonus;
 
-                flowDifficulty += overlapVelocityBuff * distRatio * velocity_change_multiplier;
-            }
+            // Apply high circle size bonus to the base velocity
+            flowDifficulty *= osuCurrObj.SmallCircleBonus;
+
+            flowDifficulty *= flow_multiplier;
 
             if (osuCurrObj.BaseObject is Slider)
             {
@@ -113,5 +87,62 @@ private static double calculateOverlapFactor(OsuDifficultyHitObject first, OsuDi
             double distance = Vector2.Distance(firstBase.StackedPosition, secondBase.StackedPosition);
             return Math.Clamp(1 - Math.Pow(Math.Max(distance - objectRadius, 0) / objectRadius, 2), 0, 1);
         }
+
+        // This bonus accounts for the fact that flow is circular movement, therefore flowing on sharp angles is harder.
+        public static double CalculateFlowAcuteAngleBonus(DifficultyHitObject current)
+        {
+            const double acute_angle_bonus_multiplier = 1.05;
+
+            if (current.BaseObject is Spinner || current.Index <= 1 || current.Previous(0).BaseObject is Spinner)
+                return 0;
+
+            var osuCurrObj = (OsuDifficultyHitObject)current;
+
+            if (osuCurrObj.Angle == null)
+                return 0;
+
+            double currAngle = (double)osuCurrObj.Angle;
+
+            double bonusBase = osuCurrObj.JumpDistance / osuCurrObj.AdjustedDeltaTime;
+
+            double acuteAngleBonus = bonusBase * SnapAimEvaluator.CalcAcuteAngleBonus(currAngle);
+
+            // If spacing is too low - decrease reward
+            acuteAngleBonus *= DifficultyCalculationUtils.ReverseLerp(osuCurrObj.JumpDistance, radius, diameter);
+
+            return acuteAngleBonus * acute_angle_bonus_multiplier;
+        }
+
+        // This bonus accounts for flow aim being harder when angle is changing.
+        public static double CalculateFlowAngleChangeBonus(DifficultyHitObject current)
+        {
+            const double angle_change_bonus_multiplier = 1.0;
+
+            if (current.BaseObject is Spinner || current.Index <= 1 || current.Previous(0).BaseObject is Spinner)
+                return 0;
+
+            var osuCurrObj = (OsuDifficultyHitObject)current;
+            var osuLast0Obj = (OsuDifficultyHitObject)current.Previous(0);
+            var osuLast1Obj = (OsuDifficultyHitObject)current.Previous(1);
+
+            if (osuCurrObj.AngleSigned == null || osuLast0Obj.AngleSigned == null)
+                return 0;
+
+            double currAngle = osuCurrObj.AngleSigned.Value;
+            double lastAngle = osuLast0Obj.AngleSigned.Value;
+
+            // Take min velocity to avoid abuse with very small spacing
+            double currVelocity = osuCurrObj.JumpDistance / osuCurrObj.AdjustedDeltaTime;
+            double prevVelocity = osuLast0Obj.JumpDistance / osuLast0Obj.AdjustedDeltaTime;
+
+            double bonusBase = Math.Min(currVelocity, prevVelocity);
+
+            double angleChangeBonus = Math.Pow(Math.Sin((currAngle - lastAngle) / 2), 2) * bonusBase;
+
+            // Take the largest of last 3 distances and if it's too small - decrease flow angle change bonus, because it's cheesable
+            angleChangeBonus *= DifficultyCalculationUtils.ReverseLerp(Math.Max(osuCurrObj.JumpDistance, osuLast1Obj.JumpDistance), 0, diameter);
+
+            return angleChangeBonus * angle_change_bonus_multiplier;
+        }
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Evaluators/Aim/SnapAimEvaluator.cs

@@ -173,11 +173,7 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current, bool with
             return aimStrain;
         }
 
-        // We decrease strain for distances <radius to fix cases where doubles with no aim requirement
-        // have their strain buffed incredibly high due to the delta time.
-        // These objects do not require any movement, so it does not make sense to award them.
-        private static double highBpmBonus(double ms, double distance) => 1 / (1 - Math.Pow(0.03, Math.Pow(ms / 1000, 0.65)))
-                                                                          * DifficultyCalculationUtils.Smootherstep(distance, 0, OsuDifficultyHitObject.NORMALISED_RADIUS);
+        private static double highBpmBonus(double ms, double distance) => 1 / (1 - Math.Pow(0.03, Math.Pow(ms / 1000, 0.65)));
 
         private static double vectorAngleRepetition(OsuDifficultyHitObject current, OsuDifficultyHitObject previous)
         {

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -116,6 +116,8 @@ public class OsuDifficultyHitObject : DifficultyHitObject
         /// </summary>
         public double? Angle { get; private set; }
 
+        public double? AngleSigned { get; private set; }
+        
         public double? AngularVelocity { get; private set; }
 
         /// <summary>
@@ -270,7 +272,8 @@ private void setDistances(double clockRate)
                 Vector2 v = BaseObject.StackedPosition - lastCursorPosition;
                 NormalisedVectorAngle = Math.Atan2(Math.Abs(v.Y), Math.Abs(v.X));
 
-                Angle = Math.Min(angle, sliderAngle);
+                AngleSigned = Math.Abs(angle) <= Math.Abs(sliderAngle) ? angle : sliderAngle;
+                Angle = Math.Abs((double)AngleSigned);
 
                 if (lastLastDifficultyObject.Angle != null)
                 {
@@ -410,7 +413,7 @@ private double calculateAngle(Vector2 currentPosition, Vector2 lastPosition, Vec
             float dot = Vector2.Dot(v1, v2);
             float det = v1.X * v2.Y - v1.Y * v2.X;
 
-            return Math.Abs(Math.Atan2(det, dot));
+            return Math.Atan2(det, dot);
         }
 
         private Vector2 getEndCursorPosition(OsuDifficultyHitObject difficultyHitObject)