Closes https://github.com/ppy/osu/issues/34959.
`ArgonCounterTextComponent` is pretty terrible and prevents being able
to fix the issue easily. The core issue is that this is the first
instance of the component's usage where the label text can be longer
than the counter in the X dimension, so the total width of any counter
is equal to max(label width, counter width), and the label will be
aligned to the left of that width, while the counter will be aligned to
the right of that width.
The fix sort of relies on the fact that I don't expect *any* consumer of
`ArgonCounterTextComponent` that meaningfully uses the wireframe digits
to want the non-wireframe digits to be aligned to the *left* rather than
the right. It's not what I'd expect any segmented display to work.
(There are usages that specify `TopLeft` anchor, but they usually
display the same number of wireframe and non-wireframe digits, so for
them it doesn't really matter if the digits are left-aligned to the
wireframes or not.)
Only seems to reproduce in gameplay for whatever reason. Can't justify
spending time to chase down why really because the previous code looked
obviously wrong on closer inspection anyway (`rightLayer` has transforms
applied to it on collapse/expand).
At some point during the leaderboard data refactor, this test scene
became completely unusable. This change rewrites it to use
`SoloGameplayLeaderboardProvider` to be able to witness the user score
being resorted and advancing through the leaderboard.
This change pulls back a significant degree of overspecialisation and
rigidity in the class structure of `HitWindows` to make subsequent
changes to hit windows, whose purpose is to improve replay playback
accuracy, possible to do cleanly.
Notably:
- `HitWindows` is full abstract now. In a few use cases, and as a
reference for ruleset implementors, `DefaultHitWindows` is provided as
a separate class instead.
This fixes the weirdness wherein `HitWindows` always declared 6 fields
for result types but some of them would never be set to a non-zero
value or read.
- `HitWindow.GetRanges()` is deleted because it is overspecialised and
prevents being able to adjust hitwindows by ±0.5ms cleanly which will
be required later.
The fallout of this is that the assertion that used `GetRanges()` in
the `HitWindows` ctor must use something else now, and the closest
thing to it was `GetAllAvailableWindows()`, which didn't return
the miss window - so I made it return the miss window and fixed the
one consumer that didn't want it (bar hit error meter) to skip it.
- Diff also contains some clean-up around `DifficultyRange` to unify
handling of it.
Closes https://github.com/ppy/osu/issues/33542.
For a diff this simple this took much more hemming and hawing because
things are a bit annoying here from a few angles:
- The only way that is considered idiomatic right now for a skin
component to not be applicable to a screen is to require a dependency
from DI that is only provided by applicable screens.
`DrawableGameplayLeaderboard` has a few of those dependencies, but the
scope of all the usages makes it so that the only really viable one to
use here is `IGameplayLeaderboardProvider` itself (see: visual tests,
and also the usage of multiplayer spectator, where the leaderboard is
*not* under a player instance).
- The smelly part of this is that the `Player` inheritance hierarchy
must ensure that *every* non-abstract class has an
`IGameplayLeaderboardProvider` cached. It is not trivial - if not
straight up impossible - to force this via some `Player` level
abstract method, because such a method would need to somehow
accommodate all possible leaderboard providers. That however also
means that every possible future `Player` implementor *must inherently
know* to also cache a leaderboard provider lest it die at runtime. I
don't love that, but I also don't see better alternatives.
- Speaking of which, I also noticed that solo spectator and playlists
don't have gameplay leaderboards. At all. Which I don't believe to be
something that I broke with the leaderboard work - I'm pretty sure
that was the pre-existing state - however I don't see any reason why
they *couldn't* receive gameplay leaderboards. I'm not doing that
here, though, just leaving TODOs for later.
I'd have preferred a `get; init;` property but tests were also attached
at the hip to the public bindable. Without some extra composition this
is the best that I can do.
Intends to close https://github.com/ppy/osu/issues/32859.
The difference between this and https://github.com/ppy/osu/pull/32942 is
that this PR takes the approach of completely moving the score sorting
behaviour to `IGameplayLeaderboardProvider` implementations.
This is going to be helpful for further work - to be precise, I am
looking to add a leaderboard position indicator in the bottom right of
multiplayer player to match stable, and having the position in the
provider will make the implementation of that *much* easier.
This PR converts the leaderboard into a full-fledged skinnable component
that can be manipulated by users at will.
Notably, this finally allows https://github.com/ppy/osu/issues/20422 to
be fixed - although it's a very mixed bag, for several reasons:
- Because of taiko players' refusal to see reason^W^W^W^Winsistence on
keeping stable behaviours related to aspect ratio treatment, I have to
assume the worst case scenario, which means than on typical
resolutions like 16:9 (or even worse, 4:3), the leaderboard will
likely not occupy as much vertical space as it probably could.
- Additionally, there's the problem of where to put the spectator list.
I settled on putting it to the right of the leaderboard, but that's
kind of janky, because the leaderboard sometimes collapses and
sometimes fully hides, leading to a very awkward space left behind. If
we had the capability to anchor elements to other elements, maybe this
could be resolved, but for now, I'm not sure what to do. I think if
some users are bothered by it they can move it where they want it. Or
delete it.