Merge branch 'master' into triangles

README.md

@@ -19,8 +19,9 @@ Detailed changelogs are published on the [official osu! site](https://osu.ppy.sh
 ## Requirements
 
 - A desktop platform with the [.NET Core SDK 2.2](https://www.microsoft.com/net/learn/get-started) or higher installed.
+- When running on linux, please have a system-wide ffmpeg installation available to support video decoding.
+- When running on Windows 7 or 8.1, **[additional prerequisites](https://docs.microsoft.com/en-us/dotnet/core/windows-prerequisites?tabs=netcore2x)** may be required to correctly run .NET Core applications if your operating system is not up-to-date with the latest service packs.
 - When working with the codebase, we recommend using an IDE with intellisense and syntax highlighting, such as [Visual Studio 2017+](https://visualstudio.microsoft.com/vs/), [Jetbrains Rider](https://www.jetbrains.com/rider/) or [Visual Studio Code](https://code.visualstudio.com/).
-- Note that there are **[additional requirements for Windows 7 and Windows 8.1](https://docs.microsoft.com/en-us/dotnet/core/windows-prerequisites?tabs=netcore2x)** which you may need to manually install if your operating system is not up-to-date.
 
 ## Running osu!
 

osu.Game.Rulesets.Osu/Mods/OsuModAutopilot.cs

@@ -2,13 +2,19 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.StateChanges;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModAutopilot : Mod
+    public class OsuModAutopilot : Mod, IApplicableFailOverride, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
     {
         public override string Name => "Autopilot";
         public override string Acronym => "AP";
@@ -17,5 +23,40 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Description => @"Automatic cursor movement - just follow the rhythm.";
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(OsuModSpunOut), typeof(ModRelax), typeof(ModSuddenDeath), typeof(ModNoFail), typeof(ModAutoplay) };
+
+        public bool AllowFail => false;
+
+        private OsuInputManager inputManager;
+
+        private List<OsuReplayFrame> replayFrames;
+
+        private int currentFrame;
+
+        public void Update(Playfield playfield)
+        {
+            if (currentFrame == replayFrames.Count - 1) return;
+
+            double time = playfield.Time.Current;
+
+            // Very naive implementation of autopilot based on proximity to replay frames.
+            // TODO: this needs to be based on user interactions to better match stable (pausing until judgement is registered).
+            if (Math.Abs(replayFrames[currentFrame + 1].Time - time) <= Math.Abs(replayFrames[currentFrame].Time - time))
+            {
+                currentFrame++;
+                new MousePositionAbsoluteInput { Position = playfield.ToScreenSpace(replayFrames[currentFrame].Position) }.Apply(inputManager.CurrentState, inputManager);
+            }
+
+            // TODO: Implement the functionality to automatically spin spinners
+        }
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            // Grab the input manager to disable the user's cursor, and for future use
+            inputManager = (OsuInputManager)drawableRuleset.KeyBindingInputManager;
+            inputManager.AllowUserCursorMovement = false;
+
+            // Generate the replay frames the cursor should follow
+            replayFrames = new OsuAutoGenerator(drawableRuleset.Beatmap).Generate().Frames.Cast<OsuReplayFrame>().ToList();
+        }
     }
 }

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -18,6 +18,12 @@ namespace osu.Game.Rulesets.Osu
             set => ((OsuKeyBindingContainer)KeyBindingContainer).AllowUserPresses = value;
         }
 
+        /// <summary>
+        /// Whether the user's cursor movement events should be accepted.
+        /// Can be used to block only movement while still accepting button input.
+        /// </summary>
+        public bool AllowUserCursorMovement { get; set; } = true;
+
         protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
             => new OsuKeyBindingContainer(ruleset, variant, unique);
 
@@ -26,6 +32,13 @@ namespace osu.Game.Rulesets.Osu
         {
         }
 
+        protected override bool Handle(UIEvent e)
+        {
+            if (e is MouseMoveEvent && !AllowUserCursorMovement) return false;
+
+            return base.Handle(e);
+        }
+
         private class OsuKeyBindingContainer : RulesetKeyBindingContainer
         {
             public bool AllowUserPresses = true;

osu.Game.Tests/Visual/Background/TestSceneUserDimContainer.cs

@@ -119,14 +119,14 @@ namespace osu.Game.Tests.Visual.Background
         {
             performFullSetup();
             createFakeStoryboard();
-            AddStep("Storyboard Enabled", () =>
+            AddStep("Enable Storyboard", () =>
             {
                 player.ReplacesBackground.Value = true;
                 player.StoryboardEnabled.Value = true;
             });
             waitForDim();
             AddAssert("Background is invisible, storyboard is visible", () => songSelect.IsBackgroundInvisible() && player.IsStoryboardVisible);
-            AddStep("Storyboard Disabled", () =>
+            AddStep("Disable Storyboard", () =>
             {
                 player.ReplacesBackground.Value = false;
                 player.StoryboardEnabled.Value = false;
@@ -149,22 +149,44 @@ namespace osu.Game.Tests.Visual.Background
         }
 
         /// <summary>
-        /// Check if the <see cref="UserDimContainer"/> is properly accepting user-defined visual changes at all.
+        /// Ensure <see cref="UserDimContainer"/> is properly accepting user-defined visual changes for a background.
         /// </summary>
         [Test]
-        public void DisableUserDimTest()
+        public void DisableUserDimBackgroundTest()
         {
             performFullSetup();
             waitForDim();
             AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
-            AddStep("EnableUserDim disabled", () => songSelect.DimEnabled.Value = false);
+            AddStep("Enable user dim", () => songSelect.DimEnabled.Value = false);
             waitForDim();
             AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && songSelect.IsUserBlurDisabled());
-            AddStep("EnableUserDim enabled", () => songSelect.DimEnabled.Value = true);
+            AddStep("Disable user dim", () => songSelect.DimEnabled.Value = true);
             waitForDim();
             AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
         }
 
+        /// <summary>
+        /// Ensure <see cref="UserDimContainer"/> is properly accepting user-defined visual changes for a storyboard.
+        /// </summary>
+        [Test]
+        public void DisableUserDimStoryboardTest()
+        {
+            performFullSetup();
+            createFakeStoryboard();
+            AddStep("Enable Storyboard", () =>
+            {
+                player.ReplacesBackground.Value = true;
+                player.StoryboardEnabled.Value = true;
+            });
+            AddStep("Enable user dim", () => player.DimmableStoryboard.EnableUserDim.Value = true);
+            AddStep("Set dim level to 1", () => songSelect.DimLevel.Value = 1f);
+            waitForDim();
+            AddAssert("Storyboard is invisible", () => !player.IsStoryboardVisible);
+            AddStep("Disable user dim", () => player.DimmableStoryboard.EnableUserDim.Value = false);
+            waitForDim();
+            AddAssert("Storyboard is visible", () => player.IsStoryboardVisible);
+        }
+
         /// <summary>
         /// Check if the visual settings container retains dim and blur when pausing
         /// </summary>

osu.Game.Tests/Visual/Online/TestSceneLeaderboardScopeSelector.cs

@@ -0,0 +1,36 @@
+// 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.Game.Overlays.BeatmapSet;
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Bindables;
+using osu.Game.Screens.Select.Leaderboards;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneLeaderboardScopeSelector : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(LeaderboardScopeSelector),
+        };
+
+        public TestSceneLeaderboardScopeSelector()
+        {
+            Bindable<BeatmapLeaderboardScope> scope = new Bindable<BeatmapLeaderboardScope>();
+
+            Add(new LeaderboardScopeSelector
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Current = { BindTarget = scope }
+            });
+
+            AddStep(@"Select global", () => scope.Value = BeatmapLeaderboardScope.Global);
+            AddStep(@"Select country", () => scope.Value = BeatmapLeaderboardScope.Country);
+            AddStep(@"Select friend", () => scope.Value = BeatmapLeaderboardScope.Friend);
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestSceneUserProfilePreviousUsernames.cs

@@ -0,0 +1,69 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Overlays.Profile.Header.Components;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    [TestFixture]
+    public class TestSceneUserProfilePreviousUsernames : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(PreviousUsernames)
+        };
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        private readonly Bindable<User> user = new Bindable<User>();
+
+        public TestSceneUserProfilePreviousUsernames()
+        {
+            Child = new PreviousUsernames
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                User = { BindTarget = user },
+            };
+
+            User[] users =
+            {
+                new User { PreviousUsernames = new[] { "username1" } },
+                new User { PreviousUsernames = new[] { "longusername", "longerusername" } },
+                new User { PreviousUsernames = new[] { "test", "angelsim", "verylongusername" } },
+                new User { PreviousUsernames = new[] { "ihavenoidea", "howcani", "makethistext", "anylonger" } },
+                new User { PreviousUsernames = new string[0] },
+                null
+            };
+
+            AddStep("single username", () => user.Value = users[0]);
+            AddStep("two usernames", () => user.Value = users[1]);
+            AddStep("three usernames", () => user.Value = users[2]);
+            AddStep("four usernames", () => user.Value = users[3]);
+            AddStep("no username", () => user.Value = users[4]);
+            AddStep("null user", () => user.Value = users[5]);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddStep("online user (Angelsim)", () =>
+            {
+                var request = new GetUserRequest(1777162);
+                request.Success += user => this.user.Value = user;
+                api.Queue(request);
+            });
+        }
+    }
+}

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

@@ -82,14 +82,13 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             var easierMods = instance.GetModsFor(ModType.DifficultyReduction);
             var harderMods = instance.GetModsFor(ModType.DifficultyIncrease);
-            var assistMods = instance.GetModsFor(ModType.Automation);
 
             var noFailMod = easierMods.FirstOrDefault(m => m is OsuModNoFail);
             var hiddenMod = harderMods.FirstOrDefault(m => m is OsuModHidden);
 
             var doubleTimeMod = harderMods.OfType<MultiMod>().FirstOrDefault(m => m.Mods.Any(a => a is OsuModDoubleTime));
 
-            var autoPilotMod = assistMods.FirstOrDefault(m => m is OsuModAutopilot);
+            var spunOutMod = easierMods.FirstOrDefault(m => m is OsuModSpunOut);
 
             var easy = easierMods.FirstOrDefault(m => m is OsuModEasy);
             var hardRock = harderMods.FirstOrDefault(m => m is OsuModHardRock);
@@ -101,7 +100,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             testMultiplierTextColour(noFailMod, modSelect.LowMultiplierColour);
             testMultiplierTextColour(hiddenMod, modSelect.HighMultiplierColour);
 
-            testUnimplementedMod(autoPilotMod);
+            testUnimplementedMod(spunOutMod);
         }
 
         [Test]

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

@@ -7,6 +7,7 @@ using osu.Framework.Configuration;
 using osu.Framework.Configuration.Tracking;
 using osu.Framework.Graphics;
 using osu.Game.Overlays;
+using osu.Game.Overlays.OSD;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
@@ -22,6 +23,12 @@ namespace osu.Game.Tests.Visual.UserInterface
             osd.BeginTracking(this, config);
             Add(osd);
 
+            AddStep("Display empty osd toast", () => osd.Display(new EmptyToast()));
+            AddAssert("Toast width is 240", () => osd.Child.Width == 240);
+
+            AddStep("Display toast with lengthy text", () => osd.Display(new LengthyToast()));
+            AddAssert("Toast width is greater than 240", () => osd.Child.Width > 240);
+
             AddRepeatStep("Change toggle (no bind)", () => config.ToggleSetting(TestConfigSetting.ToggleSettingNoKeybind), 2);
             AddRepeatStep("Change toggle (with bind)", () => config.ToggleSetting(TestConfigSetting.ToggleSettingWithKeybind), 2);
             AddRepeatStep("Change enum (no bind)", () => config.IncrementEnumSetting(TestConfigSetting.EnumSettingNoKeybind), 3);
@@ -86,6 +93,22 @@ namespace osu.Game.Tests.Visual.UserInterface
             Setting4
         }
 
+        private class EmptyToast : Toast
+        {
+            public EmptyToast()
+                : base("", "", "")
+            {
+            }
+        }
+
+        private class LengthyToast : Toast
+        {
+            public LengthyToast()
+                : base("Toast with a very very very long text", "A very very very very very very long text also", "A very very very very very long shortcut")
+            {
+            }
+        }
+
         private class TestOnScreenDisplay : OnScreenDisplay
         {
             protected override void DisplayTemporarily(Drawable toDisplay) => toDisplay.FadeIn().ResizeHeightTo(110);

osu.Game/Graphics/Containers/UserDimContainer.cs

@@ -6,7 +6,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Configuration;
-using osuTK.Graphics;
 
 namespace osu.Game.Graphics.Containers
 {
@@ -36,6 +35,8 @@ namespace osu.Game.Graphics.Containers
 
         protected Bindable<bool> ShowStoryboard { get; private set; }
 
+        protected double DimLevel => EnableUserDim.Value ? UserDimLevel.Value : 0;
+
         protected override Container<Drawable> Content => dimContent;
 
         private Container dimContent { get; }
@@ -78,8 +79,8 @@ namespace osu.Game.Graphics.Containers
         {
             ContentDisplayed = ShowDimContent;
 
-            dimContent.FadeTo((ContentDisplayed) ? 1 : 0, BACKGROUND_FADE_DURATION, Easing.OutQuint);
+            dimContent.FadeTo(ContentDisplayed ? 1 : 0, BACKGROUND_FADE_DURATION, Easing.OutQuint);
-            dimContent.FadeColour(EnableUserDim.Value ? OsuColour.Gray(1 - (float)UserDimLevel.Value) : Color4.White, BACKGROUND_FADE_DURATION, Easing.OutQuint);
+            dimContent.FadeColour(OsuColour.Gray(1 - (float)DimLevel), BACKGROUND_FADE_DURATION, Easing.OutQuint);
         }
     }
 }

osu.Game/Graphics/UserInterface/OsuTabControl.cs

@@ -31,6 +31,11 @@ namespace osu.Game.Graphics.UserInterface
         protected virtual float StripWidth() => TabContainer.Children.Sum(c => c.IsPresent ? c.DrawWidth + TabContainer.Spacing.X : 0) - TabContainer.Spacing.X;
         protected virtual float StripHeight() => 1;
 
+        /// <summary>
+        /// Whether entries should be automatically populated if <see cref="T"/> is an <see cref="Enum"/> type.
+        /// </summary>
+        protected virtual bool AddEnumEntriesAutomatically => true;
+
         private static bool isEnumType => typeof(T).IsEnum;
 
         public OsuTabControl()
@@ -45,7 +50,7 @@ namespace osu.Game.Graphics.UserInterface
                 Colour = Color4.White.Opacity(0),
             });
 
-            if (isEnumType)
+            if (isEnumType && AddEnumEntriesAutomatically)
                 foreach (var val in (T[])Enum.GetValues(typeof(T)))
                     AddItem(val);
         }

osu.Game/Graphics/UserInterface/PageTabControl.cs

@@ -24,7 +24,13 @@ namespace osu.Game.Graphics.UserInterface
             Height = 30;
         }
 
-        public class PageTabItem : TabItem<T>
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            AccentColour = colours.Yellow;
+        }
+
+        public class PageTabItem : TabItem<T>, IHasAccentColour
         {
             private const float transition_duration = 100;
 
@@ -32,6 +38,18 @@ namespace osu.Game.Graphics.UserInterface
 
             protected readonly SpriteText Text;
 
+            private Color4 accentColour;
+
+            public Color4 AccentColour
+            {
+                get => accentColour;
+                set
+                {
+                    accentColour = value;
+                    box.Colour = accentColour;
+                }
+            }
+
             public PageTabItem(T value)
                 : base(value)
             {
@@ -63,12 +81,6 @@ namespace osu.Game.Graphics.UserInterface
                 Active.BindValueChanged(active => Text.Font = Text.Font.With(Typeface.Exo, weight: active.NewValue ? FontWeight.Bold : FontWeight.Medium), true);
             }
 
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
-            {
-                box.Colour = colours.Yellow;
-            }
-
             protected override bool OnHover(HoverEvent e)
             {
                 if (!Active.Value)

osu.Game/Overlays/BeatmapSet/LeaderboardScopeSelector.cs

@@ -0,0 +1,119 @@
+// 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.Graphics.UserInterface;
+using osu.Game.Screens.Select.Leaderboards;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osuTK;
+using osu.Game.Graphics.UserInterface;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Framework.Allocation;
+using osuTK.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Input.Events;
+
+namespace osu.Game.Overlays.BeatmapSet
+{
+    public class LeaderboardScopeSelector : PageTabControl<BeatmapLeaderboardScope>
+    {
+        protected override bool AddEnumEntriesAutomatically => false;
+
+        protected override Dropdown<BeatmapLeaderboardScope> CreateDropdown() => null;
+
+        protected override TabItem<BeatmapLeaderboardScope> CreateTabItem(BeatmapLeaderboardScope value) => new ScopeSelectorTabItem(value);
+
+        public LeaderboardScopeSelector()
+        {
+            RelativeSizeAxes = Axes.X;
+
+            AddItem(BeatmapLeaderboardScope.Global);
+            AddItem(BeatmapLeaderboardScope.Country);
+            AddItem(BeatmapLeaderboardScope.Friend);
+
+            AddInternal(new GradientLine
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            AccentColour = colours.Blue;
+        }
+
+        protected override TabFillFlowContainer CreateTabFlow() => new TabFillFlowContainer
+        {
+            Anchor = Anchor.BottomCentre,
+            Origin = Anchor.BottomCentre,
+            AutoSizeAxes = Axes.X,
+            RelativeSizeAxes = Axes.Y,
+            Direction = FillDirection.Horizontal,
+            Spacing = new Vector2(20, 0),
+        };
+
+        private class ScopeSelectorTabItem : PageTabItem
+        {
+            public ScopeSelectorTabItem(BeatmapLeaderboardScope value)
+                : base(value)
+            {
+                Text.Font = OsuFont.GetFont(size: 16);
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                Text.FadeColour(AccentColour);
+
+                return base.OnHover(e);
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                base.OnHoverLost(e);
+
+                Text.FadeColour(Color4.White);
+            }
+        }
+
+        private class GradientLine : GridContainer
+        {
+            public GradientLine()
+            {
+                RelativeSizeAxes = Axes.X;
+                Size = new Vector2(0.8f, 1.5f);
+
+                ColumnDimensions = new[]
+                {
+                    new Dimension(),
+                    new Dimension(mode: GridSizeMode.Relative, size: 0.4f),
+                    new Dimension(),
+                };
+
+                Content = new[]
+                {
+                    new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = ColourInfo.GradientHorizontal(Color4.Transparent, Color4.Gray),
+                        },
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Gray,
+                        },
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = ColourInfo.GradientHorizontal(Color4.Gray, Color4.Transparent),
+                        },
+                    }
+                };
+            }
+        }
+    }
+}

osu.Game/Overlays/OSD/Toast.cs

@@ -0,0 +1,84 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Overlays.OSD
+{
+    public abstract class Toast : Container
+    {
+        private const int toast_minimum_width = 240;
+
+        private readonly Container content;
+        protected override Container<Drawable> Content => content;
+
+        protected readonly OsuSpriteText ValueText;
+
+        protected Toast(string description, string value, string shortcut)
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            // A toast's height is decided (and transformed) by the containing OnScreenDisplay.
+            RelativeSizeAxes = Axes.Y;
+            AutoSizeAxes = Axes.X;
+
+            InternalChildren = new Drawable[]
+            {
+                new Container //this container exists just to set a minimum width for the toast
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Width = toast_minimum_width
+                },
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Black,
+                    Alpha = 0.7f
+                },
+                content = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new OsuSpriteText
+                {
+                    Padding = new MarginPadding(10),
+                    Name = "Description",
+                    Font = OsuFont.GetFont(size: 14, weight: FontWeight.Black),
+                    Spacing = new Vector2(1, 0),
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    Text = description.ToUpperInvariant()
+                },
+                ValueText = new OsuSpriteText
+                {
+                    Font = OsuFont.GetFont(size: 24, weight: FontWeight.Light),
+                    Padding = new MarginPadding { Left = 10, Right = 10 },
+                    Name = "Value",
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Text = value
+                },
+                new OsuSpriteText
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    Name = "Shortcut",
+                    Alpha = 0.3f,
+                    Margin = new MarginPadding { Bottom = 15 },
+                    Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold),
+                    Text = string.IsNullOrEmpty(shortcut) ? "NO KEY BOUND" : shortcut.ToUpperInvariant()
+                },
+            };
+        }
+    }
+}

osu.Game/Overlays/OSD/TrackedSettingToast.cs

@@ -0,0 +1,147 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Configuration.Tracking;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Overlays.OSD
+{
+    public class TrackedSettingToast : Toast
+    {
+        private const int lights_bottom_margin = 40;
+
+        public TrackedSettingToast(SettingDescription description)
+            : base(description.Name, description.Value, description.Shortcut)
+        {
+            FillFlowContainer<OptionLight> optionLights;
+
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    Margin = new MarginPadding { Bottom = lights_bottom_margin },
+                    Children = new Drawable[]
+                    {
+                        optionLights = new FillFlowContainer<OptionLight>
+                        {
+                            Margin = new MarginPadding { Bottom = 5 },
+                            Spacing = new Vector2(5, 0),
+                            Direction = FillDirection.Horizontal,
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            AutoSizeAxes = Axes.Both
+                        },
+                    }
+                }
+            };
+
+            int optionCount = 0;
+            int selectedOption = -1;
+
+            switch (description.RawValue)
+            {
+                case bool val:
+                    optionCount = 1;
+                    if (val) selectedOption = 0;
+                    break;
+
+                case Enum _:
+                    var values = Enum.GetValues(description.RawValue.GetType());
+                    optionCount = values.Length;
+                    selectedOption = Convert.ToInt32(description.RawValue);
+                    break;
+            }
+
+            ValueText.Origin = optionCount > 0 ? Anchor.BottomCentre : Anchor.Centre;
+
+            for (int i = 0; i < optionCount; i++)
+                optionLights.Add(new OptionLight { Glowing = i == selectedOption });
+        }
+
+        private class OptionLight : Container
+        {
+            private Color4 glowingColour, idleColour;
+
+            private const float transition_speed = 300;
+
+            private const float glow_strength = 0.4f;
+
+            private readonly Box fill;
+
+            public OptionLight()
+            {
+                Children = new[]
+                {
+                    fill = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 1,
+                    },
+                };
+            }
+
+            private bool glowing;
+
+            public bool Glowing
+            {
+                set
+                {
+                    glowing = value;
+                    if (!IsLoaded) return;
+
+                    updateGlow();
+                }
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                fill.Colour = idleColour = Color4.White.Opacity(0.4f);
+                glowingColour = Color4.White;
+
+                Size = new Vector2(25, 5);
+
+                Masking = true;
+                CornerRadius = 3;
+
+                EdgeEffect = new EdgeEffectParameters
+                {
+                    Colour = colours.BlueDark.Opacity(glow_strength),
+                    Type = EdgeEffectType.Glow,
+                    Radius = 8,
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                updateGlow();
+                FinishTransforms(true);
+            }
+
+            private void updateGlow()
+            {
+                if (glowing)
+                {
+                    fill.FadeColour(glowingColour, transition_speed, Easing.OutQuint);
+                    FadeEdgeEffectTo(glow_strength, transition_speed, Easing.OutQuint);
+                }
+                else
+                {
+                    FadeEdgeEffectTo(0, transition_speed, Easing.OutQuint);
+                    fill.FadeColour(idleColour, transition_speed, Easing.OutQuint);
+                }
+            }
+        }
+    }
+}

osu.Game/Overlays/OnScreenDisplay.cs

@@ -8,34 +8,25 @@ using osu.Framework.Configuration;
 using osu.Framework.Configuration.Tracking;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Game.Graphics;
 using osuTK;
-using osuTK.Graphics;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Transforms;
 using osu.Framework.Threading;
 using osu.Game.Configuration;
-using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays.OSD;
 
 namespace osu.Game.Overlays
 {
+    /// <summary>
+    /// An on-screen display which automatically tracks and displays toast notifications for <seealso cref="TrackedSettings"/>.
+    /// Can also display custom content via <see cref="Display(Toast)"/>
+    /// </summary>
     public class OnScreenDisplay : Container
     {
         private readonly Container box;
 
-        private readonly SpriteText textLine1;
-        private readonly SpriteText textLine2;
-        private readonly SpriteText textLine3;
-
         private const float height = 110;
-        private const float height_notext = 98;
         private const float height_contracted = height * 0.9f;
 
-        private readonly FillFlowContainer<OptionLight> optionLights;
-
         public OnScreenDisplay()
         {
             RelativeSizeAxes = Axes.Both;
@@ -52,64 +43,6 @@ namespace osu.Game.Overlays
                     Height = height_contracted,
                     Alpha = 0,
                     CornerRadius = 20,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = Color4.Black,
-                            Alpha = 0.7f,
-                        },
-                        new Container // purely to add a minimum width
-                        {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                            Width = 240,
-                            RelativeSizeAxes = Axes.Y,
-                        },
-                        textLine1 = new OsuSpriteText
-                        {
-                            Padding = new MarginPadding(10),
-                            Font = OsuFont.GetFont(size: 14, weight: FontWeight.Black),
-                            Spacing = new Vector2(1, 0),
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopCentre,
-                        },
-                        textLine2 = new OsuSpriteText
-                        {
-                            Font = OsuFont.GetFont(size: 24, weight: FontWeight.Light),
-                            Padding = new MarginPadding { Left = 10, Right = 10 },
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.BottomCentre,
-                        },
-                        new FillFlowContainer
-                        {
-                            Anchor = Anchor.BottomCentre,
-                            Origin = Anchor.BottomCentre,
-                            AutoSizeAxes = Axes.Both,
-                            Direction = FillDirection.Vertical,
-                            Children = new Drawable[]
-                            {
-                                optionLights = new FillFlowContainer<OptionLight>
-                                {
-                                    Padding = new MarginPadding { Top = 20, Bottom = 5 },
-                                    Spacing = new Vector2(5, 0),
-                                    Direction = FillDirection.Horizontal,
-                                    Anchor = Anchor.TopCentre,
-                                    Origin = Anchor.TopCentre,
-                                    AutoSizeAxes = Axes.Both
-                                },
-                                textLine3 = new OsuSpriteText
-                                {
-                                    Anchor = Anchor.TopCentre,
-                                    Origin = Anchor.TopCentre,
-                                    Margin = new MarginPadding { Bottom = 15 },
-                                    Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold),
-                                    Alpha = 0.3f,
-                                },
-                            }
-                        }
-                    }
                 },
             };
         }
@@ -142,7 +75,7 @@ namespace osu.Game.Overlays
                 return;
 
             configManager.LoadInto(trackedSettings);
-            trackedSettings.SettingChanged += display;
+            trackedSettings.SettingChanged += displayTrackedSettingChange;
 
             trackedConfigManagers.Add((source, configManager), trackedSettings);
         }
@@ -162,55 +95,22 @@ namespace osu.Game.Overlays
                 return;
 
             existing.Unload();
-            existing.SettingChanged -= display;
+            existing.SettingChanged -= displayTrackedSettingChange;
 
             trackedConfigManagers.Remove((source, configManager));
         }
 
-        private void display(SettingDescription description)
+        /// <summary>
+        /// Displays the provided <see cref="Toast"/> temporarily.
+        /// </summary>
+        /// <param name="toast"></param>
+        public void Display(Toast toast)
         {
-            Schedule(() =>
+            box.Child = toast;
-            {
-                textLine1.Text = description.Name.ToUpperInvariant();
-                textLine2.Text = description.Value;
-                textLine3.Text = description.Shortcut.ToUpperInvariant();
-
-                if (string.IsNullOrEmpty(textLine3.Text))
-                    textLine3.Text = "NO KEY BOUND";
-
             DisplayTemporarily(box);
-
-                int optionCount = 0;
-                int selectedOption = -1;
-
-                switch (description.RawValue)
-                {
-                    case bool val:
-                        optionCount = 1;
-                        if (val) selectedOption = 0;
-                        break;
-
-                    case Enum _:
-                        var values = Enum.GetValues(description.RawValue.GetType());
-                        optionCount = values.Length;
-                        selectedOption = Convert.ToInt32(description.RawValue);
-                        break;
         }
 
-                textLine2.Origin = optionCount > 0 ? Anchor.BottomCentre : Anchor.Centre;
+        private void displayTrackedSettingChange(SettingDescription description) => Schedule(() => Display(new TrackedSettingToast(description)));
-                textLine2.Y = optionCount > 0 ? 0 : 5;
-
-                if (optionLights.Children.Count != optionCount)
-                {
-                    optionLights.Clear();
-                    for (int i = 0; i < optionCount; i++)
-                        optionLights.Add(new OptionLight());
-                }
-
-                for (int i = 0; i < optionCount; i++)
-                    optionLights.Children[i].Glowing = i == selectedOption;
-            });
-        }
 
         private TransformSequence<Drawable> fadeIn;
         private ScheduledDelegate fadeOut;
@@ -236,80 +136,5 @@ namespace osu.Game.Overlays
                     b => b.ResizeHeightTo(height_contracted, 1500, Easing.InQuint));
             }, 500);
         }
-
-        private class OptionLight : Container
-        {
-            private Color4 glowingColour, idleColour;
-
-            private const float transition_speed = 300;
-
-            private const float glow_strength = 0.4f;
-
-            private readonly Box fill;
-
-            public OptionLight()
-            {
-                Children = new[]
-                {
-                    fill = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Alpha = 1,
-                    },
-                };
-            }
-
-            private bool glowing;
-
-            public bool Glowing
-            {
-                set
-                {
-                    glowing = value;
-                    if (!IsLoaded) return;
-
-                    updateGlow();
-                }
-            }
-
-            private void updateGlow()
-            {
-                if (glowing)
-                {
-                    fill.FadeColour(glowingColour, transition_speed, Easing.OutQuint);
-                    FadeEdgeEffectTo(glow_strength, transition_speed, Easing.OutQuint);
-                }
-                else
-                {
-                    FadeEdgeEffectTo(0, transition_speed, Easing.OutQuint);
-                    fill.FadeColour(idleColour, transition_speed, Easing.OutQuint);
-                }
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
-            {
-                fill.Colour = idleColour = Color4.White.Opacity(0.4f);
-                glowingColour = Color4.White;
-
-                Size = new Vector2(25, 5);
-
-                Masking = true;
-                CornerRadius = 3;
-
-                EdgeEffect = new EdgeEffectParameters
-                {
-                    Colour = colours.BlueDark.Opacity(glow_strength),
-                    Type = EdgeEffectType.Glow,
-                    Radius = 8,
-                };
-            }
-
-            protected override void LoadComplete()
-            {
-                updateGlow();
-                FinishTransforms(true);
-            }
-        }
     }
 }

osu.Game/Overlays/Profile/Header/Components/PreviousUsernames.cs

@@ -0,0 +1,168 @@
+// 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.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Overlays.Profile.Header.Components
+{
+    public class PreviousUsernames : CompositeDrawable
+    {
+        private const int duration = 200;
+        private const int margin = 10;
+        private const int width = 310;
+        private const int move_offset = 15;
+
+        public readonly Bindable<User> User = new Bindable<User>();
+
+        private readonly TextFlowContainer text;
+        private readonly Box background;
+        private readonly SpriteText header;
+
+        public PreviousUsernames()
+        {
+            HoverIconContainer hoverIcon;
+
+            AutoSizeAxes = Axes.Y;
+            Width = width;
+            Masking = true;
+            CornerRadius = 5;
+
+            AddRangeInternal(new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new GridContainer
+                {
+                    AutoSizeAxes = Axes.Y,
+                    RelativeSizeAxes = Axes.X,
+                    RowDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.AutoSize),
+                        new Dimension(GridSizeMode.AutoSize)
+                    },
+                    ColumnDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.AutoSize),
+                        new Dimension(GridSizeMode.Distributed)
+                    },
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            hoverIcon = new HoverIconContainer(),
+                            header = new SpriteText
+                            {
+                                Anchor = Anchor.BottomLeft,
+                                Origin = Anchor.BottomLeft,
+                                Text = @"formerly known as",
+                                Font = OsuFont.GetFont(size: 10, italics: true)
+                            }
+                        },
+                        new Drawable[]
+                        {
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            text = new TextFlowContainer(s => s.Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold, italics: true))
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
+                                Direction = FillDirection.Full,
+                                Margin = new MarginPadding { Bottom = margin, Top = margin / 2f }
+                            }
+                        }
+                    }
+                }
+            });
+
+            hoverIcon.ActivateHover += showContent;
+            hideContent();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            background.Colour = colours.GreySeafoamDarker;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            User.BindValueChanged(onUserChanged, true);
+        }
+
+        private void onUserChanged(ValueChangedEvent<User> user)
+        {
+            text.Text = string.Empty;
+
+            var usernames = user.NewValue?.PreviousUsernames;
+
+            if (usernames?.Any() ?? false)
+            {
+                text.Text = string.Join(", ", usernames);
+                Show();
+                return;
+            }
+
+            Hide();
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            hideContent();
+        }
+
+        private void showContent()
+        {
+            text.FadeIn(duration, Easing.OutQuint);
+            header.FadeIn(duration, Easing.OutQuint);
+            background.FadeIn(duration, Easing.OutQuint);
+            this.MoveToY(-move_offset, duration, Easing.OutQuint);
+        }
+
+        private void hideContent()
+        {
+            text.FadeOut(duration, Easing.OutQuint);
+            header.FadeOut(duration, Easing.OutQuint);
+            background.FadeOut(duration, Easing.OutQuint);
+            this.MoveToY(0, duration, Easing.OutQuint);
+        }
+
+        private class HoverIconContainer : Container
+        {
+            public Action ActivateHover;
+
+            public HoverIconContainer()
+            {
+                AutoSizeAxes = Axes.Both;
+                Child = new SpriteIcon
+                {
+                    Margin = new MarginPadding { Top = 6, Left = margin, Right = margin * 2 },
+                    Size = new Vector2(15),
+                    Icon = FontAwesome.Solid.IdCard,
+                };
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                ActivateHover?.Invoke();
+                return base.OnHover(e);
+            }
+        }
+    }
+}

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -398,7 +398,7 @@ namespace osu.Game.Rulesets.Scoring
             if (rollingMaxBaseScore != 0)
                 Accuracy.Value = baseScore / rollingMaxBaseScore;
 
-            TotalScore.Value = getScore(Mode.Value) * scoreMultiplier;
+            TotalScore.Value = getScore(Mode.Value);
         }
 
         private double getScore(ScoringMode mode)
@@ -407,11 +407,11 @@ namespace osu.Game.Rulesets.Scoring
             {
                 default:
                 case ScoringMode.Standardised:
-                    return max_score * (base_portion * baseScore / maxBaseScore + combo_portion * HighestCombo.Value / maxHighestCombo) + bonusScore;
+                    return (max_score * (base_portion * baseScore / maxBaseScore + combo_portion * HighestCombo.Value / maxHighestCombo) + bonusScore) * scoreMultiplier;
 
                 case ScoringMode.Classic:
                     // should emulate osu-stable's scoring as closely as we can (https://osu.ppy.sh/help/wiki/Score/ScoreV1)
-                    return bonusScore + baseScore * (1 + Math.Max(0, HighestCombo.Value - 1) / 25);
+                    return bonusScore + baseScore * ((1 + Math.Max(0, HighestCombo.Value - 1) * scoreMultiplier) / 25);
             }
         }
 

osu.Game/Screens/Play/DimmableStoryboard.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Screens.Play
             base.LoadComplete();
         }
 
-        protected override bool ShowDimContent => ShowStoryboard.Value && UserDimLevel.Value < 1;
+        protected override bool ShowDimContent => ShowStoryboard.Value && DimLevel < 1;
 
         private void initializeStoryboard(bool async)
         {

osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboardScope.cs

@@ -1,13 +1,22 @@
 // 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.ComponentModel;
+
 namespace osu.Game.Screens.Select.Leaderboards
 {
     public enum BeatmapLeaderboardScope
     {
+        [Description("Local Ranking")]
         Local,
+
+        [Description("Country Ranking")]
         Country,
+
+        [Description("Global Ranking")]
         Global,
+
+        [Description("Friend Ranking")]
         Friend,
     }
 }

osu.Game/Users/User.cs

@@ -20,6 +20,9 @@ namespace osu.Game.Users
         [JsonProperty(@"username")]
         public string Username;
 
+        [JsonProperty(@"previous_usernames")]
+        public string[] PreviousUsernames;
+
         [JsonProperty(@"country")]
         public Country Country;