Move all standard multipliers to evaluators

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

@@ -10,6 +10,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators.Aim
 {
     public static class AgilityEvaluator
     {
+        private static double multiplier => 0.58 * Skills.Aim.SkillMultiplierTotal;
+
         private const double distance_cap = OsuDifficultyHitObject.NORMALISED_DIAMETER * 1.2; // 1.25 circles distance between centers
 
         /// <summary>
@@ -28,13 +30,13 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
 
             double distanceScaled = Math.Min(distance, distance_cap) / distance_cap;
 
-            double strain = distanceScaled * 1000 / osuCurrObj.AdjustedDeltaTime;
+            double strain = distanceScaled * 10 / osuCurrObj.AdjustedDeltaTime;
 
             strain *= Math.Pow(osuCurrObj.SmallCircleBonus, 1.5);
 
             strain *= highBpmBonus(osuCurrObj.AdjustedDeltaTime);
 
-            return strain;
+            return strain * multiplier;
         }
 
         private static double highBpmBonus(double ms) => 1 / (1 - Math.Pow(0.2, ms / 1000));

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

@@ -12,6 +12,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators.Aim
 {
     public static class FlowAimEvaluator
     {
+        private static double multiplier => 0.60 * Skills.Aim.SkillMultiplierTotal;
+
         private const double velocity_change_multiplier = 0.52;
 
         /// <summary>
@@ -111,7 +113,9 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current, bool with
             flowDifficulty = Math.Pow(flowDifficulty, 1.45);
 
             // Reduce difficulty for low spacing since spacing below radius is always to be flowed
-            return flowDifficulty * DifficultyCalculationUtils.Smootherstep(currDistance, 0, OsuDifficultyHitObject.NORMALISED_RADIUS);
+            flowDifficulty *= DifficultyCalculationUtils.Smootherstep(currDistance, 0, OsuDifficultyHitObject.NORMALISED_RADIUS);
+
+            return flowDifficulty * multiplier;
         }
 
         private static double calculateOverlapFactor(OsuDifficultyHitObject first, OsuDifficultyHitObject second)

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

@@ -12,6 +12,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators.Aim
 {
     public static class SnapAimEvaluator
     {
+        private static double multiplier => 0.175 * Skills.Aim.SkillMultiplierTotal;
+
         private const double wide_angle_multiplier = 9.67;
         private const double acute_angle_multiplier = 2.41;
         private const double slider_multiplier = 1.5;
@@ -165,7 +167,7 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current, bool with
 
             aimStrain *= highBpmBonus(osuCurrObj.AdjustedDeltaTime);
 
-            return aimStrain;
+            return aimStrain * multiplier;
         }
 
         private static double highBpmBonus(double ms) => 1 / (1 - Math.Pow(0.03, Math.Pow(ms / 1000, 0.65)));

osu.Game.Rulesets.Osu/Difficulty/Evaluators/FlashlightEvaluator.cs

@@ -14,6 +14,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 {
     public static class FlashlightEvaluator
     {
+        private static double multiplier => 0.000255;
+
         private const double max_opacity_bonus = 0.4;
         private const double hidden_bonus = 0.2;
 
@@ -114,7 +116,7 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current, IReadOnly
 
             result += sliderBonus * slider_multiplier;
 
-            return result;
+            return result * multiplier;
         }
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Evaluators/ReadingEvaluator.cs

@@ -13,6 +13,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 {
     public static class ReadingEvaluator
     {
+        private static double multiplier => 0.0114;
+
         private const double reading_window_size = 3000; // 3 seconds
         private const double distance_influence_threshold = OsuDifficultyHitObject.NORMALISED_DIAMETER * 1.5; // 1.5 circles distance between centers
         private const double hidden_multiplier = 0.28;
@@ -51,7 +53,7 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current, bool hidd
             // Having less time to process information is harder
             difficulty *= highBpmBonus(currObj.AdjustedDeltaTime);
 
-            return difficulty;
+            return difficulty * multiplier;
         }
 
         /// <summary>

osu.Game.Rulesets.Osu/Difficulty/Evaluators/Speed/SpeedEvaluator.cs

@@ -12,6 +12,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators.Speed
 {
     public static class SpeedEvaluator
     {
+        private static double multiplier => 0.53;
+
         private const double min_speed_bonus = 200; // 200 BPM 1/4th
         private const double speed_balancing_factor = 40;
 
@@ -44,12 +46,14 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
                 speedBonus = 0.75 * Math.Pow((DifficultyCalculationUtils.BPMToMilliseconds(min_speed_bonus) - strainTime) / speed_balancing_factor, 2);
 
             // Base difficulty with all bonuses
-            double difficulty = (1 + speedBonus) * 1000 / strainTime;
+            double difficulty = (1 + speedBonus) * 10 / strainTime;
 
             difficulty *= highBpmBonus(osuCurrObj.AdjustedDeltaTime);
 
             // Apply penalty if there's doubletappable doubles
-            return difficulty * doubletapness;
+            difficulty *= doubletapness;
+
+            return difficulty * multiplier;
         }
 
         private static double highBpmBonus(double ms) => 1 / (1 - Math.Pow(0.3, ms / 1000));

osu.Game.Rulesets.Osu/Difficulty/OsuRatingCalculator.cs

@@ -11,8 +11,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 {
     public class OsuRatingCalculator
     {
-        private const double difficulty_multiplier = 0.0675;
-
         private readonly Mod[] mods;
         private readonly int totalHits;
         private readonly double overallDifficulty;
@@ -29,7 +27,7 @@ public double ComputeAimRating(double aimDifficultyValue)
             if (mods.Any(m => m is OsuModAutopilot))
                 return 0;
 
-            double aimRating = Math.Pow(aimDifficultyValue, 0.63) * 0.02275;
+            double aimRating = Math.Pow(aimDifficultyValue, 0.63);
 
             if (mods.Any(m => m is OsuModMagnetised))
             {
@@ -129,6 +127,6 @@ public double ComputeFlashlightRating(double flashlightDifficultyValue)
             return flashlightRating * Math.Sqrt(ratingMultiplier);
         }
 
-        public static double CalculateDifficultyRating(double difficultyValue) => Math.Sqrt(difficultyValue) * difficulty_multiplier;
+        public static double CalculateDifficultyRating(double difficultyValue) => Math.Sqrt(difficultyValue);
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs

@@ -31,10 +31,7 @@ public Aim(Mod[] mods, bool includeSliders)
 
         private double currentStrain;
 
-        private double skillMultiplierSnap => 70.9;
-        private double skillMultiplierAgility => 2.35;
-        private double skillMultiplierFlow => 243.0;
-        private double skillMultiplierTotal => 1.12;
+        public static double SkillMultiplierTotal => 1.12;
         private double combinedSnapNormExponent => 1.2;
 
         /// <summary>
@@ -59,9 +56,9 @@ protected override double StrainValueAt(DifficultyHitObject current)
         {
             double decay = strainDecay(((OsuDifficultyHitObject)current).AdjustedDeltaTime);
 
-            double snapDifficulty = SnapAimEvaluator.EvaluateDifficultyOf(current, IncludeSliders) * skillMultiplierSnap;
-            double agilityDifficulty = AgilityEvaluator.EvaluateDifficultyOf(current) * skillMultiplierAgility;
-            double flowDifficulty = FlowAimEvaluator.EvaluateDifficultyOf(current, IncludeSliders) * skillMultiplierFlow;
+            double snapDifficulty = SnapAimEvaluator.EvaluateDifficultyOf(current, IncludeSliders);
+            double agilityDifficulty = AgilityEvaluator.EvaluateDifficultyOf(current);
+            double flowDifficulty = FlowAimEvaluator.EvaluateDifficultyOf(current, IncludeSliders);
 
             double totalDifficulty = calculateTotalValue(snapDifficulty, agilityDifficulty, flowDifficulty);
 
@@ -87,7 +84,8 @@ private double calculateTotalValue(double snapDifficulty, double agilityDifficul
             if (Mods.Any(m => m is OsuModTouchDevice))
             {
                 // we don't adjust agility here since agility represents TD difficulty in a decent enough way
-                snapDifficulty = Math.Pow(snapDifficulty, 0.89);
+                snapDifficulty = Math.Pow(snapDifficulty, 0.89) * 0.52;
+
                 combinedSnapDifficulty = DifficultyCalculationUtils.Norm(combinedSnapNormExponent, snapDifficulty, agilityDifficulty);
             }
 
@@ -99,9 +97,7 @@ private double calculateTotalValue(double snapDifficulty, double agilityDifficul
 
             double totalDifficulty = combinedSnapDifficulty * pSnap + flowDifficulty * pFlow;
 
-            double totalStrain = totalDifficulty * skillMultiplierTotal;
-
-            return totalStrain;
+            return totalDifficulty;
         }
 
         // A function that turns the ratio of snap : flow into the probability of snapping/flowing

osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs

@@ -20,7 +20,6 @@ public Flashlight(Mod[] mods)
         {
         }
 
-        private double skillMultiplier => 0.056;
         private double strainDecayBase => 0.15;
 
         private double currentStrain;
@@ -32,7 +31,7 @@ public Flashlight(Mod[] mods)
         protected override double StrainValueAt(DifficultyHitObject current)
         {
             currentStrain *= strainDecay(current.DeltaTime);
-            currentStrain += FlashlightEvaluator.EvaluateDifficultyOf(current, Mods) * skillMultiplier;
+            currentStrain += FlashlightEvaluator.EvaluateDifficultyOf(current, Mods);
 
             return currentStrain;
         }

osu.Game.Rulesets.Osu/Difficulty/Skills/Reading.cs

@@ -28,7 +28,6 @@ public Reading(Mod[] mods)
 
         private double currentDifficulty;
 
-        private double skillMultiplier => 2.5;
         private double strainDecayBase => 0.8;
 
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
@@ -41,7 +40,7 @@ protected override double ObjectDifficultyOf(DifficultyHitObject current)
 
             currentDifficulty *= decay;
 
-            currentDifficulty += ReadingEvaluator.EvaluateDifficultyOf(current, hasHiddenMod) * (1 - decay) * skillMultiplier;
+            currentDifficulty += ReadingEvaluator.EvaluateDifficultyOf(current, hasHiddenMod) * (1 - decay);
 
             return currentDifficulty;
         }

osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs

@@ -19,8 +19,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Speed : HarmonicSkill
     {
-        private double skillMultiplier => 1.16;
-
         private readonly List<double> sliderStrains = new List<double>();
 
         private double currentDifficulty;
@@ -42,7 +40,7 @@ protected override double ObjectDifficultyOf(DifficultyHitObject current)
             double decay = strainDecay(((OsuDifficultyHitObject)current).AdjustedDeltaTime);
 
             currentDifficulty *= decay;
-            currentDifficulty += SpeedEvaluator.EvaluateDifficultyOf(current) * (1 - decay) * skillMultiplier;
+            currentDifficulty += SpeedEvaluator.EvaluateDifficultyOf(current) * (1 - decay);
 
             double currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current);