Add first run setup dialog

osu.Game.Tests/Visual/UserInterface/TestSceneFirstRunScreenUIScale.cs

@@ -0,0 +1,19 @@
+// 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.
+
+using osu.Framework.Screens;
+using osu.Game.Overlays.FirstRunSetup;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneFirstRunScreenUIScale : OsuManualInputManagerTestScene
+    {
+        public TestSceneFirstRunScreenUIScale()
+        {
+            AddStep("load screen", () =>
+            {
+                Child = new ScreenStack(new ScreenUIScale());
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneFirstRunSetupOverlay.cs

@@ -0,0 +1,193 @@
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Configuration;
+using osu.Game.Localisation;
+using osu.Game.Overlays;
+using osu.Game.Overlays.FirstRunSetup;
+using osu.Game.Overlays.Notifications;
+using osu.Game.Screens;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneFirstRunSetupOverlay : OsuManualInputManagerTestScene
+    {
+        private FirstRunSetupOverlay overlay;
+
+        private readonly Mock<IPerformFromScreenRunner> performer = new Mock<IPerformFromScreenRunner>();
+
+        private readonly Mock<INotificationOverlay> notificationOverlay = new Mock<INotificationOverlay>();
+
+        private Notification lastNotification;
+
+        protected OsuConfigManager LocalConfig;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Dependencies.Cache(LocalConfig = new OsuConfigManager(LocalStorage));
+            Dependencies.CacheAs(performer.Object);
+            Dependencies.CacheAs(notificationOverlay.Object);
+        }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("setup dependencies", () =>
+            {
+                performer.Reset();
+                notificationOverlay.Reset();
+
+                performer.Setup(g => g.PerformFromScreen(It.IsAny<Action<IScreen>>(), It.IsAny<IEnumerable<Type>>()))
+                         .Callback((Action<IScreen> action, IEnumerable<Type> types) => action(null));
+
+                notificationOverlay.Setup(n => n.Post(It.IsAny<Notification>()))
+                                   .Callback((Notification n) => lastNotification = n);
+            });
+
+            AddStep("add overlay", () =>
+            {
+                Child = overlay = new FirstRunSetupOverlay
+                {
+                    State = { Value = Visibility.Visible }
+                };
+            });
+        }
+
+        [Test]
+        public void TestDoesntOpenOnSecondRun()
+        {
+            AddStep("set first run", () => LocalConfig.SetValue(OsuSetting.ShowFirstRunSetup, true));
+
+            AddUntilStep("step through", () =>
+            {
+                if (overlay.CurrentScreen?.IsLoaded != false) overlay.NextButton.TriggerClick();
+                return overlay.State.Value == Visibility.Hidden;
+            });
+
+            AddAssert("first run false", () => !LocalConfig.Get<bool>(OsuSetting.ShowFirstRunSetup));
+
+            AddStep("add overlay", () =>
+            {
+                Child = overlay = new FirstRunSetupOverlay();
+            });
+
+            AddWaitStep("wait some", 5);
+
+            AddAssert("overlay didn't show", () => overlay.State.Value == Visibility.Hidden);
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestOverlayRunsToFinish(bool keyboard)
+        {
+            AddUntilStep("step through", () =>
+            {
+                if (overlay.CurrentScreen?.IsLoaded != false)
+                {
+                    if (keyboard)
+                        InputManager.Key(Key.Enter);
+                    else
+                        overlay.NextButton.TriggerClick();
+                }
+
+                return overlay.State.Value == Visibility.Hidden;
+            });
+
+            AddUntilStep("wait for screens removed", () => !overlay.ChildrenOfType<Screen>().Any());
+
+            AddStep("no notifications", () => notificationOverlay.VerifyNoOtherCalls());
+
+            AddStep("display again on demand", () => overlay.Show());
+
+            AddUntilStep("back at start", () => overlay.CurrentScreen is ScreenWelcome);
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestBackButton(bool keyboard)
+        {
+            AddAssert("back button disabled", () => !overlay.BackButton.Enabled.Value);
+
+            AddUntilStep("step to last", () =>
+            {
+                var nextButton = overlay.NextButton;
+
+                if (overlay.CurrentScreen?.IsLoaded != false)
+                    nextButton.TriggerClick();
+
+                return nextButton.Text == CommonStrings.Finish;
+            });
+
+            AddUntilStep("step back to start", () =>
+            {
+                if (overlay.CurrentScreen?.IsLoaded != false)
+                {
+                    if (keyboard)
+                        InputManager.Key(Key.Escape);
+                    else
+                        overlay.BackButton.TriggerClick();
+                }
+
+                return overlay.CurrentScreen is ScreenWelcome;
+            });
+
+            AddAssert("back button disabled", () => !overlay.BackButton.Enabled.Value);
+
+            if (keyboard)
+            {
+                AddStep("exit via keyboard", () => InputManager.Key(Key.Escape));
+                AddAssert("overlay dismissed", () => overlay.State.Value == Visibility.Hidden);
+            }
+        }
+
+        [Test]
+        public void TestClickAwayToExit()
+        {
+            AddStep("click inside content", () =>
+            {
+                InputManager.MoveMouseTo(overlay.ScreenSpaceDrawQuad.Centre);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("overlay not dismissed", () => overlay.State.Value == Visibility.Visible);
+
+            AddStep("click outside content", () =>
+            {
+                InputManager.MoveMouseTo(overlay.ScreenSpaceDrawQuad.TopLeft - new Vector2(1));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("overlay dismissed", () => overlay.State.Value == Visibility.Hidden);
+        }
+
+        [Test]
+        public void TestResumeViaNotification()
+        {
+            AddStep("step to next", () => overlay.NextButton.TriggerClick());
+
+            AddAssert("is at known screen", () => overlay.CurrentScreen is ScreenUIScale);
+
+            AddStep("hide", () => overlay.Hide());
+            AddAssert("overlay hidden", () => overlay.State.Value == Visibility.Hidden);
+
+            AddStep("notification arrived", () => notificationOverlay.Verify(n => n.Post(It.IsAny<Notification>()), Times.Once));
+
+            AddStep("run notification action", () => lastNotification.Activated());
+
+            AddAssert("overlay shown", () => overlay.State.Value == Visibility.Visible);
+            AddAssert("is resumed", () => overlay.CurrentScreen is ScreenUIScale);
+        }
+    }
+}

osu.Game/Configuration/OsuConfigManager.cs

@@ -134,6 +134,8 @@ protected override void InitialiseDefaults()
 
             SetDefault(OsuSetting.Version, string.Empty);
 
+            SetDefault(OsuSetting.ShowFirstRunSetup, true);
+
             SetDefault(OsuSetting.ScreenshotFormat, ScreenshotFormat.Jpg);
             SetDefault(OsuSetting.ScreenshotCaptureMenuCursor, false);
 
@@ -308,6 +310,7 @@ public enum OsuSetting
         BeatmapListingCardSize,
         ToolbarClockDisplayMode,
         Version,
+        ShowFirstRunSetup,
         ShowConvertedBeatmaps,
         Skin,
         ScreenshotFormat,

osu.Game/Graphics/Containers/ScalingContainer.cs

@@ -79,12 +79,12 @@ public ScalingContainer(ScalingMode? targetMode = null)
             };
         }
 
-        private class ScalingDrawSizePreservingFillContainer : DrawSizePreservingFillContainer
+        public class ScalingDrawSizePreservingFillContainer : DrawSizePreservingFillContainer
         {
             private readonly bool applyUIScale;
             private Bindable<float> uiScale;
 
-            private float currentScale = 1;
+            protected float CurrentScale { get; private set; } = 1;
 
             public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
@@ -99,14 +99,14 @@ private void load(OsuConfigManager osuConfig)
                 if (applyUIScale)
                 {
                     uiScale = osuConfig.GetBindable<float>(OsuSetting.UIScale);
-                    uiScale.BindValueChanged(args => this.TransformTo(nameof(currentScale), args.NewValue, duration, Easing.OutQuart), true);
+                    uiScale.BindValueChanged(args => this.TransformTo(nameof(CurrentScale), args.NewValue, duration, Easing.OutQuart), true);
                 }
             }
 
             protected override void Update()
             {
-                Scale = new Vector2(currentScale);
-                Size = new Vector2(1 / currentScale);
+                Scale = new Vector2(CurrentScale);
+                Size = new Vector2(1 / CurrentScale);
 
                 base.Update();
             }

osu.Game/Localisation/CommonStrings.cs

@@ -9,6 +9,16 @@ public static class CommonStrings
     {
         private const string prefix = @"osu.Game.Resources.Localisation.Common";
 
+        /// <summary>
+        /// "Back"
+        /// </summary>
+        public static LocalisableString Back => new TranslatableString(getKey(@"back"), @"Back");
+
+        /// <summary>
+        /// "Finish"
+        /// </summary>
+        public static LocalisableString Finish => new TranslatableString(getKey(@"finish"), @"Finish");
+
         /// <summary>
         /// "Enabled"
         /// </summary>

osu.Game/Localisation/FirstRunSetupOverlayStrings.cs

@@ -0,0 +1,58 @@
+// 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.
+
+using osu.Framework.Localisation;
+
+namespace osu.Game.Localisation
+{
+    public static class FirstRunSetupOverlayStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.FirstRunSetupOverlay";
+
+        /// <summary>
+        /// "Get started"
+        /// </summary>
+        public static LocalisableString GetStarted => new TranslatableString(getKey(@"get_started"), @"Get started");
+
+        /// <summary>
+        /// "Click to resume first-run setup at any point"
+        /// </summary>
+        public static LocalisableString ClickToResumeFirstRunSetupAtAnyPoint => new TranslatableString(getKey(@"click_to_resume_first_run_setup_at_any_point"), @"Click to resume first-run setup at any point");
+
+        /// <summary>
+        /// "First-run setup"
+        /// </summary>
+        public static LocalisableString FirstRunSetupTitle => new TranslatableString(getKey(@"first_run_setup_title"), @"First-run setup");
+
+        /// <summary>
+        /// "Set up osu! to suit you"
+        /// </summary>
+        public static LocalisableString FirstRunSetupDescription => new TranslatableString(getKey(@"first_run_setup_description"), @"Set up osu! to suit you");
+
+        /// <summary>
+        /// "Welcome"
+        /// </summary>
+        public static LocalisableString WelcomeTitle => new TranslatableString(getKey(@"welcome_title"), @"Welcome");
+
+        /// <summary>
+        /// "Welcome to the first-run setup guide!
+        ///
+        /// osu! is a very configurable game, and diving straight into the settings can sometimes be overwhelming. This guide will help you get the important choices out of the way to ensure a great first experience!"
+        /// </summary>
+        public static LocalisableString WelcomeDescription => new TranslatableString(getKey(@"welcome_description"), @"Welcome to the first-run setup guide!
+
+osu! is a very configurable game, and diving straight into the settings can sometimes be overwhelming. This guide will help you get the important choices out of the way to ensure a great first experience!");
+
+        /// <summary>
+        /// "The size of the osu! user interface can be adjusted to your liking."
+        /// </summary>
+        public static LocalisableString UIScaleDescription => new TranslatableString(getKey(@"ui_scale_description"), @"The size of the osu! user interface can be adjusted to your liking.");
+
+        /// <summary>
+        /// "Next ({0})"
+        /// </summary>
+        public static LocalisableString Next(LocalisableString nextStepDescription) => new TranslatableString(getKey(@"next"), @"Next ({0})", nextStepDescription);
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}

osu.Game/Localisation/GeneralSettingsStrings.cs

@@ -59,6 +59,11 @@ public static class GeneralSettingsStrings
         /// </summary>
         public static LocalisableString ChangeFolderLocation => new TranslatableString(getKey(@"change_folder_location"), @"Change folder location...");
 
+        /// <summary>
+        /// "Run setup wizard"
+        /// </summary>
+        public static LocalisableString RunSetupWizard => new TranslatableString(getKey(@"run_setup_wizard"), @"Run setup wizard");
+
         private static string getKey(string key) => $"{prefix}:{key}";
     }
 }

osu.Game/OsuGame.cs

@@ -149,6 +149,8 @@ public class OsuGame : OsuGameBase, IKeyBindingHandler<GlobalAction>, ILocalUser
 
         protected SettingsOverlay Settings;
 
+        private FirstRunSetupOverlay firstRunOverlay;
+
         private VolumeOverlay volume;
 
         private OsuLogo osuLogo;
@@ -799,6 +801,7 @@ protected override void LoadComplete()
             loadComponentSingleFile(CreateUpdateManager(), Add, true);
 
             // overlay elements
+            loadComponentSingleFile(firstRunOverlay = new FirstRunSetupOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(new ManageCollectionsDialog(), overlayContent.Add, true);
             loadComponentSingleFile(beatmapListing = new BeatmapListingOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(dashboard = new DashboardOverlay(), overlayContent.Add, true);
@@ -849,7 +852,7 @@ void updateChatPollRate()
             Add(new MusicKeyBindingHandler());
 
             // side overlays which cancel each other.
-            var singleDisplaySideOverlays = new OverlayContainer[] { Settings, Notifications };
+            var singleDisplaySideOverlays = new OverlayContainer[] { Settings, Notifications, firstRunOverlay };
 
             foreach (var overlay in singleDisplaySideOverlays)
             {
@@ -874,7 +877,7 @@ void updateChatPollRate()
             }
 
             // ensure only one of these overlays are open at once.
-            var singleDisplayOverlays = new OverlayContainer[] { chatOverlay, news, dashboard, beatmapListing, changelogOverlay, rankingsOverlay, wikiOverlay };
+            var singleDisplayOverlays = new OverlayContainer[] { firstRunOverlay, chatOverlay, news, dashboard, beatmapListing, changelogOverlay, rankingsOverlay, wikiOverlay };
 
             foreach (var overlay in singleDisplayOverlays)
             {