1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-17 02:53:01 +08:00
osu-lazer/osu.Game/Screens/Play/ReplayPlayer.cs

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

155 lines
5.1 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.
2018-04-13 17:19:50 +08:00
2022-06-17 15:37:17 +08:00
#nullable disable
2021-05-25 17:37:04 +08:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Input.Bindings;
2021-09-16 17:26:12 +08:00
using osu.Framework.Input.Events;
using osu.Game.Beatmaps;
using osu.Game.Configuration;
using osu.Game.Input.Bindings;
2021-05-25 17:37:04 +08:00
using osu.Game.Rulesets.Mods;
2018-11-29 12:22:45 +08:00
using osu.Game.Scoring;
using osu.Game.Screens.Play.HUD;
using osu.Game.Screens.Play.PlayerSettings;
using osu.Game.Screens.Ranking;
using osu.Game.Users;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Screens.Play
{
[Cached]
public partial class ReplayPlayer : Player, IKeyBindingHandler<GlobalAction>
{
public const double BASE_SEEK_AMOUNT = 1000;
private readonly Func<IBeatmap, IReadOnlyList<Mod>, Score> createScore;
2018-04-13 17:19:50 +08:00
private readonly bool replayIsFailedScore;
protected override UserActivity InitialActivity => new UserActivity.WatchingReplay(Score.ScoreInfo);
2019-09-19 13:00:41 +08:00
// Disallow replays from failing. (see https://github.com/ppy/osu/issues/6108)
protected override bool CheckModsAllowFailure()
{
if (!replayIsFailedScore && !GameplayState.Mods.OfType<ModAutoplay>().Any())
return false;
return base.CheckModsAllowFailure();
}
2019-09-19 03:49:48 +08:00
public ReplayPlayer(Score score, PlayerConfiguration configuration = null)
2022-06-24 20:25:23 +08:00
: this((_, _) => score, configuration)
2021-05-25 17:37:04 +08:00
{
replayIsFailedScore = score.ScoreInfo.Rank == ScoreRank.F;
2021-05-25 17:37:04 +08:00
}
public ReplayPlayer(Func<IBeatmap, IReadOnlyList<Mod>, Score> createScore, PlayerConfiguration configuration = null)
: base(configuration)
{
2021-05-25 17:37:04 +08:00
this.createScore = createScore;
}
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
2024-01-17 15:40:45 +08:00
if (!LoadedBeatmapSuccessfully)
return;
var playbackSettings = new PlaybackSettings
{
Depth = float.MaxValue,
Expanded = { BindTarget = config.GetBindable<bool>(OsuSetting.ReplayPlaybackControlsExpanded) }
};
if (GameplayClockContainer is MasterGameplayClockContainer master)
playbackSettings.UserPlaybackRate.BindTo(master.UserPlaybackRate);
HUDOverlay.PlayerSettingsOverlay.AddAtStart(playbackSettings);
}
2020-03-23 18:31:43 +08:00
protected override void PrepareReplay()
{
DrawableRuleset?.SetReplayScore(Score);
2020-06-19 20:54:09 +08:00
}
2021-10-05 13:48:10 +08:00
protected override Score CreateScore(IBeatmap beatmap) => createScore(beatmap, Mods.Value);
// Don't re-import replay scores as they're already present in the database.
protected override Task ImportScore(Score score) => Task.CompletedTask;
public readonly BindableList<ScoreInfo> LeaderboardScores = new BindableList<ScoreInfo>();
protected override GameplayLeaderboard CreateGameplayLeaderboard() =>
new SoloGameplayLeaderboard(Score.ScoreInfo.User)
{
2022-09-27 13:43:08 +08:00
AlwaysVisible = { Value = true },
Scores = { BindTarget = LeaderboardScores }
};
protected override ResultsScreen CreateResults(ScoreInfo score) => new SoloResultsScreen(score);
2021-09-16 17:26:12 +08:00
public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
{
2021-09-16 17:26:12 +08:00
switch (e.Action)
{
case GlobalAction.StepReplayBackward:
StepFrame(-1);
return true;
case GlobalAction.StepReplayForward:
StepFrame(1);
return true;
case GlobalAction.SeekReplayBackward:
2024-01-22 20:47:38 +08:00
SeekInDirection(-5);
return true;
case GlobalAction.SeekReplayForward:
2024-01-22 20:47:38 +08:00
SeekInDirection(5);
return true;
case GlobalAction.TogglePauseReplay:
if (GameplayClockContainer.IsPaused.Value)
GameplayClockContainer.Start();
else
GameplayClockContainer.Stop();
return true;
}
return false;
}
public void StepFrame(int direction)
{
GameplayClockContainer.Stop();
var frames = GameplayState.Score.Replay.Frames;
if (frames.Count == 0)
return;
GameplayClockContainer.Seek(direction < 0
? (frames.LastOrDefault(f => f.Time < GameplayClockContainer.CurrentTime) ?? frames.First()).Time
: (frames.FirstOrDefault(f => f.Time > GameplayClockContainer.CurrentTime) ?? frames.Last()).Time
);
}
public void SeekInDirection(float amount)
{
double target = Math.Clamp(GameplayClockContainer.CurrentTime + amount * BASE_SEEK_AMOUNT, 0, GameplayState.Beatmap.GetLastObjectTime());
Seek(target);
}
2021-09-16 17:26:12 +08:00
public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
{
}
}
}