Merge pull request #14743 from AbstractQbit/inheritable-allow-track-adjust

Make `IOsuScreen.AllowTrackAdjustments` nullable

osu.Game.Tests/Visual/TestSceneOsuScreenStack.cs

@@ -5,8 +5,8 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Screens;
-using osu.Framework.Testing;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
 using osu.Game.Screens;
 using osu.Game.Screens.Play;
 using osuTK.Graphics;
@@ -18,10 +18,18 @@ namespace osu.Game.Tests.Visual
     {
         private TestOsuScreenStack stack;
 
-        [SetUpSteps]
+        [Cached]
-        public void SetUpSteps()
+        private MusicController musicController = new MusicController();
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            AddStep("Create new screen stack", () => { Child = stack = new TestOsuScreenStack { RelativeSizeAxes = Axes.Both }; });
+            stack = new TestOsuScreenStack { RelativeSizeAxes = Axes.Both };
+
+            Add(musicController);
+            Add(stack);
+
+            LoadComponent(stack);
         }
 
         [Test]
@@ -42,6 +50,44 @@ namespace osu.Game.Tests.Visual
             AddAssert("Parallax is off", () => stack.ParallaxAmount == 0);
         }
 
+        [Test]
+        public void AllowTrackAdjustmentsTest()
+        {
+            AddStep("push allowing screen", () => stack.Push(loadNewScreen<AllowScreen>()));
+            AddAssert("allows adjustments 1", () => musicController.AllowTrackAdjustments);
+
+            AddStep("push inheriting screen", () => stack.Push(loadNewScreen<InheritScreen>()));
+            AddAssert("allows adjustments 2", () => musicController.AllowTrackAdjustments);
+
+            AddStep("push disallowing screen", () => stack.Push(loadNewScreen<DisallowScreen>()));
+            AddAssert("disallows adjustments 3", () => !musicController.AllowTrackAdjustments);
+
+            AddStep("push inheriting screen", () => stack.Push(loadNewScreen<InheritScreen>()));
+            AddAssert("disallows adjustments 4", () => !musicController.AllowTrackAdjustments);
+
+            AddStep("push inheriting screen", () => stack.Push(loadNewScreen<InheritScreen>()));
+            AddAssert("disallows adjustments 5", () => !musicController.AllowTrackAdjustments);
+
+            AddStep("push allowing screen", () => stack.Push(loadNewScreen<AllowScreen>()));
+            AddAssert("allows adjustments 6", () => musicController.AllowTrackAdjustments);
+
+            // Now start exiting from screens
+            AddStep("exit screen", () => stack.Exit());
+            AddAssert("disallows adjustments 7", () => !musicController.AllowTrackAdjustments);
+
+            AddStep("exit screen", () => stack.Exit());
+            AddAssert("disallows adjustments 8", () => !musicController.AllowTrackAdjustments);
+
+            AddStep("exit screen", () => stack.Exit());
+            AddAssert("disallows adjustments 9", () => !musicController.AllowTrackAdjustments);
+
+            AddStep("exit screen", () => stack.Exit());
+            AddAssert("allows adjustments 10", () => musicController.AllowTrackAdjustments);
+
+            AddStep("exit screen", () => stack.Exit());
+            AddAssert("allows adjustments 11", () => musicController.AllowTrackAdjustments);
+        }
+
         public class TestScreen : ScreenWithBeatmapBackground
         {
             private readonly string screenText;
@@ -78,5 +124,26 @@ namespace osu.Game.Tests.Visual
         {
             public new float ParallaxAmount => base.ParallaxAmount;
         }
+
+        private class AllowScreen : OsuScreen
+        {
+            public override bool? AllowTrackAdjustments => true;
+        }
+
+        public class DisallowScreen : OsuScreen
+        {
+            public override bool? AllowTrackAdjustments => false;
+        }
+
+        private class InheritScreen : OsuScreen
+        {
+        }
+
+        private OsuScreen loadNewScreen<T>() where T : OsuScreen, new()
+        {
+            OsuScreen screen = new T();
+            LoadComponent(screen);
+            return screen;
+        }
     }
 }

osu.Game/OsuGame.cs

@@ -1075,8 +1075,6 @@ namespace osu.Game
                 OverlayActivationMode.BindTo(newOsuScreen.OverlayActivationMode);
                 API.Activity.BindTo(newOsuScreen.Activity);
 
-                MusicController.AllowTrackAdjustments = newOsuScreen.AllowTrackAdjustments;
-
                 if (newOsuScreen.HideOverlaysOnEnter)
                     CloseAllOverlays();
                 else

osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs

@@ -24,8 +24,6 @@ namespace osu.Game.Overlays.Settings.Sections.Maintenance
 
         private OsuDirectorySelector directorySelector;
 
-        public override bool AllowTrackAdjustments => false;
-
         /// <summary>
         /// Text to display in the header to inform the user of what they are selecting.
         /// </summary>

osu.Game/Screens/Edit/Editor.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Screens.Edit
 
         public override bool DisallowExternalBeatmapRulesetChanges => true;
 
-        public override bool AllowTrackAdjustments => false;
+        public override bool? AllowTrackAdjustments => false;
 
         protected bool HasUnsavedChanges => lastSavedHash != changeHandler.CurrentStateHash;
 

osu.Game/Screens/IOsuScreen.cs

@@ -59,9 +59,10 @@ namespace osu.Game.Screens
         Bindable<RulesetInfo> Ruleset { get; }
 
         /// <summary>
-        /// Whether mod track adjustments are allowed to be applied.
+        /// Whether mod track adjustments should be applied on entering this screen.
+        /// A <see langword="null"/> value means that the parent screen's value of this setting will be used.
         /// </summary>
-        bool AllowTrackAdjustments { get; }
+        bool? AllowTrackAdjustments { get; }
 
         /// <summary>
         /// Invoked when the back button has been pressed to close any overlays before exiting this <see cref="IOsuScreen"/>.

osu.Game/Screens/Import/FileImportScreen.cs

@@ -23,8 +23,6 @@ namespace osu.Game.Screens.Import
     {
         public override bool HideOverlaysOnEnter => true;
 
-        public override bool AllowTrackAdjustments => false;
-
         private OsuFileSelector fileSelector;
         private Container contentContainer;
         private TextFlowContainer currentFileText;

osu.Game/Screens/Menu/MainMenu.cs

@@ -36,8 +36,6 @@ namespace osu.Game.Screens.Menu
 
         public override bool AllowExternalScreenChange => true;
 
-        public override bool AllowTrackAdjustments => false;
-
         private Screen songSelect;
 
         private MenuSideFlashes sideFlashes;

osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         public override bool DisallowExternalBeatmapRulesetChanges => true;
 
         // We are managing our own adjustments. For now, this happens inside the Player instances themselves.
-        public override bool AllowTrackAdjustments => false;
+        public override bool? AllowTrackAdjustments => false;
 
         /// <summary>
         /// Whether all spectating players have finished loading.

osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs

@@ -24,8 +24,6 @@ namespace osu.Game.Screens.OnlinePlay
         [Cached]
         protected readonly OverlayColourProvider ColourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
 
-        public override bool AllowTrackAdjustments => false;
-
         public override bool CursorVisible => (screenStack?.CurrentScreen as IOnlinePlaySubScreen)?.CursorVisible ?? true;
 
         // this is required due to PlayerLoader eventually being pushed to the main stack

osu.Game/Screens/OnlinePlay/OnlinePlaySubScreen.cs

@@ -11,6 +11,8 @@ namespace osu.Game.Screens.OnlinePlay
     {
         public override bool DisallowExternalBeatmapRulesetChanges => false;
 
+        public override bool? AllowTrackAdjustments => true;
+
         public virtual string ShortTitle => Title;
 
         [Resolved(CanBeNull = true)]

osu.Game/Screens/OsuScreen.cs

@@ -11,11 +11,11 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets;
-using osu.Game.Screens.Menu;
 using osu.Game.Overlays;
-using osu.Game.Users;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Screens.Menu;
+using osu.Game.Users;
 
 namespace osu.Game.Screens
 {
@@ -81,7 +81,10 @@ namespace osu.Game.Screens
 
         public virtual float BackgroundParallaxAmount => 1;
 
-        public virtual bool AllowTrackAdjustments => true;
+        [Resolved]
+        private MusicController musicController { get; set; }
+
+        public virtual bool? AllowTrackAdjustments => null;
 
         public Bindable<WorkingBeatmap> Beatmap { get; private set; }
 
@@ -91,6 +94,8 @@ namespace osu.Game.Screens
 
         private OsuScreenDependencies screenDependencies;
 
+        private bool? trackAdjustmentStateAtSuspend;
+
         internal void CreateLeasedDependencies(IReadOnlyDependencyContainer dependencies) => createDependencies(dependencies);
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
@@ -170,8 +175,14 @@ namespace osu.Game.Screens
         {
             if (PlayResumeSound)
                 sampleExit?.Play();
+
             applyArrivingDefaults(true);
 
+            // it's feasible to resume to a screen if the target screen never loaded successfully.
+            // in such a case there's no need to restore this value.
+            if (trackAdjustmentStateAtSuspend != null)
+                musicController.AllowTrackAdjustments = trackAdjustmentStateAtSuspend.Value;
+
             base.OnResuming(last);
         }
 
@@ -179,6 +190,8 @@ namespace osu.Game.Screens
         {
             base.OnSuspending(next);
 
+            trackAdjustmentStateAtSuspend = musicController.AllowTrackAdjustments;
+
             onSuspendingLogo();
         }
 
@@ -186,6 +199,9 @@ namespace osu.Game.Screens
         {
             applyArrivingDefaults(false);
 
+            if (AllowTrackAdjustments != null)
+                musicController.AllowTrackAdjustments = AllowTrackAdjustments.Value;
+
             if (backgroundStack?.Push(ownedBackground = CreateBackground()) != true)
             {
                 // If the constructed instance was not actually pushed to the background stack, we don't want to track it unnecessarily.

osu.Game/Screens/Play/Player.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Screens.Play
         protected override OverlayActivation InitialOverlayActivationMode => OverlayActivation.UserTriggered;
 
         // We are managing our own adjustments (see OnEntering/OnExiting).
-        public override bool AllowTrackAdjustments => false;
+        public override bool? AllowTrackAdjustments => false;
 
         private readonly IBindable<bool> gameActive = new Bindable<bool>(true);
 

osu.Game/Screens/Select/SongSelect.cs

@@ -53,6 +53,8 @@ namespace osu.Game.Screens.Select
 
         protected virtual bool DisplayStableImportPrompt => stableImportManager?.SupportsImportFromStable == true;
 
+        public override bool? AllowTrackAdjustments => true;
+
         /// <summary>
         /// Can be null if <see cref="ShowFooter"/> is false.
         /// </summary>

osu.Game/Screens/StartupScreen.cs

@@ -16,8 +16,6 @@ namespace osu.Game.Screens
 
         public override bool CursorVisible => false;
 
-        public override bool AllowTrackAdjustments => false;
-
         protected override OverlayActivation InitialOverlayActivationMode => OverlayActivation.Disabled;
     }
 }