Implement new score multipliers (#37967)

- Part of https://github.com/ppy/osu/issues/37818

Updates score multipliers to latest proposals, and bumps replay version
ready for recalculation.

---

For anyone following along, **please wait for the incoming news post
before sharing this publicly**. This is intended for internal
development use at this point. There's still some time before these go
live.

---------

Co-authored-by: Bartłomiej Dach <dach.bartlomiej@gmail.com>

osu.Android.props

@@ -10,7 +10,7 @@
     <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.521.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.527.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.

osu.Game.Benchmarks/BenchmarkScoreMultiplierCalculator.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using NUnit.Framework;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
@@ -42,7 +43,7 @@ namespace osu.Game.Benchmarks
         public override void SetUp()
         {
             base.SetUp();
-            calculator = new OsuRuleset().CreateScoreMultiplierCalculator(new ScoreMultiplierContext());
+            calculator = new OsuRuleset().CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
         }
 
         [Benchmark]

osu.Game.Rulesets.Catch.Tests/CatchScoreMultiplierTest.cs

@@ -2,8 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Tests.Rulesets;
 
 namespace osu.Game.Rulesets.Catch.Tests
@@ -110,7 +114,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             #region Conversion
 
             [new Mod[] { new CatchModDifficultyAdjust() }, 0.5],
-            [new Mod[] { new CatchModClassic() }, 0.96],
+            [new Mod[] { new CatchModClassic() }, 1],
             [new Mod[] { new CatchModMirror() }, 1],
 
             #endregion
@@ -151,5 +155,17 @@ namespace osu.Game.Rulesets.Catch.Tests
         [TestCaseSource(nameof(test_cases))]
         public void TestMultipliers(Mod[] mods, double expectedMultiplier)
             => TestModCombination(mods, expectedMultiplier);
+
+        [TestCase(30000001, 0.96)]
+        [TestCase(30000009, 0.96)]
+        [TestCase(30000016, 0.96)]
+        [TestCase(30000017, 1)]
+        [TestCase(null, 1)]
+        public void TestClassicMultiplierVersioning(int? totalScoreVersion, double expectedMultiplier)
+        {
+            var scoreInfo = totalScoreVersion != null ? new ScoreInfo { TotalScoreVersion = totalScoreVersion.Value } : null;
+            var calculator = Ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty(), scoreInfo));
+            Assert.That(calculator.CalculateFor([new CatchModClassic()]), Is.EqualTo(expectedMultiplier).Within(Precision.DOUBLE_EPSILON));
+        }
     }
 }

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

@@ -13,8 +13,6 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public partial class CatchModFlashlight : ModFlashlight<CatchHitObject>
     {
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.12 : 1;
-
         public override BindableFloat SizeMultiplier { get; } = new BindableFloat(1)
         {
             MinValue = 0.5f,

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

@@ -16,7 +16,6 @@ namespace osu.Game.Rulesets.Catch.Mods
         public override string Name => "Floating Fruits";
         public override string Acronym => "FF";
         public override LocalisableString Description => "The fruits are... floating?";
-        public override double ScoreMultiplier => 1;
         public override IconUsage? Icon => OsuIcon.ModFloatingFruits;
 
         public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)

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

@@ -10,8 +10,6 @@ namespace osu.Game.Rulesets.Catch.Mods
 {
     public class CatchModHardRock : ModHardRock, IApplicableToBeatmapProcessor
     {
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.12 : 1;
-
         public void ApplyToBeatmapProcessor(IBeatmapProcessor beatmapProcessor)
         {
             var catchProcessor = (CatchBeatmapProcessor)beatmapProcessor;

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

@@ -16,7 +16,6 @@ namespace osu.Game.Rulesets.Catch.Mods
     public class CatchModHidden : ModHidden, IApplicableToDrawableRuleset<CatchHitObject>
     {
         public override LocalisableString Description => @"Play with fading fruits.";
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
 
         private const double fade_out_offset_multiplier = 0.6;
         private const double fade_out_duration_multiplier = 0.44;

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

@@ -23,7 +23,6 @@ namespace osu.Game.Rulesets.Catch.Mods
         public override string Acronym => "MF";
         public override LocalisableString Description => "Dashing by default, slow down!";
         public override ModType Type => ModType.Fun;
-        public override double ScoreMultiplier => 1;
         public override IconUsage? Icon => OsuIcon.ModMovingFast;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModRelax) };
 

osu.Game.Rulesets.Catch/Scoring/CatchScoreMultiplierCalculator.cs

@@ -4,6 +4,7 @@
 using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Scoring
 {
@@ -37,7 +38,7 @@ namespace osu.Game.Rulesets.Catch.Scoring
             #region Conversion
 
             Single<CatchModDifficultyAdjust>(hasMultiplier: 0.5);
-            Single<CatchModClassic>(hasMultiplier: 0.96);
+            Single<CatchModClassic>(hasMultiplier: _ => classicMultiplier(context.Score));
             // Mirror
 
             #endregion
@@ -82,5 +83,13 @@ namespace osu.Game.Rulesets.Catch.Scoring
             else
                 return 0.6 + value;
         }
+
+        private static double classicMultiplier(ScoreInfo? score)
+        {
+            if (score != null && score.TotalScoreVersion < 30000017)
+                return 0.96;
+
+            return 1;
+        }
     }
 }

osu.Game.Rulesets.Mania.Tests/ManiaScoreMultiplierTest.cs

@@ -4,6 +4,7 @@
 using System;
 using NUnit.Framework;
 using osu.Framework.Utils;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -119,7 +120,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             [new Mod[] { new ManiaModDualStages() }, 1],
             [new Mod[] { new ManiaModMirror() }, 1],
             [new Mod[] { new ManiaModDifficultyAdjust() }, 0.5],
-            [new Mod[] { new ManiaModClassic() }, 0.96],
+            [new Mod[] { new ManiaModClassic() }, 1],
             [new Mod[] { new ManiaModInvert() }, 1],
             [new Mod[] { new ManiaModConstantSpeed() }, 0.9],
             [new Mod[] { new ManiaModHoldOff() }, 0.9],
@@ -212,12 +213,24 @@ namespace osu.Game.Rulesets.Mania.Tests
         [TestCaseSource(nameof(key_mod_multiplier_test_cases))]
         public void TestKeyModMultiplierCompatibility(DateTimeOffset endDate, string clientVersion, double expectedMultiplier)
         {
-            var calculator = Ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new ScoreInfo
+            var calculator = Ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty(), new ScoreInfo
             {
                 Date = endDate,
                 ClientVersion = clientVersion
             }));
             Assert.That(calculator.CalculateFor([new ManiaModKey4()]), Is.EqualTo(expectedMultiplier).Within(Precision.DOUBLE_EPSILON));
         }
+
+        [TestCase(30000001, 0.96)]
+        [TestCase(30000009, 0.96)]
+        [TestCase(30000016, 0.96)]
+        [TestCase(30000017, 1)]
+        [TestCase(null, 1)]
+        public void TestClassicMultiplierVersioning(int? totalScoreVersion, double expectedMultiplier)
+        {
+            var scoreInfo = totalScoreVersion != null ? new ScoreInfo { TotalScoreVersion = totalScoreVersion.Value } : null;
+            var calculator = Ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty(), scoreInfo));
+            Assert.That(calculator.CalculateFor([new ManiaModClassic()]), Is.EqualTo(expectedMultiplier).Within(Precision.DOUBLE_EPSILON));
+        }
     }
 }

osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModDoubleTime.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
                 Mod = doubleTime,
                 PassCondition = () => Player.ScoreProcessor.JudgedHits > 0
                                       && Player.ScoreProcessor.Accuracy.Value == 1
-                                      && Player.ScoreProcessor.TotalScore.Value == (long)(1_000_000 * new ManiaScoreMultiplierCalculator(new ScoreMultiplierContext()).CalculateFor([doubleTime])),
+                                      && Player.ScoreProcessor.TotalScore.Value == (long)(1_000_000 * new ManiaScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty())).CalculateFor([doubleTime])),
                 Autoplay = false,
                 CreateBeatmap = () => new Beatmap
                 {

osu.Game.Rulesets.Mania/Mods/ManiaKeyMod.cs

@@ -14,7 +14,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Acronym => Name;
         public abstract int KeyCount { get; }
         public override ModType Type => ModType.Conversion;
-        public override double ScoreMultiplier => 0.9;
         public override bool Ranked => UsesDefaultConfiguration;
 
         public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)

osu.Game.Rulesets.Mania/Mods/ManiaModConstantSpeed.cs

@@ -18,8 +18,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override string Acronym => "CS";
 
-        public override double ScoreMultiplier => 0.9;
-
         public override LocalisableString Description => "No more tricky speed changes!";
 
         public override IconUsage? Icon => OsuIcon.ModConstantSpeed;

osu.Game.Rulesets.Mania/Mods/ManiaModCover.cs

@@ -20,8 +20,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => @"Decrease the playfield's viewing area.";
 
-        public override double ScoreMultiplier => 1;
-
         protected override CoverExpandDirection ExpandDirection => Direction.Value;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]

osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.cs

@@ -7,9 +7,5 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModDoubleTime : ModDoubleTime, IManiaRateAdjustmentMod
     {
-        // For now, all rate-increasing mods should be given a 1x multiplier in mania because it doesn't always
-        // make the map harder and is more of a personal preference.
-        // In the future, we can consider adjusting this by experimenting with not applying the hitwindow leniency.
-        public override double ScoreMultiplier => 1;
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModDualStages.cs

@@ -17,7 +17,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override LocalisableString Description => @"Double the stages, double the fun!";
         public override IconUsage? Icon => OsuIcon.ModDualStages;
         public override ModType Type => ModType.Conversion;
-        public override double ScoreMultiplier => 1;
 
         private bool isForCurrentRuleset;
 

osu.Game.Rulesets.Mania/Mods/ManiaModFadeIn.cs

@@ -16,7 +16,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Acronym => "FI";
         public override IconUsage? Icon => OsuIcon.ModFadeIn;
         public override LocalisableString Description => @"Keys appear out of nowhere!";
-        public override double ScoreMultiplier => 1;
         public override bool ValidForFreestyleAsRequiredMod => false;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]

osu.Game.Rulesets.Mania/Mods/ManiaModFlashlight.cs

@@ -13,7 +13,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public partial class ManiaModFlashlight : ModFlashlight<ManiaHitObject>
     {
-        public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(ModHidden) };
 
         public override BindableFloat SizeMultiplier { get; } = new BindableFloat(1)

osu.Game.Rulesets.Mania/Mods/ManiaModHardRock.cs

@@ -10,7 +10,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModHardRock : ModHardRock, IApplicableToHitObject
     {
-        public override double ScoreMultiplier => 1;
         public override bool Ranked => false;
 
         public const double HIT_WINDOW_DIFFICULTY_MULTIPLIER = 1.4;

osu.Game.Rulesets.Mania/Mods/ManiaModHidden.cs

@@ -30,7 +30,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         private const float coverage_increase_per_combo = 0.5f;
 
         public override LocalisableString Description => @"Keys fade out before you hit them!";
-        public override double ScoreMultiplier => 1;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]
         {

osu.Game.Rulesets.Mania/Mods/ManiaModHoldOff.cs

@@ -21,8 +21,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override string Acronym => "HO";
 
-        public override double ScoreMultiplier => 0.9;
-
         public override LocalisableString Description => @"Replaces all hold notes with normal notes.";
 
         public override IconUsage? Icon => OsuIcon.ModHoldOff;

osu.Game.Rulesets.Mania/Mods/ManiaModInvert.cs

@@ -20,7 +20,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Name => "Invert";
 
         public override string Acronym => "IN";
-        public override double ScoreMultiplier => 1;
 
         public override LocalisableString Description => "Hold the keys. To the beat.";
 

osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs

@@ -8,9 +8,5 @@ namespace osu.Game.Rulesets.Mania.Mods
 {
     public class ManiaModNightcore : ModNightcore<ManiaHitObject>, IManiaRateAdjustmentMod
     {
-        // For now, all rate-increasing mods should be given a 1x multiplier in mania because it doesn't always
-        // make the map any harder and is more of a personal preference.
-        // In the future, we can consider adjusting this by experimenting with not applying the hitwindow leniency.
-        public override double ScoreMultiplier => 1;
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModNoRelease.cs

@@ -26,8 +26,6 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override LocalisableString Description => "No more timing the end of hold notes.";
 
-        public override double ScoreMultiplier => 0.9;
-
         public override IconUsage? Icon => OsuIcon.ModNoRelease;
 
         public override ModType Type => ModType.DifficultyReduction;

osu.Game.Rulesets.Mania/Scoring/ManiaScoreMultiplierCalculator.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Mania.Scoring
             // Dual Stages
             // Mirror
             Single<ManiaModDifficultyAdjust>(hasMultiplier: 0.5);
-            Single<ManiaModClassic>(hasMultiplier: 0.96);
+            Single<ManiaModClassic>(hasMultiplier: _ => classicMultiplier(Context.Score));
             // Invert
             Single<ManiaModConstantSpeed>(hasMultiplier: 0.9);
             Single<ManiaModHoldOff>(hasMultiplier: 0.9);
@@ -142,5 +142,13 @@ namespace osu.Game.Rulesets.Mania.Scoring
 
             return new_key_mod_multiplier;
         }
+
+        private static double classicMultiplier(ScoreInfo? score)
+        {
+            if (score != null && score.TotalScoreVersion < 30000017)
+                return 0.96;
+
+            return 1;
+        }
     }
 }

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

@@ -17,6 +17,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
 {
     public partial class TestSceneOsuModDifficultyAdjust : OsuModTestScene
     {
+        protected override bool AllowFail => true;
+
         [Test]
         public void TestNoAdjustment() => CreateModTest(new ModTestData
         {
@@ -72,6 +74,88 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             PassCondition = () => checkSomeHit() && checkObjectsPreempt(450)
         });
 
+        [Test]
+        public void TestScoreMultiplierCorrectWithNoAdjustment() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModDifficultyAdjust(),
+            CreateBeatmap = () => new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Difficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 8
+                    }
+                },
+                HitObjects = new List<HitObject>
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 2000 }
+                }
+            },
+            Autoplay = true,
+            PassCondition = () => Player.ScoreProcessor.TotalScore.Value == 1_000_000,
+        });
+
+        [Test]
+        public void TestScoreMultiplierCorrectWithSingleAdjustment() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModDifficultyAdjust
+            {
+                ApproachRate = { Value = 7.3f }
+            },
+            CreateBeatmap = () => new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Difficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 8,
+                        ApproachRate = 7,
+                        OverallDifficulty = 6,
+                        DrainRate = 5,
+                    }
+                },
+                HitObjects = new List<HitObject>
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 2000 }
+                }
+            },
+            Autoplay = true,
+            PassCondition = () => Player.ScoreProcessor.TotalScore.Value == 850_000,
+        });
+
+        [Test]
+        public void TestScoreMultiplierCorrectWithMultipleAdjustments() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModDifficultyAdjust
+            {
+                ApproachRate = { Value = 6.8f },
+                OverallDifficulty = { Value = 6.6f }
+            },
+            CreateBeatmap = () => new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Difficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 8,
+                        ApproachRate = 7,
+                        OverallDifficulty = 6,
+                        DrainRate = 5,
+                    }
+                },
+                HitObjects = new List<HitObject>
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 2000 }
+                }
+            },
+            Autoplay = true,
+            PassCondition = () => Player.ScoreProcessor.TotalScore.Value == 630_000,
+        });
+
         private bool checkObjectsPreempt(double target)
         {
             var objects = Player.ChildrenOfType<DrawableHitCircle>();

osu.Game.Rulesets.Osu.Tests/OsuScoreMultiplierTest.cs

@@ -2,8 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Tests.Rulesets;
 
 namespace osu.Game.Rulesets.Osu.Tests
@@ -19,94 +23,106 @@ namespace osu.Game.Rulesets.Osu.Tests
         [
             #region Difficulty Reduction
 
-            [new Mod[] { new OsuModEasy() }, 0.5],
+            [new Mod[] { new OsuModEasy() }, 0.8],
+            [new Mod[] { new OsuModEasy { Retries = { Value = 1 } } }, 0.8],
+            [new Mod[] { new OsuModEasy { Retries = { Value = 3 } } }, 0.7],
+            [new Mod[] { new OsuModEasy { Retries = { Value = 5 } } }, 0.5],
+            [new Mod[] { new OsuModEasy { Retries = { Value = 8 } } }, 0.4],
+
             [new Mod[] { new OsuModNoFail() }, 0.5],
 
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.50 } } }, 0.1],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.55 } } }, 0.1],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.60 } } }, 0.2],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.65 } } }, 0.2],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.70 } } }, 0.3],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.75 } } }, 0.3],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.80 } } }, 0.4],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.85 } } }, 0.4],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.90 } } }, 0.5],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.95 } } }, 0.5],
-            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.99 } } }, 0.5],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.50 } } }, 0.20],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.55 } } }, 0.27],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.60 } } }, 0.34],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.65 } } }, 0.41],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.70 } } }, 0.48],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.75 } } }, 0.55],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.80 } } }, 0.62],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.85 } } }, 0.69],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.90 } } }, 0.76],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.95 } } }, 0.83],
+            [new Mod[] { new OsuModHalfTime { SpeedChange = { Value = 0.99 } } }, 0.83],
 
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.50 } } }, 0.1],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.55 } } }, 0.1],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.60 } } }, 0.2],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.65 } } }, 0.2],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.70 } } }, 0.3],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.75 } } }, 0.3],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.80 } } }, 0.4],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.85 } } }, 0.4],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.90 } } }, 0.5],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.95 } } }, 0.5],
-            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.99 } } }, 0.5],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.50 } } }, 0.20],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.55 } } }, 0.27],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.60 } } }, 0.34],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.65 } } }, 0.41],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.70 } } }, 0.48],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.75 } } }, 0.55],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.80 } } }, 0.62],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.85 } } }, 0.69],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.90 } } }, 0.76],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.95 } } }, 0.83],
+            [new Mod[] { new OsuModDaycore { SpeedChange = { Value = 0.99 } } }, 0.83],
 
             #endregion
 
             #region Difficulty Increase
 
-            [new Mod[] { new OsuModHardRock() }, 1.06],
+            [new Mod[] { new OsuModHardRock() }, 1.09],
             [new Mod[] { new OsuModSuddenDeath() }, 1],
             [new Mod[] { new OsuModPerfect() }, 1],
 
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.01 } } }, 1.00],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.05 } } }, 1.00],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.10 } } }, 1.02],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.15 } } }, 1.02],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.20 } } }, 1.04],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } }, 1.04],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.30 } } }, 1.06],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.35 } } }, 1.06],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.40 } } }, 1.08],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.45 } } }, 1.08],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.50 } } }, 1.10],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.55 } } }, 1.10],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.60 } } }, 1.12],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.65 } } }, 1.12],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.70 } } }, 1.14],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.75 } } }, 1.14],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.80 } } }, 1.16],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.85 } } }, 1.16],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.90 } } }, 1.18],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.95 } } }, 1.18],
-            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 2.00 } } }, 1.20],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.01 } } }, 1.000],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.05 } } }, 1.000],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.10 } } }, 1.036],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.15 } } }, 1.036],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.20 } } }, 1.082],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } }, 1.082],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.30 } } }, 1.128],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.35 } } }, 1.128],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.40 } } }, 1.174],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.45 } } }, 1.174],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.50 } } }, 1.230],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.55 } } }, 1.230],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.60 } } }, 1.266],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.65 } } }, 1.266],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.70 } } }, 1.312],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.75 } } }, 1.312],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.80 } } }, 1.358],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.85 } } }, 1.358],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.90 } } }, 1.404],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.95 } } }, 1.404],
+            [new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 2.00 } } }, 1.450],
 
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.01 } } }, 1.00],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.05 } } }, 1.00],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.10 } } }, 1.02],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.15 } } }, 1.02],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.20 } } }, 1.04],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.25 } } }, 1.04],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.30 } } }, 1.06],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.35 } } }, 1.06],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.40 } } }, 1.08],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.45 } } }, 1.08],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.50 } } }, 1.10],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.55 } } }, 1.10],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.60 } } }, 1.12],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.65 } } }, 1.12],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.70 } } }, 1.14],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.75 } } }, 1.14],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.80 } } }, 1.16],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.85 } } }, 1.16],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.90 } } }, 1.18],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.95 } } }, 1.18],
-            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 2.00 } } }, 1.20],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.01 } } }, 1.000],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.05 } } }, 1.000],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.10 } } }, 1.036],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.15 } } }, 1.036],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.20 } } }, 1.082],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.25 } } }, 1.082],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.30 } } }, 1.128],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.35 } } }, 1.128],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.40 } } }, 1.174],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.45 } } }, 1.174],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.50 } } }, 1.230],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.55 } } }, 1.230],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.60 } } }, 1.266],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.65 } } }, 1.266],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.70 } } }, 1.312],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.75 } } }, 1.312],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.80 } } }, 1.358],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.85 } } }, 1.358],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.90 } } }, 1.404],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 1.95 } } }, 1.404],
+            [new Mod[] { new OsuModNightcore { SpeedChange = { Value = 2.00 } } }, 1.450],
 
-            [new Mod[] { new OsuModHidden() }, 1.06],
-            [new Mod[] { new OsuModHidden { OnlyFadeApproachCircles = { Value = true } } }, 1],
+            [new Mod[] { new OsuModHidden() }, 1.04],
+            [new Mod[] { new OsuModHidden { OnlyFadeApproachCircles = { Value = true } } }, 1.02],
 
-            [new Mod[] { new OsuModTraceable() }, 1],
+            [new Mod[] { new OsuModTraceable() }, 1.02],
 
-            [new Mod[] { new OsuModFlashlight() }, 1.12],
-            [new Mod[] { new OsuModFlashlight { ComboBasedSize = { Value = false } } }, 1],
+            [new Mod[] { new OsuModFlashlight() }, 1.2],
+            [new Mod[] { new OsuModFlashlight { SizeMultiplier = { Value = 0.5f } } }, 1.2],
+            [new Mod[] { new OsuModFlashlight { SizeMultiplier = { Value = 0.9f } } }, 1.2],
+            [new Mod[] { new OsuModFlashlight { SizeMultiplier = { Value = 1.1f } } }, 1.18],
+            [new Mod[] { new OsuModFlashlight { SizeMultiplier = { Value = 1.5f } } }, 1.1],
+            [new Mod[] { new OsuModFlashlight { SizeMultiplier = { Value = 1.9f } } }, 1.02],
+            [new Mod[] { new OsuModFlashlight { SizeMultiplier = { Value = 2f } } }, 1.02],
+            [new Mod[] { new OsuModFlashlight { ComboBasedSize = { Value = false } } }, 1.04],
+            [new Mod[] { new OsuModFlashlight { SizeMultiplier = { Value = 1.9f }, ComboBasedSize = { Value = false } } }, 1.004],
 
-            [new Mod[] { new OsuModBlinds() }, 1.12],
+            [new Mod[] { new OsuModBlinds() }, 1.24],
             [new Mod[] { new OsuModStrictTracking() }, 1],
             [new Mod[] { new OsuModAccuracyChallenge() }, 1],
 
@@ -114,10 +130,13 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             #region Conversion
 
-            [new Mod[] { new OsuModTargetPractice() }, 0.1],
-            [new Mod[] { new OsuModDifficultyAdjust() }, 0.5],
-            [new Mod[] { new OsuModClassic() }, 0.96],
-            [new Mod[] { new OsuModRandom() }, 1],
+            [new Mod[] { new OsuModTargetPractice() }, 0.01],
+            [new Mod[] { new OsuModDifficultyAdjust() }, 1],
+
+            [new Mod[] { new OsuModClassic() }, 0.985],
+            [new Mod[] { new OsuModClassic { ClassicNoteLock = { Value = false } } }, 0.96],
+
+            [new Mod[] { new OsuModRandom() }, 0.7],
             [new Mod[] { new OsuModMirror() }, 1],
             [new Mod[] { new OsuModAlternate() }, 1],
             [new Mod[] { new OsuModSingleTap() }, 1],
@@ -130,7 +149,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             [new Mod[] { new OsuModCinema() }, 1],
             [new Mod[] { new OsuModRelax() }, 0.1],
             [new Mod[] { new OsuModAutopilot() }, 0.1],
-            [new Mod[] { new OsuModSpunOut() }, 0.9],
+            [new Mod[] { new OsuModSpunOut() }, 0.95],
 
             #endregion
 
@@ -140,19 +159,36 @@ namespace osu.Game.Rulesets.Osu.Tests
             [new Mod[] { new OsuModWiggle() }, 1],
             [new Mod[] { new OsuModSpinIn() }, 1],
             [new Mod[] { new OsuModGrow() }, 1],
+
             [new Mod[] { new OsuModDeflate() }, 1],
-            [new Mod[] { new ModWindUp() }, 0.5],
-            [new Mod[] { new ModWindDown() }, 0.5],
+            [new Mod[] { new OsuModDeflate { StartScale = { Value = 5 } } }, 0.94],
+
+            [new Mod[] { new ModWindUp() }, 0.8 * 1 + 0.2 * 1.230],
+            [new Mod[] { new ModWindUp { InitialRate = { Value = 0.7 }, FinalRate = { Value = 1.2 } } }, 0.8 * 0.48 + 0.2 * 1.082],
+            [new Mod[] { new ModWindUp { InitialRate = { Value = 0.7 }, FinalRate = { Value = 0.9 } } }, 0.8 * 0.48 + 0.2 * 0.76],
+            [new Mod[] { new ModWindUp { InitialRate = { Value = 1.1 }, FinalRate = { Value = 1.4 } } }, 0.8 * 1.036 + 0.2 * 1.174],
+
+            [new Mod[] { new ModWindDown() }, 0.8 * 0.55 + 0.2 * 1],
+            [new Mod[] { new ModWindDown { InitialRate = { Value = 1.2 }, FinalRate = { Value = 0.7 } } }, 0.8 * 0.48 + 0.2 * 1.082],
+            [new Mod[] { new ModWindDown { InitialRate = { Value = 0.9 }, FinalRate = { Value = 0.7 } } }, 0.8 * 0.48 + 0.2 * 0.76],
+            [new Mod[] { new ModWindDown { InitialRate = { Value = 1.4 }, FinalRate = { Value = 1.1 } } }, 0.8 * 1.036 + 0.2 * 1.174],
+
             [new Mod[] { new OsuModBarrelRoll() }, 1],
-            [new Mod[] { new OsuModApproachDifferent() }, 1],
+            [new Mod[] { new OsuModApproachDifferent() }, 0.7],
             [new Mod[] { new OsuModMuted() }, 1],
             [new Mod[] { new OsuModNoScope() }, 1],
-            [new Mod[] { new OsuModMagnetised() }, 0.5],
+
+            [new Mod[] { new OsuModMagnetised() }, 0.4],
+            [new Mod[] { new OsuModMagnetised { AttractionStrength = { Value = 0.05f } } }, 0.67],
+            [new Mod[] { new OsuModMagnetised { AttractionStrength = { Value = 0.2f } } }, 0.58],
+            [new Mod[] { new OsuModMagnetised { AttractionStrength = { Value = 0.7f } } }, 0.28],
+            [new Mod[] { new OsuModMagnetised { AttractionStrength = { Value = 1 } } }, 0.1],
+
             [new Mod[] { new OsuModRepel() }, 1],
-            [new Mod[] { new ModAdaptiveSpeed() }, 0.5],
+            [new Mod[] { new ModAdaptiveSpeed() }, 0.1],
             [new Mod[] { new OsuModFreezeFrame() }, 1],
             [new Mod[] { new OsuModBubbles() }, 1],
-            [new Mod[] { new OsuModSynesthesia() }, 0.8],
+            [new Mod[] { new OsuModSynesthesia() }, 0.99],
             [new Mod[] { new OsuModDepth() }, 1],
             [new Mod[] { new OsuModBloom() }, 1],
 
@@ -167,7 +203,24 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             #region Combinations
 
-            [new Mod[] { new OsuModHidden(), new OsuModHardRock() }, 1.06 * 1.06],
+            [new Mod[] { new OsuModHidden(), new OsuModHardRock() }, 1.04 * 1.09],
+
+            [new Mod[] { new OsuModHidden(), new OsuModWiggle() }, 1.02],
+            [new Mod[] { new OsuModHidden(), new OsuModGrow() }, 1.02],
+            [new Mod[] { new OsuModHidden(), new OsuModDeflate() }, 1.02],
+            [new Mod[] { new OsuModHidden(), new OsuModDeflate { StartScale = { Value = 4 } } }, 1.02 * 0.96],
+            [new Mod[] { new OsuModHidden(), new OsuModRepel() }, 1.02],
+            [new Mod[] { new OsuModHidden { OnlyFadeApproachCircles = { Value = true } }, new OsuModRepel() }, 1],
+            [new Mod[] { new OsuModHidden(), new OsuModDepth() }, 1.02],
+            [new Mod[] { new OsuModHidden(), new OsuModDepth(), new OsuModHardRock() }, 1.02 * 1.09],
+
+            [new Mod[] { new OsuModHidden(), new OsuModBlinds() }, 1.24],
+            [new Mod[] { new OsuModHidden(), new OsuModBlinds(), new OsuModHardRock() }, 1.24 * 1.09],
+
+            [new Mod[] { new OsuModTraceable(), new OsuModBlinds() }, 1.24],
+            [new Mod[] { new OsuModTraceable(), new OsuModBlinds(), new OsuModHardRock() }, 1.24 * 1.09],
+
+            [new Mod[] { new OsuModFlashlight(), new OsuModFreezeFrame() }, 1.1],
 
             #endregion
         ];
@@ -175,5 +228,70 @@ namespace osu.Game.Rulesets.Osu.Tests
         [TestCaseSource(nameof(test_cases))]
         public void TestMultipliers(Mod[] mods, double expectedMultiplier)
             => TestModCombination(mods, expectedMultiplier);
+
+        [TestCase(null, null, null, null, 1)]
+        [TestCase(2.9f, null, null, null, 0.95)]
+        [TestCase(3.1f, null, null, null, 0.95)]
+        [TestCase(null, 3.9f, null, null, 0.95)]
+        [TestCase(null, 4.1f, null, null, 0.95)]
+        [TestCase(null, null, 4.9f, null, 0.95)]
+        [TestCase(null, null, 5.1f, null, 0.95)]
+        [TestCase(null, null, null, 5.9f, 0.95)]
+        [TestCase(null, null, null, 6.1f, 0.95)]
+        [TestCase(2.9f, 3.9f, null, null, 0.95 * 0.95)]
+        [TestCase(2.9f, 3.9f, 4.9f, null, 0.95 * 0.95 * 0.95)]
+        [TestCase(2.9f, 3.9f, 4.9f, 5.9f, 0.95 * 0.95 * 0.95 * 0.95)]
+        [TestCase(0.0f, null, null, null, 0.1)]
+        [TestCase(0.0f, 0.0f, 0.0f, 0.0f, 0.1)]
+        public void TestDifficultyAdjust(float? cs, float? ar, float? od, float? hp, double expectedMultiplier)
+        {
+            var difficulty = new BeatmapDifficulty
+            {
+                CircleSize = 3,
+                ApproachRate = 4,
+                OverallDifficulty = 5,
+                DrainRate = 6,
+            };
+            var mod = new OsuModDifficultyAdjust
+            {
+                CircleSize = { Value = cs },
+                ApproachRate = { Value = ar },
+                OverallDifficulty = { Value = od },
+                DrainRate = { Value = hp },
+            };
+
+            var calculator = Ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(difficulty));
+            Assert.That(calculator.CalculateFor([mod]), Is.EqualTo(expectedMultiplier).Within(Precision.FLOAT_EPSILON));
+        }
+
+        [TestCase(30000001, 0.96)]
+        [TestCase(30000009, 0.96)]
+        [TestCase(30000016, 0.96)]
+        [TestCase(30000017, 0.985)]
+        [TestCase(null, 0.985)]
+        public void TestClassicMultiplierVersioning(int? totalScoreVersion, double expectedMultiplier)
+        {
+            var scoreInfo = totalScoreVersion != null ? new ScoreInfo { TotalScoreVersion = totalScoreVersion.Value } : null;
+            var calculator = Ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty(), scoreInfo));
+            Assert.That(calculator.CalculateFor([new OsuModClassic()]), Is.EqualTo(expectedMultiplier).Within(Precision.DOUBLE_EPSILON));
+        }
+
+        [Test]
+        public void VerySmallModMultiplier()
+        {
+            var mods = new Mod[]
+            {
+                new OsuModEasy { Retries = { Value = 10 } },
+                new OsuModNoFail(),
+                new OsuModHalfTime { SpeedChange = { Value = 0.5 } },
+                new OsuModTargetPractice(),
+                new OsuModClassic { ClassicNoteLock = { Value = false } },
+                new OsuModDeflate { StartScale = { Value = 25 } },
+                new OsuModMagnetised { AttractionStrength = { Value = 1 } },
+                new OsuModSynesthesia(),
+            };
+            var calculator = Ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
+            Assert.That(calculator.CalculateFor(mods), Is.GreaterThan(0));
+        }
     }
 }

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

@@ -21,7 +21,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public abstract partial class InputBlockingMod : Mod, IApplicableToDrawableRuleset<OsuHitObject>, IUpdatableByPlayfield
     {
-        public override double ScoreMultiplier => 1.0;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModRelax), typeof(OsuModCinema) };
         public override ModType Type => ModType.Conversion;
 

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

@@ -19,7 +19,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => "Approach Different";
         public override string Acronym => "AD";
         public override LocalisableString Description => "Never trust the approach circles...";
-        public override double ScoreMultiplier => 1;
         public override IconUsage? Icon => OsuIcon.ModApproachDifferent;
 
         public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles), typeof(OsuModFreezeFrame) };

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

@@ -23,7 +23,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModAutopilot;
         public override ModType Type => ModType.Automation;
         public override LocalisableString Description => @"Automatic cursor movement - just follow the rhythm.";
-        public override double ScoreMultiplier => 0.1;
 
         public override Type[] IncompatibleMods => new[]
         {

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

@@ -30,7 +30,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModBlinds;
         public override ModType Type => ModType.DifficultyIncrease;
 
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.12 : 1;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModFlashlight) };
         public override bool Ranked => true;
 

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

@@ -26,7 +26,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModBloom;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "The cursor blooms into.. a larger cursor!";
-        public override double ScoreMultiplier => 1;
         protected const float MIN_SIZE = 1;
         protected const float TRANSITION_DURATION = 100;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModFlashlight), typeof(OsuModNoScope), typeof(ModTouchDevice) };

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

@@ -34,8 +34,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override LocalisableString Description => "Don't let their popping distract you!";
 
-        public override double ScoreMultiplier => 1;
-
         public override IconUsage? Icon => OsuIcon.ModBubbles;
 
         public override ModType Type => ModType.Fun;

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

@@ -25,7 +25,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModDepth;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "3D. Almost.";
-        public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModFreezeFrame), typeof(ModWithVisibilityAdjustment) }).ToArray();
 
         private static readonly Vector3 camera_position = new Vector3(OsuPlayfield.BASE_SIZE.X * 0.5f, OsuPlayfield.BASE_SIZE.Y * 0.5f, -200);

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

@@ -19,7 +19,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public partial class OsuModFlashlight : ModFlashlight<OsuHitObject>, IApplicableToDrawableHitObject
     {
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.12 : 1;
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModBloom), typeof(OsuModBlinds) }).ToArray();
 
         private const double default_follow_delay = 120;

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

@@ -23,8 +23,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override IconUsage? Icon => OsuIcon.ModFreezeFrame;
 
-        public override double ScoreMultiplier => 1;
-
         public override LocalisableString Description => "Burn the notes into your memory.";
 
         /// <remarks>

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

@@ -13,8 +13,6 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModHardRock : ModHardRock, IApplicableToHitObject
     {
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
-
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModMirror)).ToArray();
 
         public void ApplyToHitObject(HitObject hitObject)

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

@@ -24,7 +24,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public Bindable<bool> OnlyFadeApproachCircles { get; } = new BindableBool();
 
         public override LocalisableString Description => @"Play with no approach circles and fading circles/sliders.";
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
 
         public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModDepth), typeof(OsuModFreezeFrame) };
 

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

@@ -27,7 +27,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModMagnetised;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "No need to chase the circles – your cursor is a magnet!";
-        public override double ScoreMultiplier => 0.5;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel), typeof(OsuModBubbles), typeof(OsuModDepth) };
 
         [SettingSource("Attraction strength", "How strong the pull is.", 0)]

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

@@ -19,8 +19,6 @@ namespace osu.Game.Rulesets.Osu.Mods
     {
         public override ModType Type => ModType.Fun;
 
-        public override double ScoreMultiplier => 1;
-
         [SettingSource("Starting Size", "The initial size multiplier applied to all objects.")]
         public abstract BindableNumber<float> StartScale { get; }
 

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

@@ -28,7 +28,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModRepel;
         public override ModType Type => ModType.Fun;
         public override LocalisableString 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), typeof(OsuModBubbles), typeof(OsuModDepth) };
 
         [SettingSource("Repulsion strength", "How strong the repulsion is.", 0)]

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

@@ -21,7 +21,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModSpinIn;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Circles spin in. No approach circles.";
-        public override double ScoreMultiplier => 1;
 
         // todo: this mod needs to be incompatible with "hidden" due to forcing the circle to remain opaque,
         // further implementation will be required for supporting that.

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

@@ -20,7 +20,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModSpunOut;
         public override ModType Type => ModType.Automation;
         public override LocalisableString Description => @"Spinners will be automatically completed.";
-        public override double ScoreMultiplier => 0.9;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(OsuModAutopilot), typeof(OsuModTargetPractice) };
         public override bool Ranked => UsesDefaultConfiguration;
 

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

@@ -29,7 +29,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModStrictTracking;
         public override ModType Type => ModType.DifficultyIncrease;
         public override LocalisableString Description => @"Once you start a slider, follow precisely or get a miss.";
-        public override double ScoreMultiplier => 1.0;
         public override Type[] IncompatibleMods => new[] { typeof(ModClassic), typeof(OsuModTargetPractice) };
 
         public void ApplyToDrawableHitObject(DrawableHitObject drawable)

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

@@ -39,7 +39,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Conversion;
         public override IconUsage? Icon => OsuIcon.ModTargetPractice;
         public override LocalisableString Description => @"Practice keeping up with the beat of the song.";
-        public override double ScoreMultiplier => 0.1;
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[]
         {

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

@@ -23,7 +23,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModTraceable;
         public override ModType Type => ModType.DifficultyIncrease;
         public override LocalisableString Description => "Put your faith in the approach circles...";
-        public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
 
         public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles), typeof(OsuModDepth) };

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

@@ -22,7 +22,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModTransform;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Everything rotates. EVERYTHING.";
-        public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModWiggle), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModFreezeFrame), typeof(OsuModDepth) }).ToArray();
 
         private float theta;

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

@@ -23,7 +23,6 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override IconUsage? Icon => OsuIcon.ModWiggle;
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "They just won't stay still...";
-        public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModDepth) };
 
         private const int wiggle_duration = 100; // (ms) Higher = fewer wiggles

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -234,7 +234,13 @@ namespace osu.Game.Rulesets.Osu
             }
         }
 
-        public override ScoreMultiplierCalculator CreateScoreMultiplierCalculator(ScoreMultiplierContext context) => new OsuScoreMultiplierCalculator(context);
+        public override ScoreMultiplierCalculator CreateScoreMultiplierCalculator(ScoreMultiplierContext context)
+        {
+            if (context.Score != null && context.Score.TotalScoreVersion < 30000017)
+                return new OsuScoreMultiplierCalculatorV1(context);
+
+            return new OsuScoreMultiplierCalculatorV2(context);
+        }
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetOsu };
 

osu.Game.Rulesets.Osu/Scoring/OsuScoreMultiplierCalculatorV1.cs

@@ -7,9 +7,9 @@ using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Scoring
 {
-    public class OsuScoreMultiplierCalculator : ScoreMultiplierCalculator
+    public class OsuScoreMultiplierCalculatorV1 : ScoreMultiplierCalculator
     {
-        public OsuScoreMultiplierCalculator(ScoreMultiplierContext context)
+        public OsuScoreMultiplierCalculatorV1(ScoreMultiplierContext context)
             : base(context)
         {
             #region Difficulty Reduction

osu.Game.Rulesets.Osu/Scoring/OsuScoreMultiplierCalculatorV2.cs

@@ -0,0 +1,200 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Scoring
+{
+    public class OsuScoreMultiplierCalculatorV2 : ScoreMultiplierCalculator
+    {
+        public OsuScoreMultiplierCalculatorV2(ScoreMultiplierContext context)
+            : base(context)
+        {
+            #region Difficulty Reduction
+
+            Single<OsuModEasy>(hasMultiplier: easyMultiplier);
+            Single<OsuModNoFail>(hasMultiplier: 0.5);
+            Single<OsuModHalfTime>(hasMultiplier: halfTime => halfTimeMultiplier(halfTime.SpeedChange.Value));
+            Single<OsuModDaycore>(hasMultiplier: daycore => halfTimeMultiplier(daycore.SpeedChange.Value));
+
+            #endregion
+
+            #region Difficulty Increase
+
+            Single<OsuModHardRock>(hasMultiplier: 1.09);
+            // Sudden Death (1.0x)
+            // Perfect (1.0x)
+            Single<OsuModDoubleTime>(hasMultiplier: doubleTime => doubleTimeMultiplier(doubleTime.SpeedChange.Value));
+            Single<OsuModNightcore>(hasMultiplier: nightcore => doubleTimeMultiplier(nightcore.SpeedChange.Value));
+
+            const double blinds_multiplier = 1.24;
+
+            Combination<OsuModHidden, OsuModBlinds>(hasMultiplier: (_, _) => blinds_multiplier);
+
+            Combination<OsuModHidden, OsuModWiggle>(hasMultiplier: (hidden, _) => hiddenMultiplier(hidden, otherModsProvideTimingInfo: true));
+            Combination<OsuModHidden, OsuModGrow>(hasMultiplier: (hidden, _) => hiddenMultiplier(hidden, otherModsProvideTimingInfo: true));
+            Combination<OsuModHidden, OsuModDeflate>(hasMultiplier: (hidden, deflate) => hiddenMultiplier(hidden, otherModsProvideTimingInfo: true) * deflateMultiplier(deflate));
+            Combination<OsuModHidden, OsuModRepel>(hasMultiplier: (hidden, _) => hiddenMultiplier(hidden, otherModsProvideTimingInfo: true));
+            Combination<OsuModHidden, OsuModDepth>(hasMultiplier: (hidden, _) => hiddenMultiplier(hidden, otherModsProvideTimingInfo: true));
+
+            Single<OsuModHidden>(hasMultiplier: hidden => hiddenMultiplier(hidden, otherModsProvideTimingInfo: false));
+
+            Combination<OsuModTraceable, OsuModBlinds>(hasMultiplier: (_, _) => blinds_multiplier);
+            Single<OsuModTraceable>(hasMultiplier: 1.02);
+
+            Combination<OsuModFlashlight, OsuModFreezeFrame>(hasMultiplier: (flashlight, _) => 1 + (flashlightMultiplier(flashlight) - 1) / 2);
+            Single<OsuModFlashlight>(hasMultiplier: flashlightMultiplier);
+
+            Single<OsuModBlinds>(hasMultiplier: blinds_multiplier);
+            // Strict Tracking (1.0x)
+            // Accuracy Challenge (1.0x)
+
+            #endregion
+
+            #region Conversion
+
+            Single<OsuModTargetPractice>(hasMultiplier: 0.01);
+            Single<OsuModDifficultyAdjust>(hasMultiplier: difficultyAdjust => difficultyAdjustMultiplier(difficultyAdjust, Context.BeatmapDifficultyWithoutMods));
+            Single<OsuModClassic>(hasMultiplier: classic => classic.ClassicNoteLock.Value ? 0.985 : 0.96);
+            Single<OsuModRandom>(hasMultiplier: 0.7);
+            // Mirror (1.0x)
+            // Alternate (1.0x)
+            // Single Tap (1.0x)
+
+            #endregion
+
+            #region Automation
+
+            // Autoplay (1.0x)
+            // Cinema (1.0x)
+            Single<OsuModRelax>(hasMultiplier: 0.1);
+            Single<OsuModAutopilot>(hasMultiplier: 0.1);
+            Single<OsuModSpunOut>(hasMultiplier: 0.95);
+
+            #endregion
+
+            #region Fun
+
+            // Transform (1.0x)
+            // Wiggle (1.0x)
+            // Spin In (1.0x)
+            // Grow (1.0x)
+            Single<OsuModDeflate>(hasMultiplier: deflateMultiplier);
+            Single<ModWindUp>(hasMultiplier: timeRampMultiplier);
+            Single<ModWindDown>(hasMultiplier: timeRampMultiplier);
+            // Barrel Roll (1.0x)
+            Single<OsuModApproachDifferent>(hasMultiplier: 0.7);
+            // Muted (1.0x)
+            // No Scope (1.0x)
+            Single<OsuModMagnetised>(hasMultiplier: magnetised => 0.7 - magnetised.AttractionStrength.Value * 0.6);
+            // Repel (1.0x)
+            Single<ModAdaptiveSpeed>(hasMultiplier: 0.1);
+            // Freeze Frame (1.0x)
+            // Bubbles (1.0x)
+            Single<OsuModSynesthesia>(hasMultiplier: 0.99);
+            // Depth (1.0x)
+            // Bloom (1.0x)
+
+            #endregion
+
+            #region System
+
+            // Touch Device (1.0x)
+            // Score V2 (1.0x)
+
+            #endregion
+        }
+
+        private static double easyMultiplier(OsuModEasy easy)
+        {
+            // 0.8x base multiplier
+            // Reduce by 0.1x per extra life
+            double value = 0.8 - Math.Max(0, 0.1 * (easy.Retries.Value - easy.Retries.Default));
+
+            return Math.Max(0.4, value);
+        }
+
+        private static double halfTimeMultiplier(double speedChange)
+        {
+            // 0.2x at 0.5x speed, +0.07x per 0.05x speed increment.
+            // Default HT (0.75x) = 0.55
+            return (int)(speedChange * 20) / 20.0 * 1.4 - 0.5;
+        }
+
+        private static double doubleTimeMultiplier(double speedChange)
+        {
+            // Floor to the nearest multiple of 0.1.
+            double value = (int)(speedChange * 10) / 10.0;
+
+            // 0.01 penalty for non-default rates.
+            double penalty = value != 1.5 && value != 1.0 ? 0.01 : 0.0;
+
+            // Linear from 1.0 to 1.46, minus the penalty.
+            // Default DT (1.5x) = 1.23
+            return (value - 1) * 0.46 + 1 - penalty;
+        }
+
+        private static double hiddenMultiplier(OsuModHidden hidden, bool otherModsProvideTimingInfo)
+        {
+            double value = 1.04;
+
+            if (hidden.OnlyFadeApproachCircles.Value)
+                value -= 0.02;
+
+            if (otherModsProvideTimingInfo)
+                value -= 0.02;
+
+            return value;
+        }
+
+        private static double flashlightMultiplier(OsuModFlashlight flashlight)
+        {
+            // Multiplier of 1.2x, reduced by 0.02 per 0.1 increase in flashlight size.
+            double value = Math.Max(1.02, Math.Min(1.2, 1.2 - 0.2 * (flashlight.SizeMultiplier.Value - 1)));
+
+            if (!flashlight.ComboBasedSize.Value)
+                value = 1 + (value - 1) / 5;
+
+            return value;
+        }
+
+        private static double difficultyAdjustMultiplier(OsuModDifficultyAdjust difficultyAdjust, IBeatmapDifficultyInfo beatmapDifficulty)
+        {
+            double selectedCircleSize = difficultyAdjust.CircleSize.Value ?? beatmapDifficulty.CircleSize;
+            double selectedDrainRate = difficultyAdjust.DrainRate.Value ?? beatmapDifficulty.DrainRate;
+            double selectedOverallDifficulty = difficultyAdjust.OverallDifficulty.Value ?? beatmapDifficulty.OverallDifficulty;
+            double selectedApproachRate = difficultyAdjust.ApproachRate.Value ?? beatmapDifficulty.ApproachRate;
+
+            double csDifference = Math.Abs(selectedCircleSize - beatmapDifficulty.CircleSize);
+            double hpDifference = Math.Abs(selectedDrainRate - beatmapDifficulty.DrainRate);
+            double odDifference = Math.Abs(selectedOverallDifficulty - beatmapDifficulty.OverallDifficulty);
+            double arDifference = Math.Abs(selectedApproachRate - beatmapDifficulty.ApproachRate);
+
+            // Per parameter, reduce multiplier by 0.05x per 0.1 change.
+            double csMultiplier = Math.Max(0.1, 1.0 - csDifference * 0.5);
+            double hpMultiplier = Math.Max(0.1, 1.0 - hpDifference * 0.5);
+            double odMultiplier = Math.Max(0.1, 1.0 - odDifference * 0.5);
+            double arMultiplier = Math.Max(0.1, 1.0 - arDifference * 0.5);
+
+            return Math.Max(0.1, csMultiplier * hpMultiplier * odMultiplier * arMultiplier);
+        }
+
+        private static double timeRampMultiplier(ModTimeRamp timeRamp)
+        {
+            double minSpeed = Math.Min(timeRamp.InitialRate.Value, timeRamp.FinalRate.Value);
+            double maxSpeed = Math.Max(timeRamp.InitialRate.Value, timeRamp.FinalRate.Value);
+
+            double minMultiplier = minSpeed < 1 ? halfTimeMultiplier(minSpeed) : doubleTimeMultiplier(minSpeed);
+            double maxMultiplier = maxSpeed < 1 ? halfTimeMultiplier(maxSpeed) : doubleTimeMultiplier(maxSpeed);
+
+            return 0.8 * minMultiplier + 0.2 * maxMultiplier;
+        }
+
+        private static double deflateMultiplier(OsuModDeflate deflate)
+            => 1.0 - Math.Max(0, 0.02 * (deflate.StartScale.Value - deflate.StartScale.Default));
+    }
+}

osu.Game.Rulesets.Taiko.Tests/TaikoScoreMultiplierTest.cs

@@ -2,8 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Mods;
+using osu.Game.Scoring;
 using osu.Game.Tests.Rulesets;
 
 namespace osu.Game.Rulesets.Taiko.Tests
@@ -113,7 +117,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             [new Mod[] { new TaikoModRandom() }, 1],
             [new Mod[] { new TaikoModDifficultyAdjust() }, 0.5],
-            [new Mod[] { new TaikoModClassic() }, 0.96],
+            [new Mod[] { new TaikoModClassic() }, 1],
             [new Mod[] { new TaikoModSwap() }, 1],
             [new Mod[] { new TaikoModSingleTap() }, 1],
             [new Mod[] { new TaikoModConstantSpeed() }, 0.9],
@@ -153,5 +157,17 @@ namespace osu.Game.Rulesets.Taiko.Tests
         [TestCaseSource(nameof(test_cases))]
         public void TestMultipliers(Mod[] mods, double expectedMultiplier)
             => TestModCombination(mods, expectedMultiplier);
+
+        [TestCase(30000001, 0.96)]
+        [TestCase(30000009, 0.96)]
+        [TestCase(30000016, 0.96)]
+        [TestCase(30000017, 1)]
+        [TestCase(null, 1)]
+        public void TestClassicMultiplierVersioning(int? totalScoreVersion, double expectedMultiplier)
+        {
+            var scoreInfo = totalScoreVersion != null ? new ScoreInfo { TotalScoreVersion = totalScoreVersion.Value } : null;
+            var calculator = Ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty(), scoreInfo));
+            Assert.That(calculator.CalculateFor([new TaikoModClassic()]), Is.EqualTo(expectedMultiplier).Within(Precision.DOUBLE_EPSILON));
+        }
     }
 }

osu.Game.Rulesets.Taiko/Mods/TaikoModConstantSpeed.cs

@@ -16,7 +16,6 @@ namespace osu.Game.Rulesets.Taiko.Mods
     {
         public override string Name => "Constant Speed";
         public override string Acronym => "CS";
-        public override double ScoreMultiplier => 0.9;
         public override LocalisableString Description => "No more tricky speed changes!";
         public override IconUsage? Icon => OsuIcon.ModConstantSpeed;
         public override ModType Type => ModType.Conversion;

osu.Game.Rulesets.Taiko/Mods/TaikoModFlashlight.cs

@@ -14,8 +14,6 @@ namespace osu.Game.Rulesets.Taiko.Mods
 {
     public partial class TaikoModFlashlight : ModFlashlight<TaikoHitObject>
     {
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.12 : 1;
-
         public override BindableFloat SizeMultiplier { get; } = new BindableFloat(1)
         {
             MinValue = 0.5f,

osu.Game.Rulesets.Taiko/Mods/TaikoModHardRock.cs

@@ -9,8 +9,6 @@ namespace osu.Game.Rulesets.Taiko.Mods
 {
     public class TaikoModHardRock : ModHardRock
     {
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
-
         /// <summary>
         /// Multiplier factor added to the scrolling speed.
         /// </summary>

osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs

@@ -17,7 +17,6 @@ namespace osu.Game.Rulesets.Taiko.Mods
     public class TaikoModHidden : ModHidden, IApplicableToDrawableRuleset<TaikoHitObject>
     {
         public override LocalisableString Description => @"Beats fade out before you hit them!";
-        public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
 
         /// <summary>
         /// How far away from the hit target should hitobjects start to fade out.

osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs

@@ -21,7 +21,6 @@ namespace osu.Game.Rulesets.Taiko.Mods
     {
         public override string Name => "Simplified Rhythm";
         public override string Acronym => "SR";
-        public override double ScoreMultiplier => 0.6;
         public override LocalisableString Description => "Simplify tricky rhythms!";
         public override IconUsage? Icon => OsuIcon.ModSimplifiedRhythm;
         public override ModType Type => ModType.DifficultyReduction;

osu.Game.Rulesets.Taiko/Mods/TaikoModSingleTap.cs

@@ -30,7 +30,6 @@ namespace osu.Game.Rulesets.Taiko.Mods
         public override LocalisableString Description => @"One key for dons, one key for kats.";
 
         public override bool Ranked => true;
-        public override double ScoreMultiplier => 1.0;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay), typeof(ModRelax), typeof(TaikoModCinema) };
         public override ModType Type => ModType.Conversion;
 

osu.Game.Rulesets.Taiko/Mods/TaikoModSwap.cs

@@ -20,7 +20,6 @@ namespace osu.Game.Rulesets.Taiko.Mods
         public override LocalisableString Description => @"Dons become kats, kats become dons";
         public override IconUsage? Icon => OsuIcon.ModSwap;
         public override ModType Type => ModType.Conversion;
-        public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(ModRandom)).ToArray();
         public override bool Ranked => true;
 

osu.Game.Rulesets.Taiko/Scoring/TaikoScoreMultiplierCalculator.cs

@@ -4,6 +4,7 @@
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Mods;
+using osu.Game.Scoring;
 
 namespace osu.Game.Rulesets.Taiko.Scoring
 {
@@ -39,7 +40,7 @@ namespace osu.Game.Rulesets.Taiko.Scoring
 
             // Random
             Single<TaikoModDifficultyAdjust>(hasMultiplier: 0.5);
-            Single<TaikoModClassic>(hasMultiplier: 0.96);
+            Single<TaikoModClassic>(hasMultiplier: _ => classicMultiplier(Context.Score));
             // Swap
             // Single Tap
             Single<TaikoModConstantSpeed>(hasMultiplier: 0.9);
@@ -83,5 +84,13 @@ namespace osu.Game.Rulesets.Taiko.Scoring
             else
                 return 0.6 + value;
         }
+
+        private static double classicMultiplier(ScoreInfo? score)
+        {
+            if (score != null && score.TotalScoreVersion < 30000017)
+                return 0.96;
+
+            return 1;
+        }
     }
 }

osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs

@@ -552,6 +552,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         }
 
         [Test]
+        [Ignore("Temporarily ignored pending correct addressing of treatment of `TotalScoreVersion` in replays")]
         public void TestTotalScoreWithoutModsBackwardsPopulatedIfMissing()
         {
             var ruleset = new OsuRuleset().RulesetInfo;

osu.Game.Tests/Mods/ModSettingsTest.cs

@@ -91,7 +91,6 @@ namespace osu.Game.Tests.Mods
         {
             public override string Name => "Non-matching setting type mod";
             public override LocalisableString Description => "Description";
-            public override double ScoreMultiplier => 1;
             public override ModType Type => ModType.Conversion;
 
             [SettingSource("Test setting")]

osu.Game.Tests/Mods/ModUtilsTest.cs

@@ -421,7 +421,6 @@ namespace osu.Game.Tests.Mods
             public override string Name => string.Empty;
             public override LocalisableString Description => string.Empty;
             public override string Acronym => string.Empty;
-            public override double ScoreMultiplier => 1;
             public override bool HasImplementation => true;
             public override bool ValidForMultiplayer => false;
             public override bool ValidForMultiplayerAsFreeMod => false;
@@ -432,7 +431,6 @@ namespace osu.Game.Tests.Mods
             public override string Name => string.Empty;
             public override LocalisableString Description => string.Empty;
             public override string Acronym => string.Empty;
-            public override double ScoreMultiplier => 1;
             public override bool HasImplementation => true;
             public override bool ValidForMultiplayerAsFreeMod => false;
         }
@@ -441,7 +439,6 @@ namespace osu.Game.Tests.Mods
         {
             public override string Name => string.Empty;
             public override LocalisableString Description => string.Empty;
-            public override double ScoreMultiplier => 1;
             public override string Acronym => string.Empty;
             public override bool HasImplementation => true;
             public override bool ValidForFreestyleAsRequiredMod => false;

osu.Game.Tests/Mods/TestCustomisableModRuleset.cs

@@ -59,8 +59,6 @@ namespace osu.Game.Tests.Mods
 
         public abstract class TestModCustomisable : Mod, IApplicableMod
         {
-            public override double ScoreMultiplier => 1.0;
-
             public override LocalisableString Description => "This is a customisable test mod.";
 
             public override ModType Type => ModType.Conversion;

osu.Game.Tests/NonVisual/DifficultyAdjustmentModCombinationsTest.cs

@@ -161,7 +161,6 @@ namespace osu.Game.Tests.NonVisual
             public override string Name => nameof(ModA);
             public override string Acronym => nameof(ModA);
             public override LocalisableString Description => string.Empty;
-            public override double ScoreMultiplier => 1;
 
             public override Type[] IncompatibleMods => new[] { typeof(ModIncompatibleWithA), typeof(ModIncompatibleWithAAndB) };
         }
@@ -171,7 +170,6 @@ namespace osu.Game.Tests.NonVisual
             public override string Name => nameof(ModB);
             public override LocalisableString Description => string.Empty;
             public override string Acronym => nameof(ModB);
-            public override double ScoreMultiplier => 1;
 
             public override Type[] IncompatibleMods => new[] { typeof(ModIncompatibleWithAAndB) };
         }
@@ -181,7 +179,6 @@ namespace osu.Game.Tests.NonVisual
             public override string Name => nameof(ModC);
             public override string Acronym => nameof(ModC);
             public override LocalisableString Description => string.Empty;
-            public override double ScoreMultiplier => 1;
         }
 
         private class ModIncompatibleWithA : Mod
@@ -189,7 +186,6 @@ namespace osu.Game.Tests.NonVisual
             public override string Name => $"Incompatible With {nameof(ModA)}";
             public override string Acronym => $"Incompatible With {nameof(ModA)}";
             public override LocalisableString Description => string.Empty;
-            public override double ScoreMultiplier => 1;
 
             public override Type[] IncompatibleMods => new[] { typeof(ModA) };
         }
@@ -208,7 +204,6 @@ namespace osu.Game.Tests.NonVisual
             public override string Name => $"Incompatible With {nameof(ModA)} and {nameof(ModB)}";
             public override string Acronym => $"Incompatible With {nameof(ModA)} and {nameof(ModB)}";
             public override LocalisableString Description => string.Empty;
-            public override double ScoreMultiplier => 1;
 
             public override Type[] IncompatibleMods => new[] { typeof(ModA), typeof(ModB) };
         }

osu.Game.Tests/Online/TestAPIModJsonSerialization.cs

@@ -185,7 +185,6 @@ namespace osu.Game.Tests.Online
             public override string Name => "Test Mod";
             public override string Acronym => "TM";
             public override LocalisableString Description => "This is a test mod.";
-            public override double ScoreMultiplier => 1;
 
             [SettingSource("Test")]
             public BindableNumber<double> TestSetting { get; } = new BindableDouble
@@ -202,7 +201,6 @@ namespace osu.Game.Tests.Online
             public override string Name => "Test Mod";
             public override string Acronym => "TMTR";
             public override LocalisableString Description => "This is a test mod.";
-            public override double ScoreMultiplier => 1;
 
             [SettingSource("Initial rate", "The starting speed of the track")]
             public override BindableNumber<double> InitialRate { get; } = new BindableDouble(1.5)

osu.Game.Tests/Online/TestAPIModMessagePackSerialization.cs

@@ -104,7 +104,6 @@ namespace osu.Game.Tests.Online
             public override string Name => "Test Mod";
             public override string Acronym => "TM";
             public override LocalisableString Description => "This is a test mod.";
-            public override double ScoreMultiplier => 1;
 
             [SettingSource("Test")]
             public BindableNumber<double> TestSetting { get; } = new BindableDouble
@@ -121,7 +120,6 @@ namespace osu.Game.Tests.Online
             public override string Name => "Test Mod";
             public override string Acronym => "TMTR";
             public override LocalisableString Description => "This is a test mod.";
-            public override double ScoreMultiplier => 1;
 
             [SettingSource("Initial rate", "The starting speed of the track")]
             public override BindableNumber<double> InitialRate { get; } = new BindableDouble(1.5)
@@ -148,7 +146,6 @@ namespace osu.Game.Tests.Online
             public override string Name => "Test Mod";
             public override string Acronym => "TM";
             public override LocalisableString Description => "This is a test mod.";
-            public override double ScoreMultiplier => 1;
 
             [SettingSource("Test")]
             public Bindable<TestEnum> TestSetting { get; } = new Bindable<TestEnum>();

osu.Game.Tests/Resources/TestResources.cs

@@ -222,12 +222,10 @@ namespace osu.Game.Tests.Resources
 
         private class TestModHardRock : ModHardRock
         {
-            public override double ScoreMultiplier => 1;
         }
 
         private class TestModDoubleTime : ModDoubleTime
         {
-            public override double ScoreMultiplier => 1;
         }
     }
 }

osu.Game.Tests/Rulesets/Scoring/ScoreMultiplierCalculatorTest.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
@@ -13,7 +14,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
         [Test]
         public void TestFlatMultiplier()
         {
-            var calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext());
+            var calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
 
             double multiplier = calculator.CalculateFor([new OsuModEasy()]);
 
@@ -23,7 +24,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
         [Test]
         public void TestSettingDependentMultiplier()
         {
-            var calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext());
+            var calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
 
             double multiplier = calculator.CalculateFor([new OsuModDaycore { SpeedChange = { Value = 0.6 } }]);
 
@@ -31,7 +32,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
         }
 
         [Test]
-        public void TestContextDependentMultiplier()
+        public void TestScoreDependentMultiplier()
         {
             TestScoreMultiplierCalculator calculator;
 
@@ -39,20 +40,39 @@ namespace osu.Game.Tests.Rulesets.Scoring
 
             Assert.Multiple(() =>
             {
-                calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext());
+                calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
                 multiplier = calculator.CalculateFor([new OsuModHardRock()]);
                 Assert.That(multiplier, Is.EqualTo(1.4));
 
-                calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new ScoreInfo { ClientVersion = "2024.123.0" }));
+                calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty(), new ScoreInfo { ClientVersion = "2024.123.0" }));
                 multiplier = calculator.CalculateFor([new OsuModHardRock()]);
                 Assert.That(multiplier, Is.EqualTo(1.2));
             });
         }
 
+        [Test]
+        public void TestDifficultyDependentMultiplier()
+        {
+            TestScoreMultiplierCalculator calculator;
+
+            double multiplier;
+
+            Assert.Multiple(() =>
+            {
+                calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
+                multiplier = calculator.CalculateFor([new OsuModEasy()]);
+                Assert.That(multiplier, Is.EqualTo(0.15));
+
+                calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty { ApproachRate = 0 }));
+                multiplier = calculator.CalculateFor([new OsuModEasy()]);
+                Assert.That(multiplier, Is.EqualTo(0.1));
+            });
+        }
+
         [Test]
         public void TestCombinationMultiplier()
         {
-            var calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext());
+            var calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
 
             double multiplier = calculator.CalculateFor([new OsuModEasy(), new OsuModDaycore()]);
 
@@ -62,7 +82,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
         [Test]
         public void TestCombinationAndFlatMultipliers()
         {
-            var calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext());
+            var calculator = new TestScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
 
             double multiplier = calculator.CalculateFor([new OsuModDaycore(), new OsuModHardRock(), new OsuModEasy()]);
 
@@ -74,7 +94,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
             public TestScoreMultiplierCalculator(ScoreMultiplierContext context)
                 : base(context)
             {
-                Single<OsuModEasy>(hasMultiplier: 0.15);
+                Single<OsuModEasy>(hasMultiplier: context.BeatmapDifficultyWithoutMods.ApproachRate == 0 ? 0.1 : 0.15);
                 Single<OsuModDaycore>(hasMultiplier: daycore => (1 + daycore.SpeedChange.Value) / 4);
                 Single<OsuModHardRock>(hasMultiplier: _ => context.Score?.ClientVersion == "2024.123.0" ? 1.2 : 1.4);
                 Combination<OsuModEasy, OsuModDaycore>(hasMultiplier: (_, _) => 0.003);

osu.Game.Tests/Rulesets/Scoring/ScoreProcessorTest.cs

@@ -481,6 +481,29 @@ namespace osu.Game.Tests.Rulesets.Scoring
             Assert.That(scoreProcessor.HighestCombo.Value, Is.Zero);
         }
 
+        [Test]
+        public void TestScoreMultiplier()
+        {
+            Mod[] mods = new Mod[] { new OsuModHardRock() };
+
+            scoreProcessor = new TestScoreProcessor();
+            scoreProcessor.Mods.Value = mods;
+
+            var workingBeatmap = new TestWorkingBeatmap(beatmap);
+            var playableBeatmap = workingBeatmap.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, mods);
+
+            scoreProcessor.ApplyBeatmap(playableBeatmap);
+
+            var judgementResult = new JudgementResult(beatmap.HitObjects.Single(), new OsuJudgement())
+            {
+                Type = HitResult.Great,
+            };
+            scoreProcessor.ApplyResult(judgementResult);
+
+            Assert.That(scoreProcessor.MaximumTotalScore, Is.EqualTo(1_000_000 * 1.1).Within(0.5d));
+            Assert.That(scoreProcessor.GetDisplayScore(ScoringMode.Standardised), Is.EqualTo(1_000_000 * 1.1).Within(0.5d));
+        }
+
         private class TestJudgement : Judgement
         {
             public override HitResult MaxResult { get; }
@@ -537,9 +560,20 @@ namespace osu.Game.Tests.Rulesets.Scoring
 
                 public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => throw new NotImplementedException();
 
+                public override ScoreMultiplierCalculator CreateScoreMultiplierCalculator(ScoreMultiplierContext context) => new TestScoreMultiplierCalculator(context);
+
                 public override string Description => string.Empty;
                 public override string ShortName => string.Empty;
             }
+
+            private class TestScoreMultiplierCalculator : ScoreMultiplierCalculator
+            {
+                public TestScoreMultiplierCalculator(ScoreMultiplierContext context)
+                    : base(context)
+                {
+                    Single<OsuModHardRock>(hasMultiplier: context.BeatmapDifficultyWithoutMods.CircleSize == 4 ? 1.1 : 1.0);
+                }
+            }
         }
     }
 }

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs

@@ -321,13 +321,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             ClickButtonWhenEnabled<UserModSelectButton>();
             AddUntilStep("mod select shows unranked", () => this.ChildrenOfType<RankingInformationDisplay>().Single().Ranked.Value == false);
-            AddAssert("score multiplier = 1.20", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
+            AddAssert("score multiplier = 1.45", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.45).Within(0.01));
 
             AddStep("select flashlight", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().ChildrenOfType<ModPanel>().Single(m => m.Mod is ModFlashlight).TriggerClick());
-            AddAssert("score multiplier = 1.35", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.35).Within(0.01));
+            AddAssert("score multiplier = 1.74", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.74).Within(0.01));
 
-            AddStep("change flashlight setting", () => ((OsuModFlashlight)this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().SelectedMods.Value.Single()).FollowDelay.Value = 1200);
-            AddAssert("score multiplier = 1.20", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
+            AddStep("change flashlight setting", () => ((OsuModFlashlight)this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().SelectedMods.Value.Single()).ComboBasedSize.Value = false);
+            AddAssert("score multiplier = 1.51", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.51).Within(0.01));
         }
 
         [Test]

osu.Game.Tests/Visual/SongSelect/TestSceneFooterButtonMods.cs

@@ -8,14 +8,13 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
 using osu.Game.Utils;
 
@@ -72,19 +71,19 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("Set ruleset", () => footerButtonMods.Ruleset.Value = ruleset.RulesetInfo);
 
             AddStep(@"Add Hidden", () => changeMods(hiddenMod));
-            assertModsMultiplier(ruleset, hiddenMod);
+            assertModsMultiplier(1.04);
 
             var hardRockMod = new Mod[] { new OsuModHardRock() };
             AddStep(@"Add HardRock", () => changeMods(hardRockMod));
-            assertModsMultiplier(ruleset, hardRockMod);
+            assertModsMultiplier(1.09);
 
             var doubleTimeMod = new Mod[] { new OsuModDoubleTime() };
             AddStep(@"Add DoubleTime", () => changeMods(doubleTimeMod));
-            assertModsMultiplier(ruleset, doubleTimeMod);
+            assertModsMultiplier(1.23);
 
             var multipleIncrementMods = new Mod[] { new OsuModDoubleTime(), new OsuModHidden(), new OsuModHardRock() };
             AddStep(@"Add multiple Mods", () => changeMods(multipleIncrementMods));
-            assertModsMultiplier(ruleset, multipleIncrementMods);
+            assertModsMultiplier(1.23 * 1.04 * 1.09);
         }
 
         [Test]
@@ -96,15 +95,60 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("Set ruleset", () => footerButtonMods.Ruleset.Value = ruleset.RulesetInfo);
 
             AddStep(@"Add Easy", () => changeMods(easyMod));
-            assertModsMultiplier(ruleset, easyMod);
+            assertModsMultiplier(0.8);
 
             var noFailMod = new Mod[] { new OsuModNoFail() };
             AddStep(@"Add NoFail", () => changeMods(noFailMod));
-            assertModsMultiplier(ruleset, noFailMod);
+            assertModsMultiplier(0.5);
 
             var multipleDecrementMods = new Mod[] { new OsuModEasy(), new OsuModNoFail() };
             AddStep(@"Add Multiple Mods", () => changeMods(multipleDecrementMods));
-            assertModsMultiplier(ruleset, multipleDecrementMods);
+            assertModsMultiplier(0.8 * 0.5);
+        }
+
+        [Test]
+        public void TestDifficultyAdjustMultiplier()
+        {
+            var ruleset = new OsuRuleset();
+            var difficultyAdjustMod = new OsuModDifficultyAdjust();
+
+            AddStep("Set ruleset", () => footerButtonMods.Ruleset.Value = ruleset.RulesetInfo);
+
+            AddStep("Set beatmap", () =>
+            {
+                var beatmap = CreateWorkingBeatmap(ruleset.RulesetInfo);
+                beatmap.BeatmapInfo.Difficulty = new BeatmapDifficulty
+                {
+                    ApproachRate = 3,
+                    OverallDifficulty = 5,
+                    CircleSize = 5,
+                    DrainRate = 6,
+                };
+                Beatmap.Value = beatmap;
+            });
+
+            AddStep(@"Set Difficulty Adjust", () => changeMods([difficultyAdjustMod]));
+            assertModsMultiplier(1);
+
+            AddStep("Adjust AR", () => difficultyAdjustMod.ApproachRate.Value = 3.3f);
+            assertModsMultiplier(0.85);
+
+            AddStep("Adjust HP", () => difficultyAdjustMod.DrainRate.Value = 6.5f);
+            assertModsMultiplier(0.6375);
+
+            AddStep("Change beatmap", () =>
+            {
+                var beatmap = CreateWorkingBeatmap(ruleset.RulesetInfo);
+                beatmap.BeatmapInfo.Difficulty = new BeatmapDifficulty
+                {
+                    ApproachRate = 3.3f,
+                    OverallDifficulty = 8,
+                    CircleSize = 8,
+                    DrainRate = 6,
+                };
+                Beatmap.Value = beatmap;
+            });
+            assertModsMultiplier(0.75);
         }
 
         [Test]
@@ -118,11 +162,9 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private void changeMods(IReadOnlyList<Mod> mods) => footerButtonMods.Mods.Value = mods;
 
-        private void assertModsMultiplier(Ruleset ruleset, IEnumerable<Mod> mods)
+        private void assertModsMultiplier(double expectedMultiplier)
         {
-            var scoreMultiplierCalculator = ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext());
-            double multiplier = scoreMultiplierCalculator.CalculateFor(mods);
-            string expectedValue = ModUtils.FormatScoreMultiplier(multiplier).ToString();
+            string expectedValue = ModUtils.FormatScoreMultiplier(expectedMultiplier).ToString();
 
             AddAssert($"Displayed multiplier is {expectedValue}", () => footerButtonMods.ChildrenOfType<OsuSpriteText>().First(t => t.Text.ToString().Contains('x')).Text.ToString(), () => Is.EqualTo(expectedValue));
         }

osu.Game.Tests/Visual/UserInterface/TestSceneBeatmapAttributeText.cs

@@ -244,7 +244,6 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             public override string Name => string.Empty;
             public override LocalisableString Description => string.Empty;
-            public override double ScoreMultiplier => 1.0;
             public override string Acronym => "Test";
         }
     }

osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs

@@ -15,6 +15,7 @@ using osu.Framework.Localisation;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
+using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
@@ -124,7 +125,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddUntilStep("two panels active", () => modSelectOverlay.ChildrenOfType<ModPanel>().Count(panel => panel.Active.Value) == 2);
             AddAssert("mod multiplier correct", () =>
             {
-                double multiplier = new OsuScoreMultiplierCalculator(new ScoreMultiplierContext()).CalculateFor(SelectedMods.Value);
+                double multiplier = new OsuScoreMultiplierCalculatorV2(new ScoreMultiplierContext(new BeatmapDifficulty())).CalculateFor(SelectedMods.Value);
                 return Precision.AlmostEquals(multiplier, this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value);
             });
             assertCustomisationToggleState(disabled: false, active: false);
@@ -139,7 +140,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddUntilStep("two panels active", () => modSelectOverlay.ChildrenOfType<ModPanel>().Count(panel => panel.Active.Value) == 2);
             AddAssert("mod multiplier correct", () =>
             {
-                double multiplier = new OsuScoreMultiplierCalculator(new ScoreMultiplierContext()).CalculateFor(SelectedMods.Value);
+                double multiplier = new OsuScoreMultiplierCalculatorV2(new ScoreMultiplierContext(new BeatmapDifficulty())).CalculateFor(SelectedMods.Value);
                 return Precision.AlmostEquals(multiplier, this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value);
             });
             assertCustomisationToggleState(disabled: false, active: false);
@@ -898,7 +899,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                 InputManager.Click(MouseButton.Left);
             });
             AddAssert("difficulty multiplier display shows correct value",
-                () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(0.1).Within(Precision.DOUBLE_EPSILON));
+                () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(0.2).Within(Precision.DOUBLE_EPSILON));
 
             // this is highly unorthodox in a test, but because the `ModSettingChangeTracker` machinery heavily leans on events and object disposal and re-creation,
             // it is instrumental in the reproduction of the failure scenario that this test is supposed to cover.
@@ -908,7 +909,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddStep("reset half time speed to default", () => modSelectOverlay.ChildrenOfType<ModCustomisationPanel>().Single()
                                                                               .ChildrenOfType<RevertToDefaultButton<double>>().Single().TriggerClick());
             AddUntilStep("difficulty multiplier display shows correct value",
-                () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(0.3).Within(Precision.DOUBLE_EPSILON));
+                () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(0.55).Within(Precision.DOUBLE_EPSILON));
         }
 
         [Test]
@@ -1031,6 +1032,51 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddAssert("OsuModPerfect panel active", () => getPanelForMod(typeof(OsuModPerfect)).Active.Value);
         }
 
+        [Test]
+        public void TestDifficultyAdjustModMultiplierIsCalculatedCorrectly()
+        {
+            createScreen();
+            AddStep("set mods", () => SelectedMods.Value = new Mod[] { new OsuModDifficultyAdjust() });
+            AddUntilStep("one panel active", () => modSelectOverlay.ChildrenOfType<ModPanel>().Count(panel => panel.Active.Value), () => Is.EqualTo(1));
+            AddAssert("mod multiplier is correct", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value,
+                () => Is.EqualTo(1).Within(Precision.FLOAT_EPSILON));
+            assertCustomisationToggleState(disabled: false, active: false);
+            AddAssert("setting items created", () => modSelectOverlay.ChildrenOfType<ISettingsItem>().Any());
+
+            AddStep("modify DA", () => SelectedMods.Value.OfType<OsuModDifficultyAdjust>().Single().CircleSize.Value = 3.9f);
+            AddAssert("mod multiplier is correct", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value,
+                () => Is.EqualTo(0.95).Within(Precision.FLOAT_EPSILON));
+
+            AddStep("replace DA completely", () =>
+            {
+                SelectedMods.Value = new Mod[]
+                {
+                    new OsuModDifficultyAdjust
+                    {
+                        ApproachRate = { Value = 6.8f },
+                        OverallDifficulty = { Value = 6.2f }
+                    }
+                };
+            });
+            AddAssert("mod multiplier is correct", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value,
+                () => Is.EqualTo(0.81).Within(Precision.FLOAT_EPSILON));
+
+            AddStep("change beatmap", () =>
+            {
+                var beatmap = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                beatmap.BeatmapInfo.Difficulty = new BeatmapDifficulty
+                {
+                    ApproachRate = 6,
+                    OverallDifficulty = 5,
+                    CircleSize = 5,
+                    DrainRate = 5,
+                };
+                modSelectOverlay.Beatmap.Value = beatmap;
+            });
+            AddAssert("mod multiplier is correct", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value,
+                () => Is.EqualTo(0.24).Within(Precision.FLOAT_EPSILON));
+        }
+
         private void waitForColumnLoad() => AddUntilStep("all column content loaded", () =>
             modSelectOverlay.ChildrenOfType<ModColumn>().Any()
             && modSelectOverlay.ChildrenOfType<ModColumn>().All(column => column.IsLoaded && column.ItemsLoaded)
@@ -1146,7 +1192,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             public override string Name => "Unimplemented mod";
             public override string Acronym => "UM";
             public override LocalisableString Description => "A mod that is not implemented.";
-            public override double ScoreMultiplier => 1;
             public override ModType Type => ModType.Conversion;
         }
 

osu.Game/Database/StandardisedScoreMigrationTools.cs

@@ -188,7 +188,10 @@ namespace osu.Game.Database
             }
 
             var ruleset = score.Ruleset.CreateInstance();
-            var scoreMultiplierCalculator = ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(score));
+
+            Debug.Assert(score.BeatmapInfo != null);
+
+            var scoreMultiplierCalculator = ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(score.BeatmapInfo.Difficulty, score));
             double modMultiplier = scoreMultiplierCalculator.CalculateFor(score.Mods);
 
             return (long)Math.Round((1000000 * (accuracyPortion * accuracyScore + (1 - accuracyPortion) * comboScore) + bonusScore) * modMultiplier);
@@ -351,7 +354,7 @@ namespace osu.Game.Database
             long maximumLegacyBaseScore = maximumLegacyAccuracyScore + maximumLegacyComboScore;
             double bonusProportion = Math.Max(0, ((long)score.LegacyTotalScore - maximumLegacyBaseScore) * maximumLegacyBonusRatio);
 
-            var modMultiplierCalculator = ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext());
+            var modMultiplierCalculator = ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(difficulty));
             double modMultiplier = modMultiplierCalculator.CalculateFor(score.Mods);
 
             long convertedTotalScoreWithoutMods;

osu.Game/Overlays/Mods/ModSelectFooterContent.cs

@@ -102,6 +102,8 @@ namespace osu.Game.Overlays.Mods
             {
                 if (beatmapAttributesDisplay != null)
                     beatmapAttributesDisplay.BeatmapInfo.Value = b.NewValue?.BeatmapInfo;
+
+                updateInformation();
             }, true);
 
             Ruleset.BindValueChanged(_ => updateInformation());
@@ -122,9 +124,11 @@ namespace osu.Game.Overlays.Mods
 
         private void updateInformation()
         {
-            if (rankingInformationDisplay != null)
+            WorkingBeatmap? workingBeatmap = Beatmap.Value;
+
+            if (rankingInformationDisplay != null && workingBeatmap != null)
             {
-                var scoreMultiplierCalculator = Ruleset.Value?.CreateInstance().CreateScoreMultiplierCalculator(new ScoreMultiplierContext());
+                var scoreMultiplierCalculator = Ruleset.Value?.CreateInstance().CreateScoreMultiplierCalculator(new ScoreMultiplierContext(workingBeatmap.BeatmapInfo.Difficulty));
                 double multiplier = scoreMultiplierCalculator?.CalculateFor(ActiveMods.Value) ?? 1;
 
                 rankingInformationDisplay.ModMultiplier.Value = multiplier;

osu.Game/Rulesets/Mods/Mod.cs

@@ -84,7 +84,8 @@ namespace osu.Game.Rulesets.Mods
         /// The score multiplier of this mod.
         /// </summary>
         [JsonIgnore]
-        public abstract double ScoreMultiplier { get; }
+        [Obsolete("This property is no longer used to calculate the score multiplier. Use `Ruleset.CreateScoreMultiplierCalculator()` instead.")]
+        public virtual double ScoreMultiplier => 1;
 
         /// <summary>
         /// Returns true if this mod is implemented (and playable).

osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs

@@ -30,8 +30,6 @@ namespace osu.Game.Rulesets.Mods
 
         public override ModType Type => ModType.DifficultyIncrease;
 
-        public override double ScoreMultiplier => 1.0;
-
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(ModEasyWithExtraLives), typeof(ModPerfect) }).ToArray();
 
         public override bool RequiresConfiguration => false;

osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs

@@ -33,8 +33,6 @@ namespace osu.Game.Rulesets.Mods
 
         public override ModType Type => ModType.Fun;
 
-        public override double ScoreMultiplier => 0.5;
-
         public sealed override bool ValidForMultiplayer => false;
         public sealed override bool ValidForMultiplayerAsFreeMod => false;
 

osu.Game/Rulesets/Mods/ModAutoplay.cs

@@ -18,7 +18,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModAutoplay;
         public override ModType Type => ModType.Automation;
         public override LocalisableString Description => "Watch a perfect automated play through the song.";
-        public override double ScoreMultiplier => 1;
 
         public sealed override bool UserPlayable => false;
         public sealed override bool ValidForMultiplayer => false;

osu.Game/Rulesets/Mods/ModBarrelRoll.cs

@@ -40,7 +40,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "BR";
         public override IconUsage? Icon => OsuIcon.ModBarrelRoll;
         public override LocalisableString Description => "The whole playfield is on a wheel!";
-        public override double ScoreMultiplier => 1;
 
         public override IEnumerable<(LocalisableString setting, LocalisableString value)> SettingDescription
         {

osu.Game/Rulesets/Mods/ModClassic.cs

@@ -13,8 +13,6 @@ namespace osu.Game.Rulesets.Mods
 
         public override string Acronym => "CL";
 
-        public override double ScoreMultiplier => 0.96;
-
         public override IconUsage? Icon => OsuIcon.ModClassic;
 
         public override LocalisableString Description => "Feeling nostalgic?";

osu.Game/Rulesets/Mods/ModDaycore.cs

@@ -30,13 +30,10 @@ namespace osu.Game.Rulesets.Mods
 
         private readonly BindableNumber<double> tempoAdjust = new BindableDouble(1);
         private readonly BindableNumber<double> freqAdjust = new BindableDouble(1);
-        private readonly RateAdjustModHelper rateAdjustHelper;
 
         protected ModDaycore()
         {
-            rateAdjustHelper = new RateAdjustModHelper(SpeedChange);
-
-            // intentionally not deferring the speed change handling to `RateAdjustModHelper`
+            // intentionally not using `RateAdjustModHelper`
             // as the expected result of operation is not the same (daycore should preserve constant pitch).
             SpeedChange.BindValueChanged(val =>
             {
@@ -50,7 +47,5 @@ namespace osu.Game.Rulesets.Mods
             track.AddAdjustment(AdjustableProperty.Frequency, freqAdjust);
             track.AddAdjustment(AdjustableProperty.Tempo, tempoAdjust);
         }
-
-        public override double ScoreMultiplier => rateAdjustHelper.ScoreMultiplier;
     }
 }

osu.Game/Rulesets/Mods/ModDifficultyAdjust.cs

@@ -25,8 +25,6 @@ namespace osu.Game.Rulesets.Mods
 
         public override IconUsage? Icon => OsuIcon.ModDifficultyAdjust;
 
-        public override double ScoreMultiplier => 0.5;
-
         public override bool RequiresConfiguration => true;
 
         public override bool ValidForFreestyleAsRequiredMod => true;

osu.Game/Rulesets/Mods/ModDoubleTime.cs

@@ -56,7 +56,5 @@ namespace osu.Game.Rulesets.Mods
         {
             rateAdjustHelper.ApplyToTrack(track);
         }
-
-        public override double ScoreMultiplier => rateAdjustHelper.ScoreMultiplier;
     }
 }

osu.Game/Rulesets/Mods/ModEasy.cs

@@ -14,7 +14,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "EZ";
         public override IconUsage? Icon => OsuIcon.ModEasy;
         public override ModType Type => ModType.DifficultyReduction;
-        public override double ScoreMultiplier => 0.5;
         public override Type[] IncompatibleMods => new[] { typeof(ModHardRock), typeof(ModDifficultyAdjust) };
         public override bool Ranked => UsesDefaultConfiguration;
         public override bool ValidForFreestyleAsRequiredMod => true;

osu.Game/Rulesets/Mods/ModHalfTime.cs

@@ -56,7 +56,5 @@ namespace osu.Game.Rulesets.Mods
         {
             rateAdjustHelper.ApplyToTrack(track);
         }
-
-        public override double ScoreMultiplier => rateAdjustHelper.ScoreMultiplier;
     }
 }

osu.Game/Rulesets/Mods/ModMirror.cs

@@ -12,6 +12,5 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "MR";
         public override IconUsage? Icon => OsuIcon.ModMirror;
         public override ModType Type => ModType.Conversion;
-        public override double ScoreMultiplier => 1;
     }
 }

osu.Game/Rulesets/Mods/ModMuted.cs

@@ -25,7 +25,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModMuted;
         public override LocalisableString Description => "Can you still feel the rhythm without music?";
         public override ModType Type => ModType.Fun;
-        public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
         public override bool ValidForFreestyleAsRequiredMod => true;
     }

osu.Game/Rulesets/Mods/ModNightcore.cs

@@ -41,13 +41,9 @@ namespace osu.Game.Rulesets.Mods
         private readonly BindableNumber<double> tempoAdjust = new BindableDouble(1);
         private readonly BindableNumber<double> freqAdjust = new BindableDouble(1);
 
-        private readonly RateAdjustModHelper rateAdjustHelper;
-
         protected ModNightcore()
         {
-            rateAdjustHelper = new RateAdjustModHelper(SpeedChange);
-
-            // intentionally not deferring the speed change handling to `RateAdjustModHelper`
+            // intentionally not using `RateAdjustModHelper`
             // as the expected result of operation is not the same (nightcore should preserve constant pitch).
             SpeedChange.BindValueChanged(val =>
             {
@@ -61,8 +57,6 @@ namespace osu.Game.Rulesets.Mods
             track.AddAdjustment(AdjustableProperty.Frequency, freqAdjust);
             track.AddAdjustment(AdjustableProperty.Tempo, tempoAdjust);
         }
-
-        public override double ScoreMultiplier => rateAdjustHelper.ScoreMultiplier;
     }
 
     public abstract partial class ModNightcore<TObject> : ModNightcore, IApplicableToDrawableRuleset<TObject>

osu.Game/Rulesets/Mods/ModNoFail.cs

@@ -18,7 +18,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModNoFail;
         public override ModType Type => ModType.DifficultyReduction;
         public override LocalisableString Description => "You can't fail, no matter what.";
-        public override double ScoreMultiplier => 0.5;
         public override Type[] IncompatibleMods => new[] { typeof(ModFailCondition), typeof(ModCinema) };
         public override bool Ranked => UsesDefaultConfiguration;
         public override bool ValidForFreestyleAsRequiredMod => true;

osu.Game/Rulesets/Mods/ModNoMod.cs

@@ -15,7 +15,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "No Mod";
         public override string Acronym => "NM";
         public override LocalisableString Description => "No mods applied.";
-        public override double ScoreMultiplier => 1;
         public override IconUsage? Icon => OsuIcon.ModNoMod;
         public override ModType Type => ModType.System;
     }

osu.Game/Rulesets/Mods/ModNoScope.cs

@@ -22,7 +22,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "NS";
         public override ModType Type => ModType.Fun;
         public override IconUsage? Icon => OsuIcon.ModNoScope;
-        public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
 
         /// <summary>

osu.Game/Rulesets/Mods/ModPerfect.cs

@@ -17,7 +17,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "PF";
         public override IconUsage? Icon => OsuIcon.ModPerfect;
         public override ModType Type => ModType.DifficultyIncrease;
-        public override double ScoreMultiplier => 1;
         public override LocalisableString Description => "SS or quit.";
         public override bool Ranked => true;
         public override bool ValidForFreestyleAsRequiredMod => true;

osu.Game/Rulesets/Mods/ModRandom.cs

@@ -15,7 +15,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "RD";
         public override ModType Type => ModType.Conversion;
         public override IconUsage? Icon => OsuIcon.ModRandom;
-        public override double ScoreMultiplier => 1;
 
         [SettingSource("Seed", "Use a custom seed instead of a random one", SettingControlType = typeof(SettingsNumberBox))]
         public Bindable<int?> Seed { get; } = new Bindable<int?>();

osu.Game/Rulesets/Mods/ModRelax.cs

@@ -13,7 +13,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Acronym => "RX";
         public override IconUsage? Icon => OsuIcon.ModRelax;
         public override ModType Type => ModType.Automation;
-        public override double ScoreMultiplier => 0.1;
         public override Type[] IncompatibleMods => new[] { typeof(ModAutoplay) };
     }
 }

osu.Game/Rulesets/Mods/ModScoreV2.cs

@@ -18,7 +18,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModScoreV2;
         public override ModType Type => ModType.System;
         public override LocalisableString Description => "Score set on earlier osu! versions with the V2 scoring algorithm active.";
-        public override double ScoreMultiplier => 1;
         public override bool UserPlayable => false;
         public override bool ValidForMultiplayer => false;
         public override bool ValidForMultiplayerAsFreeMod => false;

osu.Game/Rulesets/Mods/ModSuddenDeath.cs

@@ -18,7 +18,6 @@ namespace osu.Game.Rulesets.Mods
         public override IconUsage? Icon => OsuIcon.ModSuddenDeath;
         public override ModType Type => ModType.DifficultyIncrease;
         public override LocalisableString Description => "Miss and fail.";
-        public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
         public override bool ValidForFreestyleAsRequiredMod => true;
 

osu.Game/Rulesets/Mods/ModSynesthesia.cs

@@ -15,7 +15,6 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "Synesthesia";
         public override string Acronym => "SY";
         public override LocalisableString Description => "Colours hit objects based on the rhythm.";
-        public override double ScoreMultiplier => 0.8;
         public override IconUsage? Icon => OsuIcon.ModSynesthesia;
         public override ModType Type => ModType.Fun;
     }

osu.Game/Rulesets/Mods/ModTimeRamp.cs

@@ -21,8 +21,6 @@ namespace osu.Game.Rulesets.Mods
         /// </summary>
         public const double FINAL_RATE_PROGRESS = 0.75f;
 
-        public override double ScoreMultiplier => 0.5;
-
         [SettingSource("Initial rate", "The starting speed of the track", SettingControlType = typeof(MultiplierSettingsSlider))]
         public abstract BindableNumber<double> InitialRate { get; }