1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 07:42:54 +08:00
osu-lazer/osu.Game/Screens/Play/Player.cs

328 lines
11 KiB
C#
Raw Normal View History

// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
2016-09-29 19:13:58 +08:00
using OpenTK;
2016-11-09 07:13:20 +08:00
using osu.Framework.Allocation;
using osu.Framework.Audio;
using osu.Framework.Configuration;
2016-11-14 16:23:33 +08:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Input;
using osu.Framework.Logging;
using osu.Framework.Screens;
2016-11-14 16:23:33 +08:00
using osu.Framework.Timing;
using osu.Game.Configuration;
2017-04-18 15:05:58 +08:00
using osu.Game.Rulesets;
using osu.Game.Rulesets.UI;
using osu.Game.Screens.Backgrounds;
2016-12-18 03:59:41 +08:00
using System;
2017-01-27 20:57:22 +08:00
using System.Linq;
using osu.Framework.Threading;
using osu.Game.Rulesets.Mods;
2017-04-18 15:05:58 +08:00
using osu.Game.Rulesets.Scoring;
using osu.Game.Screens.Ranking;
using osu.Framework.Audio.Sample;
using osu.Game.Beatmaps;
using osu.Game.Online.API;
2016-09-29 19:13:58 +08:00
2016-11-14 16:23:33 +08:00
namespace osu.Game.Screens.Play
2016-09-29 19:13:58 +08:00
{
2017-02-17 17:59:30 +08:00
public class Player : OsuScreen
2016-09-29 19:13:58 +08:00
{
2017-02-17 17:59:30 +08:00
protected override BackgroundScreen CreateBackground() => new BackgroundScreenBeatmap(Beatmap);
2016-10-05 19:03:52 +08:00
internal override bool ShowOverlays => false;
2017-08-09 12:28:29 +08:00
internal override bool HasLocalCursorDisplayed => !pauseContainer.IsPaused && !HasFailed && RulesetContainer.ProvidingUserCursor;
2017-03-16 22:58:36 +08:00
public Action RestartRequested;
internal override bool AllowBeatmapRulesetChange => false;
2017-04-02 02:17:24 +08:00
public bool HasFailed { get; private set; }
public int RestartCount;
private IAdjustableClock adjustableSourceClock;
private FramedOffsetClock offsetClock;
private DecoupleableInterpolatingFramedClock decoupledClock;
2016-11-16 14:48:35 +08:00
private PauseContainer pauseContainer;
private RulesetInfo ruleset;
private APIAccess api;
2016-11-29 19:30:16 +08:00
private ScoreProcessor scoreProcessor;
2017-08-09 12:28:29 +08:00
protected RulesetContainer RulesetContainer;
#region User Settings
private Bindable<double> dimLevel;
private Bindable<bool> mouseWheelDisabled;
private Bindable<double> userAudioOffset;
private SampleChannel sampleRestart;
#endregion
private HUDOverlay hudOverlay;
2017-03-28 15:49:58 +08:00
private FailOverlay failOverlay;
2017-08-09 12:28:29 +08:00
private bool loadedSuccessfully => RulesetContainer?.Objects.Any() == true;
2017-07-19 18:10:04 +08:00
2017-08-22 17:02:38 +08:00
[BackgroundDependencyLoader]
private void load(AudioManager audio, OsuConfigManager config, APIAccess api)
2016-10-05 19:49:31 +08:00
{
this.api = api;
2017-05-15 09:56:27 +08:00
dimLevel = config.GetBindable<double>(OsuSetting.DimLevel);
2017-05-15 09:56:27 +08:00
mouseWheelDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableWheel);
2017-02-28 18:44:12 +08:00
sampleRestart = audio.Sample.Get(@"Gameplay/restart");
WorkingBeatmap working = Beatmap.Value;
Beatmap beatmap;
try
{
beatmap = working.Beatmap;
if (beatmap == null)
2017-05-07 00:38:17 +08:00
throw new InvalidOperationException("Beatmap was not loaded");
2017-04-17 14:44:46 +08:00
2017-08-22 17:02:38 +08:00
ruleset = Ruleset.Value ?? beatmap.BeatmapInfo.Ruleset;
var rulesetInstance = ruleset.CreateInstance();
2017-04-20 10:36:50 +08:00
2017-04-17 14:44:46 +08:00
try
{
2017-08-09 12:28:29 +08:00
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(working, ruleset.ID == beatmap.BeatmapInfo.Ruleset.ID);
2017-04-17 14:44:46 +08:00
}
2017-04-20 11:11:03 +08:00
catch (BeatmapInvalidForRulesetException)
2017-04-17 14:44:46 +08:00
{
2017-08-09 12:28:29 +08:00
// we may fail to create a RulesetContainer if the beatmap cannot be loaded with the user's preferred ruleset
2017-04-20 10:36:50 +08:00
// let's try again forcing the beatmap's ruleset.
ruleset = beatmap.BeatmapInfo.Ruleset;
2017-04-20 10:36:50 +08:00
rulesetInstance = ruleset.CreateInstance();
2017-08-09 12:28:29 +08:00
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(Beatmap, true);
2017-04-17 14:44:46 +08:00
}
2017-04-26 19:22:03 +08:00
2017-08-09 12:28:29 +08:00
if (!RulesetContainer.Objects.Any())
2017-05-07 00:38:17 +08:00
throw new InvalidOperationException("Beatmap contains no hit objects!");
}
catch (Exception e)
{
Logger.Log($"Could not load this beatmap sucessfully ({e})!", LoggingTarget.Runtime, LogLevel.Error);
//couldn't load, hard abort!
Exit();
return;
}
2016-10-05 19:49:31 +08:00
adjustableSourceClock = (IAdjustableClock)working.Track ?? new StopwatchClock();
2017-04-26 17:32:47 +08:00
decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
2017-08-09 12:28:29 +08:00
var firstObjectTime = RulesetContainer.Objects.First().StartTime;
decoupledClock.Seek(Math.Min(0, firstObjectTime - Math.Max(beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, beatmap.BeatmapInfo.AudioLeadIn)));
2017-04-26 17:07:22 +08:00
decoupledClock.ProcessFrame();
offsetClock = new FramedOffsetClock(decoupledClock);
2017-05-15 09:56:27 +08:00
userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
userAudioOffset.ValueChanged += v => offsetClock.Offset = v;
userAudioOffset.TriggerChange();
Schedule(() =>
{
adjustableSourceClock.Reset();
foreach (var mod in working.Mods.Value.OfType<IApplicableToClock>())
mod.ApplyToClock(adjustableSourceClock);
2017-04-26 17:07:22 +08:00
decoupledClock.ChangeSource(adjustableSourceClock);
});
Children = new Drawable[]
2016-10-06 22:33:09 +08:00
{
pauseContainer = new PauseContainer
{
AudioClock = decoupledClock,
FramedClock = offsetClock,
OnRetry = Restart,
OnQuit = Exit,
2017-08-09 12:28:29 +08:00
CheckCanPause = () => ValidForResume && !HasFailed && !RulesetContainer.HasReplayLoaded,
Retries = RestartCount,
OnPause = () => {
hudOverlay.KeyCounter.IsCounting = pauseContainer.IsPaused;
},
OnResume = () => {
hudOverlay.KeyCounter.IsCounting = true;
},
Children = new Drawable[]
{
2017-05-19 21:12:09 +08:00
new SkipButton(firstObjectTime) { AudioClock = decoupledClock },
2017-04-26 17:07:22 +08:00
new Container
2017-02-28 19:14:48 +08:00
{
2017-04-26 17:07:22 +08:00
RelativeSizeAxes = Axes.Both,
Clock = offsetClock,
Children = new Drawable[]
{
2017-08-09 12:28:29 +08:00
RulesetContainer,
2017-04-26 17:07:22 +08:00
}
2017-02-28 19:14:48 +08:00
},
hudOverlay = new HUDOverlay
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre
},
}
},
2017-04-06 14:34:52 +08:00
failOverlay = new FailOverlay
{
OnRetry = Restart,
OnQuit = Exit,
2017-04-09 21:26:31 +08:00
},
2017-04-10 11:06:10 +08:00
new HotkeyRetryOverlay
2017-04-09 21:26:31 +08:00
{
Action = () => {
//we want to hide the hitrenderer immediately (looks better).
//we may be able to remove this once the mouse cursor trail is improved.
2017-08-09 12:28:29 +08:00
RulesetContainer?.Hide();
Restart();
},
2017-04-06 14:34:52 +08:00
}
};
2017-08-09 12:28:29 +08:00
scoreProcessor = RulesetContainer.CreateScoreProcessor();
hudOverlay.BindProcessor(scoreProcessor);
2017-08-09 12:28:29 +08:00
hudOverlay.BindRulesetContainer(RulesetContainer);
2017-08-09 12:28:29 +08:00
hudOverlay.Progress.Objects = RulesetContainer.Objects;
hudOverlay.Progress.AudioClock = decoupledClock;
2017-08-09 12:28:29 +08:00
hudOverlay.Progress.AllowSeeking = RulesetContainer.HasReplayLoaded;
hudOverlay.Progress.OnSeek = pos => decoupledClock.Seek(pos);
hudOverlay.ModDisplay.Current.BindTo(working.Mods);
// Bind ScoreProcessor to ourselves
scoreProcessor.AllJudged += onCompletion;
scoreProcessor.Failed += onFail;
}
public void Restart()
{
sampleRestart?.Play();
2017-04-18 14:52:38 +08:00
ValidForResume = false;
RestartRequested?.Invoke();
Exit();
}
private ScheduledDelegate onCompletionEvent;
private void onCompletion()
2016-11-29 22:59:56 +08:00
{
// Only show the completion screen if the player hasn't failed
if (scoreProcessor.HasFailed || onCompletionEvent != null)
return;
ValidForResume = false;
using (BeginDelayedSequence(1000))
2016-11-29 22:59:56 +08:00
{
onCompletionEvent = Schedule(delegate
{
var score = new Score
{
2017-07-19 12:32:16 +08:00
Beatmap = Beatmap.Value.BeatmapInfo,
Ruleset = ruleset
};
scoreProcessor.PopulateScore(score);
score.User = RulesetContainer.Replay?.User ?? api.LocalUser.Value;
Push(new Results(score));
});
}
2016-11-29 22:59:56 +08:00
}
2017-08-05 10:59:58 +08:00
private bool onFail()
2017-01-20 15:51:43 +08:00
{
2017-08-05 10:59:58 +08:00
if (Beatmap.Value.Mods.Value.Any(m => !m.AllowFail))
return false;
decoupledClock.Stop();
2017-01-20 15:51:43 +08:00
2017-04-02 02:17:24 +08:00
HasFailed = true;
failOverlay.Retries = RestartCount;
failOverlay.Show();
2017-08-05 10:59:58 +08:00
return true;
2017-01-20 15:51:43 +08:00
}
2017-02-17 17:59:30 +08:00
protected override void OnEntering(Screen last)
{
base.OnEntering(last);
2017-07-19 18:10:04 +08:00
if (!loadedSuccessfully)
return;
2017-07-23 02:50:25 +08:00
(Background as BackgroundScreenBeatmap)?.BlurTo(Vector2.Zero, 1500, Easing.OutQuint);
Background?.FadeTo(1 - (float)dimLevel, 1500, Easing.OutQuint);
Content.Alpha = 0;
dimLevel.ValueChanged += newDim => Background?.FadeTo(1 - (float)newDim, 800);
2017-07-16 23:28:20 +08:00
Content
.ScaleTo(0.7f)
2017-07-23 02:50:25 +08:00
.ScaleTo(1, 750, Easing.OutQuint)
2017-07-16 23:28:20 +08:00
.Delay(250)
.FadeIn(250);
this.Delay(750).Schedule(() =>
{
if (!pauseContainer.IsPaused)
decoupledClock.Start();
});
pauseContainer.Alpha = 0;
2017-07-23 02:50:25 +08:00
pauseContainer.FadeIn(750, Easing.OutQuint);
}
protected override void OnSuspending(Screen next)
{
fadeOut();
base.OnSuspending(next);
}
2016-11-16 14:48:35 +08:00
2017-02-17 17:59:30 +08:00
protected override bool OnExiting(Screen next)
2016-12-17 00:13:24 +08:00
{
2017-08-09 12:28:29 +08:00
if (HasFailed || !ValidForResume || pauseContainer?.AllowExit != false || RulesetContainer?.HasReplayLoaded != false)
{
fadeOut();
return base.OnExiting(next);
}
2017-07-19 18:10:04 +08:00
if (loadedSuccessfully)
{
pauseContainer.Pause();
}
return true;
2016-12-17 00:13:24 +08:00
}
private void fadeOut()
{
const float fade_out_duration = 250;
2017-08-09 12:28:29 +08:00
RulesetContainer?.FadeOut(fade_out_duration);
Content.FadeOut(fade_out_duration);
2017-07-23 02:50:25 +08:00
hudOverlay?.ScaleTo(0.7f, fade_out_duration * 3, Easing.In);
Background?.FadeTo(1f, fade_out_duration);
2016-12-17 00:13:24 +08:00
}
protected override bool OnWheel(InputState state) => mouseWheelDisabled.Value && !pauseContainer.IsPaused;
2016-09-29 19:13:58 +08:00
}
2017-04-11 23:09:45 +08:00
}