2019-06-04 07:13:16 +00:00
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
2019-01-24 08:43:03 +00:00
// See the LICENCE file in the repository root for full licence text.
2018-04-13 09:19:50 +00:00
using System ;
2019-04-09 04:33:16 +00:00
using System.Collections.Generic ;
2020-03-24 05:13:46 +00:00
using System.IO ;
2018-04-13 09:19:50 +00:00
using System.Linq ;
2020-12-18 07:51:59 +00:00
using System.Threading.Tasks ;
2020-12-17 07:17:13 +00:00
using JetBrains.Annotations ;
2018-04-13 09:19:50 +00:00
using osu.Framework.Allocation ;
using osu.Framework.Audio ;
using osu.Framework.Audio.Sample ;
2019-02-21 10:04:31 +00:00
using osu.Framework.Bindables ;
2018-04-13 09:19:50 +00:00
using osu.Framework.Graphics ;
using osu.Framework.Graphics.Containers ;
2018-10-02 03:02:47 +00:00
using osu.Framework.Input.Events ;
2018-04-13 09:19:50 +00:00
using osu.Framework.Logging ;
using osu.Framework.Screens ;
using osu.Framework.Threading ;
using osu.Game.Beatmaps ;
using osu.Game.Configuration ;
2019-01-04 04:29:37 +00:00
using osu.Game.Graphics.Containers ;
2020-03-24 05:13:46 +00:00
using osu.Game.IO.Archives ;
2018-04-13 09:19:50 +00:00
using osu.Game.Online.API ;
2018-06-06 06:10:09 +00:00
using osu.Game.Overlays ;
2020-12-18 09:31:49 +00:00
using osu.Game.Replays ;
2018-04-13 09:19:50 +00:00
using osu.Game.Rulesets ;
using osu.Game.Rulesets.Mods ;
2020-12-18 09:31:49 +00:00
using osu.Game.Rulesets.Replays ;
2018-04-13 09:19:50 +00:00
using osu.Game.Rulesets.Scoring ;
using osu.Game.Rulesets.UI ;
2018-11-28 07:12:57 +00:00
using osu.Game.Scoring ;
2020-03-24 05:13:46 +00:00
using osu.Game.Scoring.Legacy ;
2018-04-13 09:19:50 +00:00
using osu.Game.Screens.Ranking ;
using osu.Game.Skinning ;
2019-04-12 20:54:35 +00:00
using osu.Game.Users ;
2018-04-13 09:19:50 +00:00
namespace osu.Game.Screens.Play
{
2019-11-01 06:32:06 +00:00
[Cached]
2020-10-14 10:39:48 +00:00
[Cached(typeof(ISamplePlaybackDisabler))]
2021-03-23 05:47:15 +00:00
public abstract class Player : ScreenWithBeatmapBackground , ISamplePlaybackDisabler
2018-04-13 09:19:50 +00:00
{
2020-04-20 03:42:33 +00:00
/// <summary>
/// The delay upon completion of the beatmap before displaying the results screen.
/// </summary>
public const double RESULTS_DISPLAY_DELAY = 1000.0 ;
2019-06-25 07:55:49 +00:00
public override bool AllowBackButton = > false ; // handled by HoldForMenuButton
2018-04-13 09:19:50 +00:00
2019-06-12 07:33:15 +00:00
protected override UserActivity InitialActivity = > new UserActivity . SoloGame ( Beatmap . Value . BeatmapInfo , Ruleset . Value ) ;
2018-04-13 09:19:50 +00:00
2019-01-23 11:52:00 +00:00
public override float BackgroundParallaxAmount = > 0.1f ;
2018-04-13 09:19:50 +00:00
2019-01-28 06:41:54 +00:00
public override bool HideOverlaysOnEnter = > true ;
2018-04-13 09:19:50 +00:00
2020-08-31 09:16:13 +00:00
protected override OverlayActivation InitialOverlayActivationMode = > OverlayActivation . UserTriggered ;
2020-08-08 19:21:30 +00:00
2020-09-01 07:55:10 +00:00
// We are managing our own adjustments (see OnEntering/OnExiting).
public override bool AllowRateAdjustments = > false ;
2018-06-06 06:10:09 +00:00
2021-02-05 06:07:59 +00:00
private readonly IBindable < bool > gameActive = new Bindable < bool > ( true ) ;
2020-10-14 10:39:48 +00:00
private readonly Bindable < bool > samplePlaybackDisabled = new Bindable < bool > ( ) ;
2018-06-06 06:10:09 +00:00
2019-05-10 06:39:25 +00:00
/// <summary>
/// Whether gameplay should pause when the game window focus is lost.
/// </summary>
protected virtual bool PauseOnFocusLost = > true ;
2018-06-06 06:10:09 +00:00
2018-04-13 09:19:50 +00:00
public Action RestartRequested ;
public bool HasFailed { get ; private set ; }
private Bindable < bool > mouseWheelDisabled ;
2019-02-25 04:27:44 +00:00
private readonly Bindable < bool > storyboardReplacesBackground = new Bindable < bool > ( ) ;
2018-04-13 09:19:50 +00:00
2020-10-07 07:22:39 +00:00
protected readonly Bindable < bool > LocalUserPlaying = new Bindable < bool > ( ) ;
2020-10-06 12:09:35 +00:00
2018-04-13 09:19:50 +00:00
public int RestartCount ;
2018-11-29 05:56:29 +00:00
[Resolved]
private ScoreManager scoreManager { get ; set ; }
2018-04-13 09:19:50 +00:00
2019-08-26 03:21:49 +00:00
private RulesetInfo rulesetInfo ;
2018-04-13 09:19:50 +00:00
2019-08-26 03:21:49 +00:00
private Ruleset ruleset ;
2018-04-13 09:19:50 +00:00
2020-02-14 13:14:00 +00:00
[Resolved]
private IAPIProvider api { get ; set ; }
2018-04-13 09:19:50 +00:00
2020-09-01 09:07:19 +00:00
[Resolved]
private MusicController musicController { get ; set ; }
2020-08-02 19:34:35 +00:00
2021-01-19 08:11:40 +00:00
private Sample sampleRestart ;
2018-04-13 09:19:50 +00:00
2019-12-12 06:14:59 +00:00
public BreakOverlay BreakOverlay ;
2018-04-13 09:19:50 +00:00
2020-10-10 22:15:20 +00:00
/// <summary>
/// Whether the gameplay is currently in a break.
/// </summary>
2020-10-11 12:46:55 +00:00
public readonly IBindable < bool > IsBreakTime = new BindableBool ( ) ;
2020-10-10 13:07:17 +00:00
2020-03-26 06:28:56 +00:00
private BreakTracker breakTracker ;
2021-04-16 04:59:10 +00:00
private SkipOverlay skipIntroOverlay ;
2021-04-14 04:04:03 +00:00
private SkipOverlay skipOutroOverlay ;
2019-02-28 11:01:15 +00:00
protected ScoreProcessor ScoreProcessor { get ; private set ; }
2019-12-19 11:03:14 +00:00
protected HealthProcessor HealthProcessor { get ; private set ; }
2019-03-19 14:44:15 +00:00
protected DrawableRuleset DrawableRuleset { get ; private set ; }
2018-04-13 09:19:50 +00:00
2019-02-28 11:01:15 +00:00
protected HUDOverlay HUDOverlay { get ; private set ; }
2018-04-13 09:19:50 +00:00
2019-03-19 14:44:15 +00:00
public bool LoadedBeatmapSuccessfully = > DrawableRuleset ? . Objects . Any ( ) = = true ;
2018-04-13 09:19:50 +00:00
2019-03-17 15:46:15 +00:00
protected GameplayClockContainer GameplayClockContainer { get ; private set ; }
2018-04-13 09:19:50 +00:00
2019-11-25 07:24:29 +00:00
public DimmableStoryboard DimmableStoryboard { get ; private set ; }
2018-04-13 09:19:50 +00:00
2019-04-09 04:33:16 +00:00
[Cached]
2019-04-17 07:11:59 +00:00
[Cached(Type = typeof(IBindable<IReadOnlyList<Mod>>))]
2019-04-25 08:36:17 +00:00
protected new readonly Bindable < IReadOnlyList < Mod > > Mods = new Bindable < IReadOnlyList < Mod > > ( Array . Empty < Mod > ( ) ) ;
2019-04-09 04:33:16 +00:00
2019-09-18 19:49:28 +00:00
/// <summary>
2019-09-19 04:58:54 +00:00
/// Whether failing should be allowed.
2019-09-19 05:31:11 +00:00
/// By default, this checks whether all selected mods allow failing.
2019-09-18 19:49:28 +00:00
/// </summary>
2020-05-12 11:08:35 +00:00
protected virtual bool CheckModsAllowFailure ( ) = > Mods . Value . OfType < IApplicableFailOverride > ( ) . All ( m = > m . PerformFail ( ) ) ;
2019-09-18 19:49:28 +00:00
2020-12-23 08:39:08 +00:00
public readonly PlayerConfiguration Configuration ;
2019-03-26 07:53:44 +00:00
/// <summary>
/// Create a new player instance.
/// </summary>
2021-03-23 05:47:15 +00:00
protected Player ( PlayerConfiguration configuration = null )
2019-03-26 07:53:44 +00:00
{
2020-12-23 09:07:38 +00:00
Configuration = configuration ? ? new PlayerConfiguration ( ) ;
2019-03-26 07:53:44 +00:00
}
2018-04-13 09:19:50 +00:00
2020-02-14 03:30:11 +00:00
private GameplayBeatmap gameplayBeatmap ;
2020-06-18 14:35:03 +00:00
private ScreenSuspensionHandler screenSuspension ;
2020-02-14 03:30:11 +00:00
private DependencyContainer dependencies ;
protected override IReadOnlyDependencyContainer CreateChildDependencies ( IReadOnlyDependencyContainer parent )
= > dependencies = new DependencyContainer ( base . CreateChildDependencies ( parent ) ) ;
2020-03-23 10:31:43 +00:00
protected override void LoadComplete ( )
{
base . LoadComplete ( ) ;
2020-10-23 05:47:21 +00:00
// replays should never be recorded or played back when autoplay is enabled
if ( ! Mods . Value . Any ( m = > m is ModAutoplay ) )
PrepareReplay ( ) ;
2021-02-05 06:07:59 +00:00
gameActive . BindValueChanged ( _ = > updatePauseOnFocusLostState ( ) , true ) ;
2020-03-23 10:31:43 +00:00
}
2020-12-17 07:17:13 +00:00
[CanBeNull]
2020-12-14 07:52:14 +00:00
private Score recordingScore ;
2020-03-23 10:31:43 +00:00
/// <summary>
/// Run any recording / playback setup for replays.
/// </summary>
protected virtual void PrepareReplay ( )
{
2020-12-17 07:14:41 +00:00
DrawableRuleset . SetRecordTarget ( recordingScore = new Score ( ) ) ;
2020-12-14 08:33:33 +00:00
ScoreProcessor . NewJudgement + = result = > ScoreProcessor . PopulateScore ( recordingScore . ScoreInfo ) ;
2020-03-23 10:31:43 +00:00
}
2020-10-07 05:46:58 +00:00
[BackgroundDependencyLoader(true)]
2021-02-08 10:59:07 +00:00
private void load ( AudioManager audio , OsuConfigManager config , OsuGameBase game )
2018-04-13 09:19:50 +00:00
{
2019-04-17 07:11:59 +00:00
Mods . Value = base . Mods . Value . Select ( m = > m . CreateCopy ( ) ) . ToArray ( ) ;
2019-04-09 04:33:16 +00:00
2019-12-12 06:58:11 +00:00
if ( Beatmap . Value is DummyWorkingBeatmap )
return ;
IBeatmap playableBeatmap = loadPlayableBeatmap ( ) ;
2019-03-06 11:30:14 +00:00
2019-12-12 06:58:11 +00:00
if ( playableBeatmap = = null )
2018-04-13 09:19:50 +00:00
return ;
2019-05-28 08:06:01 +00:00
sampleRestart = audio . Samples . Get ( @"Gameplay/restart" ) ;
2018-04-13 09:19:50 +00:00
mouseWheelDisabled = config . GetBindable < bool > ( OsuSetting . MouseDisableWheel ) ;
2020-10-07 05:46:58 +00:00
if ( game ! = null )
2021-02-08 06:58:41 +00:00
gameActive . BindTo ( game . IsActive ) ;
2021-02-08 11:05:16 +00:00
2021-02-08 10:59:07 +00:00
if ( game is OsuGame osuGame )
LocalUserPlaying . BindTo ( osuGame . LocalUserPlaying ) ;
2020-10-06 12:09:35 +00:00
2019-12-12 06:58:11 +00:00
DrawableRuleset = ruleset . CreateDrawableRulesetWith ( playableBeatmap , Mods . Value ) ;
2019-12-24 08:01:17 +00:00
ScoreProcessor = ruleset . CreateScoreProcessor ( ) ;
ScoreProcessor . ApplyBeatmap ( playableBeatmap ) ;
2019-04-25 10:56:57 +00:00
ScoreProcessor . Mods . BindTo ( Mods ) ;
2018-04-13 09:19:50 +00:00
2019-12-27 07:14:49 +00:00
HealthProcessor = ruleset . CreateHealthProcessor ( playableBeatmap . HitObjects [ 0 ] . StartTime ) ;
2019-12-24 08:01:17 +00:00
HealthProcessor . ApplyBeatmap ( playableBeatmap ) ;
2019-12-19 11:03:14 +00:00
2018-06-29 07:49:11 +00:00
if ( ! ScoreProcessor . Mode . Disabled )
config . BindWith ( OsuSetting . ScoreDisplayMode , ScoreProcessor . Mode ) ;
2018-04-13 09:19:50 +00:00
2020-10-27 09:56:28 +00:00
InternalChild = GameplayClockContainer = CreateGameplayClockContainer ( Beatmap . Value , DrawableRuleset . GameplayStartTime ) ;
2018-04-13 09:19:50 +00:00
2020-02-14 03:30:11 +00:00
AddInternal ( gameplayBeatmap = new GameplayBeatmap ( playableBeatmap ) ) ;
2020-06-18 14:35:03 +00:00
AddInternal ( screenSuspension = new ScreenSuspensionHandler ( GameplayClockContainer ) ) ;
2020-02-14 03:30:11 +00:00
dependencies . CacheAs ( gameplayBeatmap ) ;
2020-09-29 05:09:51 +00:00
var beatmapSkinProvider = new BeatmapSkinProvidingContainer ( Beatmap . Value . Skin ) ;
// the beatmapSkinProvider is used as the fallback source here to allow the ruleset-specific skin implementation
// full access to all skin sources.
var rulesetSkinProvider = new SkinProvidingContainer ( ruleset . CreateLegacySkinProvider ( beatmapSkinProvider , playableBeatmap ) ) ;
// load the skinning hierarchy first.
// this is intentionally done in two stages to ensure things are in a loaded state before exposing the ruleset to skin sources.
GameplayClockContainer . Add ( beatmapSkinProvider . WithChild ( rulesetSkinProvider ) ) ;
rulesetSkinProvider . AddRange ( new [ ]
{
// underlay and gameplay should have access the to skinning sources.
createUnderlayComponents ( ) ,
createGameplayComponents ( Beatmap . Value , playableBeatmap )
} ) ;
2020-10-16 09:19:09 +00:00
// also give the HUD a ruleset container to allow rulesets to potentially override HUD elements (used to disable combo counters etc.)
// we may want to limit this in the future to disallow rulesets from outright replacing elements the user expects to be there.
var hudRulesetContainer = new SkinProvidingContainer ( ruleset . CreateLegacySkinProvider ( beatmapSkinProvider , playableBeatmap ) ) ;
2020-09-29 05:09:51 +00:00
// add the overlay components as a separate step as they proxy some elements from the above underlay/gameplay components.
2020-10-16 09:19:09 +00:00
GameplayClockContainer . Add ( hudRulesetContainer . WithChild ( createOverlayComponents ( Beatmap . Value ) ) ) ;
2018-04-13 09:19:50 +00:00
2020-05-08 07:37:50 +00:00
if ( ! DrawableRuleset . AllowGameplayOverlays )
2020-05-07 06:52:36 +00:00
{
HUDOverlay . ShowHud . Value = false ;
HUDOverlay . ShowHud . Disabled = true ;
BreakOverlay . Hide ( ) ;
2021-04-16 04:59:10 +00:00
skipIntroOverlay . Hide ( ) ;
2021-04-17 21:45:38 +00:00
skipOutroOverlay . Hide ( ) ;
2020-05-07 06:52:36 +00:00
}
2020-10-27 09:13:45 +00:00
DrawableRuleset . FrameStableClock . WaitingOnFrames . BindValueChanged ( waiting = >
{
if ( waiting . NewValue )
GameplayClockContainer . Stop ( ) ;
else
GameplayClockContainer . Start ( ) ;
} ) ;
2020-10-27 05:10:12 +00:00
DrawableRuleset . IsPaused . BindValueChanged ( paused = >
{
updateGameplayState ( ) ;
updateSampleDisabledState ( ) ;
} ) ;
DrawableRuleset . FrameStableClock . IsCatchingUp . BindValueChanged ( _ = > updateSampleDisabledState ( ) ) ;
2020-10-27 04:54:33 +00:00
2020-10-06 12:09:35 +00:00
DrawableRuleset . HasReplayLoaded . BindValueChanged ( _ = > updateGameplayState ( ) ) ;
2020-08-16 15:18:40 +00:00
2019-08-27 09:27:21 +00:00
// bind clock into components that require it
DrawableRuleset . IsPaused . BindTo ( GameplayClockContainer . IsPaused ) ;
2018-04-13 09:19:50 +00:00
2020-11-10 14:32:30 +00:00
DrawableRuleset . NewResult + = r = >
2019-12-19 11:03:14 +00:00
{
HealthProcessor . ApplyResult ( r ) ;
ScoreProcessor . ApplyResult ( r ) ;
2020-05-03 14:55:44 +00:00
gameplayBeatmap . ApplyResult ( r ) ;
2019-12-19 11:03:14 +00:00
} ;
2020-11-10 14:32:30 +00:00
DrawableRuleset . RevertResult + = r = >
2019-12-19 11:03:14 +00:00
{
HealthProcessor . RevertResult ( r ) ;
ScoreProcessor . RevertResult ( r ) ;
} ;
2019-12-11 08:25:06 +00:00
2021-04-18 03:35:43 +00:00
DimmableStoryboard . HasStoryboardEnded . ValueChanged + = storyboardEnded = >
2021-04-18 01:49:07 +00:00
{
2021-04-19 03:25:20 +00:00
if ( storyboardEnded . NewValue & & completionProgressDelegate = = null )
updateCompletionState ( new ValueChangedEvent < bool > ( true , ScoreProcessor . HasCompleted . Value ) ) ;
2021-04-18 01:49:07 +00:00
} ;
2019-12-19 11:03:14 +00:00
// Bind the judgement processors to ourselves
2020-04-19 02:58:22 +00:00
ScoreProcessor . HasCompleted . ValueChanged + = updateCompletionState ;
2019-12-19 11:03:14 +00:00
HealthProcessor . Failed + = onFail ;
2018-04-13 09:19:50 +00:00
2019-08-27 09:27:21 +00:00
foreach ( var mod in Mods . Value . OfType < IApplicableToScoreProcessor > ( ) )
mod . ApplyToScoreProcessor ( ScoreProcessor ) ;
2019-12-19 11:03:14 +00:00
foreach ( var mod in Mods . Value . OfType < IApplicableToHealthProcessor > ( ) )
mod . ApplyToHealthProcessor ( HealthProcessor ) ;
2020-10-11 12:46:55 +00:00
IsBreakTime . BindTo ( breakTracker . IsBreakTime ) ;
2020-10-11 12:51:48 +00:00
IsBreakTime . BindValueChanged ( onBreakTimeChanged , true ) ;
2019-08-27 09:27:21 +00:00
}
2018-04-13 09:19:50 +00:00
2020-10-27 09:56:28 +00:00
protected virtual GameplayClockContainer CreateGameplayClockContainer ( WorkingBeatmap beatmap , double gameplayStart ) = > new GameplayClockContainer ( beatmap , gameplayStart ) ;
2020-09-29 05:09:51 +00:00
private Drawable createUnderlayComponents ( ) = >
DimmableStoryboard = new DimmableStoryboard ( Beatmap . Value . Storyboard ) { RelativeSizeAxes = Axes . Both } ;
2018-04-13 09:19:50 +00:00
2020-09-29 05:09:51 +00:00
private Drawable createGameplayComponents ( WorkingBeatmap working , IBeatmap playableBeatmap ) = > new ScalingContainer ( ScalingMode . Gameplay )
2019-08-27 09:27:21 +00:00
{
2020-09-29 05:09:51 +00:00
Children = new Drawable [ ]
2019-08-26 03:21:49 +00:00
{
2020-09-29 05:09:51 +00:00
DrawableRuleset . With ( r = >
r . FrameStableComponents . Children = new Drawable [ ]
{
ScoreProcessor ,
HealthProcessor ,
2020-11-13 04:35:01 +00:00
new ComboEffects ( ScoreProcessor ) ,
2020-09-29 05:09:51 +00:00
breakTracker = new BreakTracker ( DrawableRuleset . GameplayStartTime , ScoreProcessor )
{
Breaks = working . Beatmap . Breaks
}
} ) ,
}
} ;
2018-04-13 09:19:50 +00:00
2020-12-23 08:39:08 +00:00
private Drawable createOverlayComponents ( WorkingBeatmap working )
2019-08-27 09:27:21 +00:00
{
2020-12-23 08:39:08 +00:00
var container = new Container
2018-04-13 09:19:50 +00:00
{
2020-12-23 08:39:08 +00:00
RelativeSizeAxes = Axes . Both ,
Children = new [ ]
2020-03-27 20:19:49 +00:00
{
2020-12-23 08:39:08 +00:00
DimmableStoryboard . OverlayLayerContainer . CreateProxy ( ) ,
BreakOverlay = new BreakOverlay ( working . Beatmap . BeatmapInfo . LetterboxInBreaks , ScoreProcessor )
2018-04-13 09:19:50 +00:00
{
2020-12-23 08:39:08 +00:00
Clock = DrawableRuleset . FrameStableClock ,
ProcessCustomClock = false ,
Breaks = working . Beatmap . Breaks
2019-05-10 06:51:12 +00:00
} ,
2020-12-23 08:39:08 +00:00
// display the cursor above some HUD elements.
DrawableRuleset . Cursor ? . CreateProxy ( ) ? ? new Container ( ) ,
DrawableRuleset . ResumeOverlay ? . CreateProxy ( ) ? ? new Container ( ) ,
HUDOverlay = new HUDOverlay ( ScoreProcessor , HealthProcessor , DrawableRuleset , Mods . Value )
2020-03-06 09:00:17 +00:00
{
2020-12-23 08:39:08 +00:00
HoldToQuit =
{
2021-02-09 07:24:29 +00:00
Action = ( ) = > PerformExit ( true ) ,
2020-12-23 08:39:08 +00:00
IsPaused = { BindTarget = GameplayClockContainer . IsPaused }
} ,
PlayerSettingsOverlay = { PlaybackSettings = { UserPlaybackRate = { BindTarget = GameplayClockContainer . UserPlaybackRate } } } ,
KeyCounter =
{
AlwaysVisible = { BindTarget = DrawableRuleset . HasReplayLoaded } ,
IsCounting = false
} ,
RequestSeek = time = >
{
GameplayClockContainer . Seek ( time ) ;
GameplayClockContainer . Start ( ) ;
} ,
Anchor = Anchor . Centre ,
Origin = Anchor . Centre
2020-03-06 09:00:17 +00:00
} ,
2021-04-16 04:59:10 +00:00
skipIntroOverlay = new SkipOverlay ( DrawableRuleset . GameplayStartTime )
2020-11-24 06:41:56 +00:00
{
2021-01-21 22:10:11 +00:00
RequestSkip = performUserRequestedSkip
2020-11-24 06:41:56 +00:00
} ,
2021-04-17 16:28:31 +00:00
skipOutroOverlay = new SkipOverlay ( Beatmap . Value . Storyboard . LatestEventTime ? ? 0 )
2021-04-14 04:04:03 +00:00
{
2021-04-17 21:45:38 +00:00
RequestSkip = scheduleCompletion ,
Alpha = 0
2021-04-14 04:04:03 +00:00
} ,
2020-12-23 08:39:08 +00:00
FailOverlay = new FailOverlay
2018-04-13 09:19:50 +00:00
{
2020-12-23 08:39:08 +00:00
OnRetry = Restart ,
2021-02-09 07:24:29 +00:00
OnQuit = ( ) = > PerformExit ( true ) ,
2020-12-23 08:39:08 +00:00
} ,
PauseOverlay = new PauseOverlay
{
OnResume = Resume ,
Retries = RestartCount ,
OnRetry = Restart ,
2021-02-09 07:24:29 +00:00
OnQuit = ( ) = > PerformExit ( true ) ,
2020-12-23 08:39:08 +00:00
} ,
new HotkeyExitOverlay
{
Action = ( ) = >
{
if ( ! this . IsCurrentScreen ( ) ) return ;
2018-04-13 09:19:50 +00:00
2020-12-23 08:39:08 +00:00
fadeOut ( true ) ;
2021-02-09 08:28:57 +00:00
PerformExit ( false ) ;
2020-12-23 08:39:08 +00:00
} ,
2018-04-13 09:19:50 +00:00
} ,
2020-12-23 08:39:08 +00:00
failAnimation = new FailAnimation ( DrawableRuleset ) { OnComplete = onFailComplete , } ,
}
} ;
2021-04-16 04:59:10 +00:00
if ( ! Configuration . AllowSkipping )
2021-04-16 05:03:15 +00:00
{
2021-04-16 04:59:10 +00:00
skipIntroOverlay . Expire ( ) ;
2021-04-16 05:03:15 +00:00
skipOutroOverlay . Expire ( ) ;
}
2021-04-14 04:04:03 +00:00
2020-12-23 08:39:08 +00:00
if ( Configuration . AllowRestart )
{
container . Add ( new HotkeyRetryOverlay
2019-06-24 09:15:27 +00:00
{
Action = ( ) = >
{
if ( ! this . IsCurrentScreen ( ) ) return ;
fadeOut ( true ) ;
2020-12-23 08:39:08 +00:00
Restart ( ) ;
2019-06-24 09:15:27 +00:00
} ,
2020-12-23 08:39:08 +00:00
} ) ;
2020-09-29 05:09:51 +00:00
}
2020-12-23 08:39:08 +00:00
return container ;
}
2018-04-13 09:19:50 +00:00
2020-03-06 09:00:17 +00:00
private void onBreakTimeChanged ( ValueChangedEvent < bool > isBreakTime )
2020-02-29 15:37:42 +00:00
{
2020-10-11 12:51:48 +00:00
updateGameplayState ( ) ;
2020-03-06 09:00:17 +00:00
updatePauseOnFocusLostState ( ) ;
HUDOverlay . KeyCounter . IsCounting = ! isBreakTime . NewValue ;
2020-02-29 15:37:42 +00:00
}
2020-10-06 12:09:35 +00:00
private void updateGameplayState ( )
2020-08-03 19:25:45 +00:00
{
2020-10-06 12:09:35 +00:00
bool inGameplay = ! DrawableRuleset . HasReplayLoaded . Value & & ! DrawableRuleset . IsPaused . Value & & ! breakTracker . IsBreakTime . Value ;
OverlayActivationMode . Value = inGameplay ? OverlayActivation . Disabled : OverlayActivation . UserTriggered ;
2020-10-07 07:22:39 +00:00
LocalUserPlaying . Value = inGameplay ;
2020-08-03 19:25:45 +00:00
}
2020-10-27 05:10:12 +00:00
private void updateSampleDisabledState ( )
{
samplePlaybackDisabled . Value = DrawableRuleset . FrameStableClock . IsCatchingUp . Value | | GameplayClockContainer . GameplayClock . IsPaused . Value ;
}
2021-02-05 06:07:59 +00:00
private void updatePauseOnFocusLostState ( )
{
2021-02-22 13:59:35 +00:00
if ( ! PauseOnFocusLost | | ! pausingSupportedByCurrentState | | breakTracker . IsBreakTime . Value )
2021-02-05 06:07:59 +00:00
return ;
if ( gameActive . Value = = false )
2021-02-19 06:35:29 +00:00
{
2021-02-22 07:03:27 +00:00
bool paused = Pause ( ) ;
2021-02-23 04:23:32 +00:00
// if the initial pause could not be satisfied, the pause cooldown may be active.
// reschedule the pause attempt until it can be achieved.
2021-02-22 07:03:27 +00:00
if ( ! paused )
2021-02-19 08:33:26 +00:00
Scheduler . AddOnce ( updatePauseOnFocusLostState ) ;
2021-02-19 06:35:29 +00:00
}
2021-02-05 06:07:59 +00:00
}
2019-12-11 06:45:50 +00:00
2019-12-12 06:58:11 +00:00
private IBeatmap loadPlayableBeatmap ( )
2018-04-13 09:19:50 +00:00
{
2019-12-12 06:58:11 +00:00
IBeatmap playable ;
2019-03-06 11:30:14 +00:00
try
{
2019-12-12 06:58:11 +00:00
if ( Beatmap . Value . Beatmap = = null )
2019-03-06 11:30:14 +00:00
throw new InvalidOperationException ( "Beatmap was not loaded" ) ;
2018-04-13 09:19:50 +00:00
2019-12-12 06:58:11 +00:00
rulesetInfo = Ruleset . Value ? ? Beatmap . Value . BeatmapInfo . Ruleset ;
2019-08-26 03:21:49 +00:00
ruleset = rulesetInfo . CreateInstance ( ) ;
2019-03-06 11:30:14 +00:00
try
{
2019-12-12 06:58:11 +00:00
playable = Beatmap . Value . GetPlayableBeatmap ( ruleset . RulesetInfo , Mods . Value ) ;
2019-03-06 11:30:14 +00:00
}
catch ( BeatmapInvalidForRulesetException )
{
2019-12-12 06:58:11 +00:00
// A playable beatmap may not be creatable with the user's preferred ruleset, so try using the beatmap's default ruleset
rulesetInfo = Beatmap . Value . BeatmapInfo . Ruleset ;
2019-08-26 03:21:49 +00:00
ruleset = rulesetInfo . CreateInstance ( ) ;
2019-12-12 06:58:11 +00:00
playable = Beatmap . Value . GetPlayableBeatmap ( rulesetInfo , Mods . Value ) ;
2018-04-13 09:19:50 +00:00
}
2019-12-12 06:58:11 +00:00
if ( playable . HitObjects . Count = = 0 )
2019-03-06 11:30:14 +00:00
{
Logger . Log ( "Beatmap contains no hit objects!" , level : LogLevel . Error ) ;
return null ;
}
}
catch ( Exception e )
{
2020-09-23 07:30:20 +00:00
Logger . Error ( e , "Could not load beatmap successfully!" ) ;
2019-03-06 11:30:14 +00:00
//couldn't load, hard abort!
return null ;
}
2018-04-21 17:21:09 +00:00
2019-12-12 06:58:11 +00:00
return playable ;
2018-04-13 09:19:50 +00:00
}
2018-07-18 16:18:07 +00:00
2020-12-23 14:51:26 +00:00
/// <summary>
/// Exits the <see cref="Player"/>.
/// </summary>
2021-02-09 08:14:16 +00:00
/// <param name="showDialogFirst">
/// Whether the pause or fail dialog should be shown before performing an exit.
/// If true and a dialog is not yet displayed, the exit will be blocked the the relevant dialog will display instead.
2020-12-23 14:51:26 +00:00
/// </param>
2021-02-09 08:14:16 +00:00
protected void PerformExit ( bool showDialogFirst )
2018-12-13 07:17:24 +00:00
{
2019-06-24 09:15:27 +00:00
// if a restart has been requested, cancel any pending completion (user has shown intent to restart).
2019-08-06 14:05:12 +00:00
completionProgressDelegate ? . Cancel ( ) ;
2018-04-13 09:19:50 +00:00
2021-02-15 06:57:21 +00:00
// there is a chance that the exit was performed after the transition to results has started.
// we want to give the user what they want, so forcefully return to this screen (to proceed with the upwards exit process).
2021-02-09 07:24:29 +00:00
if ( ! this . IsCurrentScreen ( ) )
{
ValidForResume = false ;
this . MakeCurrent ( ) ;
2021-02-15 05:03:41 +00:00
return ;
2021-02-09 07:24:29 +00:00
}
2018-04-13 09:19:50 +00:00
2021-02-19 08:26:54 +00:00
bool pauseOrFailDialogVisible =
PauseOverlay . State . Value = = Visibility . Visible | | FailOverlay . State . Value = = Visibility . Visible ;
2020-12-23 14:51:26 +00:00
2021-02-19 08:26:54 +00:00
if ( showDialogFirst & & ! pauseOrFailDialogVisible )
2021-02-09 07:24:29 +00:00
{
2021-02-15 06:57:21 +00:00
// if the fail animation is currently in progress, accelerate it (it will show the pause dialog on completion).
2021-02-19 08:26:54 +00:00
if ( ValidForResume & & HasFailed )
2021-02-09 07:24:29 +00:00
{
failAnimation . FinishTransforms ( true ) ;
return ;
}
2021-02-20 04:35:25 +00:00
// there's a chance the pausing is not supported in the current state, at which point immediate exit should be preferred.
if ( pausingSupportedByCurrentState )
{
// in the case a dialog needs to be shown, attempt to pause and show it.
// this may fail (see internal checks in Pause()) but the fail cases are temporary, so don't fall through to Exit().
Pause ( ) ;
return ;
}
2021-04-14 04:04:03 +00:00
2021-04-17 21:45:38 +00:00
// if the score is ready for display but results screen has not been pushed yet (e.g. storyboard is still playing beyond gameplay), then transition to results screen instead of exiting.
if ( prepareScoreForDisplayTask ! = null )
2021-04-14 04:04:03 +00:00
scheduleCompletion ( ) ;
2021-02-09 07:24:29 +00:00
}
this . Exit ( ) ;
2018-04-13 09:19:50 +00:00
}
2021-01-21 22:10:11 +00:00
private void performUserRequestedSkip ( )
{
// user requested skip
// disable sample playback to stop currently playing samples and perform skip
samplePlaybackDisabled . Value = true ;
GameplayClockContainer . Skip ( ) ;
// return samplePlaybackDisabled.Value to what is defined by the beatmap's current state
updateSampleDisabledState ( ) ;
}
2019-11-01 06:51:45 +00:00
/// <summary>
/// Restart gameplay via a parent <see cref="PlayerLoader"/>.
/// <remarks>This can be called from a child screen in order to trigger the restart process.</remarks>
/// </summary>
2018-04-13 09:19:50 +00:00
public void Restart ( )
{
2020-12-23 08:39:08 +00:00
if ( ! Configuration . AllowRestart )
return ;
2020-10-07 08:40:54 +00:00
// at the point of restarting the track should either already be paused or the volume should be zero.
// stopping here is to ensure music doesn't become audible after exiting back to PlayerLoader.
musicController . Stop ( ) ;
2018-04-13 09:19:50 +00:00
sampleRestart ? . Play ( ) ;
RestartRequested ? . Invoke ( ) ;
2019-11-01 06:32:06 +00:00
2021-02-09 08:14:16 +00:00
PerformExit ( false ) ;
2018-04-13 09:19:50 +00:00
}
2019-08-06 14:05:12 +00:00
private ScheduledDelegate completionProgressDelegate ;
2021-03-23 06:45:22 +00:00
private Task < ScoreInfo > prepareScoreForDisplayTask ;
2018-04-13 09:19:50 +00:00
2020-04-19 02:58:22 +00:00
private void updateCompletionState ( ValueChangedEvent < bool > completionState )
2018-04-13 09:19:50 +00:00
{
2020-03-19 05:10:54 +00:00
// screen may be in the exiting transition phase.
if ( ! this . IsCurrentScreen ( ) )
return ;
2020-04-19 02:59:56 +00:00
if ( ! completionState . NewValue )
{
completionProgressDelegate ? . Cancel ( ) ;
completionProgressDelegate = null ;
ValidForResume = true ;
return ;
}
2020-04-21 02:51:20 +00:00
if ( completionProgressDelegate ! = null )
throw new InvalidOperationException ( $"{nameof(updateCompletionState)} was fired more than once" ) ;
2018-04-13 09:19:50 +00:00
// Only show the completion screen if the player hasn't failed
2020-04-21 02:51:20 +00:00
if ( HealthProcessor . HasFailed )
2018-04-13 09:19:50 +00:00
return ;
ValidForResume = false ;
2020-12-23 08:39:08 +00:00
if ( ! Configuration . ShowResults ) return ;
2018-04-13 09:19:50 +00:00
2021-03-23 06:45:22 +00:00
prepareScoreForDisplayTask ? ? = Task . Run ( async ( ) = >
2020-12-18 07:51:59 +00:00
{
2020-12-18 09:20:36 +00:00
var score = CreateScore ( ) ;
try
2020-12-18 07:51:59 +00:00
{
2021-03-23 06:45:22 +00:00
await PrepareScoreForResultsAsync ( score ) . ConfigureAwait ( false ) ;
2020-12-18 09:20:36 +00:00
}
catch ( Exception ex )
{
2021-03-23 06:45:22 +00:00
Logger . Error ( ex , "Score preparation failed!" ) ;
2020-12-18 07:51:59 +00:00
}
2020-12-18 18:32:05 +00:00
try
{
2021-03-08 03:57:16 +00:00
await ImportScore ( score ) . ConfigureAwait ( false ) ;
2020-12-18 18:32:05 +00:00
}
catch ( Exception ex )
{
Logger . Error ( ex , "Score import failed!" ) ;
}
return score . ScoreInfo ;
2020-12-18 09:20:36 +00:00
} ) ;
2021-04-18 01:49:07 +00:00
var storyboardHasOutro = DimmableStoryboard . ContentDisplayed & & ! DimmableStoryboard . HasStoryboardEnded . Value ;
2021-04-16 04:59:10 +00:00
if ( storyboardHasOutro )
2021-04-14 04:04:03 +00:00
{
skipOutroOverlay . Show ( ) ;
return ;
}
2020-12-18 09:20:36 +00:00
using ( BeginDelayedSequence ( RESULTS_DISPLAY_DELAY ) )
scheduleCompletion ( ) ;
2018-04-13 09:19:50 +00:00
}
2020-12-18 09:20:36 +00:00
private void scheduleCompletion ( ) = > completionProgressDelegate = Schedule ( ( ) = >
{
2021-03-23 06:45:22 +00:00
if ( ! prepareScoreForDisplayTask . IsCompleted )
2020-12-18 09:20:36 +00:00
{
scheduleCompletion ( ) ;
return ;
}
// screen may be in the exiting transition phase.
if ( this . IsCurrentScreen ( ) )
2021-03-23 06:45:22 +00:00
this . Push ( CreateResults ( prepareScoreForDisplayTask . Result ) ) ;
2020-12-18 09:20:36 +00:00
} ) ;
2019-03-18 02:48:11 +00:00
protected override bool OnScroll ( ScrollEvent e ) = > mouseWheelDisabled . Value & & ! GameplayClockContainer . IsPaused . Value ;
#region Fail Logic
protected FailOverlay FailOverlay { get ; private set ; }
2019-06-04 07:13:16 +00:00
private FailAnimation failAnimation ;
2018-04-13 09:19:50 +00:00
private bool onFail ( )
{
2020-05-12 11:08:35 +00:00
if ( ! CheckModsAllowFailure ( ) )
2018-04-13 09:19:50 +00:00
return false ;
2018-10-31 11:03:37 +00:00
HasFailed = true ;
2019-03-18 02:48:11 +00:00
// There is a chance that we could be in a paused state as the ruleset's internal clock (see FrameStabilityContainer)
// could process an extra frame after the GameplayClock is stopped.
// In such cases we want the fail state to precede a user triggered pause.
2019-06-11 05:28:52 +00:00
if ( PauseOverlay . State . Value = = Visibility . Visible )
2019-03-18 02:48:11 +00:00
PauseOverlay . Hide ( ) ;
2019-09-18 16:45:59 +00:00
failAnimation . Start ( ) ;
2019-09-19 08:53:10 +00:00
if ( Mods . Value . OfType < IApplicableFailOverride > ( ) . Any ( m = > m . RestartOnFail ) )
2018-10-14 15:18:52 +00:00
Restart ( ) ;
2018-04-13 09:19:50 +00:00
return true ;
}
2019-06-04 07:13:16 +00:00
// Called back when the transform finishes
private void onFailComplete ( )
{
GameplayClockContainer . Stop ( ) ;
2019-03-18 02:48:11 +00:00
FailOverlay . Retries = RestartCount ;
FailOverlay . Show ( ) ;
2018-04-13 09:19:50 +00:00
}
2019-03-18 02:48:11 +00:00
#endregion
#region Pause Logic
public bool IsResuming { get ; private set ; }
/// <summary>
/// The amount of gameplay time after which a second pause is allowed.
/// </summary>
private const double pause_cooldown = 1000 ;
protected PauseOverlay PauseOverlay { get ; private set ; }
private double? lastPauseActionTime ;
2021-02-19 08:42:30 +00:00
protected bool PauseCooldownActive = >
2021-02-19 06:34:39 +00:00
lastPauseActionTime . HasValue & & GameplayClockContainer . GameplayClock . CurrentTime < lastPauseActionTime + pause_cooldown ;
2021-02-20 04:35:25 +00:00
/// <summary>
/// A set of conditionals which defines whether the current game state and configuration allows for
/// pausing to be attempted via <see cref="Pause"/>. If false, the game should generally exit if a user pause
/// is attempted.
/// </summary>
private bool pausingSupportedByCurrentState = >
2019-03-18 02:48:11 +00:00
// must pass basic screen conditions (beatmap loaded, instance allows pause)
2020-12-23 08:39:08 +00:00
LoadedBeatmapSuccessfully & & Configuration . AllowPause & & ValidForResume
2019-03-18 02:48:11 +00:00
// replays cannot be paused and exit immediately
2019-03-20 06:27:06 +00:00
& & ! DrawableRuleset . HasReplayLoaded . Value
2019-03-18 02:48:11 +00:00
// cannot pause if we are already in a fail state
2021-02-20 04:35:25 +00:00
& & ! HasFailed ;
2019-03-18 02:48:11 +00:00
private bool canResume = >
// cannot resume from a non-paused state
GameplayClockContainer . IsPaused . Value
// cannot resume if we are already in a fail state
& & ! HasFailed
// already resuming
& & ! IsResuming ;
2021-02-22 07:03:27 +00:00
public bool Pause ( )
2019-03-18 02:48:11 +00:00
{
2021-02-22 07:03:27 +00:00
if ( ! pausingSupportedByCurrentState ) return false ;
2021-02-20 04:35:25 +00:00
2021-02-22 07:03:27 +00:00
if ( ! IsResuming & & PauseCooldownActive )
return false ;
2019-03-18 02:48:11 +00:00
2019-10-25 19:57:49 +00:00
if ( IsResuming )
{
DrawableRuleset . CancelResume ( ) ;
2019-11-01 05:43:52 +00:00
IsResuming = false ;
2019-10-25 19:57:49 +00:00
}
2019-03-18 02:48:11 +00:00
GameplayClockContainer . Stop ( ) ;
PauseOverlay . Show ( ) ;
lastPauseActionTime = GameplayClockContainer . GameplayClock . CurrentTime ;
2021-02-22 07:03:27 +00:00
return true ;
2019-03-18 02:48:11 +00:00
}
public void Resume ( )
{
if ( ! canResume ) return ;
IsResuming = true ;
PauseOverlay . Hide ( ) ;
2019-03-18 05:40:53 +00:00
2019-04-07 19:32:55 +00:00
// breaks and time-based conditions may allow instant resume.
2020-03-26 06:28:56 +00:00
if ( breakTracker . IsBreakTime . Value )
2019-03-18 05:40:53 +00:00
completeResume ( ) ;
else
2019-03-20 06:27:06 +00:00
DrawableRuleset . RequestResume ( completeResume ) ;
2019-03-18 05:40:53 +00:00
void completeResume ( )
{
GameplayClockContainer . Start ( ) ;
IsResuming = false ;
}
2019-03-18 02:48:11 +00:00
}
#endregion
#region Screen Logic
2019-01-23 11:52:00 +00:00
public override void OnEntering ( IScreen last )
2018-04-13 09:19:50 +00:00
{
base . OnEntering ( last ) ;
2018-04-20 08:30:27 +00:00
if ( ! LoadedBeatmapSuccessfully )
2018-04-13 09:19:50 +00:00
return ;
2019-01-23 11:52:00 +00:00
Alpha = 0 ;
this
2018-04-13 09:19:50 +00:00
. ScaleTo ( 0.7f )
. ScaleTo ( 1 , 750 , Easing . OutQuint )
. Delay ( 250 )
. FadeIn ( 250 ) ;
2021-01-04 09:32:23 +00:00
ApplyToBackground ( b = >
{
2021-04-13 06:24:35 +00:00
b . IgnoreUserSettings . Value = false ;
2021-01-04 09:32:23 +00:00
b . BlurAmount . Value = 0 ;
// bind component bindables.
b . IsBreakTime . BindTo ( breakTracker . IsBreakTime ) ;
b . StoryboardReplacesBackground . BindTo ( storyboardReplacesBackground ) ;
} ) ;
2018-04-13 09:19:50 +00:00
2020-07-22 03:41:06 +00:00
HUDOverlay . IsBreakTime . BindTo ( breakTracker . IsBreakTime ) ;
2020-03-26 06:28:56 +00:00
DimmableStoryboard . IsBreakTime . BindTo ( breakTracker . IsBreakTime ) ;
2019-12-10 20:06:13 +00:00
2019-07-12 02:50:06 +00:00
DimmableStoryboard . StoryboardReplacesBackground . BindTo ( storyboardReplacesBackground ) ;
2018-04-13 09:19:50 +00:00
2019-02-25 04:15:37 +00:00
storyboardReplacesBackground . Value = Beatmap . Value . Storyboard . ReplacesBackground & & Beatmap . Value . Storyboard . HasDrawable ;
2019-02-18 07:34:11 +00:00
2019-11-25 07:24:29 +00:00
foreach ( var mod in Mods . Value . OfType < IApplicableToPlayer > ( ) )
mod . ApplyToPlayer ( this ) ;
2019-06-29 01:23:59 +00:00
foreach ( var mod in Mods . Value . OfType < IApplicableToHUD > ( ) )
mod . ApplyToHUD ( HUDOverlay ) ;
2020-08-02 19:34:35 +00:00
2020-09-01 09:07:19 +00:00
// Our mods are local copies of the global mods so they need to be re-applied to the track.
// This is done through the music controller (for now), because resetting speed adjustments on the beatmap track also removes adjustments provided by DrawableTrack.
// Todo: In the future, player will receive in a track and will probably not have to worry about this...
musicController . ResetTrackAdjustments ( ) ;
2020-09-01 07:55:10 +00:00
foreach ( var mod in Mods . Value . OfType < IApplicableToTrack > ( ) )
2020-09-01 09:07:19 +00:00
mod . ApplyToTrack ( musicController . CurrentTrack ) ;
2020-09-03 19:56:47 +00:00
2020-10-06 12:09:35 +00:00
updateGameplayState ( ) ;
2020-12-24 06:32:55 +00:00
GameplayClockContainer . FadeInFromZero ( 750 , Easing . OutQuint ) ;
StartGameplay ( ) ;
}
/// <summary>
/// Called to trigger the starting of the gameplay clock and underlying gameplay.
/// This will be called on entering the player screen once. A derived class may block the first call to this to delay the start of gameplay.
/// </summary>
protected virtual void StartGameplay ( )
{
if ( GameplayClockContainer . GameplayClock . IsRunning )
throw new InvalidOperationException ( $"{nameof(StartGameplay)} should not be called when the gameplay clock is already running" ) ;
GameplayClockContainer . Restart ( ) ;
2018-04-13 09:19:50 +00:00
}
2019-01-23 11:52:00 +00:00
public override void OnSuspending ( IScreen next )
2018-04-13 09:19:50 +00:00
{
2020-06-18 14:35:03 +00:00
screenSuspension ? . Expire ( ) ;
2018-04-13 09:19:50 +00:00
fadeOut ( ) ;
base . OnSuspending ( next ) ;
}
2019-01-23 11:52:00 +00:00
public override bool OnExiting ( IScreen next )
2018-04-13 09:19:50 +00:00
{
2020-06-18 14:35:03 +00:00
screenSuspension ? . Expire ( ) ;
2019-08-06 14:05:12 +00:00
if ( completionProgressDelegate ! = null & & ! completionProgressDelegate . Cancelled & & ! completionProgressDelegate . Completed )
2018-07-27 22:34:51 +00:00
{
2019-08-06 14:05:12 +00:00
// proceed to result screen if beatmap already finished playing
2020-03-19 05:10:54 +00:00
completionProgressDelegate . RunTask ( ) ;
2018-07-27 22:34:51 +00:00
return true ;
}
2019-11-01 05:11:18 +00:00
// GameplayClockContainer performs seeks / start / stop operations on the beatmap's track.
// as we are no longer the current screen, we cannot guarantee the track is still usable.
2019-12-23 10:13:36 +00:00
GameplayClockContainer ? . StopUsingBeatmapClock ( ) ;
2019-11-01 05:11:18 +00:00
2020-09-01 09:07:19 +00:00
musicController . ResetTrackAdjustments ( ) ;
2020-09-01 07:55:10 +00:00
2019-03-16 05:20:10 +00:00
fadeOut ( ) ;
return base . OnExiting ( next ) ;
2018-04-13 09:19:50 +00:00
}
2020-12-18 08:47:33 +00:00
/// <summary>
/// Creates the player's <see cref="Score"/>.
/// </summary>
/// <returns>The <see cref="Score"/>.</returns>
2020-12-18 07:51:59 +00:00
protected virtual Score CreateScore ( )
2020-12-18 06:36:24 +00:00
{
2020-12-18 07:51:59 +00:00
var score = new Score
2020-12-18 06:36:24 +00:00
{
2020-12-18 07:51:59 +00:00
ScoreInfo = new ScoreInfo
{
Beatmap = Beatmap . Value . BeatmapInfo ,
Ruleset = rulesetInfo ,
Mods = Mods . Value . ToArray ( ) ,
}
2020-12-18 06:36:24 +00:00
} ;
if ( DrawableRuleset . ReplayScore ! = null )
2020-12-18 07:51:59 +00:00
{
score . ScoreInfo . User = DrawableRuleset . ReplayScore . ScoreInfo ? . User ? ? new GuestUser ( ) ;
score . Replay = DrawableRuleset . ReplayScore . Replay ;
}
2020-12-18 06:36:24 +00:00
else
2020-12-18 07:51:59 +00:00
{
score . ScoreInfo . User = api . LocalUser . Value ;
2020-12-18 09:31:49 +00:00
score . Replay = new Replay { Frames = recordingScore ? . Replay . Frames . ToList ( ) ? ? new List < ReplayFrame > ( ) } ;
2020-12-18 07:51:59 +00:00
}
2020-12-18 06:36:24 +00:00
2020-12-18 07:51:59 +00:00
ScoreProcessor . PopulateScore ( score . ScoreInfo ) ;
2020-12-18 06:36:24 +00:00
return score ;
}
2020-12-18 08:47:33 +00:00
/// <summary>
2020-12-18 18:32:05 +00:00
/// Imports the player's <see cref="Score"/> to the local database.
2020-12-18 08:47:33 +00:00
/// </summary>
2020-12-18 18:32:05 +00:00
/// <param name="score">The <see cref="Score"/> to import.</param>
/// <returns>The imported score.</returns>
2020-12-19 04:58:56 +00:00
protected virtual Task ImportScore ( Score score )
2020-03-29 13:51:28 +00:00
{
2020-12-18 07:51:59 +00:00
// Replays are already populated and present in the game's database, so should not be re-imported.
2020-03-29 13:51:28 +00:00
if ( DrawableRuleset . ReplayScore ! = null )
2020-12-19 04:58:56 +00:00
return Task . CompletedTask ;
2020-03-29 13:51:28 +00:00
2020-12-18 07:51:59 +00:00
LegacyByteArrayReader replayReader ;
2020-03-29 13:51:28 +00:00
2020-12-18 07:51:59 +00:00
using ( var stream = new MemoryStream ( ) )
2020-03-29 13:51:28 +00:00
{
2020-12-18 07:51:59 +00:00
new LegacyScoreEncoder ( score , gameplayBeatmap . PlayableBeatmap ) . Encode ( stream ) ;
replayReader = new LegacyByteArrayReader ( stream . ToArray ( ) , "replay.osr" ) ;
2020-03-29 13:51:28 +00:00
}
2020-12-19 04:58:56 +00:00
return scoreManager . Import ( score . ScoreInfo , replayReader ) ;
2020-03-29 13:51:28 +00:00
}
2020-12-18 18:32:05 +00:00
/// <summary>
2021-03-23 06:45:22 +00:00
/// Prepare the <see cref="Score"/> for display at results.
2020-12-18 18:32:05 +00:00
/// </summary>
2021-03-23 06:45:22 +00:00
/// <param name="score">The <see cref="Score"/> to prepare.</param>
/// <returns>A task that prepares the provided score. On completion, the score is assumed to be ready for display.</returns>
protected virtual Task PrepareScoreForResultsAsync ( Score score ) = > Task . CompletedTask ;
2020-12-18 18:32:05 +00:00
2020-12-18 08:47:33 +00:00
/// <summary>
/// Creates the <see cref="ResultsScreen"/> for a <see cref="ScoreInfo"/>.
/// </summary>
/// <param name="score">The <see cref="ScoreInfo"/> to be displayed in the results screen.</param>
/// <returns>The <see cref="ResultsScreen"/>.</returns>
2020-12-18 06:36:24 +00:00
protected virtual ResultsScreen CreateResults ( ScoreInfo score ) = > new SoloResultsScreen ( score , true ) ;
2018-08-02 10:08:23 +00:00
private void fadeOut ( bool instant = false )
2018-04-13 09:19:50 +00:00
{
2018-08-02 10:08:23 +00:00
float fadeOutDuration = instant ? 0 : 250 ;
2019-01-23 11:52:00 +00:00
this . FadeOut ( fadeOutDuration ) ;
2018-04-13 09:19:50 +00:00
2021-04-13 06:24:35 +00:00
ApplyToBackground ( b = > b . IgnoreUserSettings . Value = true ) ;
2019-02-25 04:15:37 +00:00
storyboardReplacesBackground . Value = false ;
2018-04-13 09:19:50 +00:00
}
2019-03-18 02:48:11 +00:00
#endregion
2020-10-14 10:39:48 +00:00
IBindable < bool > ISamplePlaybackDisabler . SamplePlaybackDisabled = > samplePlaybackDisabled ;
2018-04-13 09:19:50 +00:00
}
}