1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-17 23:02:55 +08:00
osu-lazer/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs

496 lines
16 KiB
C#
Raw Normal View History

2019-03-17 23:46:15 +08:00
// 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.
2022-06-17 15:37:17 +08:00
#nullable disable
using System.Linq;
2019-03-18 18:44:21 +08:00
using NUnit.Framework;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
2019-03-18 10:48:11 +08:00
using osu.Framework.Graphics.Containers;
using osu.Framework.Logging;
2019-03-18 13:57:06 +08:00
using osu.Framework.Screens;
using osu.Framework.Testing;
using osu.Game.Configuration;
using osu.Game.Graphics.Containers;
using osu.Game.Graphics.Cursor;
2019-03-17 23:46:15 +08:00
using osu.Game.Rulesets;
using osu.Game.Rulesets.UI;
2019-03-17 23:46:15 +08:00
using osu.Game.Screens.Play;
2020-07-17 18:17:48 +08:00
using osu.Game.Skinning;
using osuTK;
using osuTK.Input;
2019-03-17 23:46:15 +08:00
2019-03-25 00:02:36 +08:00
namespace osu.Game.Tests.Visual.Gameplay
2019-03-17 23:46:15 +08:00
{
2022-11-24 13:32:20 +08:00
public partial class TestScenePause : OsuPlayerTestScene
2019-03-17 23:46:15 +08:00
{
2019-03-18 18:44:21 +08:00
protected new PausePlayer Player => (PausePlayer)base.Player;
private readonly Container content;
protected override Container<Drawable> Content => content;
private bool gameplayClockAlwaysGoingForward = true;
private double lastForwardCheckTime;
public TestScenePause()
2019-03-17 23:46:15 +08:00
{
base.Content.Add(content = new GlobalCursorDisplay { RelativeSizeAxes = Axes.Both });
2019-03-17 23:46:15 +08:00
}
[BackgroundDependencyLoader]
private void load()
{
LocalConfig.SetValue(OsuSetting.UIHoldActivationDelay, 0.0);
}
[SetUpSteps]
public override void SetUpSteps()
{
base.SetUpSteps();
AddStep("resume player", () => Player.GameplayClockContainer.Start());
confirmClockRunning(true);
}
2023-01-11 07:51:22 +08:00
[Test]
public void TestTogglePauseViaBackAction()
{
pauseViaBackAction();
pauseViaBackAction();
confirmPausedWithNoOverlay();
}
[Test]
public void TestTogglePauseViaPauseGameplayAction()
{
pauseViaPauseGameplayAction();
pauseViaPauseGameplayAction();
confirmPausedWithNoOverlay();
}
[Test]
public void TestForwardPlaybackGuarantee()
{
hookForwardPlaybackCheck();
AddUntilStep("wait for forward playback", () => Player.GameplayClockContainer.CurrentTime > 1000);
AddStep("seek before gameplay", () => Player.GameplayClockContainer.Seek(-5000));
checkForwardPlayback();
}
[Test]
public void TestPauseWithLargeOffset()
{
AddStep("force large offset", () =>
{
var offset = (BindableDouble)LocalConfig.GetBindable<double>(OsuSetting.AudioOffset);
// use a large negative offset to avoid triggering a fail from forwards seeking.
offset.MinValue = -5000;
offset.Value = -5000;
});
hookForwardPlaybackCheck();
AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
pauseAndConfirm();
resumeAndConfirm();
checkForwardPlayback();
AddStep("reset offset", () => LocalConfig.SetValue(OsuSetting.AudioOffset, 0.0));
}
private void checkForwardPlayback() => AddAssert("time didn't go too far backwards", () => gameplayClockAlwaysGoingForward);
private void hookForwardPlaybackCheck()
{
AddStep("add time forward check hook", () =>
{
lastForwardCheckTime = double.MinValue;
gameplayClockAlwaysGoingForward = true;
Player.OnUpdate += _ =>
{
var frameStableClock = Player.ChildrenOfType<FrameStabilityContainer>().Single().Clock;
double currentTime = frameStableClock.CurrentTime;
bool goingForward = currentTime >= lastForwardCheckTime;
lastForwardCheckTime = currentTime;
gameplayClockAlwaysGoingForward &= goingForward;
if (!goingForward)
Logger.Log($"Went too far backwards (last stop: {lastForwardCheckTime:N1} current: {currentTime:N1})");
};
});
}
2019-03-18 18:44:21 +08:00
[Test]
public void TestPauseResume()
2019-03-17 23:46:15 +08:00
{
AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
pauseAndConfirm();
AddAssert("player not playing", () => !Player.LocalUserPlaying.Value);
resumeAndConfirm();
AddAssert("continued playing forward", () => Player.LastResumeTime, () => Is.GreaterThanOrEqualTo(Player.LastPauseTime));
AddUntilStep("player playing", () => Player.LocalUserPlaying.Value);
}
[Test]
public void TestResumeWithResumeOverlay()
{
AddStep("move cursor to center", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.Centre));
AddUntilStep("wait for hitobjects", () => Player.HealthProcessor.Health.Value < 1);
pauseAndConfirm();
resume();
confirmPausedWithNoOverlay();
2020-11-05 22:41:56 +08:00
AddStep("click to resume", () => InputManager.Click(MouseButton.Left));
confirmClockRunning(true);
}
[Test]
public void TestPauseWithResumeOverlay()
{
AddStep("move cursor to center", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.Centre));
AddUntilStep("wait for hitobjects", () => Player.HealthProcessor.Health.Value < 1);
pauseAndConfirm();
resume();
confirmPausedWithNoOverlay();
pauseAndConfirm();
AddUntilStep("resume overlay is not active", () => Player.DrawableRuleset.ResumeOverlay.State.Value == Visibility.Hidden);
confirmPaused();
confirmNotExited();
}
[Test]
public void TestResumeWithResumeOverlaySkipped()
{
AddStep("move cursor to button", () =>
InputManager.MoveMouseTo(Player.HUDOverlay.HoldToQuit.Children.OfType<HoldToConfirmContainer>().First().ScreenSpaceDrawQuad.Centre));
AddUntilStep("wait for hitobjects", () => Player.HealthProcessor.Health.Value < 1);
2019-03-21 15:33:34 +08:00
pauseAndConfirm();
resumeAndConfirm();
2019-03-18 18:44:21 +08:00
}
2019-03-18 10:48:11 +08:00
[Test]
public void TestUserPauseWhenPauseNotAllowed()
{
AddStep("disable pause support", () => Player.Configuration.AllowPause = false);
pauseViaBackAction();
confirmExited();
}
[Test]
public void TestUserPauseDuringCooldownTooSoon()
{
AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
pauseAndConfirm();
resume();
pauseViaBackAction();
confirmResumed();
confirmNotExited();
}
[Test]
public void TestQuickExitDuringCooldownTooSoon()
{
AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
pauseAndConfirm();
resume();
exitViaQuickExitAction();
confirmResumed();
AddAssert("exited", () => !Player.IsCurrentScreen());
}
2019-03-21 15:11:44 +08:00
[Test]
public void TestExitSoonAfterResumeSucceeds()
2019-03-21 15:11:44 +08:00
{
2019-11-28 14:58:26 +08:00
AddStep("seek before gameplay", () => Player.GameplayClockContainer.Seek(-5000));
2019-03-21 15:33:34 +08:00
2019-11-28 14:58:26 +08:00
pauseAndConfirm();
2019-03-21 15:33:34 +08:00
resume();
AddStep("exit quick", () => Player.Exit());
2019-03-21 15:33:34 +08:00
confirmResumed();
AddAssert("exited", () => !Player.IsCurrentScreen());
2019-03-21 15:11:44 +08:00
}
2019-03-18 18:44:21 +08:00
[Test]
public void TestPauseAfterFail()
{
AddUntilStep("wait for fail", () => Player.GameplayState.HasFailed);
2019-06-04 15:13:16 +08:00
AddUntilStep("fail overlay shown", () => Player.FailOverlayVisible);
2019-03-18 10:48:11 +08:00
2019-03-21 15:33:34 +08:00
confirmClockRunning(false);
AddStep("pause via forced pause", () => Player.Pause());
2019-03-21 15:33:34 +08:00
confirmPausedWithNoOverlay();
2019-03-18 18:44:21 +08:00
AddAssert("fail overlay still shown", () => Player.FailOverlayVisible);
2019-03-21 15:11:44 +08:00
2019-03-21 15:33:34 +08:00
exitAndConfirm();
2019-03-21 15:11:44 +08:00
}
2019-10-04 11:25:23 +08:00
[Test]
public void TestExitFromFailedGameplayAfterFailAnimation()
2019-10-04 11:25:23 +08:00
{
AddUntilStep("wait for fail", () => Player.GameplayState.HasFailed);
AddUntilStep("wait for fail overlay shown", () => Player.FailOverlayVisible);
confirmClockRunning(false);
pauseViaBackAction();
confirmExited();
}
[Test]
public void TestExitFromFailedGameplayDuringFailAnimation()
{
AddUntilStep("wait for fail", () => Player.GameplayState.HasFailed);
// will finish the fail animation and show the fail/pause screen.
pauseViaBackAction();
AddAssert("fail overlay shown", () => Player.FailOverlayVisible);
2019-10-04 11:25:23 +08:00
// will actually exit.
pauseViaBackAction();
2019-10-04 11:25:23 +08:00
confirmExited();
}
[Test]
public void TestQuickRetryFromFailedGameplay()
{
AddUntilStep("wait for fail", () => Player.GameplayState.HasFailed);
2020-09-29 13:18:54 +08:00
AddStep("quick retry", () => Player.GameplayClockContainer.ChildrenOfType<HotkeyRetryOverlay>().First().Action?.Invoke());
confirmExited();
}
[Test]
public void TestQuickExitFromFailedGameplay()
{
AddUntilStep("wait for fail", () => Player.GameplayState.HasFailed);
exitViaQuickExitAction();
confirmExited();
}
2019-03-21 15:11:44 +08:00
[Test]
public void TestExitFromGameplay()
{
// an externally triggered exit should immediately exit, skipping all pause logic.
2019-11-28 14:58:26 +08:00
AddStep("exit", () => Player.Exit());
2019-10-03 03:07:07 +08:00
confirmExited();
2019-03-18 18:44:21 +08:00
}
2019-03-18 13:57:06 +08:00
[Test]
public void TestQuickExitFromGameplay()
{
exitViaQuickExitAction();
confirmExited();
}
2019-06-25 22:48:42 +08:00
[Test]
public void TestExitViaHoldToExit()
{
2024-08-20 16:59:55 +08:00
AddStep("set hold button always visible", () => LocalConfig.SetValue(OsuSetting.AlwaysShowHoldForMenuButton, true));
2019-06-25 22:48:42 +08:00
AddStep("exit", () =>
{
InputManager.MoveMouseTo(Player.HUDOverlay.HoldToQuit.First(c => c is HoldToConfirmContainer));
InputManager.PressButton(MouseButton.Left);
});
confirmPaused();
AddStep("release", () => InputManager.ReleaseButton(MouseButton.Left));
exitAndConfirm();
}
2019-03-18 18:44:21 +08:00
[Test]
public void TestExitFromPause()
{
2019-03-21 15:33:34 +08:00
pauseAndConfirm();
exitAndConfirm();
}
2019-03-18 13:57:06 +08:00
[Test]
public void TestRestartAfterResume()
{
2019-11-28 14:58:26 +08:00
AddStep("seek before gameplay", () => Player.GameplayClockContainer.Seek(-5000));
pauseAndConfirm();
resumeAndConfirm();
restart();
confirmExited();
}
2020-07-17 18:17:48 +08:00
[Test]
public void TestPauseSoundLoop()
{
AddStep("seek before gameplay", () => Player.GameplayClockContainer.Seek(-5000));
SkinnableSound getLoop() => Player.ChildrenOfType<PauseOverlay>().FirstOrDefault()?.ChildrenOfType<SkinnableSound>().FirstOrDefault();
pauseAndConfirm();
AddAssert("loop is playing", () => getLoop().IsPlaying);
resumeAndConfirm();
AddUntilStep("loop is stopped", () => !getLoop().IsPlaying);
AddUntilStep("pause again", () =>
{
Player.Pause();
return !Player.GameplayClockContainer.IsRunning;
2020-07-17 18:17:48 +08:00
});
AddAssert("loop is playing", () => getLoop().IsPlaying);
resumeAndConfirm();
AddUntilStep("loop is stopped", () => !getLoop().IsPlaying);
}
2019-03-21 15:33:34 +08:00
private void pauseAndConfirm()
{
pauseViaBackAction();
2019-03-21 15:33:34 +08:00
confirmPaused();
2019-03-21 15:11:44 +08:00
}
2019-03-21 15:33:34 +08:00
private void resumeAndConfirm()
{
resume();
confirmResumed();
}
private void exitAndConfirm()
2019-03-21 15:11:44 +08:00
{
confirmNotExited();
2019-03-18 18:44:21 +08:00
AddStep("exit", () => Player.Exit());
2019-03-21 15:33:34 +08:00
confirmExited();
2019-11-06 09:32:09 +08:00
confirmNoTrackAdjustments();
2019-03-21 15:33:34 +08:00
}
private void confirmPaused()
{
confirmClockRunning(false);
confirmNotExited();
AddAssert("player not failed", () => !Player.GameplayState.HasFailed);
2019-03-21 15:33:34 +08:00
AddAssert("pause overlay shown", () => Player.PauseOverlayVisible);
}
private void confirmResumed()
{
confirmClockRunning(true);
confirmPauseOverlayShown(false);
}
private void confirmPausedWithNoOverlay()
{
confirmClockRunning(false);
confirmPauseOverlayShown(false);
}
private void confirmExited() => AddUntilStep("player exited", () => !Player.IsCurrentScreen());
private void confirmNotExited() => AddAssert("player not exited", () => Player.IsCurrentScreen());
2019-03-17 23:46:15 +08:00
2019-11-06 09:32:09 +08:00
private void confirmNoTrackAdjustments()
{
AddUntilStep("track has no adjustments", () => Beatmap.Value.Track.AggregateFrequency.Value, () => Is.EqualTo(1));
2019-11-06 09:32:09 +08:00
}
private void restart() => AddStep("restart", () => Player.Restart());
private void pauseViaBackAction() => AddStep("press escape", () => InputManager.Key(Key.Escape));
2023-01-11 07:51:22 +08:00
private void pauseViaPauseGameplayAction() => AddStep("press middle mouse", () => InputManager.Click(MouseButton.Middle));
private void exitViaQuickExitAction() => AddStep("press ctrl-tilde", () =>
{
InputManager.PressKey(Key.ControlLeft);
InputManager.PressKey(Key.Tilde);
InputManager.ReleaseKey(Key.Tilde);
InputManager.ReleaseKey(Key.ControlLeft);
});
2019-03-21 15:33:34 +08:00
private void resume() => AddStep("resume", () => Player.Resume());
private void confirmPauseOverlayShown(bool isShown) =>
AddAssert("pause overlay " + (isShown ? "shown" : "hidden"), () => Player.PauseOverlayVisible == isShown);
private void confirmClockRunning(bool isRunning) =>
AddUntilStep("clock " + (isRunning ? "running" : "stopped"), () =>
{
bool completed = Player.GameplayClockContainer.IsRunning == isRunning;
if (completed)
{
}
return completed;
});
2019-03-21 15:33:34 +08:00
2019-03-18 18:44:21 +08:00
protected override bool AllowFail => true;
protected override TestPlayer CreatePlayer(Ruleset ruleset) => new PausePlayer();
2019-03-18 18:44:21 +08:00
2022-11-24 13:32:20 +08:00
protected partial class PausePlayer : TestPlayer
2019-03-17 23:46:15 +08:00
{
public double LastPauseTime { get; private set; }
public double LastResumeTime { get; private set; }
public bool FailOverlayVisible => FailOverlay.State.Value == Visibility.Visible;
2019-03-18 10:48:11 +08:00
public bool PauseOverlayVisible => PauseOverlay.State.Value == Visibility.Visible;
public override void OnEntering(ScreenTransitionEvent e)
{
base.OnEntering(e);
GameplayClockContainer.Stop();
}
private bool? isRunning;
protected override void UpdateAfterChildren()
{
base.UpdateAfterChildren();
if (GameplayClockContainer.IsRunning != isRunning)
{
isRunning = GameplayClockContainer.IsRunning;
if (isRunning.Value)
LastResumeTime = GameplayClockContainer.CurrentTime;
else
LastPauseTime = GameplayClockContainer.CurrentTime;
}
}
2019-03-17 23:46:15 +08:00
}
}
}