1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-18 09:23:22 +08:00
osu-lazer/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemResultsScreen.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

263 lines
10 KiB
C#
Raw Normal View History

// 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 System.Collections.Generic;
2020-07-22 19:24:55 +08:00
using System.Diagnostics;
using System.Linq;
2020-06-09 17:53:55 +08:00
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Game.Graphics.UserInterface;
using osu.Game.Online.API;
2020-12-25 12:38:11 +08:00
using osu.Game.Online.Rooms;
using osu.Game.Rulesets;
using osu.Game.Scoring;
using osu.Game.Screens.Ranking;
namespace osu.Game.Screens.OnlinePlay.Playlists
{
public abstract partial class PlaylistItemResultsScreen : ResultsScreen
{
protected readonly long RoomId;
protected readonly PlaylistItem PlaylistItem;
protected LoadingSpinner LeftSpinner { get; private set; } = null!;
protected LoadingSpinner CentreSpinner { get; private set; } = null!;
protected LoadingSpinner RightSpinner { get; private set; } = null!;
2020-07-31 20:39:50 +08:00
private MultiplayerScores? higherScores;
private MultiplayerScores? lowerScores;
[Resolved]
protected IAPIProvider API { get; private set; } = null!;
2020-06-09 17:53:55 +08:00
[Resolved]
protected ScoreManager ScoreManager { get; private set; } = null!;
[Resolved]
protected RulesetStore Rulesets { get; private set; } = null!;
protected PlaylistItemResultsScreen(ScoreInfo? score, long roomId, PlaylistItem playlistItem)
: base(score)
{
RoomId = roomId;
PlaylistItem = playlistItem;
}
2020-06-09 17:53:55 +08:00
[BackgroundDependencyLoader]
private void load()
{
2020-07-31 18:57:05 +08:00
AddInternal(new Container
2020-06-09 17:53:55 +08:00
{
2020-07-31 18:57:05 +08:00
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding { Bottom = TwoLayerButton.SIZE_EXTENDED.Y },
Children = new Drawable[]
{
2020-07-31 20:39:50 +08:00
LeftSpinner = new PanelListLoadingSpinner(ScorePanelList)
2020-07-31 18:57:05 +08:00
{
Anchor = Anchor.CentreLeft,
Origin = Anchor.Centre,
},
2020-07-31 20:39:50 +08:00
CentreSpinner = new PanelListLoadingSpinner(ScorePanelList)
2020-07-31 18:57:05 +08:00
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
State = { Value = Score == null ? Visibility.Visible : Visibility.Hidden },
},
2020-07-31 20:39:50 +08:00
RightSpinner = new PanelListLoadingSpinner(ScorePanelList)
2020-07-31 18:57:05 +08:00
{
Anchor = Anchor.CentreRight,
Origin = Anchor.Centre,
},
}
2020-06-09 17:53:55 +08:00
});
}
protected abstract APIRequest<MultiplayerScore> CreateScoreRequest();
protected sealed override APIRequest FetchScores(Action<IEnumerable<ScoreInfo>> scoresCallback)
{
// This performs two requests:
// 1. A request to show the relevant score (and scores around).
// 2. If that fails, a request to index the room starting from the highest score.
var userScoreReq = CreateScoreRequest();
2020-06-09 17:53:55 +08:00
userScoreReq.Success += userScore =>
2020-06-09 17:53:55 +08:00
{
var allScores = new List<MultiplayerScore> { userScore };
// Other scores could have arrived between score submission and entering the results screen. Ensure the local player score position is up to date.
if (Score != null)
{
Score.Position = userScore.Position;
ScorePanelList.GetPanelForScore(Score).ScorePosition.Value = userScore.Position;
}
if (userScore.ScoresAround?.Higher != null)
{
allScores.AddRange(userScore.ScoresAround.Higher.Scores);
higherScores = userScore.ScoresAround.Higher;
Debug.Assert(userScore.Position != null);
setPositions(higherScores, userScore.Position.Value, -1);
}
if (userScore.ScoresAround?.Lower != null)
{
allScores.AddRange(userScore.ScoresAround.Lower.Scores);
lowerScores = userScore.ScoresAround.Lower;
Debug.Assert(userScore.Position != null);
setPositions(lowerScores, userScore.Position.Value, 1);
}
Schedule(() =>
{
PerformSuccessCallback(scoresCallback, allScores);
hideLoadingSpinners();
});
};
2020-07-31 16:58:48 +08:00
// On failure, fallback to a normal index.
userScoreReq.Failure += _ => API.Queue(createIndexRequest(scoresCallback));
2020-06-09 17:53:55 +08:00
return userScoreReq;
2020-07-22 19:24:55 +08:00
}
protected override APIRequest? FetchNextPage(int direction, Action<IEnumerable<ScoreInfo>> scoresCallback)
2020-07-22 19:24:55 +08:00
{
Debug.Assert(direction == 1 || direction == -1);
MultiplayerScores? pivot = direction == -1 ? higherScores : lowerScores;
if (pivot?.Cursor == null)
2020-07-22 19:24:55 +08:00
return null;
2020-07-31 18:57:05 +08:00
if (pivot == higherScores)
2020-07-31 20:39:50 +08:00
LeftSpinner.Show();
2020-07-31 18:57:05 +08:00
else
2020-07-31 20:39:50 +08:00
RightSpinner.Show();
2020-07-31 18:57:05 +08:00
2020-07-31 16:58:48 +08:00
return createIndexRequest(scoresCallback, pivot);
}
/// <summary>
/// Creates a <see cref="IndexPlaylistScoresRequest"/> with an optional score pivot.
/// </summary>
/// <remarks>Does not queue the request.</remarks>
/// <param name="scoresCallback">The callback to perform with the resulting scores.</param>
/// <param name="pivot">An optional score pivot to retrieve scores around. Can be null to retrieve scores from the highest score.</param>
/// <returns>The indexing <see cref="APIRequest"/>.</returns>
private APIRequest createIndexRequest(Action<IEnumerable<ScoreInfo>> scoresCallback, MultiplayerScores? pivot = null)
2020-07-31 16:58:48 +08:00
{
var indexReq = pivot != null
? new IndexPlaylistScoresRequest(RoomId, PlaylistItem.ID, pivot.Cursor, pivot.Params)
: new IndexPlaylistScoresRequest(RoomId, PlaylistItem.ID);
2020-07-22 19:24:55 +08:00
indexReq.Success += r =>
{
2020-07-31 16:58:48 +08:00
if (pivot == lowerScores)
{
lowerScores = r;
setPositions(r, pivot, 1);
}
2020-07-31 16:58:48 +08:00
else
{
2020-07-31 16:58:48 +08:00
higherScores = r;
setPositions(r, pivot, -1);
}
Schedule(() =>
{
PerformSuccessCallback(scoresCallback, r.Scores, r);
hideLoadingSpinners(r);
});
2020-07-22 19:24:55 +08:00
};
2020-07-31 18:57:05 +08:00
indexReq.Failure += _ => hideLoadingSpinners(pivot);
2020-07-22 19:24:55 +08:00
return indexReq;
}
2020-07-31 16:58:48 +08:00
/// <summary>
/// Transforms returned <see cref="MultiplayerScores"/> into <see cref="ScoreInfo"/>s, ensure the <see cref="ScorePanelList"/> is put into a sane state, and invokes a given success callback.
/// </summary>
/// <param name="callback">The callback to invoke with the final <see cref="ScoreInfo"/>s.</param>
/// <param name="scores">The <see cref="MultiplayerScore"/>s that were retrieved from <see cref="APIRequest"/>s.</param>
/// <param name="pivot">An optional pivot around which the scores were retrieved.</param>
protected virtual ScoreInfo[] PerformSuccessCallback(Action<IEnumerable<ScoreInfo>> callback, List<MultiplayerScore> scores, MultiplayerScores? pivot = null)
2020-07-22 19:24:55 +08:00
{
var scoreInfos = scores.Select(s => s.CreateScoreInfo(ScoreManager, Rulesets, PlaylistItem, Beatmap.Value.BeatmapInfo)).OrderByTotalScore().ToArray();
2020-07-22 19:24:55 +08:00
// Invoke callback to add the scores.
callback.Invoke(scoreInfos);
2020-07-22 19:24:55 +08:00
return scoreInfos;
}
2020-07-31 18:57:05 +08:00
private void hideLoadingSpinners(MultiplayerScores? pivot = null)
2020-07-31 18:57:05 +08:00
{
2020-07-31 20:39:50 +08:00
CentreSpinner.Hide();
2020-07-31 18:57:05 +08:00
if (pivot == lowerScores)
2020-07-31 20:39:50 +08:00
RightSpinner.Hide();
2020-07-31 18:57:05 +08:00
else if (pivot == higherScores)
2020-07-31 20:39:50 +08:00
LeftSpinner.Hide();
2020-07-31 18:57:05 +08:00
}
/// <summary>
2020-07-31 22:16:55 +08:00
/// Applies positions to all <see cref="MultiplayerScore"/>s referenced to a given pivot.
/// </summary>
/// <param name="scores">The <see cref="MultiplayerScores"/> to set positions on.</param>
/// <param name="pivot">The pivot.</param>
/// <param name="increment">The amount to increment the pivot position by for each <see cref="MultiplayerScore"/> in <paramref name="scores"/>.</param>
private void setPositions(MultiplayerScores scores, MultiplayerScores? pivot, int increment)
=> setPositions(scores, pivot?.Scores[^1].Position ?? 0, increment);
/// <summary>
2020-07-31 22:16:55 +08:00
/// Applies positions to all <see cref="MultiplayerScore"/>s referenced to a given pivot.
/// </summary>
/// <param name="scores">The <see cref="MultiplayerScores"/> to set positions on.</param>
/// <param name="pivotPosition">The pivot position.</param>
/// <param name="increment">The amount to increment the pivot position by for each <see cref="MultiplayerScore"/> in <paramref name="scores"/>.</param>
private void setPositions(MultiplayerScores scores, int pivotPosition, int increment)
{
foreach (var s in scores.Scores)
{
pivotPosition += increment;
s.Position = pivotPosition;
}
}
2020-07-31 18:57:05 +08:00
private partial class PanelListLoadingSpinner : LoadingSpinner
{
private readonly ScorePanelList list;
/// <summary>
/// Creates a new <see cref="PanelListLoadingSpinner"/>.
/// </summary>
/// <param name="list">The list to track.</param>
/// <param name="withBox">Whether the spinner should have a surrounding black box for visibility.</param>
public PanelListLoadingSpinner(ScorePanelList list, bool withBox = true)
: base(withBox)
{
this.list = list;
}
protected override void Update()
{
base.Update();
float panelOffset = list.DrawWidth / 2 - ScorePanel.EXPANDED_WIDTH;
if ((Anchor & Anchor.x0) > 0)
X = (float)(panelOffset - list.Current);
else if ((Anchor & Anchor.x2) > 0)
X = (float)(list.ScrollableExtent - list.Current - panelOffset);
}
}
}
}