mirror of
https://github.com/ppy/osu.git
synced 2026-05-27 06:29:54 +08:00
Bartłomiej Dach
9727d95ad9
- Part of https://github.com/ppy/osu/issues/37818
During review, I would like to direct particular attention to the
following changes:
## [Migrate song select to new score multiplier
API](https://github.com/ppy/osu/commit/945fd78539da3ae57d1550a5bbfb0f859d153cc4)
This was a confusing change to write because of the way song selects
hook their mod overlays up to global bindables. In particular different
things happen in different circumstances.
- When going through `SongSelect.CreateModOverlay()`, which is called by
the base `SongSelect`, the mod overlay is automatically bound to global
bindables via `SongSelect.on{ArrivingAt,Leaving}Screen()`.
- For multiplayer user mod select overlays, which are bolted on by
subclasses of `SongSelect`, manual hook-up is required.
- As for free mod select overlays, they don't show mod multipliers at
all, and don't have easy access to the ruleset, and thus the hookup is
skipped entirely as redundant.
## [Fix score multiplier registrations being shared between
implementations via superclass static
fields](https://github.com/ppy/osu/commit/ba0a7ad421e0c84c2d8162b6bbdd3a0683f5a6a6)
Revealed by `ScoreMultiplierCalculatorTest` starting to fail due to
interference from `OsuScoreMultiplierCalculator`.
It's not ideal from a performance standpoint but it's the simplest
choice for now. Tricks could be pulled to salvage the static. One is
```csharp
public class ScoreMultiplierCalculator<T>
where T : ScoreMultiplierCalculator<T>
{
}
```
This works because of generics internals; static instance members are
not shared between different specialisations of a generic class. It is
also very unintuitive, so I would rather not. (It trips a ReSharper
inspection too, which would have to be silenced.)
From a performance standpoint this is not ideal, but a significant chunk
of migrated usages already precede the construction of the calculator
via the known-expensive `RulesetInfo.CreateInstance()`, and the paths
that actually construct the calculator do not appear to be that hot. If
need be, this can be handled by actually caching ruleset instances and
their derivative subcomponents.
## [Introduce passing of context to score multiplier
calculator](https://github.com/ppy/osu/pull/37845/changes/9e9242b3221dddacd226f4b3b9c5632d7350e998)
This is required for two reasons:
- The upcoming mod rebalance will require out-of-band supplementary
information that is not available for reading from the mod instances
themselves for calculating the multiplier.
- This context, namely passing of `ScoreInfo`, will be used for
implementing backwards compatibility with old scores and their score
multipliers. This is required because it has turned out under inspection
that all server-side lazer replays recorded until now are missing
`TotalScoreWithoutMods` due to an omission of not sending it across the
wire to spectator server.
Because the score import flow uses replays, filtered through
`LegacyScoreDecoder`, to populate total score in the realm database, it
is basically impossible to ignore scores that are missing
`TotalScoreWithoutMods`, because that will result in bug reports that
the scores do not have the new score multipliers applied.
Thus, passing of `ScoreInfo` will facilitate implementation of
versioning score multipliers, which should result in less breakage than
not doing so.
An example of this is added in 341b2d6e55,
which should handle the case of mania mod multipliers having been
changed without any attempt to facilitate for it in
https://github.com/ppy/osu/pull/30506.
---------
Co-authored-by: Dean Herbert <pe@ppy.sh>
67 lines
2.2 KiB
C#
67 lines
2.2 KiB
C#
// 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.Collections.Generic;
|
|
using BenchmarkDotNet.Attributes;
|
|
using NUnit.Framework;
|
|
using osu.Game.Rulesets.Mods;
|
|
using osu.Game.Rulesets.Osu;
|
|
using osu.Game.Rulesets.Osu.Mods;
|
|
using osu.Game.Rulesets.Scoring;
|
|
|
|
namespace osu.Game.Benchmarks
|
|
{
|
|
public class BenchmarkScoreMultiplierCalculator : BenchmarkTest
|
|
{
|
|
private ScoreMultiplierCalculator calculator = null!;
|
|
|
|
[Params(1, 10, 100)]
|
|
public int Times { get; set; }
|
|
|
|
public record ModTestCase(string Description, IEnumerable<Mod> Mods)
|
|
{
|
|
public override string ToString() => Description;
|
|
}
|
|
|
|
public static IEnumerable<ModTestCase> ValuesForMods =>
|
|
[
|
|
new ModTestCase("no mods", []),
|
|
new ModTestCase("single mod", [new OsuModHardRock()]),
|
|
new ModTestCase("single mod 2", [new OsuModEasy()]),
|
|
new ModTestCase("multiple mods", [new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime()]),
|
|
new ModTestCase("mods with adjusted settings", [
|
|
new OsuModDoubleTime { SpeedChange = { Value = 2 } },
|
|
new OsuModHidden { OnlyFadeApproachCircles = { Value = true } },
|
|
new OsuModHardRock()
|
|
]),
|
|
];
|
|
|
|
[ParamsSource(nameof(ValuesForMods))]
|
|
public ModTestCase Mods { get; set; } = null!;
|
|
|
|
public override void SetUp()
|
|
{
|
|
base.SetUp();
|
|
calculator = new OsuRuleset().CreateScoreMultiplierCalculator(new ScoreMultiplierContext());
|
|
}
|
|
|
|
[Benchmark]
|
|
public double ViaCalculator()
|
|
=> viaCalculator(Times, Mods);
|
|
|
|
[Test]
|
|
public void ViaCalculator([Values(100)] int times, [ValueSource(nameof(ValuesForMods))] ModTestCase mods)
|
|
=> viaCalculator(times, mods);
|
|
|
|
private double viaCalculator(int times, ModTestCase mods)
|
|
{
|
|
double scoreMultiplier = 1;
|
|
|
|
for (int i = 0; i < times; ++i)
|
|
scoreMultiplier = calculator.CalculateFor(mods.Mods);
|
|
|
|
return scoreMultiplier;
|
|
}
|
|
}
|
|
}
|