Merge pull request #15609 from bdach/gameplay-test/share-clock-state

Transfer beatmap track time between editor and gameplay test screens

osu.Game.Tests/Visual/Editing/TestSceneEditorTestGameplay.cs

@@ -14,6 +14,7 @@ using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Game.Screens.Edit.GameplayTest;
+using osu.Game.Screens.Play;
 using osu.Game.Tests.Beatmaps.IO;
 using osuTK.Graphics;
 using osuTK.Input;
@@ -150,6 +151,35 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("track stopped", () => !Beatmap.Value.Track.IsRunning);
         }
 
+        [Test]
+        public void TestSharedClockState()
+        {
+            AddStep("seek to 00:01:00", () => EditorClock.Seek(60_000));
+            AddStep("click test gameplay button", () =>
+            {
+                var button = Editor.ChildrenOfType<TestGameplayButton>().Single();
+
+                InputManager.MoveMouseTo(button);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            EditorPlayer editorPlayer = null;
+            AddUntilStep("player pushed", () => (editorPlayer = Stack.CurrentScreen as EditorPlayer) != null);
+
+            GameplayClockContainer gameplayClockContainer = null;
+            AddStep("fetch gameplay clock", () => gameplayClockContainer = editorPlayer.ChildrenOfType<GameplayClockContainer>().First());
+            AddUntilStep("gameplay clock running", () => gameplayClockContainer.IsRunning);
+            AddAssert("gameplay time past 00:01:00", () => gameplayClockContainer.CurrentTime >= 60_000);
+
+            double timeAtPlayerExit = 0;
+            AddWaitStep("wait some", 5);
+            AddStep("store time before exit", () => timeAtPlayerExit = gameplayClockContainer.CurrentTime);
+
+            AddStep("exit player", () => editorPlayer.Exit());
+            AddUntilStep("current screen is editor", () => Stack.CurrentScreen is Editor);
+            AddAssert("time is past player exit", () => EditorClock.CurrentTime >= timeAtPlayerExit);
+        }
+
         public override void TearDownSteps()
         {
             base.TearDownSteps();

osu.Game/Screens/Edit/Editor.cs

@@ -325,6 +325,19 @@ namespace osu.Game.Screens.Edit
         /// </summary>
         public void UpdateClockSource() => clock.ChangeSource(Beatmap.Value.Track);
 
+        /// <summary>
+        /// Creates an <see cref="EditorState"/> instance representing the current state of the editor.
+        /// </summary>
+        /// <param name="nextBeatmap">
+        /// The next beatmap to be shown, in the case of difficulty switch.
+        /// <see langword="null"/> indicates that the beatmap will not be changing.
+        /// </param>
+        public EditorState GetState([CanBeNull] BeatmapInfo nextBeatmap = null) => new EditorState
+        {
+            Time = clock.CurrentTimeAccurate,
+            ClipboardContent = nextBeatmap == null || editorBeatmap.BeatmapInfo.RulesetID == nextBeatmap.RulesetID ? Clipboard.Content.Value : string.Empty
+        };
+
         /// <summary>
         /// Restore the editor to a provided state.
         /// </summary>
@@ -780,11 +793,7 @@ namespace osu.Game.Screens.Edit
             return new DifficultyMenuItem(beatmapInfo, isCurrentDifficulty, SwitchToDifficulty);
         }
 
-        protected void SwitchToDifficulty(BeatmapInfo nextBeatmap) => loader?.ScheduleDifficultySwitch(nextBeatmap, new EditorState
-        {
-            Time = clock.CurrentTimeAccurate,
-            ClipboardContent = editorBeatmap.BeatmapInfo.RulesetID == nextBeatmap.RulesetID ? Clipboard.Content.Value : string.Empty
-        });
+        protected void SwitchToDifficulty(BeatmapInfo nextBeatmap) => loader?.ScheduleDifficultySwitch(nextBeatmap, GetState(nextBeatmap));
 
         private void cancelExit()
         {
@@ -807,7 +816,7 @@ namespace osu.Game.Screens.Edit
                 pushEditorPlayer();
             }
 
-            void pushEditorPlayer() => this.Push(new EditorPlayerLoader());
+            void pushEditorPlayer() => this.Push(new EditorPlayerLoader(this));
         }
 
         public double SnapTime(double time, double? referenceTime) => editorBeatmap.SnapTime(time, referenceTime);

osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Screens;
+using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Screens.Play;
 
@@ -10,14 +11,22 @@ namespace osu.Game.Screens.Edit.GameplayTest
 {
     public class EditorPlayer : Player
     {
-        public EditorPlayer()
-            : base(new PlayerConfiguration { ShowResults = false })
-        {
-        }
+        private readonly Editor editor;
+        private readonly EditorState editorState;
 
         [Resolved]
         private MusicController musicController { get; set; }
 
+        public EditorPlayer(Editor editor)
+            : base(new PlayerConfiguration { ShowResults = false })
+        {
+            this.editor = editor;
+            editorState = editor.GetState();
+        }
+
+        protected override GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart)
+            => new MasterGameplayClockContainer(beatmap, editorState.Time, true);
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -35,9 +44,22 @@ namespace osu.Game.Screens.Edit.GameplayTest
 
         protected override bool CheckModsAllowFailure() => false; // never fail.
 
+        public override void OnEntering(IScreen last)
+        {
+            base.OnEntering(last);
+
+            // finish alpha transforms on entering to avoid gameplay starting in a half-hidden state.
+            // the finish calls are purposefully not propagated to children to avoid messing up their state.
+            FinishTransforms();
+            GameplayClockContainer.FinishTransforms(false, nameof(Alpha));
+        }
+
         public override bool OnExiting(IScreen next)
         {
             musicController.Stop();
+
+            editorState.Time = GameplayClockContainer.CurrentTime;
+            editor.RestoreState(editorState);
             return base.OnExiting(next);
         }
     }

osu.Game/Screens/Edit/GameplayTest/EditorPlayerLoader.cs

@@ -14,8 +14,8 @@ namespace osu.Game.Screens.Edit.GameplayTest
         [Resolved]
         private OsuLogo osuLogo { get; set; }
 
-        public EditorPlayerLoader()
-            : base(() => new EditorPlayer())
+        public EditorPlayerLoader(Editor editor)
+            : base(() => new EditorPlayer(editor))
         {
         }