Add beatmap difficulty before mods as context for score multiplier calculations (ppy#37921)

- Part of ppy#37818

Access to difficulty info is required for the upcoming multiplier
proposals. All places providing difficulty info intentionally use
`IBeatmapInfo` as the difficulty info exposed to the calculator should
_always_ be pre-mods for our usecase.

There's a couple of quirks:

- The usage in `ScoreProcessor` is a bit troubling to me but I can't see
a way to make it better without refactoring it. Essentially, we don't
have a beatmap until `ApplyBeatmap` is called, but most usages of
`ScoreProcessor` are setting `Mods` prior to `ApplyBeatmap` so there is
a `null` check in the logic for when mods change. Additionally, this
means a new bindable of the beatmap via `ApplyBeatmap` which also feels
a bit dirty. Open to suggestions.
- ~~`BeatmapLeaderboardScore.Tooltip` is using a null-forgiving on the
`BeatmapInfo`, but there's basically no context available on if this is
an issue - the only code path which sets the score is `SetContent` which
has no callers, so it's essentially dead code. Makes sense given it's
Select V1.~~

---------

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

Author: tsunyoku

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 @@ public record ModTestCase(string Description, IEnumerable<Mod> Mods)
         public override void SetUp()
         {
             base.SetUp();
-            calculator = new OsuRuleset().CreateScoreMultiplierCalculator(new ScoreMultiplierContext());
+            calculator = new OsuRuleset().CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
         }
 
         [Benchmark]

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;
@@ -212,7 +213,7 @@ [new DateTimeOffset(2026, 7, 18, 0, 20, 15, 0, TimeSpan.Zero), "2026.522.1-tachy
         [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

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

@@ -56,7 +56,7 @@ public void TestHitWindowWithDoubleTime()
                 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.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 @@ public class ScoreMultiplierCalculatorTest
         [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,36 +24,55 @@ public void TestFlatMultiplier()
         [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 } }]);
 
             Assert.That(multiplier, Is.EqualTo(0.4));
         }
 
         [Test]
-        public void TestContextDependentMultiplier()
+        public void TestScoreDependentMultiplier()
         {
             TestScoreMultiplierCalculator calculator;
 
             double multiplier;
 
             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 @@ public void TestCombinationMultiplier()
         [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 @@ private class TestScoreMultiplierCalculator : ScoreMultiplierCalculator
             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 @@ public void TestComboAccounting([Values] bool shuffleResults)
             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 @@ private class TestRuleset : Ruleset
 
                 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/SongSelect/TestSceneFooterButtonMods.cs

@@ -8,6 +8,7 @@
 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;
@@ -120,7 +121,7 @@ public void TestUnrankedBadge()
 
         private void assertModsMultiplier(Ruleset ruleset, IEnumerable<Mod> mods)
         {
-            var scoreMultiplierCalculator = ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext());
+            var scoreMultiplierCalculator = ruleset.CreateScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty()));
             double multiplier = scoreMultiplierCalculator.CalculateFor(mods);
             string expectedValue = ModUtils.FormatScoreMultiplier(multiplier).ToString();
 

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

@@ -15,6 +15,7 @@
 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 @@ public void TestPreexistingSelection()
             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 OsuScoreMultiplierCalculator(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 @@ public void TestExternalSelection()
             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 OsuScoreMultiplierCalculator(new ScoreMultiplierContext(new BeatmapDifficulty())).CalculateFor(SelectedMods.Value);
                 return Precision.AlmostEquals(multiplier, this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value);
             });
             assertCustomisationToggleState(disabled: false, active: false);

osu.Game/Database/StandardisedScoreMigrationTools.cs

@@ -188,7 +188,10 @@ public static long GetOldStandardised(ScoreInfo score)
             }
 
             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 @@ private static (long withoutMods, long withMods) convertFromLegacyTotalScore(Sco
             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 @@ protected override void LoadComplete()
             {
                 if (beatmapAttributesDisplay != null)
                     beatmapAttributesDisplay.BeatmapInfo.Value = b.NewValue?.BeatmapInfo;
+
+                updateInformation();
             }, true);
 
             Ruleset.BindValueChanged(_ => updateInformation());
@@ -122,9 +124,11 @@ protected override void LoadComplete()
 
         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/Scoring/ScoreMultiplierCalculator.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 
@@ -95,6 +96,12 @@ public double CalculateFor(IEnumerable<Mod> mods)
     /// </summary>
     public class ScoreMultiplierContext
     {
+        /// <summary>
+        /// The difficulty info for the beatmap that the multipliers are calculated for.
+        /// This must be the difficulty info for the beatmap BEFORE any mod application.
+        /// </summary>
+        public IBeatmapDifficultyInfo BeatmapDifficultyWithoutMods { get; }
+
         /// <summary>
         /// The score that the multipliers are calculated for.
         /// Mostly relevant and present in backwards compatibility scenarios.
@@ -104,24 +111,19 @@ public class ScoreMultiplierContext
 
         /// <summary>
         /// Constructs a new instance.
-        /// Use this in situations wherein the current valid score multipliers are needed.
-        /// </summary>
-        public ScoreMultiplierContext()
-            : this(null)
-        {
-        }
-
-        /// <summary>
-        /// Constructs a new instance.
-        /// Use this in backwards compatibility scenarios when dealing with a specific <paramref name="score"/>.
         /// </summary>
+        /// <param name="beatmapDifficultyWithoutMods">
+        /// The difficulty info for the beatmap that the multipliers are calculated for.
+        /// This must be the difficulty info for the beatmap BEFORE any mod application.
+        /// </param>
         /// <param name="score">
         /// The score that the multipliers are calculated for.
         /// Mostly relevant and present in backwards compatibility scenarios.
-        /// In usages where the current valid score multipliers are required, pass <see langword="null"/> or use a constructor that does not require this.
+        /// In usages where the current valid score multipliers are required, pass <see langword="null"/> or omit this parameter entirely.
         /// </param>
-        public ScoreMultiplierContext(ScoreInfo? score)
+        public ScoreMultiplierContext(IBeatmapDifficultyInfo beatmapDifficultyWithoutMods, ScoreInfo? score = null)
         {
+            BeatmapDifficultyWithoutMods = beatmapDifficultyWithoutMods;
             Score = score;
         }
     }