Merge branch 'master' into beatmap-mod-selector

osu.Game/Beatmaps/Beatmap.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Beatmaps
     /// <summary>
     /// A Beatmap containing converted HitObjects.
     /// </summary>
-    public class Beatmap<T> : IBeatmap
+    public class Beatmap<T> : IBeatmap<T>
         where T : HitObject
     {
         public BeatmapInfo BeatmapInfo { get; set; } = new BeatmapInfo
@@ -36,17 +36,13 @@ namespace osu.Game.Beatmaps
 
         public List<BreakPeriod> Breaks { get; set; } = new List<BreakPeriod>();
 
-        /// <summary>
-        /// Total amount of break time in the beatmap.
-        /// </summary>
         [JsonIgnore]
         public double TotalBreakTime => Breaks.Sum(b => b.Duration);
 
-        /// <summary>
-        /// The HitObjects this Beatmap contains.
-        /// </summary>
         [JsonConverter(typeof(TypedListConverter<HitObject>))]
-        public List<T> HitObjects = new List<T>();
+        public List<T> HitObjects { get; set; } = new List<T>();
+
+        IReadOnlyList<T> IBeatmap<T>.HitObjects => HitObjects;
 
         IReadOnlyList<HitObject> IBeatmap.HitObjects => HitObjects;
 

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -129,6 +129,23 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public List<ScoreInfo> Scores { get; set; }
 
+        [JsonIgnore]
+        public DifficultyRating DifficultyRating
+        {
+            get
+            {
+                var rating = StarDifficulty;
+
+                if (rating < 2.0) return DifficultyRating.Easy;
+                if (rating < 2.7) return DifficultyRating.Normal;
+                if (rating < 4.0) return DifficultyRating.Hard;
+                if (rating < 5.3) return DifficultyRating.Insane;
+                if (rating < 6.5) return DifficultyRating.Expert;
+
+                return DifficultyRating.ExpertPlus;
+            }
+        }
+
         public override string ToString() => $"{Metadata} [{Version}]".Trim();
 
         public bool Equals(BeatmapInfo other)

osu.Game/Beatmaps/BeatmapManager_WorkingBeatmap.cs

@@ -136,21 +136,17 @@ namespace osu.Game.Beatmaps
                 return storyboard;
             }
 
-            protected override Skin GetSkin()
+            protected override ISkin GetSkin()
             {
-                Skin skin;
-
                 try
                 {
-                    skin = new LegacyBeatmapSkin(BeatmapInfo, store, AudioManager);
+                    return new LegacyBeatmapSkin(BeatmapInfo, store, AudioManager);
                 }
                 catch (Exception e)
                 {
                     Logger.Error(e, "Skin failed to load");
-                    skin = new DefaultSkin();
+                    return null;
                 }
-
-                return skin;
             }
         }
     }

osu.Game/Beatmaps/BeatmapSetOnlineInfo.cs

@@ -75,6 +75,28 @@ namespace osu.Game.Beatmaps
         /// The availability of this beatmap set.
         /// </summary>
         public BeatmapSetOnlineAvailability Availability { get; set; }
+
+        /// <summary>
+        /// The song genre of this beatmap set.
+        /// </summary>
+        public BeatmapSetOnlineGenre Genre { get; set; }
+
+        /// <summary>
+        /// The song language of this beatmap set.
+        /// </summary>
+        public BeatmapSetOnlineLanguage Language { get; set; }
+    }
+
+    public class BeatmapSetOnlineGenre
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+    }
+
+    public class BeatmapSetOnlineLanguage
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
     }
 
     public class BeatmapSetOnlineCovers

osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs

@@ -14,6 +14,8 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         public TimeSignatures TimeSignature = TimeSignatures.SimpleQuadruple;
 
+        public const double DEFAULT_BEAT_LENGTH = 1000;
+
         /// <summary>
         /// The beat length at this control point.
         /// </summary>
@@ -23,7 +25,7 @@ namespace osu.Game.Beatmaps.ControlPoints
             set => beatLength = MathHelper.Clamp(value, 6, 60000);
         }
 
-        private double beatLength = 1000;
+        private double beatLength = DEFAULT_BEAT_LENGTH;
 
         public bool Equals(TimingControlPoint other)
             => base.Equals(other)

osu.Game/Beatmaps/DifficultyRating.cs

@@ -0,0 +1,15 @@
+// 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.
+
+namespace osu.Game.Beatmaps
+{
+    public enum DifficultyRating
+    {
+        Easy,
+        Normal,
+        Hard,
+        Insane,
+        Expert,
+        ExpertPlus
+    }
+}

osu.Game/Beatmaps/Drawables/DifficultyColouredContainer.cs

@@ -1,85 +0,0 @@
-// 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.Graphics.Containers;
-using osu.Game.Graphics;
-using osuTK.Graphics;
-
-namespace osu.Game.Beatmaps.Drawables
-{
-    public abstract class DifficultyColouredContainer : Container, IHasAccentColour
-    {
-        public Color4 AccentColour { get; set; }
-
-        private readonly BeatmapInfo beatmap;
-        private OsuColour palette;
-
-        protected DifficultyColouredContainer(BeatmapInfo beatmap)
-        {
-            this.beatmap = beatmap;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour palette)
-        {
-            if (palette == null)
-                throw new ArgumentNullException(nameof(palette));
-
-            this.palette = palette;
-            AccentColour = getColour(beatmap);
-        }
-
-        private enum DifficultyRating
-        {
-            Easy,
-            Normal,
-            Hard,
-            Insane,
-            Expert,
-            ExpertPlus
-        }
-
-        private DifficultyRating getDifficultyRating(BeatmapInfo beatmap)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-
-            var rating = beatmap.StarDifficulty;
-
-            if (rating < 2.0) return DifficultyRating.Easy;
-            if (rating < 2.7) return DifficultyRating.Normal;
-            if (rating < 4.0) return DifficultyRating.Hard;
-            if (rating < 5.3) return DifficultyRating.Insane;
-            if (rating < 6.5) return DifficultyRating.Expert;
-
-            return DifficultyRating.ExpertPlus;
-        }
-
-        private Color4 getColour(BeatmapInfo beatmap)
-        {
-            switch (getDifficultyRating(beatmap))
-            {
-                case DifficultyRating.Easy:
-                    return palette.Green;
-
-                default:
-                case DifficultyRating.Normal:
-                    return palette.Blue;
-
-                case DifficultyRating.Hard:
-                    return palette.Yellow;
-
-                case DifficultyRating.Insane:
-                    return palette.Pink;
-
-                case DifficultyRating.Expert:
-                    return palette.Purple;
-
-                case DifficultyRating.ExpertPlus:
-                    return palette.Gray0;
-            }
-        }
-    }
-}

osu.Game/Beatmaps/Drawables/DifficultyIcon.cs

@@ -1,4 +1,4 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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;
@@ -6,35 +6,58 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.Drawables
 {
-    public class DifficultyIcon : DifficultyColouredContainer
+    public class DifficultyIcon : CompositeDrawable, IHasCustomTooltip
     {
+        private readonly BeatmapInfo beatmap;
         private readonly RulesetInfo ruleset;
 
-        public DifficultyIcon(BeatmapInfo beatmap, RulesetInfo ruleset = null)
-            : base(beatmap)
+        private readonly Container iconContainer;
+
+        /// <summary>
+        /// Size of this difficulty icon.
+        /// </summary>
+        public new Vector2 Size
         {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-
-            this.ruleset = ruleset ?? beatmap.Ruleset;
-
-            Size = new Vector2(20);
+            get => iconContainer.Size;
+            set => iconContainer.Size = value;
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
+        public DifficultyIcon(BeatmapInfo beatmap, RulesetInfo ruleset = null, bool shouldShowTooltip = true)
         {
-            Children = new Drawable[]
+            this.beatmap = beatmap ?? throw new ArgumentNullException(nameof(beatmap));
+
+            this.ruleset = ruleset ?? beatmap.Ruleset;
+            if (shouldShowTooltip)
+                TooltipContent = beatmap;
+
+            AutoSizeAxes = Axes.Both;
+
+            InternalChild = iconContainer = new Container { Size = new Vector2(20f) };
+        }
+
+        public string TooltipText { get; set; }
+
+        public ITooltip GetCustomTooltip() => new DifficultyIconTooltip();
+
+        public object TooltipContent { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            iconContainer.Children = new Drawable[]
             {
                 new CircularContainer
                 {
@@ -52,7 +75,7 @@ namespace osu.Game.Beatmaps.Drawables
                     Child = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Colour = AccentColour,
+                        Colour = colours.ForDifficultyRating(beatmap.DifficultyRating),
                     },
                 },
                 new ConstrainedIconContainer
@@ -65,5 +88,96 @@ namespace osu.Game.Beatmaps.Drawables
                 }
             };
         }
+
+        private class DifficultyIconTooltip : VisibilityContainer, ITooltip
+        {
+            private readonly OsuSpriteText difficultyName, starRating;
+            private readonly Box background;
+
+            private readonly FillFlowContainer difficultyFlow;
+
+            public DifficultyIconTooltip()
+            {
+                AutoSizeAxes = Axes.Both;
+                Masking = true;
+                CornerRadius = 5;
+
+                Children = new Drawable[]
+                {
+                    background = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both
+                    },
+                    new FillFlowContainer
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        AutoSizeDuration = 200,
+                        AutoSizeEasing = Easing.OutQuint,
+                        Direction = FillDirection.Vertical,
+                        Padding = new MarginPadding(10),
+                        Children = new Drawable[]
+                        {
+                            difficultyName = new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Font = OsuFont.GetFont(size: 16, weight: FontWeight.Bold),
+                            },
+                            difficultyFlow = new FillFlowContainer
+                            {
+                                AutoSizeAxes = Axes.Both,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Direction = FillDirection.Horizontal,
+                                Children = new Drawable[]
+                                {
+                                    starRating = new OsuSpriteText
+                                    {
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        Font = OsuFont.GetFont(size: 16, weight: FontWeight.Regular),
+                                    },
+                                    new SpriteIcon
+                                    {
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        Margin = new MarginPadding { Left = 4 },
+                                        Icon = FontAwesome.Solid.Star,
+                                        Size = new Vector2(12),
+                                    },
+                                }
+                            }
+                        }
+                    }
+                };
+            }
+
+            private OsuColour colours;
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                this.colours = colours;
+                background.Colour = colours.Gray3;
+            }
+
+            public bool SetContent(object content)
+            {
+                if (!(content is BeatmapInfo beatmap))
+                    return false;
+
+                difficultyName.Text = beatmap.Version;
+                starRating.Text = $"{beatmap.StarDifficulty:0.##}";
+                difficultyFlow.Colour = colours.ForDifficultyRating(beatmap.DifficultyRating);
+
+                return true;
+            }
+
+            public void Move(Vector2 pos) => Position = pos;
+
+            protected override void PopIn() => this.FadeIn(200, Easing.OutQuint);
+
+            protected override void PopOut() => this.FadeOut(200, Easing.OutQuint);
+        }
     }
 }

osu.Game/Beatmaps/Drawables/GroupedDifficultyIcon.cs

@@ -0,0 +1,37 @@
+// 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.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets;
+using osuTK.Graphics;
+
+namespace osu.Game.Beatmaps.Drawables
+{
+    /// <summary>
+    /// A difficulty icon that contains a counter on the right-side of it.
+    /// </summary>
+    /// <remarks>
+    /// Used in cases when there are too many difficulty icons to show.
+    /// </remarks>
+    public class GroupedDifficultyIcon : DifficultyIcon
+    {
+        public GroupedDifficultyIcon(List<BeatmapInfo> beatmaps, RulesetInfo ruleset, Color4 counterColour)
+            : base(beatmaps.OrderBy(b => b.StarDifficulty).Last(), ruleset, false)
+        {
+            AddInternal(new OsuSpriteText
+            {
+                Anchor = Anchor.CentreRight,
+                Origin = Anchor.CentreRight,
+                Padding = new MarginPadding { Left = Size.X },
+                Margin = new MarginPadding { Left = 2, Right = 5 },
+                Font = OsuFont.GetFont(size: 14, weight: FontWeight.SemiBold),
+                Text = beatmaps.Count.ToString(),
+                Colour = counterColour,
+            });
+        }
+    }
+}

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -54,7 +54,7 @@ namespace osu.Game.Beatmaps
             {
                 public override IEnumerable<Mod> GetModsFor(ModType type) => new Mod[] { };
 
-                public override DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
+                public override DrawableRuleset CreateDrawableRulesetWith(IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
                 {
                     throw new NotImplementedException();
                 }

osu.Game/Beatmaps/Formats/LegacyDifficultyCalculatorBeatmapDecoder.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Beatmaps.Formats
 
         private class LegacyDifficultyCalculatorControlPoint : TimingControlPoint
         {
-            public override double BeatLength { get; set; } = 1000;
+            public override double BeatLength { get; set; } = DEFAULT_BEAT_LENGTH;
         }
     }
 }

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -121,7 +121,7 @@ namespace osu.Game.Beatmaps.Formats
                         var layer = parseLayer(split[2]);
                         var path = cleanFilename(split[3]);
                         var volume = split.Length > 4 ? float.Parse(split[4], CultureInfo.InvariantCulture) : 100;
-                        storyboard.GetLayer(layer).Add(new StoryboardSample(path, time, volume));
+                        storyboard.GetLayer(layer).Add(new StoryboardSampleInfo(path, time, (int)volume));
                         break;
                     }
                 }
@@ -246,7 +246,7 @@ namespace osu.Game.Beatmaps.Formats
                                 switch (type)
                                 {
                                     case "A":
-                                        timelineGroup?.BlendingMode.Add(easing, startTime, endTime, BlendingMode.Additive, startTime == endTime ? BlendingMode.Additive : BlendingMode.Inherit);
+                                        timelineGroup?.BlendingParameters.Add(easing, startTime, endTime, BlendingParameters.Additive, startTime == endTime ? BlendingParameters.Additive : BlendingParameters.Inherit);
                                         break;
 
                                     case "H":

osu.Game/Beatmaps/IBeatmap.cs

@@ -53,4 +53,13 @@ namespace osu.Game.Beatmaps
         /// <returns>The shallow-cloned beatmap.</returns>
         IBeatmap Clone();
     }
+
+    public interface IBeatmap<out T> : IBeatmap
+        where T : HitObject
+    {
+        /// <summary>
+        /// The hitobjects contained by this beatmap.
+        /// </summary>
+        new IReadOnlyList<T> HitObjects { get; }
+    }
 }

osu.Game/Beatmaps/IWorkingBeatmap.cs

@@ -0,0 +1,61 @@
+// 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.Collections.Generic;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.UI;
+using osu.Game.Skinning;
+using osu.Game.Storyboards;
+
+namespace osu.Game.Beatmaps
+{
+    public interface IWorkingBeatmap
+    {
+        /// <summary>
+        /// Retrieves the <see cref="IBeatmap"/> which this <see cref="WorkingBeatmap"/> represents.
+        /// </summary>
+        IBeatmap Beatmap { get; }
+
+        /// <summary>
+        /// Retrieves the background for this <see cref="WorkingBeatmap"/>.
+        /// </summary>
+        Texture Background { get; }
+
+        /// <summary>
+        /// Retrieves the audio track for this <see cref="WorkingBeatmap"/>.
+        /// </summary>
+        Track Track { get; }
+
+        /// <summary>
+        /// Retrieves the <see cref="Waveform"/> for the <see cref="Track"/> of this <see cref="WorkingBeatmap"/>.
+        /// </summary>
+        Waveform Waveform { get; }
+
+        /// <summary>
+        /// Retrieves the <see cref="Storyboard"/> which this <see cref="WorkingBeatmap"/> provides.
+        /// </summary>
+        Storyboard Storyboard { get; }
+
+        /// <summary>
+        /// Retrieves the <see cref="Skin"/> which this <see cref="WorkingBeatmap"/> provides.
+        /// </summary>
+        ISkin Skin { get; }
+
+        /// <summary>
+        /// Constructs a playable <see cref="IBeatmap"/> from <see cref="Beatmap"/> using the applicable converters for a specific <see cref="RulesetInfo"/>.
+        /// <para>
+        /// The returned <see cref="IBeatmap"/> is in a playable state - all <see cref="HitObject"/> and <see cref="BeatmapDifficulty"/> <see cref="Mod"/>s
+        /// have been applied, and <see cref="HitObject"/>s have been fully constructed.
+        /// </para>
+        /// </summary>
+        /// <param name="ruleset">The <see cref="RulesetInfo"/> to create a playable <see cref="IBeatmap"/> for.</param>
+        /// <param name="mods">The <see cref="Mod"/>s to apply to the <see cref="IBeatmap"/>.</param>
+        /// <returns>The converted <see cref="IBeatmap"/>.</returns>
+        /// <exception cref="BeatmapInvalidForRulesetException">If <see cref="Beatmap"/> could not be converted to <paramref name="ruleset"/>.</exception>
+        IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods);
+    }
+}

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -16,14 +16,13 @@ using osu.Framework.Audio;
 using osu.Framework.Statistics;
 using osu.Game.IO.Serialization;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.UI;
 using osu.Game.Skinning;
 
 namespace osu.Game.Beatmaps
 {
-    public abstract class WorkingBeatmap : IDisposable
+    public abstract class WorkingBeatmap : IWorkingBeatmap, IDisposable
     {
         public readonly BeatmapInfo BeatmapInfo;
 
@@ -46,7 +45,7 @@ namespace osu.Game.Beatmaps
             background = new RecyclableLazy<Texture>(GetBackground, BackgroundStillValid);
             waveform = new RecyclableLazy<Waveform>(GetWaveform);
             storyboard = new RecyclableLazy<Storyboard>(GetStoryboard);
-            skin = new RecyclableLazy<Skin>(GetSkin);
+            skin = new RecyclableLazy<ISkin>(GetSkin);
 
             total_count.Value++;
         }
@@ -97,17 +96,6 @@ namespace osu.Game.Beatmaps
         /// <returns>The applicable <see cref="IBeatmapConverter"/>.</returns>
         protected virtual IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap, Ruleset ruleset) => ruleset.CreateBeatmapConverter(beatmap);
 
-        /// <summary>
-        /// Constructs a playable <see cref="IBeatmap"/> from <see cref="Beatmap"/> using the applicable converters for a specific <see cref="RulesetInfo"/>.
-        /// <para>
-        /// The returned <see cref="IBeatmap"/> is in a playable state - all <see cref="HitObject"/> and <see cref="BeatmapDifficulty"/> <see cref="Mod"/>s
-        /// have been applied, and <see cref="HitObject"/>s have been fully constructed.
-        /// </para>
-        /// </summary>
-        /// <param name="ruleset">The <see cref="RulesetInfo"/> to create a playable <see cref="IBeatmap"/> for.</param>
-        /// <param name="mods">The <see cref="Mod"/>s to apply to the <see cref="IBeatmap"/>.</param>
-        /// <returns>The converted <see cref="IBeatmap"/>.</returns>
-        /// <exception cref="BeatmapInvalidForRulesetException">If <see cref="Beatmap"/> could not be converted to <paramref name="ruleset"/>.</exception>
         public IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods)
         {
             var rulesetInstance = ruleset.CreateInstance();
@@ -214,10 +202,10 @@ namespace osu.Game.Beatmaps
         private readonly RecyclableLazy<Storyboard> storyboard;
 
         public bool SkinLoaded => skin.IsResultAvailable;
-        public Skin Skin => skin.Value;
+        public ISkin Skin => skin.Value;
 
-        protected virtual Skin GetSkin() => new DefaultSkin();
-        private readonly RecyclableLazy<Skin> skin;
+        protected virtual ISkin GetSkin() => new DefaultSkin();
+        private readonly RecyclableLazy<ISkin> skin;
 
         /// <summary>
         /// Transfer pieces of a beatmap to a new one, where possible, to save on loading.

osu.Game/Configuration/IntroSequence.cs

@@ -0,0 +1,11 @@
+// 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.
+
+namespace osu.Game.Configuration
+{
+    public enum IntroSequence
+    {
+        Circles,
+        Triangles
+    }
+}

osu.Game/Configuration/OsuConfigManager.cs

@@ -8,6 +8,7 @@ using osu.Framework.Platform;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
 
 namespace osu.Game.Configuration
 {
@@ -17,7 +18,7 @@ namespace osu.Game.Configuration
         {
             // UI/selection defaults
             Set(OsuSetting.Ruleset, 0, 0, int.MaxValue);
-            Set(OsuSetting.Skin, 0, 0, int.MaxValue);
+            Set(OsuSetting.Skin, 0, -1, int.MaxValue);
 
             Set(OsuSetting.BeatmapDetailTab, BeatmapDetailTab.Details);
 
@@ -25,6 +26,9 @@ namespace osu.Game.Configuration
             Set(OsuSetting.DisplayStarsMinimum, 0.0, 0, 10, 0.1);
             Set(OsuSetting.DisplayStarsMaximum, 10.0, 0, 10, 0.1);
 
+            Set(OsuSetting.SongSelectGroupingMode, GroupMode.All);
+            Set(OsuSetting.SongSelectSortingMode, SortMode.Title);
+
             Set(OsuSetting.RandomSelectAlgorithm, RandomSelectAlgorithm.RandomPermutation);
 
             Set(OsuSetting.ChatDisplayHeight, ChatOverlay.DEFAULT_HEIGHT, 0.2, 1);
@@ -79,6 +83,7 @@ namespace osu.Game.Configuration
             Set(OsuSetting.ShowInterface, true);
             Set(OsuSetting.ShowHealthDisplayWhenCantFail, true);
             Set(OsuSetting.KeyOverlay, false);
+            Set(OsuSetting.ScoreMeter, ScoreMeterType.HitErrorBoth);
 
             Set(OsuSetting.FloatingComments, false);
 
@@ -105,6 +110,8 @@ namespace osu.Game.Configuration
             Set(OsuSetting.ScalingPositionY, 0.5f, 0f, 1f);
 
             Set(OsuSetting.UIScale, 1f, 0.8f, 1.6f, 0.01f);
+
+            Set(OsuSetting.IntroSequence, IntroSequence.Triangles);
         }
 
         public OsuConfigManager(Storage storage)
@@ -130,6 +137,7 @@ namespace osu.Game.Configuration
         BlurLevel,
         ShowStoryboard,
         KeyOverlay,
+        ScoreMeter,
         FloatingComments,
         ShowInterface,
         ShowHealthDisplayWhenCantFail,
@@ -148,6 +156,8 @@ namespace osu.Game.Configuration
         SaveUsername,
         DisplayStarsMinimum,
         DisplayStarsMaximum,
+        SongSelectGroupingMode,
+        SongSelectSortingMode,
         RandomSelectAlgorithm,
         ShowFpsDisplay,
         ChatDisplayHeight,
@@ -167,6 +177,7 @@ namespace osu.Game.Configuration
         ScalingPositionY,
         ScalingSizeX,
         ScalingSizeY,
-        UIScale
+        UIScale,
+        IntroSequence
     }
 }

osu.Game/Configuration/ScoreMeterType.cs

@@ -1,12 +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.Configuration
 {
     public enum ScoreMeterType
     {
+        [Description("None")]
         None,
-        Colour,
-        Error
+
+        [Description("Hit Error (left)")]
+        HitErrorLeft,
+
+        [Description("Hit Error (right)")]
+        HitErrorRight,
+
+        [Description("Hit Error (both)")]
+        HitErrorBoth,
     }
 }

osu.Game/Graphics/Containers/HoldToConfirmContainer.cs

@@ -12,9 +12,11 @@ namespace osu.Game.Graphics.Containers
     {
         public Action Action;
 
-        private const int activate_delay = 400;
+        private const int default_activation_delay = 200;
         private const int fadeout_delay = 200;
 
+        private readonly double activationDelay;
+
         private bool fired;
         private bool confirming;
 
@@ -25,13 +27,22 @@ namespace osu.Game.Graphics.Containers
 
         public Bindable<double> Progress = new BindableDouble();
 
+        /// <summary>
+        /// Create a new instance.
+        /// </summary>
+        /// <param name="activationDelay">The time requried before an action is confirmed.</param>
+        protected HoldToConfirmContainer(double activationDelay = default_activation_delay)
+        {
+            this.activationDelay = activationDelay;
+        }
+
         protected void BeginConfirm()
         {
             if (confirming || (!AllowMultipleFires && fired)) return;
 
             confirming = true;
 
-            this.TransformBindableTo(Progress, 1, activate_delay * (1 - Progress.Value), Easing.Out).OnComplete(_ => Confirm());
+            this.TransformBindableTo(Progress, 1, activationDelay * (1 - Progress.Value), Easing.Out).OnComplete(_ => Confirm());
         }
 
         protected virtual void Confirm()

osu.Game/Graphics/Containers/OsuFocusedOverlayContainer.cs

@@ -15,6 +15,7 @@ using osu.Game.Overlays;
 
 namespace osu.Game.Graphics.Containers
 {
+    [Cached(typeof(IPreviewTrackOwner))]
     public abstract class OsuFocusedOverlayContainer : FocusedOverlayContainer, IPreviewTrackOwner, IKeyBindingHandler<GlobalAction>
     {
         private SampleChannel samplePopIn;
@@ -38,13 +39,6 @@ namespace osu.Game.Graphics.Containers
 
         protected readonly Bindable<OverlayActivation> OverlayActivationMode = new Bindable<OverlayActivation>(OverlayActivation.All);
 
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-        {
-            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-            dependencies.CacheAs<IPreviewTrackOwner>(this);
-            return dependencies;
-        }
-
         [BackgroundDependencyLoader(true)]
         private void load(AudioManager audio)
         {
@@ -68,15 +62,23 @@ namespace osu.Game.Graphics.Containers
 
         protected override bool OnClick(ClickEvent e)
         {
-            if (!base.ReceivePositionalInputAt(e.ScreenSpaceMousePosition))
-            {
-                Hide();
-                return true;
-            }
+            closeIfOutside(e);
 
             return base.OnClick(e);
         }
 
+        protected override bool OnDragEnd(DragEndEvent e)
+        {
+            closeIfOutside(e);
+            return base.OnDragEnd(e);
+        }
+
+        private void closeIfOutside(MouseEvent e)
+        {
+            if (!base.ReceivePositionalInputAt(e.ScreenSpaceMousePosition))
+                Hide();
+        }
+
         public virtual bool OnPressed(GlobalAction action)
         {
             switch (action)

osu.Game/Graphics/Containers/OsuScrollContainer.cs

@@ -98,7 +98,7 @@ namespace osu.Game.Graphics.Containers
             public OsuScrollbar(Direction scrollDir)
                 : base(scrollDir)
             {
-                Blending = BlendingMode.Additive;
+                Blending = BlendingParameters.Additive;
 
                 CornerRadius = 5;
 

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -150,7 +150,7 @@ namespace osu.Game.Graphics.Cursor
                             },
                             AdditiveLayer = new Sprite
                             {
-                                Blending = BlendingMode.Additive,
+                                Blending = BlendingParameters.Additive,
                                 Colour = colour.Pink,
                                 Alpha = 0,
                                 Texture = textures.Get(@"Cursor/menu-cursor-additive"),

osu.Game/Graphics/Cursor/OsuTooltipContainer.cs

@@ -30,22 +30,24 @@ namespace osu.Game.Graphics.Cursor
             private readonly OsuSpriteText text;
             private bool instantMovement = true;
 
-            public override string TooltipText
+            public override bool SetContent(object content)
             {
-                set
+                if (!(content is string contentString))
+                    return false;
+
+                if (contentString == text.Text) return true;
+
+                text.Text = contentString;
+
+                if (IsPresent)
                 {
-                    if (value == text.Text) return;
-
-                    text.Text = value;
-
-                    if (IsPresent)
-                    {
-                        AutoSizeDuration = 250;
-                        background.FlashColour(OsuColour.Gray(0.4f), 1000, Easing.OutQuint);
-                    }
-                    else
-                        AutoSizeDuration = 0;
+                    AutoSizeDuration = 250;
+                    background.FlashColour(OsuColour.Gray(0.4f), 1000, Easing.OutQuint);
                 }
+                else
+                    AutoSizeDuration = 0;
+
+                return true;
             }
 
             public OsuTooltip()

osu.Game/Graphics/DrawableDate.cs

@@ -2,11 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using Humanizer;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Utils;
 
 namespace osu.Game.Graphics
 {
@@ -71,7 +71,7 @@ namespace osu.Game.Graphics
             Scheduler.AddDelayed(updateTimeWithReschedule, timeUntilNextUpdate);
         }
 
-        protected virtual string Format() => Date.Humanize();
+        protected virtual string Format() => HumanizerUtils.Humanize(Date);
 
         private void updateTime() => Text = Format();
 

osu.Game/Graphics/OsuColour.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Game.Beatmaps;
 using osuTK.Graphics;
 
 namespace osu.Game.Graphics
@@ -37,6 +38,31 @@ namespace osu.Game.Graphics
             }
         }
 
+        public Color4 ForDifficultyRating(DifficultyRating difficulty)
+        {
+            switch (difficulty)
+            {
+                case DifficultyRating.Easy:
+                    return Green;
+
+                default:
+                case DifficultyRating.Normal:
+                    return Blue;
+
+                case DifficultyRating.Hard:
+                    return Yellow;
+
+                case DifficultyRating.Insane:
+                    return Pink;
+
+                case DifficultyRating.Expert:
+                    return Purple;
+
+                case DifficultyRating.ExpertPlus:
+                    return Gray0;
+            }
+        }
+
         // See https://github.com/ppy/osu-web/blob/master/resources/assets/less/colors.less
         public readonly Color4 PurpleLighter = FromHex(@"eeeeff");
         public readonly Color4 PurpleLight = FromHex(@"aa88ff");

osu.Game/Graphics/ScreenshotManager.cs

@@ -22,7 +22,7 @@ using SixLabors.ImageSharp;
 
 namespace osu.Game.Graphics
 {
-    public class ScreenshotManager : Container, IKeyBindingHandler<GlobalAction>, IHandleGlobalInput
+    public class ScreenshotManager : Container, IKeyBindingHandler<GlobalAction>, IHandleGlobalKeyboardInput
     {
         private readonly BindableBool cursorVisibility = new BindableBool(true);
 

osu.Game/Graphics/Sprites/GlowingSpriteText.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Graphics.Sprites
                     BlurSigma = new Vector2(4),
                     CacheDrawnFrameBuffer = true,
                     RelativeSizeAxes = Axes.Both,
-                    Blending = BlendingMode.Additive,
+                    Blending = BlendingParameters.Additive,
                     Size = new Vector2(3f),
                     Children = new[]
                     {

osu.Game/Graphics/UserInterface/DialogButton.cs

@@ -254,7 +254,7 @@ namespace osu.Game.Graphics.UserInterface
             colourContainer.Add(flash);
 
             flash.Colour = ButtonColour;
-            flash.Blending = BlendingMode.Additive;
+            flash.Blending = BlendingParameters.Additive;
             flash.Alpha = 0.3f;
             flash.FadeOutFromOne(click_duration);
             flash.Expire();

osu.Game/Graphics/UserInterface/OsuAnimatedButton.cs

@@ -64,7 +64,7 @@ namespace osu.Game.Graphics.UserInterface
                     {
                         RelativeSizeAxes = Axes.Both,
                         Colour = HoverColour,
-                        Blending = BlendingMode.Additive,
+                        Blending = BlendingParameters.Additive,
                         Alpha = 0,
                     },
                 }

osu.Game/Graphics/UserInterface/OsuButton.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Graphics.UserInterface
                 hover = new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Blending = BlendingMode.Additive,
+                    Blending = BlendingParameters.Additive,
                     Colour = Color4.White.Opacity(0.1f),
                     Alpha = 0,
                     Depth = -1

osu.Game/Graphics/UserInterface/OsuCheckbox.cs

@@ -72,17 +72,11 @@ namespace osu.Game.Graphics.UserInterface
             Current.DisabledChanged += disabled => labelText.Alpha = Nub.Alpha = disabled ? 0.3f : 1;
         }
 
-        protected override void LoadComplete()
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
         {
-            base.LoadComplete();
-
-            Current.ValueChanged += enabled =>
-            {
-                if (enabled.NewValue)
-                    sampleChecked?.Play();
-                else
-                    sampleUnchecked?.Play();
-            };
+            sampleChecked = audio.Samples.Get(@"UI/check-on");
+            sampleUnchecked = audio.Samples.Get(@"UI/check-off");
         }
 
         protected override bool OnHover(HoverEvent e)
@@ -99,11 +93,13 @@ namespace osu.Game.Graphics.UserInterface
             base.OnHoverLost(e);
         }
 
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        protected override void OnUserChange(bool value)
         {
-            sampleChecked = audio.Samples.Get(@"UI/check-on");
-            sampleUnchecked = audio.Samples.Get(@"UI/check-off");
+            base.OnUserChange(value);
+            if (value)
+                sampleChecked?.Play();
+            else
+                sampleUnchecked?.Play();
         }
     }
 }

osu.Game/Input/Bindings/GlobalActionContainer.cs

@@ -10,7 +10,7 @@ using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Input.Bindings
 {
-    public class GlobalActionContainer : DatabasedKeyBindingContainer<GlobalAction>, IHandleGlobalInput
+    public class GlobalActionContainer : DatabasedKeyBindingContainer<GlobalAction>, IHandleGlobalKeyboardInput
     {
         private readonly Drawable handler;
 
@@ -20,7 +20,7 @@ namespace osu.Game.Input.Bindings
                 handler = game;
         }
 
-        public override IEnumerable<KeyBinding> DefaultKeyBindings => GlobalKeyBindings.Concat(InGameKeyBindings);
+        public override IEnumerable<KeyBinding> DefaultKeyBindings => GlobalKeyBindings.Concat(InGameKeyBindings).Concat(AudioControlKeyBindings);
 
         public IEnumerable<KeyBinding> GlobalKeyBindings => new[]
         {
@@ -32,11 +32,6 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(new[] { InputKey.Control, InputKey.Alt, InputKey.R }, GlobalAction.ResetInputSettings),
             new KeyBinding(new[] { InputKey.Control, InputKey.T }, GlobalAction.ToggleToolbar),
             new KeyBinding(new[] { InputKey.Control, InputKey.O }, GlobalAction.ToggleSettings),
-            new KeyBinding(InputKey.Up, GlobalAction.IncreaseVolume),
-            new KeyBinding(InputKey.MouseWheelUp, GlobalAction.IncreaseVolume),
-            new KeyBinding(InputKey.Down, GlobalAction.DecreaseVolume),
-            new KeyBinding(InputKey.MouseWheelDown, GlobalAction.DecreaseVolume),
-            new KeyBinding(InputKey.F4, GlobalAction.ToggleMute),
 
             new KeyBinding(InputKey.Escape, GlobalAction.Back),
             new KeyBinding(InputKey.ExtraMouseButton1, GlobalAction.Back),
@@ -55,6 +50,22 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(new[] { InputKey.Control, InputKey.Minus }, GlobalAction.DecreaseScrollSpeed),
         };
 
+        public IEnumerable<KeyBinding> AudioControlKeyBindings => new[]
+        {
+            new KeyBinding(InputKey.Up, GlobalAction.IncreaseVolume),
+            new KeyBinding(InputKey.MouseWheelUp, GlobalAction.IncreaseVolume),
+            new KeyBinding(InputKey.Down, GlobalAction.DecreaseVolume),
+            new KeyBinding(InputKey.MouseWheelDown, GlobalAction.DecreaseVolume),
+            new KeyBinding(InputKey.F4, GlobalAction.ToggleMute),
+
+            new KeyBinding(InputKey.TrackPrevious, GlobalAction.MusicPrev),
+            new KeyBinding(InputKey.F1, GlobalAction.MusicPrev),
+            new KeyBinding(InputKey.TrackNext, GlobalAction.MusicNext),
+            new KeyBinding(InputKey.F5, GlobalAction.MusicNext),
+            new KeyBinding(InputKey.PlayPause, GlobalAction.MusicPlay),
+            new KeyBinding(InputKey.F3, GlobalAction.MusicPlay)
+        };
+
         protected override IEnumerable<Drawable> KeyBindingInputQueue =>
             handler == null ? base.KeyBindingInputQueue : base.KeyBindingInputQueue.Prepend(handler);
     }
@@ -115,5 +126,15 @@ namespace osu.Game.Input.Bindings
 
         [Description("Quick exit (Hold)")]
         QuickExit,
+
+        // Game-wide beatmap msi ccotolle keybindings
+        [Description("Next track")]
+        MusicNext,
+
+        [Description("Previous track")]
+        MusicPrev,
+
+        [Description("Play / pause")]
+        MusicPlay,
     }
 }

osu.Game/Input/IdleTracker.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Input
     /// <summary>
     /// Track whether the end-user is in an idle state, based on their last interaction with the game.
     /// </summary>
-    public class IdleTracker : Component, IKeyBindingHandler<PlatformAction>, IHandleGlobalInput
+    public class IdleTracker : Component, IKeyBindingHandler<PlatformAction>, IHandleGlobalKeyboardInput
     {
         private readonly double timeToIdle;
 

osu.Game/Online/API/Requests/GetUserKudosuHistoryRequest.cs

@@ -0,0 +1,21 @@
+// 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.Collections.Generic;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetUserKudosuHistoryRequest : PaginatedAPIRequest<List<APIKudosuHistory>>
+    {
+        private readonly long userId;
+
+        public GetUserKudosuHistoryRequest(long userId, int page = 0, int itemsPerPage = 5)
+            : base(page, itemsPerPage)
+        {
+            this.userId = userId;
+        }
+
+        protected override string Target => $"users/{userId}/kudosu";
+    }
+}

osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs

@@ -69,6 +69,12 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"availability")]
         private BeatmapSetOnlineAvailability availability { get; set; }
 
+        [JsonProperty(@"genre")]
+        private BeatmapSetOnlineGenre genre { get; set; }
+
+        [JsonProperty(@"language")]
+        private BeatmapSetOnlineLanguage language { get; set; }
+
         [JsonProperty(@"beatmaps")]
         private IEnumerable<APIBeatmap> beatmaps { get; set; }
 
@@ -95,6 +101,8 @@ namespace osu.Game.Online.API.Requests.Responses
                     LastUpdated = lastUpdated,
                     Availability = availability,
                     HasFavourited = hasFavourited,
+                    Genre = genre,
+                    Language = language
                 },
                 Beatmaps = beatmaps?.Select(b => b.ToBeatmap(rulesets)).ToList(),
             };

osu.Game/Online/API/Requests/Responses/APIKudosuHistory.cs

@@ -0,0 +1,83 @@
+// 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 Newtonsoft.Json;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIKudosuHistory
+    {
+        [JsonProperty("created_at")]
+        public DateTimeOffset CreatedAt;
+
+        [JsonProperty("amount")]
+        public int Amount;
+
+        [JsonProperty("post")]
+        public ModdingPost Post;
+
+        public class ModdingPost
+        {
+            [JsonProperty("url")]
+            public string Url;
+
+            [JsonProperty("title")]
+            public string Title;
+        }
+
+        [JsonProperty("giver")]
+        public KudosuGiver Giver;
+
+        public class KudosuGiver
+        {
+            [JsonProperty("url")]
+            public string Url;
+
+            [JsonProperty("username")]
+            public string Username;
+        }
+
+        public KudosuSource Source;
+
+        public KudosuAction Action;
+
+        [JsonProperty("action")]
+        private string action
+        {
+            set
+            {
+                // incoming action may contain a prefix. if it doesn't, it's a legacy forum event.
+
+                string[] split = value.Split('.');
+
+                if (split.Length > 1)
+                    Enum.TryParse(split.First().Replace("_", ""), true, out Source);
+                else
+                    Source = KudosuSource.Forum;
+
+                Enum.TryParse(split.Last(), true, out Action);
+            }
+        }
+    }
+
+    public enum KudosuSource
+    {
+        Unknown,
+        AllowKudosu,
+        Delete,
+        DenyKudosu,
+        Forum,
+        Recalculate,
+        Restore,
+        Vote
+    }
+
+    public enum KudosuAction
+    {
+        Give,
+        Reset,
+        Revoke,
+    }
+}

osu.Game/Online/Chat/MessageFormatter.cs

@@ -122,6 +122,7 @@ namespace osu.Game.Online.Chat
                                 return new LinkDetails(LinkAction.OpenBeatmapSet, args[3]);
 
                             case "u":
+                            case "users":
                                 return new LinkDetails(LinkAction.OpenUserProfile, args[3]);
                         }
                     }

osu.Game/OsuGame.cs

@@ -182,7 +182,26 @@ namespace osu.Game
             // bind config int to database SkinInfo
             configSkin = LocalConfig.GetBindable<int>(OsuSetting.Skin);
             SkinManager.CurrentSkinInfo.ValueChanged += skin => configSkin.Value = skin.NewValue.ID;
-            configSkin.ValueChanged += skinId => SkinManager.CurrentSkinInfo.Value = SkinManager.Query(s => s.ID == skinId.NewValue) ?? SkinInfo.Default;
+            configSkin.ValueChanged += skinId =>
+            {
+                var skinInfo = SkinManager.Query(s => s.ID == skinId.NewValue);
+
+                if (skinInfo == null)
+                {
+                    switch (skinId.NewValue)
+                    {
+                        case -1:
+                            skinInfo = DefaultLegacySkin.Info;
+                            break;
+
+                        default:
+                            skinInfo = SkinInfo.Default;
+                            break;
+                    }
+                }
+
+                SkinManager.CurrentSkinInfo.Value = skinInfo;
+            };
             configSkin.TriggerChange();
 
             IsActive.BindValueChanged(active => updateActiveState(active.NewValue), true);
@@ -299,7 +318,7 @@ namespace osu.Game
             }, $"watch {databasedScoreInfo}", bypassScreenAllowChecks: true);
         }
 
-        #region Beatmap jukebox progression
+        #region Beatmap progression
 
         private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> beatmap)
         {
@@ -469,6 +488,8 @@ namespace osu.Game
             loadComponentSingleFile(volume = new VolumeOverlay(), leftFloatingOverlayContent.Add);
             loadComponentSingleFile(new OnScreenDisplay(), Add, true);
 
+            loadComponentSingleFile(musicController = new MusicController(), Add, true);
+
             loadComponentSingleFile(notifications = new NotificationOverlay
             {
                 GetToolbarHeight = () => ToolbarOffset,
@@ -495,7 +516,7 @@ namespace osu.Game
                 Origin = Anchor.TopRight,
             }, rightFloatingOverlayContent.Add, true);
 
-            loadComponentSingleFile(musicController = new MusicController
+            loadComponentSingleFile(new NowPlayingOverlay
             {
                 GetToolbarHeight = () => ToolbarOffset,
                 Anchor = Anchor.TopRight,

osu.Game/OsuGameBase.cs

@@ -158,7 +158,7 @@ namespace osu.Game
 
             runMigrations();
 
-            dependencies.Cache(SkinManager = new SkinManager(Host.Storage, contextFactory, Host, Audio));
+            dependencies.Cache(SkinManager = new SkinManager(Host.Storage, contextFactory, Host, Audio, new NamespacedResourceStore<byte[]>(Resources, "Skins/Legacy")));
             dependencies.CacheAs<ISkinSource>(SkinManager);
 
             API = new APIAccess(LocalConfig);

osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs

@@ -91,7 +91,8 @@ namespace osu.Game.Overlays.BeatmapSet
                     {
                         difficulties = new DifficultiesContainer
                         {
-                            AutoSizeAxes = Axes.Both,
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
                             Margin = new MarginPadding { Left = -(tile_icon_padding + tile_spacing / 2) },
                             OnLostHover = () =>
                             {
@@ -234,7 +235,7 @@ namespace osu.Game.Overlays.BeatmapSet
                             Colour = Color4.Black.Opacity(0.5f),
                         },
                     },
-                    icon = new DifficultyIcon(beatmap)
+                    icon = new DifficultyIcon(beatmap, shouldShowTooltip: false)
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,

osu.Game/Overlays/BeatmapSet/Info.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Overlays.BeatmapSet
 
         public Info()
         {
-            MetadataSection source, tags;
+            MetadataSection source, tags, genre, language;
             RelativeSizeAxes = Axes.X;
             Height = 220;
             Masking = true;
@@ -83,11 +83,12 @@ namespace osu.Game.Overlays.BeatmapSet
                             {
                                 RelativeSizeAxes = Axes.X,
                                 AutoSizeAxes = Axes.Y,
-                                Direction = FillDirection.Vertical,
-                                LayoutDuration = transition_duration,
+                                Direction = FillDirection.Full,
                                 Children = new[]
                                 {
                                     source = new MetadataSection("Source"),
+                                    genre = new MetadataSection("Genre") { Width = 0.5f },
+                                    language = new MetadataSection("Language") { Width = 0.5f },
                                     tags = new MetadataSection("Tags"),
                                 },
                             },
@@ -119,6 +120,8 @@ namespace osu.Game.Overlays.BeatmapSet
             {
                 source.Text = b.NewValue?.Metadata.Source ?? string.Empty;
                 tags.Text = b.NewValue?.Metadata.Tags ?? string.Empty;
+                genre.Text = b.NewValue?.OnlineInfo?.Genre?.Name ?? string.Empty;
+                language.Text = b.NewValue?.OnlineInfo?.Language?.Name ?? string.Empty;
             };
         }
 
@@ -139,7 +142,7 @@ namespace osu.Game.Overlays.BeatmapSet
                 {
                     if (string.IsNullOrEmpty(value))
                     {
-                        this.FadeOut(transition_duration);
+                        Hide();
                         return;
                     }
 
@@ -149,12 +152,6 @@ namespace osu.Game.Overlays.BeatmapSet
                 }
             }
 
-            public Color4 TextColour
-            {
-                get => textFlow.Colour;
-                set => textFlow.Colour = value;
-            }
-
             public MetadataSection(string title)
             {
                 RelativeSizeAxes = Axes.X;

osu.Game/Overlays/BeatmapSet/Scores/TopScoreUserSection.cs

@@ -1,7 +1,6 @@
 // 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 Humanizer;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -14,6 +13,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Scoring;
 using osu.Game.Users.Drawables;
+using osu.Game.Utils;
 using osuTK;
 using osuTK.Graphics;
 
@@ -132,7 +132,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
             {
                 avatar.User = value.User;
                 flag.Country = value.User.Country;
-                date.Text = $@"achieved {value.Date.Humanize()}";
+                date.Text = $@"achieved {HumanizerUtils.Humanize(value.Date)}";
 
                 usernameText.Clear();
                 usernameText.AddUserLink(value.User);

osu.Game/Overlays/Chat/DrawableChannel.cs

@@ -30,27 +30,24 @@ namespace osu.Game.Overlays.Chat
         [BackgroundDependencyLoader]
         private void load()
         {
-            Children = new Drawable[]
+            Child = new OsuContextMenuContainer
             {
-                scroll = new OsuScrollContainer
+                RelativeSizeAxes = Axes.Both,
+                Masking = true,
+                Child = scroll = new OsuScrollContainer
                 {
                     RelativeSizeAxes = Axes.Both,
                     // Some chat lines have effects that slightly protrude to the bottom,
                     // which we do not want to mask away, hence the padding.
                     Padding = new MarginPadding { Bottom = 5 },
-                    Child = new OsuContextMenuContainer
+                    Child = ChatLineFlow = new ChatLineContainer
                     {
+                        Padding = new MarginPadding { Left = 20, Right = 20 },
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
-                        Child = ChatLineFlow = new ChatLineContainer
-                        {
-                            Padding = new MarginPadding { Left = 20, Right = 20 },
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            Direction = FillDirection.Vertical,
-                        }
-                    },
-                }
+                        Direction = FillDirection.Vertical,
+                    }
+                },
             };
 
             newMessagesArrived(Channel.Messages);

osu.Game/Overlays/Chat/Selection/ChannelListItem.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Overlays.Chat.Selection
         private Color4 topicColour;
         private Color4 hoverColour;
 
-        public IEnumerable<string> FilterTerms => new[] { channel.Name };
+        public IEnumerable<string> FilterTerms => new[] { channel.Name, channel.Topic };
 
         public bool MatchingFilter
         {

osu.Game/Overlays/Direct/DirectGridPanel.cs

@@ -151,7 +151,7 @@ namespace osu.Game.Overlays.Direct
                                             AutoSizeAxes = Axes.X,
                                             Height = 20,
                                             Margin = new MarginPadding { Top = vertical_padding, Bottom = vertical_padding },
-                                            Children = GetDifficultyIcons(),
+                                            Children = GetDifficultyIcons(colours),
                                         },
                                     },
                                 },

osu.Game/Overlays/Direct/DirectListPanel.cs

@@ -129,7 +129,7 @@ namespace osu.Game.Overlays.Direct
                                                     AutoSizeAxes = Axes.X,
                                                     Height = 20,
                                                     Margin = new MarginPadding { Top = vertical_padding, Bottom = vertical_padding },
-                                                    Children = GetDifficultyIcons(),
+                                                    Children = GetDifficultyIcons(colours),
                                                 },
                                             },
                                         },

osu.Game/Overlays/Direct/DirectPanel.cs

@@ -28,13 +28,14 @@ namespace osu.Game.Overlays.Direct
         public readonly BeatmapSetInfo SetInfo;
 
         private const double hover_transition_time = 400;
+        private const int maximum_difficulty_icons = 15;
 
         private Container content;
 
         private BeatmapSetOverlay beatmapSetOverlay;
 
         public PreviewTrack Preview => PlayButton.Preview;
-        public Bindable<bool> PreviewPlaying => PlayButton.Playing;
+        public Bindable<bool> PreviewPlaying => PlayButton?.Playing;
 
         protected abstract PlayButton PlayButton { get; }
         protected abstract Box PreviewBar { get; }
@@ -138,12 +139,18 @@ namespace osu.Game.Overlays.Direct
             };
         }
 
-        protected List<DifficultyIcon> GetDifficultyIcons()
+        protected List<DifficultyIcon> GetDifficultyIcons(OsuColour colours)
         {
             var icons = new List<DifficultyIcon>();
 
-            foreach (var b in SetInfo.Beatmaps.OrderBy(beatmap => beatmap.StarDifficulty))
-                icons.Add(new DifficultyIcon(b));
+            if (SetInfo.Beatmaps.Count > maximum_difficulty_icons)
+            {
+                foreach (var ruleset in SetInfo.Beatmaps.Select(b => b.Ruleset).Distinct())
+                    icons.Add(new GroupedDifficultyIcon(SetInfo.Beatmaps.FindAll(b => b.Ruleset.Equals(ruleset)), ruleset, this is DirectListPanel ? Color4.White : colours.Gray5));
+            }
+            else
+                foreach (var b in SetInfo.Beatmaps.OrderBy(beatmap => beatmap.StarDifficulty))
+                    icons.Add(new DifficultyIcon(b));
 
             return icons;
         }

osu.Game/Overlays/KeyBinding/GlobalKeyBindingsSection.cs

@@ -15,6 +15,7 @@ namespace osu.Game.Overlays.KeyBinding
         public GlobalKeyBindingsSection(GlobalActionContainer manager)
         {
             Add(new DefaultBindingsSubsection(manager));
+            Add(new AudioControlKeyBindingsSubsection(manager));
             Add(new InGameKeyBindingsSubsection(manager));
         }
 
@@ -39,5 +40,16 @@ namespace osu.Game.Overlays.KeyBinding
                 Defaults = manager.InGameKeyBindings;
             }
         }
+
+        private class AudioControlKeyBindingsSubsection : KeyBindingsSubsection
+        {
+            protected override string Header => "Audio";
+
+            public AudioControlKeyBindingsSubsection(GlobalActionContainer manager)
+                : base(null)
+            {
+                Defaults = manager.AudioControlKeyBindings;
+            }
+        }
     }
 }

osu.Game/Overlays/MusicController.cs

@@ -1,292 +1,121 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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 System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-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.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.Events;
-using osu.Framework.Localisation;
+using osu.Framework.Input.Bindings;
 using osu.Framework.Threading;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Overlays.Music;
+using osu.Game.Input.Bindings;
+using osu.Game.Overlays.OSD;
 using osu.Game.Rulesets.Mods;
-using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Overlays
 {
-    public class MusicController : OsuFocusedOverlayContainer
+    /// <summary>
+    /// Handles playback of the global music track.
+    /// </summary>
+    public class MusicController : Component, IKeyBindingHandler<GlobalAction>
     {
-        private const float player_height = 130;
-        private const float transition_length = 800;
-        private const float progress_height = 10;
-        private const float bottom_black_area_height = 55;
-
-        private Drawable background;
-        private ProgressBar progressBar;
-
-        private IconButton prevButton;
-        private IconButton playButton;
-        private IconButton nextButton;
-        private IconButton playlistButton;
-
-        private SpriteText title, artist;
-
-        private PlaylistOverlay playlist;
-
-        private BeatmapManager beatmaps;
+        [Resolved]
+        private BeatmapManager beatmaps { get; set; }
 
         private List<BeatmapSetInfo> beatmapSets;
 
-        private Container dragContainer;
-        private Container playerContainer;
-
         public bool IsUserPaused { get; private set; }
 
+        /// <summary>
+        /// Fired when the global <see cref="WorkingBeatmap"/> has changed.
+        /// Includes direction information for display purposes.
+        /// </summary>
+        public event Action<WorkingBeatmap, TrackChangeDirection> TrackChanged;
+
         [Resolved]
-        private Bindable<WorkingBeatmap> beatmap { get; set; }
+        private IBindable<WorkingBeatmap> beatmap { get; set; }
 
         [Resolved]
         private IBindable<IReadOnlyList<Mod>> mods { get; set; }
 
-        /// <summary>
-        /// Provide a source for the toolbar height.
-        /// </summary>
-        public Func<float> GetToolbarHeight;
-
-        public MusicController()
-        {
-            Width = 400;
-            Margin = new MarginPadding(10);
-        }
+        [Resolved(canBeNull: true)]
+        private OnScreenDisplay onScreenDisplay { get; set; }
 
         [BackgroundDependencyLoader]
-        private void load(Bindable<WorkingBeatmap> beatmap, BeatmapManager beatmaps, OsuColour colours)
+        private void load()
         {
-            this.beatmaps = beatmaps;
-
-            Children = new Drawable[]
-            {
-                dragContainer = new DragContainer
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
-                    Children = new Drawable[]
-                    {
-                        playlist = new PlaylistOverlay
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            Y = player_height + 10,
-                            OrderChanged = playlistOrderChanged
-                        },
-                        playerContainer = new Container
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            Height = player_height,
-                            Masking = true,
-                            CornerRadius = 5,
-                            EdgeEffect = new EdgeEffectParameters
-                            {
-                                Type = EdgeEffectType.Shadow,
-                                Colour = Color4.Black.Opacity(40),
-                                Radius = 5,
-                            },
-                            Children = new[]
-                            {
-                                background = new Background(),
-                                title = new OsuSpriteText
-                                {
-                                    Origin = Anchor.BottomCentre,
-                                    Anchor = Anchor.TopCentre,
-                                    Position = new Vector2(0, 40),
-                                    Font = OsuFont.GetFont(size: 25, italics: true),
-                                    Colour = Color4.White,
-                                    Text = @"Nothing to play",
-                                },
-                                artist = new OsuSpriteText
-                                {
-                                    Origin = Anchor.TopCentre,
-                                    Anchor = Anchor.TopCentre,
-                                    Position = new Vector2(0, 45),
-                                    Font = OsuFont.GetFont(size: 15, weight: FontWeight.Bold, italics: true),
-                                    Colour = Color4.White,
-                                    Text = @"Nothing to play",
-                                },
-                                new Container
-                                {
-                                    Padding = new MarginPadding { Bottom = progress_height },
-                                    Height = bottom_black_area_height,
-                                    RelativeSizeAxes = Axes.X,
-                                    Origin = Anchor.BottomCentre,
-                                    Anchor = Anchor.BottomCentre,
-                                    Children = new Drawable[]
-                                    {
-                                        new FillFlowContainer<IconButton>
-                                        {
-                                            AutoSizeAxes = Axes.Both,
-                                            Direction = FillDirection.Horizontal,
-                                            Spacing = new Vector2(5),
-                                            Origin = Anchor.Centre,
-                                            Anchor = Anchor.Centre,
-                                            Children = new[]
-                                            {
-                                                prevButton = new MusicIconButton
-                                                {
-                                                    Anchor = Anchor.Centre,
-                                                    Origin = Anchor.Centre,
-                                                    Action = prev,
-                                                    Icon = FontAwesome.Solid.StepBackward,
-                                                },
-                                                playButton = new MusicIconButton
-                                                {
-                                                    Anchor = Anchor.Centre,
-                                                    Origin = Anchor.Centre,
-                                                    Scale = new Vector2(1.4f),
-                                                    IconScale = new Vector2(1.4f),
-                                                    Action = togglePause,
-                                                    Icon = FontAwesome.Regular.PlayCircle,
-                                                },
-                                                nextButton = new MusicIconButton
-                                                {
-                                                    Anchor = Anchor.Centre,
-                                                    Origin = Anchor.Centre,
-                                                    Action = () => next(),
-                                                    Icon = FontAwesome.Solid.StepForward,
-                                                },
-                                            }
-                                        },
-                                        playlistButton = new MusicIconButton
-                                        {
-                                            Origin = Anchor.Centre,
-                                            Anchor = Anchor.CentreRight,
-                                            Position = new Vector2(-bottom_black_area_height / 2, 0),
-                                            Icon = FontAwesome.Solid.Bars,
-                                            Action = () => playlist.ToggleVisibility(),
-                                        },
-                                    }
-                                },
-                                progressBar = new ProgressBar
-                                {
-                                    Origin = Anchor.BottomCentre,
-                                    Anchor = Anchor.BottomCentre,
-                                    Height = progress_height,
-                                    FillColour = colours.Yellow,
-                                    OnSeek = attemptSeek
-                                }
-                            },
-                        },
-                    }
-                }
-            };
-
             beatmapSets = beatmaps.GetAllUsableBeatmapSets();
             beatmaps.ItemAdded += handleBeatmapAdded;
             beatmaps.ItemRemoved += handleBeatmapRemoved;
-
-            playlist.State.ValueChanged += s => playlistButton.FadeColour(s.NewValue == Visibility.Visible ? colours.Yellow : Color4.White, 200, Easing.OutQuint);
         }
 
-        private ScheduledDelegate seekDelegate;
-
-        private void attemptSeek(double progress)
+        protected override void LoadComplete()
         {
-            seekDelegate?.Cancel();
-            seekDelegate = Schedule(() =>
-            {
-                if (!beatmap.Disabled)
-                    current?.Track.Seek(progress);
-            });
+            beatmap.BindValueChanged(beatmapChanged, true);
+            mods.BindValueChanged(_ => updateAudioAdjustments(), true);
+            base.LoadComplete();
         }
 
-        private void playlistOrderChanged(BeatmapSetInfo beatmapSetInfo, int index)
+        /// <summary>
+        /// Change the position of a <see cref="BeatmapSetInfo"/> in the current playlist.
+        /// </summary>
+        /// <param name="beatmapSetInfo">The beatmap to move.</param>
+        /// <param name="index">The new position.</param>
+        public void ChangeBeatmapSetPosition(BeatmapSetInfo beatmapSetInfo, int index)
         {
             beatmapSets.Remove(beatmapSetInfo);
             beatmapSets.Insert(index, beatmapSetInfo);
         }
 
-        private void handleBeatmapAdded(BeatmapSetInfo set) => Schedule(() => beatmapSets.Add(set));
+        /// <summary>
+        /// Returns whether the current beatmap track is playing.
+        /// </summary>
+        public bool IsPlaying => beatmap.Value.Track.IsRunning;
 
-        private void handleBeatmapRemoved(BeatmapSetInfo set) => Schedule(() => beatmapSets.RemoveAll(s => s.ID == set.ID));
+        private void handleBeatmapAdded(BeatmapSetInfo set) =>
+            Schedule(() => beatmapSets.Add(set));
 
-        protected override void LoadComplete()
+        private void handleBeatmapRemoved(BeatmapSetInfo set) =>
+            Schedule(() => beatmapSets.RemoveAll(s => s.ID == set.ID));
+
+        private ScheduledDelegate seekDelegate;
+
+        public void SeekTo(double position)
         {
-            beatmap.BindValueChanged(beatmapChanged, true);
-            beatmap.BindDisabledChanged(beatmapDisabledChanged, true);
-            mods.BindValueChanged(_ => updateAudioAdjustments(), true);
-            base.LoadComplete();
-        }
-
-        private void beatmapDisabledChanged(bool disabled)
-        {
-            if (disabled)
-                playlist.Hide();
-
-            playButton.Enabled.Value = !disabled;
-            prevButton.Enabled.Value = !disabled;
-            nextButton.Enabled.Value = !disabled;
-            playlistButton.Enabled.Value = !disabled;
-        }
-
-        protected override void UpdateAfterChildren()
-        {
-            base.UpdateAfterChildren();
-            Height = dragContainer.Height;
-
-            dragContainer.Padding = new MarginPadding { Top = GetToolbarHeight?.Invoke() ?? 0 };
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            if (pendingBeatmapSwitch != null)
+            seekDelegate?.Cancel();
+            seekDelegate = Schedule(() =>
             {
-                pendingBeatmapSwitch();
-                pendingBeatmapSwitch = null;
-            }
-
-            var track = current?.TrackLoaded ?? false ? current.Track : null;
-
-            if (track?.IsDummyDevice == false)
-            {
-                progressBar.EndTime = track.Length;
-                progressBar.CurrentTime = track.CurrentTime;
-
-                playButton.Icon = track.IsRunning ? FontAwesome.Regular.PauseCircle : FontAwesome.Regular.PlayCircle;
-            }
-            else
-            {
-                progressBar.CurrentTime = 0;
-                progressBar.EndTime = 1;
-                playButton.Icon = FontAwesome.Regular.PlayCircle;
-            }
+                if (!beatmap.Disabled)
+                    current?.Track.Seek(position);
+            });
         }
 
-        private void togglePause()
+        /// <summary>
+        /// Start playing the current track (if not already playing).
+        /// </summary>
+        public void Play()
+        {
+            if (!IsPlaying)
+                TogglePause();
+        }
+
+        /// <summary>
+        /// Toggle pause / play.
+        /// </summary>
+        /// <returns>Whether the operation was successful.</returns>
+        public bool TogglePause()
         {
             var track = current?.Track;
 
             if (track == null)
             {
-                if (!beatmap.Disabled)
-                    next(true);
-                return;
+                if (beatmap.Disabled)
+                    return false;
+
+                next(true);
+                return true;
             }
 
             if (track.IsRunning)
@@ -299,48 +128,70 @@ namespace osu.Game.Overlays
                 track.Start();
                 IsUserPaused = false;
             }
+
+            return true;
         }
 
-        private void prev()
+        /// <summary>
+        /// Play the previous track.
+        /// </summary>
+        /// <returns>Whether the operation was successful.</returns>
+        public bool PrevTrack()
         {
-            queuedDirection = TransformDirection.Prev;
+            queuedDirection = TrackChangeDirection.Prev;
 
             var playable = beatmapSets.TakeWhile(i => i.ID != current.BeatmapSetInfo.ID).LastOrDefault() ?? beatmapSets.LastOrDefault();
 
             if (playable != null)
             {
-                beatmap.Value = beatmaps.GetWorkingBeatmap(playable.Beatmaps.First(), beatmap.Value);
+                if (beatmap is Bindable<WorkingBeatmap> working)
+                    working.Value = beatmaps.GetWorkingBeatmap(playable.Beatmaps.First(), beatmap.Value);
                 beatmap.Value.Track.Restart();
+
+                return true;
             }
+
+            return false;
         }
 
-        private void next(bool instant = false)
+        /// <summary>
+        /// Play the next random or playlist track.
+        /// </summary>
+        /// <returns>Whether the operation was successful.</returns>
+        public bool NextTrack() => next();
+
+        private bool next(bool instant = false)
         {
             if (!instant)
-                queuedDirection = TransformDirection.Next;
+                queuedDirection = TrackChangeDirection.Next;
 
             var playable = beatmapSets.SkipWhile(i => i.ID != current.BeatmapSetInfo.ID).Skip(1).FirstOrDefault() ?? beatmapSets.FirstOrDefault();
 
             if (playable != null)
             {
-                beatmap.Value = beatmaps.GetWorkingBeatmap(playable.Beatmaps.First(), beatmap.Value);
+                if (beatmap is Bindable<WorkingBeatmap> working)
+                    working.Value = beatmaps.GetWorkingBeatmap(playable.Beatmaps.First(), beatmap.Value);
                 beatmap.Value.Track.Restart();
+                return true;
             }
+
+            return false;
         }
 
         private WorkingBeatmap current;
-        private TransformDirection? queuedDirection;
+
+        private TrackChangeDirection? queuedDirection;
 
         private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> beatmap)
         {
-            TransformDirection direction = TransformDirection.None;
+            TrackChangeDirection direction = TrackChangeDirection.None;
 
             if (current != null)
             {
                 bool audioEquals = beatmap.NewValue?.BeatmapInfo?.AudioEquals(current.BeatmapInfo) ?? false;
 
                 if (audioEquals)
-                    direction = TransformDirection.None;
+                    direction = TrackChangeDirection.None;
                 else if (queuedDirection.HasValue)
                 {
                     direction = queuedDirection.Value;
@@ -352,13 +203,13 @@ namespace osu.Game.Overlays
                     var last = beatmapSets.TakeWhile(b => b.ID != current.BeatmapSetInfo?.ID).Count();
                     var next = beatmap.NewValue == null ? -1 : beatmapSets.TakeWhile(b => b.ID != beatmap.NewValue.BeatmapSetInfo?.ID).Count();
 
-                    direction = last > next ? TransformDirection.Prev : TransformDirection.Next;
+                    direction = last > next ? TrackChangeDirection.Prev : TrackChangeDirection.Next;
                 }
             }
 
-            progressBar.CurrentTime = 0;
+            current = beatmap.NewValue;
+            TrackChanged?.Invoke(current, direction);
 
-            updateDisplay(current = beatmap.NewValue, direction);
             updateAudioAdjustments();
 
             queuedDirection = null;
@@ -376,167 +227,60 @@ namespace osu.Game.Overlays
                 mod.ApplyToClock(track);
         }
 
-        private Action pendingBeatmapSwitch;
-
-        private void updateDisplay(WorkingBeatmap beatmap, TransformDirection direction)
+        protected override void Dispose(bool isDisposing)
         {
-            // avoid using scheduler as our scheduler may not be run for a long time, holding references to beatmaps.
-            pendingBeatmapSwitch = delegate
+            base.Dispose(isDisposing);
+
+            if (beatmaps != null)
             {
-                // todo: this can likely be replaced with WorkingBeatmap.GetBeatmapAsync()
-                Task.Run(() =>
-                {
-                    if (beatmap?.Beatmap == null) //this is not needed if a placeholder exists
-                    {
-                        title.Text = @"Nothing to play";
-                        artist.Text = @"Nothing to play";
-                    }
-                    else
-                    {
-                        BeatmapMetadata metadata = beatmap.Metadata;
-                        title.Text = new LocalisedString((metadata.TitleUnicode, metadata.Title));
-                        artist.Text = new LocalisedString((metadata.ArtistUnicode, metadata.Artist));
-                    }
-                });
-
-                LoadComponentAsync(new Background(beatmap) { Depth = float.MaxValue }, newBackground =>
-                {
-                    switch (direction)
-                    {
-                        case TransformDirection.Next:
-                            newBackground.Position = new Vector2(400, 0);
-                            newBackground.MoveToX(0, 500, Easing.OutCubic);
-                            background.MoveToX(-400, 500, Easing.OutCubic);
-                            break;
-
-                        case TransformDirection.Prev:
-                            newBackground.Position = new Vector2(-400, 0);
-                            newBackground.MoveToX(0, 500, Easing.OutCubic);
-                            background.MoveToX(400, 500, Easing.OutCubic);
-                            break;
-                    }
-
-                    background.Expire();
-                    background = newBackground;
-
-                    playerContainer.Add(newBackground);
-                });
-            };
-        }
-
-        protected override void PopIn()
-        {
-            base.PopIn();
-
-            this.FadeIn(transition_length, Easing.OutQuint);
-            dragContainer.ScaleTo(1, transition_length, Easing.OutElastic);
-        }
-
-        protected override void PopOut()
-        {
-            base.PopOut();
-
-            this.FadeOut(transition_length, Easing.OutQuint);
-            dragContainer.ScaleTo(0.9f, transition_length, Easing.OutQuint);
-        }
-
-        private enum TransformDirection
-        {
-            None,
-            Next,
-            Prev
-        }
-
-        private class MusicIconButton : IconButton
-        {
-            public MusicIconButton()
-            {
-                AutoSizeAxes = Axes.Both;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
-            {
-                HoverColour = colours.YellowDark.Opacity(0.6f);
-                FlashColour = colours.Yellow;
-            }
-
-            protected override void LoadComplete()
-            {
-                base.LoadComplete();
-
-                // works with AutoSizeAxes above to make buttons autosize with the scale animation.
-                Content.AutoSizeAxes = Axes.None;
-                Content.Size = new Vector2(DEFAULT_BUTTON_SIZE);
+                beatmaps.ItemAdded -= handleBeatmapAdded;
+                beatmaps.ItemRemoved -= handleBeatmapRemoved;
             }
         }
 
-        private class Background : BufferedContainer
+        public bool OnPressed(GlobalAction action)
         {
-            private readonly Sprite sprite;
-            private readonly WorkingBeatmap beatmap;
+            if (beatmap.Disabled)
+                return false;
 
-            public Background(WorkingBeatmap beatmap = null)
+            switch (action)
             {
-                this.beatmap = beatmap;
-                CacheDrawnFrameBuffer = true;
-                Depth = float.MaxValue;
-                RelativeSizeAxes = Axes.Both;
+                case GlobalAction.MusicPlay:
+                    if (TogglePause())
+                        onScreenDisplay?.Display(new MusicControllerToast(IsPlaying ? "Play track" : "Pause track"));
+                    return true;
 
-                Children = new Drawable[]
-                {
-                    sprite = new Sprite
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = OsuColour.Gray(150),
-                        FillMode = FillMode.Fill,
-                    },
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Height = bottom_black_area_height,
-                        Origin = Anchor.BottomCentre,
-                        Anchor = Anchor.BottomCentre,
-                        Colour = Color4.Black.Opacity(0.5f)
-                    }
-                };
+                case GlobalAction.MusicNext:
+                    if (NextTrack())
+                        onScreenDisplay?.Display(new MusicControllerToast("Next track"));
+
+                    return true;
+
+                case GlobalAction.MusicPrev:
+                    if (PrevTrack())
+                        onScreenDisplay?.Display(new MusicControllerToast("Previous track"));
+
+                    return true;
             }
 
-            [BackgroundDependencyLoader]
-            private void load(TextureStore textures)
-            {
-                sprite.Texture = beatmap?.Background ?? textures.Get(@"Backgrounds/bg4");
-            }
+            return false;
         }
 
-        private class DragContainer : Container
+        public bool OnReleased(GlobalAction action) => false;
+
+        public class MusicControllerToast : Toast
         {
-            protected override bool OnDragStart(DragStartEvent e)
+            public MusicControllerToast(string action)
+                : base("Music Playback", action, string.Empty)
             {
-                return true;
-            }
-
-            protected override bool OnDrag(DragEvent e)
-            {
-                Vector2 change = e.MousePosition - e.MouseDownPosition;
-
-                // Diminish the drag distance as we go further to simulate "rubber band" feeling.
-                change *= change.Length <= 0 ? 0 : (float)Math.Pow(change.Length, 0.7f) / change.Length;
-
-                this.MoveTo(change);
-                return true;
-            }
-
-            protected override bool OnDragEnd(DragEndEvent e)
-            {
-                this.MoveTo(Vector2.Zero, 800, Easing.OutElastic);
-                return base.OnDragEnd(e);
             }
         }
+    }
 
-        /// <summary>
-        /// Play the next random or playlist track.
-        /// </summary>
-        public void NextTrack() => next();
+    public enum TrackChangeDirection
+    {
+        None,
+        Next,
+        Prev
     }
 }

osu.Game/Overlays/NowPlayingOverlay.cs

@@ -0,0 +1,404 @@
+// 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.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+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.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays.Music;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Overlays
+{
+    public class NowPlayingOverlay : OsuFocusedOverlayContainer
+    {
+        private const float player_height = 130;
+        private const float transition_length = 800;
+        private const float progress_height = 10;
+        private const float bottom_black_area_height = 55;
+
+        private Drawable background;
+        private ProgressBar progressBar;
+
+        private IconButton prevButton;
+        private IconButton playButton;
+        private IconButton nextButton;
+        private IconButton playlistButton;
+
+        private SpriteText title, artist;
+
+        private PlaylistOverlay playlist;
+
+        private Container dragContainer;
+        private Container playerContainer;
+
+        /// <summary>
+        /// Provide a source for the toolbar height.
+        /// </summary>
+        public Func<float> GetToolbarHeight;
+
+        [Resolved]
+        private MusicController musicController { get; set; }
+
+        [Resolved]
+        private Bindable<WorkingBeatmap> beatmap { get; set; }
+
+        public NowPlayingOverlay()
+        {
+            Width = 400;
+            Margin = new MarginPadding(10);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Children = new Drawable[]
+            {
+                dragContainer = new DragContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Children = new Drawable[]
+                    {
+                        playlist = new PlaylistOverlay
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Y = player_height + 10,
+                            OrderChanged = musicController.ChangeBeatmapSetPosition
+                        },
+                        playerContainer = new Container
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Height = player_height,
+                            Masking = true,
+                            CornerRadius = 5,
+                            EdgeEffect = new EdgeEffectParameters
+                            {
+                                Type = EdgeEffectType.Shadow,
+                                Colour = Color4.Black.Opacity(40),
+                                Radius = 5,
+                            },
+                            Children = new[]
+                            {
+                                background = new Background(),
+                                title = new OsuSpriteText
+                                {
+                                    Origin = Anchor.BottomCentre,
+                                    Anchor = Anchor.TopCentre,
+                                    Position = new Vector2(0, 40),
+                                    Font = OsuFont.GetFont(size: 25, italics: true),
+                                    Colour = Color4.White,
+                                    Text = @"Nothing to play",
+                                },
+                                artist = new OsuSpriteText
+                                {
+                                    Origin = Anchor.TopCentre,
+                                    Anchor = Anchor.TopCentre,
+                                    Position = new Vector2(0, 45),
+                                    Font = OsuFont.GetFont(size: 15, weight: FontWeight.Bold, italics: true),
+                                    Colour = Color4.White,
+                                    Text = @"Nothing to play",
+                                },
+                                new Container
+                                {
+                                    Padding = new MarginPadding { Bottom = progress_height },
+                                    Height = bottom_black_area_height,
+                                    RelativeSizeAxes = Axes.X,
+                                    Origin = Anchor.BottomCentre,
+                                    Anchor = Anchor.BottomCentre,
+                                    Children = new Drawable[]
+                                    {
+                                        new FillFlowContainer<IconButton>
+                                        {
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Spacing = new Vector2(5),
+                                            Origin = Anchor.Centre,
+                                            Anchor = Anchor.Centre,
+                                            Children = new[]
+                                            {
+                                                prevButton = new MusicIconButton
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    Action = () => musicController.PrevTrack(),
+                                                    Icon = FontAwesome.Solid.StepBackward,
+                                                },
+                                                playButton = new MusicIconButton
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    Scale = new Vector2(1.4f),
+                                                    IconScale = new Vector2(1.4f),
+                                                    Action = () => musicController.TogglePause(),
+                                                    Icon = FontAwesome.Regular.PlayCircle,
+                                                },
+                                                nextButton = new MusicIconButton
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    Action = () => musicController.NextTrack(),
+                                                    Icon = FontAwesome.Solid.StepForward,
+                                                },
+                                            }
+                                        },
+                                        playlistButton = new MusicIconButton
+                                        {
+                                            Origin = Anchor.Centre,
+                                            Anchor = Anchor.CentreRight,
+                                            Position = new Vector2(-bottom_black_area_height / 2, 0),
+                                            Icon = FontAwesome.Solid.Bars,
+                                            Action = () => playlist.ToggleVisibility(),
+                                        },
+                                    }
+                                },
+                                progressBar = new ProgressBar
+                                {
+                                    Origin = Anchor.BottomCentre,
+                                    Anchor = Anchor.BottomCentre,
+                                    Height = progress_height,
+                                    FillColour = colours.Yellow,
+                                    OnSeek = musicController.SeekTo
+                                }
+                            },
+                        },
+                    }
+                }
+            };
+
+            playlist.State.ValueChanged += s => playlistButton.FadeColour(s.NewValue == Visibility.Visible ? colours.Yellow : Color4.White, 200, Easing.OutQuint);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            beatmap.BindDisabledChanged(beatmapDisabledChanged, true);
+
+            musicController.TrackChanged += trackChanged;
+            trackChanged(beatmap.Value);
+        }
+
+        protected override void PopIn()
+        {
+            base.PopIn();
+
+            this.FadeIn(transition_length, Easing.OutQuint);
+            dragContainer.ScaleTo(1, transition_length, Easing.OutElastic);
+        }
+
+        protected override void PopOut()
+        {
+            base.PopOut();
+
+            this.FadeOut(transition_length, Easing.OutQuint);
+            dragContainer.ScaleTo(0.9f, transition_length, Easing.OutQuint);
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            Height = dragContainer.Height;
+            dragContainer.Padding = new MarginPadding { Top = GetToolbarHeight?.Invoke() ?? 0 };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (pendingBeatmapSwitch != null)
+            {
+                pendingBeatmapSwitch();
+                pendingBeatmapSwitch = null;
+            }
+
+            var track = beatmap.Value?.TrackLoaded ?? false ? beatmap.Value.Track : null;
+
+            if (track?.IsDummyDevice == false)
+            {
+                progressBar.EndTime = track.Length;
+                progressBar.CurrentTime = track.CurrentTime;
+
+                playButton.Icon = track.IsRunning ? FontAwesome.Regular.PauseCircle : FontAwesome.Regular.PlayCircle;
+            }
+            else
+            {
+                progressBar.CurrentTime = 0;
+                progressBar.EndTime = 1;
+                playButton.Icon = FontAwesome.Regular.PlayCircle;
+            }
+        }
+
+        private Action pendingBeatmapSwitch;
+
+        private void trackChanged(WorkingBeatmap beatmap, TrackChangeDirection direction = TrackChangeDirection.None)
+        {
+            // avoid using scheduler as our scheduler may not be run for a long time, holding references to beatmaps.
+            pendingBeatmapSwitch = delegate
+            {
+                // todo: this can likely be replaced with WorkingBeatmap.GetBeatmapAsync()
+                Task.Run(() =>
+                {
+                    if (beatmap?.Beatmap == null) //this is not needed if a placeholder exists
+                    {
+                        title.Text = @"Nothing to play";
+                        artist.Text = @"Nothing to play";
+                    }
+                    else
+                    {
+                        BeatmapMetadata metadata = beatmap.Metadata;
+                        title.Text = new LocalisedString((metadata.TitleUnicode, metadata.Title));
+                        artist.Text = new LocalisedString((metadata.ArtistUnicode, metadata.Artist));
+                    }
+                });
+
+                LoadComponentAsync(new Background(beatmap) { Depth = float.MaxValue }, newBackground =>
+                {
+                    switch (direction)
+                    {
+                        case TrackChangeDirection.Next:
+                            newBackground.Position = new Vector2(400, 0);
+                            newBackground.MoveToX(0, 500, Easing.OutCubic);
+                            background.MoveToX(-400, 500, Easing.OutCubic);
+                            break;
+
+                        case TrackChangeDirection.Prev:
+                            newBackground.Position = new Vector2(-400, 0);
+                            newBackground.MoveToX(0, 500, Easing.OutCubic);
+                            background.MoveToX(400, 500, Easing.OutCubic);
+                            break;
+                    }
+
+                    background.Expire();
+                    background = newBackground;
+
+                    playerContainer.Add(newBackground);
+                });
+            };
+        }
+
+        private void beatmapDisabledChanged(bool disabled)
+        {
+            if (disabled)
+                playlist.Hide();
+
+            playButton.Enabled.Value = !disabled;
+            prevButton.Enabled.Value = !disabled;
+            nextButton.Enabled.Value = !disabled;
+            playlistButton.Enabled.Value = !disabled;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (musicController != null)
+                musicController.TrackChanged -= trackChanged;
+        }
+
+        private class MusicIconButton : IconButton
+        {
+            public MusicIconButton()
+            {
+                AutoSizeAxes = Axes.Both;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                HoverColour = colours.YellowDark.Opacity(0.6f);
+                FlashColour = colours.Yellow;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                // works with AutoSizeAxes above to make buttons autosize with the scale animation.
+                Content.AutoSizeAxes = Axes.None;
+                Content.Size = new Vector2(DEFAULT_BUTTON_SIZE);
+            }
+        }
+
+        private class Background : BufferedContainer
+        {
+            private readonly Sprite sprite;
+            private readonly WorkingBeatmap beatmap;
+
+            public Background(WorkingBeatmap beatmap = null)
+            {
+                this.beatmap = beatmap;
+                CacheDrawnFrameBuffer = true;
+                Depth = float.MaxValue;
+                RelativeSizeAxes = Axes.Both;
+
+                Children = new Drawable[]
+                {
+                    sprite = new Sprite
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = OsuColour.Gray(150),
+                        FillMode = FillMode.Fill,
+                    },
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Height = bottom_black_area_height,
+                        Origin = Anchor.BottomCentre,
+                        Anchor = Anchor.BottomCentre,
+                        Colour = Color4.Black.Opacity(0.5f)
+                    }
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                sprite.Texture = beatmap?.Background ?? textures.Get(@"Backgrounds/bg4");
+            }
+        }
+
+        private class DragContainer : Container
+        {
+            protected override bool OnDragStart(DragStartEvent e)
+            {
+                return true;
+            }
+
+            protected override bool OnDrag(DragEvent e)
+            {
+                Vector2 change = e.MousePosition - e.MouseDownPosition;
+
+                // Diminish the drag distance as we go further to simulate "rubber band" feeling.
+                change *= change.Length <= 0 ? 0 : (float)Math.Pow(change.Length, 0.7f) / change.Length;
+
+                this.MoveTo(change);
+                return true;
+            }
+
+            protected override bool OnDragEnd(DragEndEvent e)
+            {
+                this.MoveTo(Vector2.Zero, 800, Easing.OutElastic);
+                return base.OnDragEnd(e);
+            }
+        }
+    }
+}

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,56 +95,23 @@ 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(() =>
-            {
-                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;
-                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;
-            });
+            box.Child = toast;
+            DisplayTemporarily(box);
         }
 
+        private void displayTrackedSettingChange(SettingDescription description) => Schedule(() => Display(new TrackedSettingToast(description)));
+
         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/BottomHeaderContainer.cs

@@ -140,6 +140,9 @@ namespace osu.Game.Overlays.Profile.Header
         {
             if (string.IsNullOrEmpty(content)) return;
 
+            // newlines could be contained in API returned user content.
+            content = content.Replace("\n", " ");
+
             bottomLinkContainer.AddIcon(icon, text =>
             {
                 text.Font = text.Font.With(size: 10);

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/Overlays/Profile/Header/Components/RankGraph.cs

@@ -196,17 +196,30 @@ namespace osu.Game.Overlays.Profile.Header.Components
             }
         }
 
-        public string TooltipText => Statistics.Value?.Ranks.Global == null ? "" : $"#{ranks[dayIndex].Value:#,##0}|{ranked_days - ranks[dayIndex].Key + 1}";
+        public object TooltipContent
+        {
+            get
+            {
+                if (Statistics.Value?.Ranks.Global == null)
+                    return null;
+
+                var days = ranked_days - ranks[dayIndex].Key + 1;
+
+                return new TooltipDisplayContent
+                {
+                    Rank = $"#{ranks[dayIndex].Value:#,##0}",
+                    Time = days == 0 ? "now" : $"{days} days ago"
+                };
+            }
+        }
 
         public ITooltip GetCustomTooltip() => new RankGraphTooltip();
 
-        public class RankGraphTooltip : VisibilityContainer, ITooltip
+        private class RankGraphTooltip : VisibilityContainer, ITooltip
         {
             private readonly OsuSpriteText globalRankingText, timeText;
             private readonly Box background;
 
-            public string TooltipText { get; set; }
-
             public RankGraphTooltip()
             {
                 AutoSizeAxes = Axes.Both;
@@ -260,11 +273,14 @@ namespace osu.Game.Overlays.Profile.Header.Components
                 background.Colour = colours.GreySeafoamDark;
             }
 
-            public void Refresh()
+            public bool SetContent(object content)
             {
-                var info = TooltipText.Split('|');
-                globalRankingText.Text = info[0];
-                timeText.Text = info[1] == "0" ? "now" : $"{info[1]} days ago";
+                if (!(content is TooltipDisplayContent info))
+                    return false;
+
+                globalRankingText.Text = info.Rank;
+                timeText.Text = info.Time;
+                return true;
             }
 
             private bool instantMove = true;
@@ -280,9 +296,19 @@ namespace osu.Game.Overlays.Profile.Header.Components
                     this.MoveTo(pos, 200, Easing.OutQuint);
             }
 
-            protected override void PopIn() => this.FadeIn(200, Easing.OutQuint);
+            protected override void PopIn()
+            {
+                instantMove |= !IsPresent;
+                this.FadeIn(200, Easing.OutQuint);
+            }
 
             protected override void PopOut() => this.FadeOut(200, Easing.OutQuint);
         }
+
+        private class TooltipDisplayContent
+        {
+            public string Rank;
+            public string Time;
+        }
     }
 }

osu.Game/Overlays/Profile/Sections/Beatmaps/PaginatedBeatmapContainer.cs

@@ -1,21 +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.Linq;
+using System.Collections.Generic;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.Direct;
 using osu.Game.Users;
 using osuTK;
 
 namespace osu.Game.Overlays.Profile.Sections.Beatmaps
 {
-    public class PaginatedBeatmapContainer : PaginatedContainer
+    public class PaginatedBeatmapContainer : PaginatedContainer<APIBeatmapSet>
     {
         private const float panel_padding = 10f;
         private readonly BeatmapSetType type;
-        private GetUserBeatmapsRequest request;
 
         public PaginatedBeatmapContainer(BeatmapSetType type, Bindable<User> user, string header, string missing = "None... yet.")
             : base(user, header, missing)
@@ -27,37 +28,15 @@ namespace osu.Game.Overlays.Profile.Sections.Beatmaps
             ItemsContainer.Spacing = new Vector2(panel_padding);
         }
 
-        protected override void ShowMore()
-        {
-            request = new GetUserBeatmapsRequest(User.Value.Id, type, VisiblePages++, ItemsPerPage);
-            request.Success += sets => Schedule(() =>
+        protected override APIRequest<List<APIBeatmapSet>> CreateRequest() =>
+            new GetUserBeatmapsRequest(User.Value.Id, type, VisiblePages++, ItemsPerPage);
+
+        protected override Drawable CreateDrawableItem(APIBeatmapSet model) => !model.OnlineBeatmapSetID.HasValue
+            ? null
+            : new DirectGridPanel(model.ToBeatmapSet(Rulesets))
             {
-                MoreButton.FadeTo(sets.Count == ItemsPerPage ? 1 : 0);
-                MoreButton.IsLoading = false;
-
-                if (!sets.Any() && VisiblePages == 1)
-                {
-                    MissingText.Show();
-                    return;
-                }
-
-                foreach (var s in sets)
-                {
-                    if (!s.OnlineBeatmapSetID.HasValue)
-                        continue;
-
-                    var panel = new DirectGridPanel(s.ToBeatmapSet(Rulesets));
-                    ItemsContainer.Add(panel);
-                }
-            });
-
-            Api.Queue(request);
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            request?.Cancel();
-        }
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+            };
     }
 }

osu.Game/Overlays/Profile/Sections/Historical/PaginatedMostPlayedBeatmapContainer.cs

@@ -1,19 +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 System.Linq;
+using System.Collections.Generic;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Users;
 
 namespace osu.Game.Overlays.Profile.Sections.Historical
 {
-    public class PaginatedMostPlayedBeatmapContainer : PaginatedContainer
+    public class PaginatedMostPlayedBeatmapContainer : PaginatedContainer<APIUserMostPlayedBeatmap>
     {
-        private GetUserMostPlayedBeatmapsRequest request;
-
         public PaginatedMostPlayedBeatmapContainer(Bindable<User> user)
             : base(user, "Most Played Beatmaps", "No records. :(")
         {
@@ -22,35 +22,10 @@ namespace osu.Game.Overlays.Profile.Sections.Historical
             ItemsContainer.Direction = FillDirection.Vertical;
         }
 
-        protected override void ShowMore()
-        {
-            request = new GetUserMostPlayedBeatmapsRequest(User.Value.Id, VisiblePages++, ItemsPerPage);
-            request.Success += beatmaps => Schedule(() =>
-            {
-                MoreButton.FadeTo(beatmaps.Count == ItemsPerPage ? 1 : 0);
-                MoreButton.IsLoading = false;
+        protected override APIRequest<List<APIUserMostPlayedBeatmap>> CreateRequest() =>
+            new GetUserMostPlayedBeatmapsRequest(User.Value.Id, VisiblePages++, ItemsPerPage);
 
-                if (!beatmaps.Any() && VisiblePages == 1)
-                {
-                    MissingText.Show();
-                    return;
-                }
-
-                MissingText.Hide();
-
-                foreach (var beatmap in beatmaps)
-                {
-                    ItemsContainer.Add(new DrawableMostPlayedBeatmap(beatmap.GetBeatmapInfo(Rulesets), beatmap.PlayCount));
-                }
-            });
-
-            Api.Queue(request);
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            request?.Cancel();
-        }
+        protected override Drawable CreateDrawableItem(APIUserMostPlayedBeatmap model) =>
+            new DrawableMostPlayedBeatmap(model.GetBeatmapInfo(Rulesets), model.PlayCount);
     }
 }

osu.Game/Overlays/Profile/Sections/Kudosu/DrawableKudosuHistoryItem.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 osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Chat;
+using System;
+using osuTK;
+
+namespace osu.Game.Overlays.Profile.Sections.Kudosu
+{
+    public class DrawableKudosuHistoryItem : CompositeDrawable
+    {
+        private const int height = 25;
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        private readonly APIKudosuHistory historyItem;
+        private readonly LinkFlowContainer linkFlowContainer;
+        private readonly DrawableDate date;
+
+        public DrawableKudosuHistoryItem(APIKudosuHistory historyItem)
+        {
+            this.historyItem = historyItem;
+
+            Height = height;
+            RelativeSizeAxes = Axes.X;
+            AddRangeInternal(new Drawable[]
+            {
+                linkFlowContainer = new LinkFlowContainer
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    AutoSizeAxes = Axes.Both,
+                    Spacing = new Vector2(0, 3),
+                },
+                date = new DrawableDate(historyItem.CreatedAt)
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                }
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            date.Colour = colours.GreySeafoamLighter;
+            var formattedSource = MessageFormatter.FormatText(getString(historyItem));
+            linkFlowContainer.AddLinks(formattedSource.Text, formattedSource.Links);
+        }
+
+        private string getString(APIKudosuHistory item)
+        {
+            string amount = $"{Math.Abs(item.Amount)} kudosu";
+            string post = $"[{item.Post.Title}]({item.Post.Url})";
+
+            switch (item.Source)
+            {
+                case KudosuSource.AllowKudosu:
+                    switch (item.Action)
+                    {
+                        case KudosuAction.Give:
+                            return $"Received {amount} from kudosu deny repeal of modding post {post}";
+                    }
+
+                    break;
+
+                case KudosuSource.DenyKudosu:
+                    switch (item.Action)
+                    {
+                        case KudosuAction.Reset:
+                            return $"Denied {amount} from modding post {post}";
+                    }
+
+                    break;
+
+                case KudosuSource.Delete:
+                    switch (item.Action)
+                    {
+                        case KudosuAction.Reset:
+                            return $"Lost {amount} from modding post deletion of {post}";
+                    }
+
+                    break;
+
+                case KudosuSource.Restore:
+                    switch (item.Action)
+                    {
+                        case KudosuAction.Give:
+                            return $"Received {amount} from modding post restoration of {post}";
+                    }
+
+                    break;
+
+                case KudosuSource.Vote:
+                    switch (item.Action)
+                    {
+                        case KudosuAction.Give:
+                            return $"Received {amount} from obtaining votes in modding post of {post}";
+
+                        case KudosuAction.Reset:
+                            return $"Lost {amount} from losing votes in modding post of {post}";
+                    }
+
+                    break;
+
+                case KudosuSource.Recalculate:
+                    switch (item.Action)
+                    {
+                        case KudosuAction.Give:
+                            return $"Received {amount} from votes recalculation in modding post of {post}";
+
+                        case KudosuAction.Reset:
+                            return $"Lost {amount} from votes recalculation in modding post of {post}";
+                    }
+
+                    break;
+
+                case KudosuSource.Forum:
+
+                    string giver = $"[{item.Giver?.Username}]({item.Giver?.Url})";
+
+                    switch (historyItem.Action)
+                    {
+                        case KudosuAction.Give:
+                            return $"Received {amount} from {giver} for a post at {post}";
+
+                        case KudosuAction.Reset:
+                            return $"Kudosu reset by {giver} for the post {post}";
+
+                        case KudosuAction.Revoke:
+                            return $"Denied kudosu by {giver} for the post {post}";
+                    }
+
+                    break;
+            }
+
+            return $"Unknown event ({amount} change)";
+        }
+    }
+}

osu.Game/Overlays/Profile/Sections/Kudosu/PaginatedKudosuHistoryContainer.cs

@@ -0,0 +1,27 @@
+// 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.Game.Online.API.Requests;
+using osu.Game.Users;
+using osu.Framework.Bindables;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.API;
+using System.Collections.Generic;
+
+namespace osu.Game.Overlays.Profile.Sections.Kudosu
+{
+    public class PaginatedKudosuHistoryContainer : PaginatedContainer<APIKudosuHistory>
+    {
+        public PaginatedKudosuHistoryContainer(Bindable<User> user, string header, string missing)
+            : base(user, header, missing)
+        {
+            ItemsPerPage = 5;
+        }
+
+        protected override APIRequest<List<APIKudosuHistory>> CreateRequest()
+            => new GetUserKudosuHistoryRequest(User.Value.Id, VisiblePages++, ItemsPerPage);
+
+        protected override Drawable CreateDrawableItem(APIKudosuHistory item) => new DrawableKudosuHistoryItem(item);
+    }
+}

osu.Game/Overlays/Profile/Sections/KudosuSection.cs

@@ -1,6 +1,7 @@
 // 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.Game.Overlays.Profile.Sections.Kudosu;
 
 namespace osu.Game.Overlays.Profile.Sections
@@ -13,9 +14,10 @@ namespace osu.Game.Overlays.Profile.Sections
 
         public KudosuSection()
         {
-            Children = new[]
+            Children = new Drawable[]
             {
                 new KudosuInfo(User),
+                new PaginatedKudosuHistoryContainer(User, null, @"This user hasn't received any kudosu!"),
             };
         }
     }

osu.Game/Overlays/Profile/Sections/PaginatedContainer.cs

@@ -11,22 +11,27 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Online.API;
 using osu.Game.Rulesets;
 using osu.Game.Users;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 
 namespace osu.Game.Overlays.Profile.Sections
 {
-    public abstract class PaginatedContainer : FillFlowContainer
+    public abstract class PaginatedContainer<TModel> : FillFlowContainer
     {
-        protected readonly FillFlowContainer ItemsContainer;
-        protected readonly ShowMoreButton MoreButton;
-        protected readonly OsuSpriteText MissingText;
+        private readonly ShowMoreButton moreButton;
+        private readonly OsuSpriteText missingText;
+        private APIRequest<List<TModel>> retrievalRequest;
+        private CancellationTokenSource loadCancellation;
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
 
         protected int VisiblePages;
         protected int ItemsPerPage;
 
         protected readonly Bindable<User> User = new Bindable<User>();
-
-        protected IAPIProvider Api;
-        protected APIRequest RetrievalRequest;
+        protected readonly FillFlowContainer ItemsContainer;
         protected RulesetStore Rulesets;
 
         protected PaginatedContainer(Bindable<User> user, string header, string missing)
@@ -51,15 +56,15 @@ namespace osu.Game.Overlays.Profile.Sections
                     RelativeSizeAxes = Axes.X,
                     Spacing = new Vector2(0, 2),
                 },
-                MoreButton = new ShowMoreButton
+                moreButton = new ShowMoreButton
                 {
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre,
                     Alpha = 0,
                     Margin = new MarginPadding { Top = 10 },
-                    Action = ShowMore,
+                    Action = showMore,
                 },
-                MissingText = new OsuSpriteText
+                missingText = new OsuSpriteText
                 {
                     Font = OsuFont.GetFont(size: 15),
                     Text = missing,
@@ -69,9 +74,8 @@ namespace osu.Game.Overlays.Profile.Sections
         }
 
         [BackgroundDependencyLoader]
-        private void load(IAPIProvider api, RulesetStore rulesets)
+        private void load(RulesetStore rulesets)
         {
-            Api = api;
             Rulesets = rulesets;
 
             User.ValueChanged += onUserChanged;
@@ -80,13 +84,54 @@ namespace osu.Game.Overlays.Profile.Sections
 
         private void onUserChanged(ValueChangedEvent<User> e)
         {
+            loadCancellation?.Cancel();
+            retrievalRequest?.Cancel();
+
             VisiblePages = 0;
             ItemsContainer.Clear();
 
             if (e.NewValue != null)
-                ShowMore();
+                showMore();
         }
 
-        protected abstract void ShowMore();
+        private void showMore()
+        {
+            loadCancellation = new CancellationTokenSource();
+
+            retrievalRequest = CreateRequest();
+            retrievalRequest.Success += UpdateItems;
+
+            api.Queue(retrievalRequest);
+        }
+
+        protected virtual void UpdateItems(List<TModel> items) => Schedule(() =>
+        {
+            if (!items.Any() && VisiblePages == 1)
+            {
+                moreButton.Hide();
+                moreButton.IsLoading = false;
+                missingText.Show();
+                return;
+            }
+
+            LoadComponentsAsync(items.Select(CreateDrawableItem).Where(d => d != null), drawables =>
+            {
+                missingText.Hide();
+                moreButton.FadeTo(items.Count == ItemsPerPage ? 1 : 0);
+                moreButton.IsLoading = false;
+
+                ItemsContainer.AddRange(drawables);
+            }, loadCancellation.Token);
+        });
+
+        protected abstract APIRequest<List<TModel>> CreateRequest();
+
+        protected abstract Drawable CreateDrawableItem(TModel model);
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            retrievalRequest?.Cancel();
+        }
     }
 }

osu.Game/Overlays/Profile/Sections/Ranks/PaginatedScoreContainer.cs

@@ -5,18 +5,18 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Online.API.Requests;
 using osu.Game.Users;
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using System.Collections.Generic;
+using osu.Game.Online.API;
 
 namespace osu.Game.Overlays.Profile.Sections.Ranks
 {
-    public class PaginatedScoreContainer : PaginatedContainer
+    public class PaginatedScoreContainer : PaginatedContainer<APILegacyScoreInfo>
     {
         private readonly bool includeWeight;
         private readonly ScoreType type;
-        private GetUserScoresRequest request;
 
         public PaginatedScoreContainer(ScoreType type, Bindable<User> user, string header, string missing, bool includeWeight = false)
             : base(user, header, missing)
@@ -29,52 +29,27 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
             ItemsContainer.Direction = FillDirection.Vertical;
         }
 
-        protected override void ShowMore()
+        protected override void UpdateItems(List<APILegacyScoreInfo> items)
         {
-            request = new GetUserScoresRequest(User.Value.Id, type, VisiblePages++, ItemsPerPage);
-            request.Success += scores => Schedule(() =>
-            {
-                foreach (var s in scores)
-                    s.Ruleset = Rulesets.GetRuleset(s.RulesetID);
+            foreach (var item in items)
+                item.Ruleset = Rulesets.GetRuleset(item.RulesetID);
 
-                if (!scores.Any() && VisiblePages == 1)
-                {
-                    MoreButton.Hide();
-                    MoreButton.IsLoading = false;
-                    MissingText.Show();
-                    return;
-                }
-
-                IEnumerable<DrawableProfileScore> drawableScores;
-
-                switch (type)
-                {
-                    default:
-                        drawableScores = scores.Select(score => new DrawablePerformanceScore(score, includeWeight ? Math.Pow(0.95, ItemsContainer.Count) : (double?)null));
-                        break;
-
-                    case ScoreType.Recent:
-                        drawableScores = scores.Select(score => new DrawableTotalScore(score));
-                        break;
-                }
-
-                LoadComponentsAsync(drawableScores, s =>
-                {
-                    MissingText.Hide();
-                    MoreButton.FadeTo(scores.Count == ItemsPerPage ? 1 : 0);
-                    MoreButton.IsLoading = false;
-
-                    ItemsContainer.AddRange(s);
-                });
-            });
-
-            Api.Queue(request);
+            base.UpdateItems(items);
         }
 
-        protected override void Dispose(bool isDisposing)
+        protected override APIRequest<List<APILegacyScoreInfo>> CreateRequest() =>
+            new GetUserScoresRequest(User.Value.Id, type, VisiblePages++, ItemsPerPage);
+
+        protected override Drawable CreateDrawableItem(APILegacyScoreInfo model)
         {
-            base.Dispose(isDisposing);
-            request?.Cancel();
+            switch (type)
+            {
+                default:
+                    return new DrawablePerformanceScore(model, includeWeight ? Math.Pow(0.95, ItemsContainer.Count) : (double?)null);
+
+                case ScoreType.Recent:
+                    return new DrawableTotalScore(model);
+            }
         }
     }
 }

osu.Game/Overlays/Profile/Sections/Recent/PaginatedRecentActivityContainer.cs

@@ -4,51 +4,24 @@
 using osu.Framework.Graphics;
 using osu.Game.Online.API.Requests;
 using osu.Game.Users;
-using System.Linq;
 using osu.Framework.Bindables;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.API;
+using System.Collections.Generic;
 
 namespace osu.Game.Overlays.Profile.Sections.Recent
 {
-    public class PaginatedRecentActivityContainer : PaginatedContainer
+    public class PaginatedRecentActivityContainer : PaginatedContainer<APIRecentActivity>
     {
-        private GetUserRecentActivitiesRequest request;
-
         public PaginatedRecentActivityContainer(Bindable<User> user, string header, string missing)
             : base(user, header, missing)
         {
             ItemsPerPage = 5;
         }
 
-        protected override void ShowMore()
-        {
-            request = new GetUserRecentActivitiesRequest(User.Value.Id, VisiblePages++, ItemsPerPage);
-            request.Success += activities => Schedule(() =>
-            {
-                MoreButton.FadeTo(activities.Count == ItemsPerPage ? 1 : 0);
-                MoreButton.IsLoading = false;
+        protected override APIRequest<List<APIRecentActivity>> CreateRequest() =>
+            new GetUserRecentActivitiesRequest(User.Value.Id, VisiblePages++, ItemsPerPage);
 
-                if (!activities.Any() && VisiblePages == 1)
-                {
-                    MissingText.Show();
-                    return;
-                }
-
-                MissingText.Hide();
-
-                foreach (APIRecentActivity activity in activities)
-                {
-                    ItemsContainer.Add(new DrawableRecentActivity(activity));
-                }
-            });
-
-            Api.Queue(request);
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            request?.Cancel();
-        }
+        protected override Drawable CreateDrawableItem(APIRecentActivity model) => new DrawableRecentActivity(model);
     }
 }

osu.Game/Overlays/Profile/Sections/ShowMoreButton.cs

@@ -124,14 +124,12 @@ namespace osu.Game.Overlays.Profile.Sections
 
         private class ChevronIcon : SpriteIcon
         {
-            private const int bottom_margin = 2;
             private const int icon_size = 8;
 
             public ChevronIcon()
             {
                 Anchor = Anchor.Centre;
                 Origin = Anchor.Centre;
-                Margin = new MarginPadding { Bottom = bottom_margin };
                 Size = new Vector2(icon_size);
                 Icon = FontAwesome.Solid.ChevronDown;
             }

osu.Game/Overlays/Settings/Sections/Audio/MainMenuSettings.cs

@@ -1,7 +1,10 @@
 // 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.Graphics;
 using osu.Game.Configuration;
 
 namespace osu.Game.Overlays.Settings.Sections.Audio
@@ -13,7 +16,7 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
-            Children = new[]
+            Children = new Drawable[]
             {
                 new SettingsCheckbox
                 {
@@ -25,6 +28,12 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
                     LabelText = "osu! music theme",
                     Bindable = config.GetBindable<bool>(OsuSetting.MenuMusic)
                 },
+                new SettingsDropdown<IntroSequence>
+                {
+                    LabelText = "Intro sequence",
+                    Bindable = config.GetBindable<IntroSequence>(OsuSetting.IntroSequence),
+                    Items = Enum.GetValues(typeof(IntroSequence)).Cast<IntroSequence>()
+                },
             };
         }
     }

osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs

@@ -44,6 +44,11 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                     LabelText = "Always show key overlay",
                     Bindable = config.GetBindable<bool>(OsuSetting.KeyOverlay)
                 },
+                new SettingsEnumDropdown<ScoreMeterType>
+                {
+                    LabelText = "Score meter type",
+                    Bindable = config.GetBindable<ScoreMeterType>(OsuSetting.ScoreMeter)
+                },
                 new SettingsEnumDropdown<ScoringMode>
                 {
                     LabelText = "Score display mode",

osu.Game/Overlays/SettingsSubPanel.cs

@@ -57,7 +57,6 @@ namespace osu.Game.Overlays
                             {
                                 Anchor = Anchor.Centre,
                                 Origin = Anchor.Centre,
-                                Y = -15,
                                 Size = new Vector2(15),
                                 Shadow = true,
                                 Icon = FontAwesome.Solid.ChevronLeft

osu.Game/Overlays/Toolbar/ToolbarButton.cs

@@ -79,7 +79,7 @@ namespace osu.Game.Overlays.Toolbar
                 {
                     RelativeSizeAxes = Axes.Both,
                     Colour = OsuColour.Gray(80).Opacity(180),
-                    Blending = BlendingMode.Additive,
+                    Blending = BlendingParameters.Additive,
                     Alpha = 0,
                 },
                 Flow = new FillFlowContainer

osu.Game/Overlays/Toolbar/ToolbarMusicButton.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Overlays.Toolbar
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(MusicController music)
+        private void load(NowPlayingOverlay music)
         {
             StateContainer = music;
         }

osu.Game/Overlays/Toolbar/ToolbarOverlayToggleButton.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Overlays.Toolbar
             {
                 RelativeSizeAxes = Axes.Both,
                 Colour = OsuColour.Gray(150).Opacity(180),
-                Blending = BlendingMode.Additive,
+                Blending = BlendingParameters.Additive,
                 Depth = 2,
                 Alpha = 0,
             });

osu.Game/Overlays/Volume/MuteButton.cs

@@ -65,16 +65,15 @@ namespace osu.Game.Overlays.Volume
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(20),
                 }
             });
 
-            Current.ValueChanged += muted =>
+            Current.BindValueChanged(muted =>
             {
                 icon.Icon = muted.NewValue ? FontAwesome.Solid.VolumeMute : FontAwesome.Solid.VolumeUp;
-            };
-
-            Current.TriggerChange();
+                icon.Size = new Vector2(muted.NewValue ? 18 : 20);
+                icon.Margin = new MarginPadding { Right = muted.NewValue ? 2 : 0 };
+            }, true);
         }
 
         protected override bool OnHover(HoverEvent e)

osu.Game/Overlays/Volume/VolumeControlReceptor.cs

@@ -9,7 +9,7 @@ using osu.Game.Input.Bindings;
 
 namespace osu.Game.Overlays.Volume
 {
-    public class VolumeControlReceptor : Container, IScrollBindingHandler<GlobalAction>, IHandleGlobalInput
+    public class VolumeControlReceptor : Container, IScrollBindingHandler<GlobalAction>, IHandleGlobalKeyboardInput
     {
         public Func<GlobalAction, bool> ActionRequested;
         public Func<GlobalAction, float, bool, bool> ScrollActionRequested;

osu.Game/Rulesets/Edit/DrawableEditRuleset.cs

@@ -1,110 +0,0 @@
-// 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.Linq;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.UI;
-
-namespace osu.Game.Rulesets.Edit
-{
-    public abstract class DrawableEditRuleset : CompositeDrawable
-    {
-        /// <summary>
-        /// The <see cref="Playfield"/> contained by this <see cref="DrawableEditRuleset"/>.
-        /// </summary>
-        public abstract Playfield Playfield { get; }
-
-        public abstract PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer();
-
-        internal DrawableEditRuleset()
-        {
-            RelativeSizeAxes = Axes.Both;
-        }
-
-        /// <summary>
-        /// Adds a <see cref="HitObject"/> to the <see cref="Beatmap"/> and displays a visual representation of it.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
-        /// <returns>The visual representation of <paramref name="hitObject"/>.</returns>
-        internal abstract DrawableHitObject Add(HitObject hitObject);
-
-        /// <summary>
-        /// Removes a <see cref="HitObject"/> from the <see cref="Beatmap"/> and the display.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="HitObject"/> to remove.</param>
-        /// <returns>The visual representation of the removed <paramref name="hitObject"/>.</returns>
-        internal abstract DrawableHitObject Remove(HitObject hitObject);
-    }
-
-    public class DrawableEditRuleset<TObject> : DrawableEditRuleset
-        where TObject : HitObject
-    {
-        public override Playfield Playfield => drawableRuleset.Playfield;
-
-        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => drawableRuleset.CreatePlayfieldAdjustmentContainer();
-
-        private Ruleset ruleset => drawableRuleset.Ruleset;
-        private Beatmap<TObject> beatmap => drawableRuleset.Beatmap;
-
-        private readonly DrawableRuleset<TObject> drawableRuleset;
-
-        public DrawableEditRuleset(DrawableRuleset<TObject> drawableRuleset)
-        {
-            this.drawableRuleset = drawableRuleset;
-
-            InternalChild = drawableRuleset;
-
-            Playfield.DisplayJudgements.Value = false;
-        }
-
-        internal override DrawableHitObject Add(HitObject hitObject)
-        {
-            var tObject = (TObject)hitObject;
-
-            // Add to beatmap, preserving sorting order
-            var insertionIndex = beatmap.HitObjects.FindLastIndex(h => h.StartTime <= hitObject.StartTime);
-            beatmap.HitObjects.Insert(insertionIndex + 1, tObject);
-
-            // Process object
-            var processor = ruleset.CreateBeatmapProcessor(beatmap);
-
-            processor?.PreProcess();
-            tObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty);
-            processor?.PostProcess();
-
-            // Add visual representation
-            var drawableObject = drawableRuleset.CreateDrawableRepresentation(tObject);
-
-            drawableRuleset.Playfield.Add(drawableObject);
-            drawableRuleset.Playfield.PostProcess();
-
-            return drawableObject;
-        }
-
-        internal override DrawableHitObject Remove(HitObject hitObject)
-        {
-            var tObject = (TObject)hitObject;
-
-            // Remove from beatmap
-            beatmap.HitObjects.Remove(tObject);
-
-            // Process the beatmap
-            var processor = ruleset.CreateBeatmapProcessor(beatmap);
-
-            processor?.PreProcess();
-            processor?.PostProcess();
-
-            // Remove visual representation
-            var drawableObject = Playfield.AllHitObjects.Single(d => d.HitObject == hitObject);
-
-            drawableRuleset.Playfield.Remove(drawableObject);
-            drawableRuleset.Playfield.PostProcess();
-
-            return drawableObject;
-        }
-    }
-}

osu.Game/Rulesets/Edit/DrawableEditRulesetWrapper.cs

@@ -0,0 +1,80 @@
+// 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.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit;
+
+namespace osu.Game.Rulesets.Edit
+{
+    /// <summary>
+    /// A wrapper for a <see cref="DrawableRuleset{TObject}"/>. Handles adding visual representations of <see cref="HitObject"/>s to the underlying <see cref="DrawableRuleset{TObject}"/>.
+    /// </summary>
+    internal class DrawableEditRulesetWrapper<TObject> : CompositeDrawable
+        where TObject : HitObject
+    {
+        public Playfield Playfield => drawableRuleset.Playfield;
+
+        private readonly DrawableRuleset<TObject> drawableRuleset;
+
+        [Resolved]
+        private IEditorBeatmap<TObject> beatmap { get; set; }
+
+        public DrawableEditRulesetWrapper(DrawableRuleset<TObject> drawableRuleset)
+        {
+            this.drawableRuleset = drawableRuleset;
+
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChild = drawableRuleset;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            drawableRuleset.FrameStablePlayback = false;
+            Playfield.DisplayJudgements.Value = false;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            beatmap.HitObjectAdded += addHitObject;
+            beatmap.HitObjectRemoved += removeHitObject;
+        }
+
+        private void addHitObject(HitObject hitObject)
+        {
+            var drawableObject = drawableRuleset.CreateDrawableRepresentation((TObject)hitObject);
+
+            drawableRuleset.Playfield.Add(drawableObject);
+            drawableRuleset.Playfield.PostProcess();
+        }
+
+        private void removeHitObject(HitObject hitObject)
+        {
+            var drawableObject = Playfield.AllHitObjects.Single(d => d.HitObject == hitObject);
+
+            drawableRuleset.Playfield.Remove(drawableObject);
+            drawableRuleset.Playfield.PostProcess();
+        }
+
+        public PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => drawableRuleset.CreatePlayfieldAdjustmentContainer();
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (beatmap != null)
+            {
+                beatmap.HitObjectAdded -= addHitObject;
+                beatmap.HitObjectRemoved -= removeHitObject;
+            }
+        }
+    }
+}

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -18,45 +18,47 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Components.RadioButtons;
+using osu.Game.Screens.Edit.Compose;
 using osu.Game.Screens.Edit.Compose.Components;
 
 namespace osu.Game.Rulesets.Edit
 {
-    public abstract class HitObjectComposer : CompositeDrawable
+    [Cached(Type = typeof(IPlacementHandler))]
+    public abstract class HitObjectComposer<TObject> : HitObjectComposer, IPlacementHandler
+        where TObject : HitObject
     {
-        public IEnumerable<DrawableHitObject> HitObjects => DrawableRuleset.Playfield.AllHitObjects;
+        protected IRulesetConfigManager Config { get; private set; }
 
         protected readonly Ruleset Ruleset;
 
-        protected readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
-
-        protected IRulesetConfigManager Config { get; private set; }
-
-        private readonly List<Container> layerContainers = new List<Container>();
-
-        protected DrawableEditRuleset DrawableRuleset { get; private set; }
+        private IWorkingBeatmap workingBeatmap;
+        private Beatmap<TObject> playableBeatmap;
+        private EditorBeatmap<TObject> editorBeatmap;
+        private IBeatmapProcessor beatmapProcessor;
 
+        private DrawableEditRulesetWrapper<TObject> drawableRulesetWrapper;
         private BlueprintContainer blueprintContainer;
+        private readonly List<Container> layerContainers = new List<Container>();
 
         private InputManager inputManager;
 
-        internal HitObjectComposer(Ruleset ruleset)
+        protected HitObjectComposer(Ruleset ruleset)
         {
             Ruleset = ruleset;
-
             RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, IFrameBasedClock framedClock)
+        private void load(IFrameBasedClock framedClock)
         {
-            Beatmap.BindTo(beatmap);
-
             try
             {
-                DrawableRuleset = CreateDrawableRuleset();
-                DrawableRuleset.Clock = framedClock;
+                drawableRulesetWrapper = new DrawableEditRulesetWrapper<TObject>(CreateDrawableRuleset(Ruleset, workingBeatmap, Array.Empty<Mod>()))
+                {
+                    Clock = framedClock
+                };
             }
             catch (Exception e)
             {
@@ -64,10 +66,10 @@ namespace osu.Game.Rulesets.Edit
                 return;
             }
 
-            var layerBelowRuleset = DrawableRuleset.CreatePlayfieldAdjustmentContainer();
+            var layerBelowRuleset = drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer();
             layerBelowRuleset.Child = new EditorPlayfieldBorder { RelativeSizeAxes = Axes.Both };
 
-            var layerAboveRuleset = DrawableRuleset.CreatePlayfieldAdjustmentContainer();
+            var layerAboveRuleset = drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer();
             layerAboveRuleset.Child = blueprintContainer = new BlueprintContainer();
 
             layerContainers.Add(layerBelowRuleset);
@@ -98,7 +100,7 @@ namespace osu.Game.Rulesets.Edit
                             Children = new Drawable[]
                             {
                                 layerBelowRuleset,
-                                DrawableRuleset,
+                                drawableRulesetWrapper,
                                 layerAboveRuleset
                             }
                         }
@@ -118,6 +120,28 @@ namespace osu.Game.Rulesets.Edit
             toolboxCollection.Items[0].Select();
         }
 
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var parentWorkingBeatmap = parent.Get<IBindable<WorkingBeatmap>>().Value;
+
+            playableBeatmap = (Beatmap<TObject>)parentWorkingBeatmap.GetPlayableBeatmap(Ruleset.RulesetInfo, Array.Empty<Mod>());
+            workingBeatmap = new EditorWorkingBeatmap<TObject>(playableBeatmap, parentWorkingBeatmap);
+
+            beatmapProcessor = Ruleset.CreateBeatmapProcessor(playableBeatmap);
+
+            editorBeatmap = new EditorBeatmap<TObject>(playableBeatmap);
+            editorBeatmap.HitObjectAdded += addHitObject;
+            editorBeatmap.HitObjectRemoved += removeHitObject;
+
+            var dependencies = new DependencyContainer(parent);
+            dependencies.CacheAs<IEditorBeatmap>(editorBeatmap);
+            dependencies.CacheAs<IEditorBeatmap<TObject>>(editorBeatmap);
+
+            Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(Ruleset);
+
+            return base.CreateChildDependencies(dependencies);
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -125,45 +149,76 @@ namespace osu.Game.Rulesets.Edit
             inputManager = GetContainingInputManager();
         }
 
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-        {
-            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-
-            dependencies.CacheAs(this);
-            Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(Ruleset);
-
-            return dependencies;
-        }
-
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
 
             layerContainers.ForEach(l =>
             {
-                l.Anchor = DrawableRuleset.Playfield.Anchor;
-                l.Origin = DrawableRuleset.Playfield.Origin;
-                l.Position = DrawableRuleset.Playfield.Position;
-                l.Size = DrawableRuleset.Playfield.Size;
+                l.Anchor = drawableRulesetWrapper.Playfield.Anchor;
+                l.Origin = drawableRulesetWrapper.Playfield.Origin;
+                l.Position = drawableRulesetWrapper.Playfield.Position;
+                l.Size = drawableRulesetWrapper.Playfield.Size;
             });
         }
 
+        private void addHitObject(HitObject hitObject)
+        {
+            beatmapProcessor?.PreProcess();
+            hitObject.ApplyDefaults(playableBeatmap.ControlPointInfo, playableBeatmap.BeatmapInfo.BaseDifficulty);
+            beatmapProcessor?.PostProcess();
+        }
+
+        private void removeHitObject(HitObject hitObject)
+        {
+            beatmapProcessor?.PreProcess();
+            beatmapProcessor?.PostProcess();
+        }
+
+        public override IEnumerable<DrawableHitObject> HitObjects => drawableRulesetWrapper.Playfield.AllHitObjects;
+        public override bool CursorInPlacementArea => drawableRulesetWrapper.Playfield.ReceivePositionalInputAt(inputManager.CurrentState.Mouse.Position);
+
+        protected abstract IReadOnlyList<HitObjectCompositionTool> CompositionTools { get; }
+
+        protected abstract DrawableRuleset<TObject> CreateDrawableRuleset(Ruleset ruleset, IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods);
+
+        public void BeginPlacement(HitObject hitObject)
+        {
+        }
+
+        public void EndPlacement(HitObject hitObject) => editorBeatmap.Add(hitObject);
+
+        public void Delete(HitObject hitObject) => editorBeatmap.Remove(hitObject);
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (editorBeatmap != null)
+            {
+                editorBeatmap.HitObjectAdded -= addHitObject;
+                editorBeatmap.HitObjectRemoved -= removeHitObject;
+            }
+        }
+    }
+
+    [Cached(typeof(HitObjectComposer))]
+    public abstract class HitObjectComposer : CompositeDrawable
+    {
+        internal HitObjectComposer()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        /// <summary>
+        /// All the <see cref="DrawableHitObject"/>s.
+        /// </summary>
+        public abstract IEnumerable<DrawableHitObject> HitObjects { get; }
+
         /// <summary>
         /// Whether the user's cursor is currently in an area of the <see cref="HitObjectComposer"/> that is valid for placement.
         /// </summary>
-        public virtual bool CursorInPlacementArea => DrawableRuleset.Playfield.ReceivePositionalInputAt(inputManager.CurrentState.Mouse.Position);
-
-        /// <summary>
-        /// Adds a <see cref="HitObject"/> to the <see cref="Beatmaps.Beatmap"/> and visualises it.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
-        public void Add(HitObject hitObject) => blueprintContainer.AddBlueprintFor(DrawableRuleset.Add(hitObject));
-
-        public void Remove(HitObject hitObject) => blueprintContainer.RemoveBlueprintFor(DrawableRuleset.Remove(hitObject));
-
-        internal abstract DrawableEditRuleset CreateDrawableRuleset();
-
-        protected abstract IReadOnlyList<HitObjectCompositionTool> CompositionTools { get; }
+        public abstract bool CursorInPlacementArea { get; }
 
         /// <summary>
         /// Creates a <see cref="SelectionBlueprint"/> for a specific <see cref="DrawableHitObject"/>.
@@ -176,18 +231,4 @@ namespace osu.Game.Rulesets.Edit
         /// </summary>
         public virtual SelectionHandler CreateSelectionHandler() => new SelectionHandler();
     }
-
-    public abstract class HitObjectComposer<TObject> : HitObjectComposer
-        where TObject : HitObject
-    {
-        protected HitObjectComposer(Ruleset ruleset)
-            : base(ruleset)
-        {
-        }
-
-        internal override DrawableEditRuleset CreateDrawableRuleset()
-            => new DrawableEditRuleset<TObject>(CreateDrawableRuleset(Ruleset, Beatmap.Value, Array.Empty<Mod>()));
-
-        protected abstract DrawableRuleset<TObject> CreateDrawableRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods);
-    }
 }

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -7,7 +7,9 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.TypeExtensions;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
+using osu.Framework.Threading;
 using osu.Game.Audio;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
@@ -132,6 +134,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </summary>
         public event Action<DrawableHitObject, ArmedState> ApplyCustomUpdateState;
 
+#pragma warning disable 618 // (legacy state management) - can be removed 20200227
+
         /// <summary>
         /// Enables automatic transform management of this hitobject. Implementation of transforms should be done in <see cref="UpdateInitialTransforms"/> and <see cref="UpdateStateTransforms"/> only. Rewinding and removing previous states is done automatically.
         /// </summary>
@@ -139,6 +143,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// Going forward, this is the preferred way of implementing <see cref="DrawableHitObject"/>s. Previous functionality
         /// is offered as a compatibility layer until all rulesets have been migrated across.
         /// </remarks>
+        [Obsolete("Use UpdateInitialTransforms()/UpdateStateTransforms() instead")] // can be removed 20200227
         protected virtual bool UseTransformStateManagement => true;
 
         protected override void ClearInternal(bool disposeChildren = true) => throw new InvalidOperationException($"Should never clear a {nameof(DrawableHitObject)}");
@@ -183,6 +188,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <summary>
         /// Apply (generally fade-in) transforms leading into the <see cref="HitObject"/> start time.
         /// The local drawable hierarchy is recursively delayed to <see cref="LifetimeStart"/> for convenience.
+        ///
+        /// By default this will fade in the object from zero with no duration.
         /// </summary>
         /// <remarks>
         /// This is called once before every <see cref="UpdateStateTransforms"/>. This is to ensure a good state in the case
@@ -190,6 +197,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </remarks>
         protected virtual void UpdateInitialTransforms()
         {
+            this.FadeInFromZero();
         }
 
         /// <summary>
@@ -219,10 +227,13 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// Should generally not be used when <see cref="UseTransformStateManagement"/> is true; use <see cref="UpdateStateTransforms"/> instead.
         /// </summary>
         /// <param name="state">The new armed state.</param>
+        [Obsolete("Use UpdateInitialTransforms()/UpdateStateTransforms() instead")] // can be removed 20200227
         protected virtual void UpdateState(ArmedState state)
         {
         }
 
+#pragma warning restore 618
+
         #endregion
 
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)
@@ -268,6 +279,14 @@ namespace osu.Game.Rulesets.Objects.Drawables
             UpdateResult(false);
         }
 
+        /// <summary>
+        /// Schedules an <see cref="Action"/> to this <see cref="DrawableHitObject"/>.
+        /// </summary>
+        /// <remarks>
+        /// Only provided temporarily until hitobject pooling is implemented.
+        /// </remarks>
+        protected internal new ScheduledDelegate Schedule(Action action) => base.Schedule(action);
+
         private double? lifetimeStart;
 
         public override double LifetimeStart

osu.Game/Rulesets/Objects/HitWindows.cs

@@ -65,6 +65,19 @@ namespace osu.Game.Rulesets.Objects
             return HitResult.None;
         }
 
+        /// <summary>
+        /// Retrieves a mapping of <see cref="HitResult"/>s to their half window timing for all allowed <see cref="HitResult"/>s.
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerable<(HitResult result, double length)> GetAllAvailableHalfWindows()
+        {
+            for (var result = HitResult.Meh; result <= HitResult.Perfect; ++result)
+            {
+                if (IsHitResultAllowed(result))
+                    yield return (result, HalfWindowFor(result));
+            }
+        }
+
         /// <summary>
         /// Check whether it is possible to achieve the provided <see cref="HitResult"/>.
         /// </summary>

osu.Game/Rulesets/Replays/AutoGenerator.cs

@@ -3,6 +3,7 @@
 
 using osu.Game.Beatmaps;
 using osu.Game.Replays;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Replays
 {
@@ -34,5 +35,13 @@ namespace osu.Game.Rulesets.Replays
         protected const double KEY_UP_DELAY = 50;
 
         #endregion
+
+        protected virtual HitObject GetNextObject(int currentIndex)
+        {
+            if (currentIndex >= Beatmap.HitObjects.Count - 1)
+                return null;
+
+            return Beatmap.HitObjects[currentIndex + 1];
+        }
     }
 }

osu.Game/Rulesets/Ruleset.cs

@@ -18,6 +18,7 @@ using osu.Game.Configuration;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Scoring;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets
 {
@@ -44,6 +45,8 @@ namespace osu.Game.Rulesets
 
         public ModAutoplay GetAutoplayMod() => GetAllMods().OfType<ModAutoplay>().First();
 
+        public virtual ISkin CreateLegacySkinProvider(ISkinSource source) => null;
+
         protected Ruleset(RulesetInfo rulesetInfo = null)
         {
             RulesetInfo = rulesetInfo ?? createRulesetInfo();
@@ -56,7 +59,7 @@ namespace osu.Game.Rulesets
         /// <param name="mods">The <see cref="Mod"/>s to apply.</param>
         /// <exception cref="BeatmapInvalidForRulesetException">Unable to successfully load the beatmap to be usable with this ruleset.</exception>
         /// <returns></returns>
-        public abstract DrawableRuleset CreateDrawableRulesetWith(WorkingBeatmap beatmap, IReadOnlyList<Mod> mods);
+        public abstract DrawableRuleset CreateDrawableRulesetWith(IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods);
 
         /// <summary>
         /// Creates a <see cref="IBeatmapConverter"/> to convert a <see cref="IBeatmap"/> to one that is applicable for this <see cref="Ruleset"/>.

osu.Game/Rulesets/RulesetConfigCache.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets
         public IRulesetConfigManager GetConfigFor(Ruleset ruleset)
         {
             if (ruleset.RulesetInfo.ID == null)
-                throw new InvalidOperationException("The provided ruleset doesn't have a valid id.");
+                return null;
 
             return configCache.GetOrAdd(ruleset.RulesetInfo.ID.Value, _ => ruleset.CreateConfig(settingsStore));
         }

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -90,7 +90,7 @@ namespace osu.Game.Rulesets.Scoring
         /// <summary>
         /// Whether all <see cref="Judgement"/>s have been processed.
         /// </summary>
-        protected virtual bool HasCompleted => false;
+        public virtual bool HasCompleted => false;
 
         /// <summary>
         /// Whether this ScoreProcessor has already triggered the failed state.
@@ -205,7 +205,7 @@ namespace osu.Game.Rulesets.Scoring
         private const double combo_portion = 0.7;
         private const double max_score = 1000000;
 
-        protected sealed override bool HasCompleted => JudgedHits == MaxHits;
+        public sealed override bool HasCompleted => JudgedHits == MaxHits;
 
         protected int MaxHits { get; private set; }
         protected int JudgedHits { get; private set; }
@@ -325,9 +325,6 @@ namespace osu.Game.Rulesets.Scoring
 
             JudgedHits++;
 
-            if (result.Type != HitResult.None)
-                scoreResultCounts[result.Type] = scoreResultCounts.GetOrDefault(result.Type) + 1;
-
             if (result.Judgement.AffectsCombo)
             {
                 switch (result.Type)
@@ -352,6 +349,9 @@ namespace osu.Game.Rulesets.Scoring
             }
             else
             {
+                if (result.HasResult)
+                    scoreResultCounts[result.Type] = scoreResultCounts.GetOrDefault(result.Type) + 1;
+
                 baseScore += result.Judgement.NumericResultFor(result);
                 rollingMaxBaseScore += result.Judgement.MaxNumericResult;
             }
@@ -371,9 +371,6 @@ namespace osu.Game.Rulesets.Scoring
 
             JudgedHits--;
 
-            if (result.Type != HitResult.None)
-                scoreResultCounts[result.Type] = scoreResultCounts.GetOrDefault(result.Type) - 1;
-
             if (result.Judgement.IsBonus)
             {
                 if (result.IsHit)
@@ -381,6 +378,9 @@ namespace osu.Game.Rulesets.Scoring
             }
             else
             {
+                if (result.HasResult)
+                    scoreResultCounts[result.Type] = scoreResultCounts.GetOrDefault(result.Type) - 1;
+
                 baseScore -= result.Judgement.NumericResultFor(result);
                 rollingMaxBaseScore -= result.Judgement.MaxNumericResult;
             }

osu.Game/Rulesets/Timing/MultiplierControlPoint.cs

@@ -20,7 +20,13 @@ namespace osu.Game.Rulesets.Timing
         /// <summary>
         /// The aggregate multiplier which this <see cref="MultiplierControlPoint"/> provides.
         /// </summary>
-        public double Multiplier => Velocity * DifficultyPoint.SpeedMultiplier * 1000 / TimingPoint.BeatLength;
+        public double Multiplier => Velocity * DifficultyPoint.SpeedMultiplier * BaseBeatLength / TimingPoint.BeatLength;
+
+        /// <summary>
+        /// The base beat length to scale the <see cref="TimingPoint"/> provided multiplier relative to.
+        /// </summary>
+        /// <example>For a <see cref="BaseBeatLength"/> of 1000, a <see cref="TimingPoint"/> with a beat length of 500 will increase the multiplier by 2.</example>
+        public double BaseBeatLength = TimingControlPoint.DEFAULT_BEAT_LENGTH;
 
         /// <summary>
         /// The velocity multiplier.

osu.Game/Rulesets/UI/DrawableRuleset.cs

@@ -62,6 +62,22 @@ namespace osu.Game.Rulesets.UI
 
         public override GameplayClock FrameStableClock => frameStabilityContainer.GameplayClock;
 
+        private bool frameStablePlayback = true;
+
+        /// <summary>
+        /// Whether to enable frame-stable playback.
+        /// </summary>
+        internal bool FrameStablePlayback
+        {
+            get => frameStablePlayback;
+            set
+            {
+                frameStablePlayback = false;
+                if (frameStabilityContainer != null)
+                    frameStabilityContainer.FrameStablePlayback = value;
+            }
+        }
+
         /// <summary>
         /// Invoked when a <see cref="JudgementResult"/> has been applied by a <see cref="DrawableHitObject"/>.
         /// </summary>
@@ -97,7 +113,7 @@ namespace osu.Game.Rulesets.UI
         /// <param name="ruleset">The ruleset being represented.</param>
         /// <param name="workingBeatmap">The beatmap to create the hit renderer for.</param>
         /// <param name="mods">The <see cref="Mod"/>s to apply.</param>
-        protected DrawableRuleset(Ruleset ruleset, WorkingBeatmap workingBeatmap, IReadOnlyList<Mod> mods)
+        protected DrawableRuleset(Ruleset ruleset, IWorkingBeatmap workingBeatmap, IReadOnlyList<Mod> mods)
             : base(ruleset)
         {
             if (workingBeatmap == null)
@@ -147,6 +163,7 @@ namespace osu.Game.Rulesets.UI
             {
                 frameStabilityContainer = new FrameStabilityContainer(GameplayStartTime)
                 {
+                    FrameStablePlayback = FrameStablePlayback,
                     Child = KeyBindingInputManager
                         .WithChild(CreatePlayfieldAdjustmentContainer()
                             .WithChild(Playfield)
@@ -198,10 +215,6 @@ namespace osu.Game.Rulesets.UI
                 continueResume();
         }
 
-        public ResumeOverlay ResumeOverlay { get; private set; }
-
-        protected virtual ResumeOverlay CreateResumeOverlay() => null;
-
         /// <summary>
         /// Creates and adds the visual representation of a <see cref="TObject"/> to this <see cref="DrawableRuleset{TObject}"/>.
         /// </summary>
@@ -372,6 +385,13 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         public abstract GameplayCursorContainer Cursor { get; }
 
+        /// <summary>
+        /// An optional overlay used when resuming gameplay from a paused state.
+        /// </summary>
+        public ResumeOverlay ResumeOverlay { get; protected set; }
+
+        protected virtual ResumeOverlay CreateResumeOverlay() => null;
+
         /// <summary>
         /// Sets a replay to be used, overriding local input.
         /// </summary>

osu.Game/Rulesets/UI/FrameStabilityContainer.cs

@@ -24,6 +24,11 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         public int MaxCatchUpFrames { get; set; } = 5;
 
+        /// <summary>
+        /// Whether to enable frame-stable playback.
+        /// </summary>
+        internal bool FrameStablePlayback = true;
+
         [Cached]
         public GameplayClock GameplayClock { get; }
 
@@ -113,7 +118,13 @@ namespace osu.Game.Rulesets.UI
 
             try
             {
-                if (firstConsumption)
+                if (!FrameStablePlayback)
+                {
+                    manualClock.CurrentTime = newProposedTime;
+                    requireMoreUpdateLoops = false;
+                    return;
+                }
+                else if (firstConsumption)
                 {
                     // On the first update, frame-stability seeking would result in unexpected/unwanted behaviour.
                     // Instead we perform an initial seek to the proposed time.

osu.Game/Rulesets/UI/ModIcon.cs

@@ -54,7 +54,6 @@ namespace osu.Game.Rulesets.UI
                     Anchor = Anchor.Centre,
                     Size = new Vector2(size),
                     Icon = OsuIcon.ModBg,
-                    Y = -6.5f,
                     Shadow = true,
                 },
                 modIcon = new SpriteIcon

osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs

@@ -69,6 +69,11 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         protected virtual bool UserScrollSpeedAdjustment => true;
 
+        /// <summary>
+        /// Whether <see cref="TimingControlPoint"/> beat lengths should scale relative to the most common beat length in the <see cref="Beatmap"/>.
+        /// </summary>
+        protected virtual bool RelativeScaleBeatLengths => false;
+
         /// <summary>
         /// Provides the default <see cref="MultiplierControlPoint"/>s that adjust the scrolling rate of <see cref="HitObject"/>s
         /// inside this <see cref="DrawableRuleset{TObject}"/>.
@@ -81,7 +86,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         [Cached(Type = typeof(IScrollingInfo))]
         private readonly LocalScrollingInfo scrollingInfo;
 
-        protected DrawableScrollingRuleset(Ruleset ruleset, WorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
+        protected DrawableScrollingRuleset(Ruleset ruleset, IWorkingBeatmap beatmap, IReadOnlyList<Mod> mods)
             : base(ruleset, beatmap, mods)
         {
             scrollingInfo = new LocalScrollingInfo();
@@ -107,16 +112,38 @@ namespace osu.Game.Rulesets.UI.Scrolling
         [BackgroundDependencyLoader]
         private void load()
         {
-            // Calculate default multiplier control points
+            double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
+            double baseBeatLength = TimingControlPoint.DEFAULT_BEAT_LENGTH;
+
+            if (RelativeScaleBeatLengths)
+            {
+                IReadOnlyList<TimingControlPoint> timingPoints = Beatmap.ControlPointInfo.TimingPoints;
+                double maxDuration = 0;
+
+                for (int i = 0; i < timingPoints.Count; i++)
+                {
+                    if (timingPoints[i].Time > lastObjectTime)
+                        break;
+
+                    double endTime = i < timingPoints.Count - 1 ? timingPoints[i + 1].Time : lastObjectTime;
+                    double duration = endTime - timingPoints[i].Time;
+
+                    if (duration > maxDuration)
+                    {
+                        maxDuration = duration;
+                        baseBeatLength = timingPoints[i].BeatLength;
+                    }
+                }
+            }
+
+            // Merge sequences of timing and difficulty control points to create the aggregate "multiplier" control point
             var lastTimingPoint = new TimingControlPoint();
             var lastDifficultyPoint = new DifficultyControlPoint();
-
-            // Merge timing + difficulty points
             var allPoints = new SortedList<ControlPoint>(Comparer<ControlPoint>.Default);
             allPoints.AddRange(Beatmap.ControlPointInfo.TimingPoints);
             allPoints.AddRange(Beatmap.ControlPointInfo.DifficultyPoints);
 
-            // Generate the timing points, making non-timing changes use the previous timing change
+            // Generate the timing points, making non-timing changes use the previous timing change and vice-versa
             var timingChanges = allPoints.Select(c =>
             {
                 var timingPoint = c as TimingControlPoint;
@@ -131,14 +158,13 @@ namespace osu.Game.Rulesets.UI.Scrolling
                 return new MultiplierControlPoint(c.Time)
                 {
                     Velocity = Beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier,
+                    BaseBeatLength = baseBeatLength,
                     TimingPoint = lastTimingPoint,
                     DifficultyPoint = lastDifficultyPoint
                 };
             });
 
-            double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
-
-            // Perform some post processing of the timing changes
+            // Trim unwanted sequences of timing changes
             timingChanges = timingChanges
                             // Collapse sections after the last hit object
                             .Where(s => s.StartTime <= lastObjectTime)
@@ -147,7 +173,6 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
             controlPoints.AddRange(timingChanges);
 
-            // If we have no control points, add a default one
             if (controlPoints.Count == 0)
                 controlPoints.Add(new MultiplierControlPoint { Velocity = Beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier });
         }

osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs

@@ -1,6 +1,7 @@
 // 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.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
@@ -12,8 +13,13 @@ namespace osu.Game.Rulesets.UI.Scrolling
 {
     public class ScrollingHitObjectContainer : HitObjectContainer
     {
-        private readonly IBindable<double> timeRange = new BindableDouble();
+        /// <summary>
+        /// A multiplier applied to the length of the scrolling area to determine a safe default lifetime end for hitobjects.
+        /// This is only used to limit the lifetime end within reason, as proper lifetime management should be implemented on hitobjects themselves.
+        /// </summary>
+        private const float safe_lifetime_end_multiplier = 2;
 
+        private readonly IBindable<double> timeRange = new BindableDouble();
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
         [Resolved]
@@ -45,8 +51,13 @@ namespace osu.Game.Rulesets.UI.Scrolling
         public override bool Remove(DrawableHitObject hitObject)
         {
             var result = base.Remove(hitObject);
+
             if (result)
+            {
                 initialStateCache.Invalidate();
+                hitObjectInitialStateCache.Remove(hitObject);
+            }
+
             return result;
         }
 
@@ -81,31 +92,56 @@ namespace osu.Game.Rulesets.UI.Scrolling
                 scrollingInfo.Algorithm.Reset();
 
                 foreach (var obj in Objects)
+                {
+                    computeLifetimeStartRecursive(obj);
                     computeInitialStateRecursive(obj);
+                }
+
                 initialStateCache.Validate();
             }
         }
 
-        private void computeInitialStateRecursive(DrawableHitObject hitObject)
+        private void computeLifetimeStartRecursive(DrawableHitObject hitObject)
         {
             hitObject.LifetimeStart = scrollingInfo.Algorithm.GetDisplayStartTime(hitObject.HitObject.StartTime, timeRange.Value);
 
-            if (hitObject.HitObject is IHasEndTime endTime)
+            foreach (var obj in hitObject.NestedHitObjects)
+                computeLifetimeStartRecursive(obj);
+        }
+
+        private readonly Dictionary<DrawableHitObject, Cached> hitObjectInitialStateCache = new Dictionary<DrawableHitObject, Cached>();
+
+        // Cant use AddOnce() since the delegate is re-constructed every invocation
+        private void computeInitialStateRecursive(DrawableHitObject hitObject) => hitObject.Schedule(() =>
+        {
+            if (!hitObjectInitialStateCache.TryGetValue(hitObject, out var cached))
+                cached = hitObjectInitialStateCache[hitObject] = new Cached();
+
+            if (cached.IsValid)
+                return;
+
+            double endTime = hitObject.HitObject.StartTime;
+
+            if (hitObject.HitObject is IHasEndTime e)
             {
+                endTime = e.EndTime;
+
                 switch (direction.Value)
                 {
                     case ScrollingDirection.Up:
                     case ScrollingDirection.Down:
-                        hitObject.Height = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, timeRange.Value, scrollLength);
+                        hitObject.Height = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime, timeRange.Value, scrollLength);
                         break;
 
                     case ScrollingDirection.Left:
                     case ScrollingDirection.Right:
-                        hitObject.Width = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, timeRange.Value, scrollLength);
+                        hitObject.Width = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime, timeRange.Value, scrollLength);
                         break;
                 }
             }
 
+            hitObject.LifetimeEnd = scrollingInfo.Algorithm.TimeAt(scrollLength * safe_lifetime_end_multiplier, endTime, timeRange.Value, scrollLength);
+
             foreach (var obj in hitObject.NestedHitObjects)
             {
                 computeInitialStateRecursive(obj);
@@ -113,7 +149,9 @@ namespace osu.Game.Rulesets.UI.Scrolling
                 // Nested hitobjects don't need to scroll, but they do need accurate positions
                 updatePosition(obj, hitObject.HitObject.StartTime);
             }
-        }
+
+            cached.Validate();
+        });
 
         protected override void UpdateAfterChildrenLife()
         {

osu.Game/Screens/BackgroundScreen.cs

@@ -11,8 +11,11 @@ namespace osu.Game.Screens
 {
     public abstract class BackgroundScreen : Screen, IEquatable<BackgroundScreen>
     {
-        protected BackgroundScreen()
+        private readonly bool animateOnEnter;
+
+        protected BackgroundScreen(bool animateOnEnter = true)
         {
+            this.animateOnEnter = animateOnEnter;
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
         }
@@ -39,11 +42,14 @@ namespace osu.Game.Screens
 
         public override void OnEntering(IScreen last)
         {
-            this.FadeOut();
-            this.MoveToX(x_movement_amount);
+            if (animateOnEnter)
+            {
+                this.FadeOut();
+                this.MoveToX(x_movement_amount);
 
-            this.FadeIn(transition_length, Easing.InOutQuart);
-            this.MoveToX(0, transition_length, Easing.InOutQuart);
+                this.FadeIn(transition_length, Easing.InOutQuart);
+                this.MoveToX(0, transition_length, Easing.InOutQuart);
+            }
 
             base.OnEntering(last);
         }

osu.Game/Screens/Backgrounds/BackgroundScreenDefault.cs

@@ -25,6 +25,11 @@ namespace osu.Game.Screens.Backgrounds
         private Bindable<User> user;
         private Bindable<Skin> skin;
 
+        public BackgroundScreenDefault(bool animateOnEnter = true)
+            : base(animateOnEnter)
+        {
+        }
+
         [BackgroundDependencyLoader]
         private void load(IAPIProvider api, SkinManager skinManager)
         {

osu.Game/Screens/Edit/BindableBeatDivisor.cs

@@ -4,6 +4,9 @@
 using System;
 using System.Linq;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Colour;
+using osu.Game.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.Edit
 {
@@ -35,5 +38,41 @@ namespace osu.Game.Screens.Edit
         protected override int DefaultMinValue => VALID_DIVISORS.First();
         protected override int DefaultMaxValue => VALID_DIVISORS.Last();
         protected override int DefaultPrecision => 1;
+
+        /// <summary>
+        /// Retrieves the appropriate colour for a beat divisor.
+        /// </summary>
+        /// <param name="beatDivisor">The beat divisor.</param>
+        /// <param name="colours">The set of colours.</param>
+        /// <returns>The applicable colour from <paramref name="colours"/> for <paramref name="beatDivisor"/>.</returns>
+        public static ColourInfo GetColourFor(int beatDivisor, OsuColour colours)
+        {
+            switch (beatDivisor)
+            {
+                case 2:
+                    return colours.BlueLight;
+
+                case 4:
+                    return colours.Blue;
+
+                case 8:
+                    return colours.BlueDarker;
+
+                case 16:
+                    return colours.PurpleDark;
+
+                case 3:
+                    return colours.YellowLight;
+
+                case 6:
+                    return colours.Yellow;
+
+                case 12:
+                    return colours.YellowDarker;
+
+                default:
+                    return Color4.White;
+            }
+        }
     }
 }

osu.Game/Screens/Edit/Components/RadioButtons/DrawableRadioButton.cs

@@ -51,7 +51,7 @@ namespace osu.Game.Screens.Edit.Components.RadioButtons
                 Scale = new Vector2(0.5f),
                 X = 10,
                 Masking = true,
-                Blending = BlendingMode.Additive,
+                Blending = BlendingParameters.Additive,
                 Child = new Box { RelativeSizeAxes = Axes.Both }
             };
         }

osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs

@@ -188,6 +188,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             private Marker marker;
 
+            [Resolved]
+            private OsuColour colours { get; set; }
+
             private readonly BindableBeatDivisor beatDivisor;
             private readonly int[] availableDivisors;
 
@@ -204,11 +207,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
             {
                 foreach (var t in availableDivisors)
                 {
-                    AddInternal(new Tick(t)
+                    AddInternal(new Tick
                     {
                         Anchor = Anchor.TopLeft,
                         Origin = Anchor.TopCentre,
                         RelativePositionAxes = Axes.X,
+                        Colour = BindableBeatDivisor.GetColourFor(t, colours),
                         X = getMappedPosition(t)
                     });
                 }
@@ -284,11 +288,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             private class Tick : CompositeDrawable
             {
-                private readonly int divisor;
-
-                public Tick(int divisor)
+                public Tick()
                 {
-                    this.divisor = divisor;
                     Size = new Vector2(2.5f, 10);
 
                     InternalChild = new Box { RelativeSizeAxes = Axes.Both };
@@ -296,42 +297,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
                     CornerRadius = 0.5f;
                     Masking = true;
                 }
-
-                [BackgroundDependencyLoader]
-                private void load(OsuColour colours)
-                {
-                    Colour = getColourForDivisor(divisor, colours);
-                }
-
-                private ColourInfo getColourForDivisor(int divisor, OsuColour colours)
-                {
-                    switch (divisor)
-                    {
-                        case 2:
-                            return colours.BlueLight;
-
-                        case 4:
-                            return colours.Blue;
-
-                        case 8:
-                            return colours.BlueDarker;
-
-                        case 16:
-                            return colours.PurpleDark;
-
-                        case 3:
-                            return colours.YellowLight;
-
-                        case 6:
-                            return colours.Yellow;
-
-                        case 12:
-                            return colours.YellowDarker;
-
-                        default:
-                            return Color4.White;
-                    }
-                }
             }
 
             private class Marker : CompositeDrawable
@@ -360,7 +325,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                             Origin = Anchor.BottomCentre,
                             Anchor = Anchor.BottomCentre,
                             Colour = ColourInfo.GradientVertical(Color4.White.Opacity(0.2f), Color4.White),
-                            Blending = BlendingMode.Additive,
+                            Blending = BlendingParameters.Additive,
                         },
                         new EquilateralTriangle
                         {

osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs

@@ -11,6 +11,7 @@ using osu.Framework.Input.Events;
 using osu.Framework.Input.States;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Screens.Edit.Compose.Components
@@ -29,6 +30,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [Resolved]
         private HitObjectComposer composer { get; set; }
 
+        [Resolved]
+        private IEditorBeatmap beatmap { get; set; }
+
         public BlueprintContainer()
         {
             RelativeSizeAxes = Axes.Both;
@@ -53,7 +57,15 @@ namespace osu.Game.Screens.Edit.Compose.Components
             };
 
             foreach (var obj in composer.HitObjects)
-                AddBlueprintFor(obj);
+                addBlueprintFor(obj);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            beatmap.HitObjectAdded += addBlueprintFor;
+            beatmap.HitObjectRemoved += removeBlueprintFor;
         }
 
         private HitObjectCompositionTool currentTool;
@@ -75,11 +87,32 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
         }
 
-        /// <summary>
-        /// Adds a blueprint for a <see cref="DrawableHitObject"/> which adds movement support.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to create a blueprint for.</param>
-        public void AddBlueprintFor(DrawableHitObject hitObject)
+        private void addBlueprintFor(HitObject hitObject)
+        {
+            var drawable = composer.HitObjects.FirstOrDefault(d => d.HitObject == hitObject);
+            if (drawable == null)
+                return;
+
+            addBlueprintFor(drawable);
+        }
+
+        private void removeBlueprintFor(HitObject hitObject)
+        {
+            var blueprint = selectionBlueprints.Single(m => m.HitObject.HitObject == hitObject);
+            if (blueprint == null)
+                return;
+
+            blueprint.Deselect();
+
+            blueprint.Selected -= onBlueprintSelected;
+            blueprint.Deselected -= onBlueprintDeselected;
+            blueprint.SelectionRequested -= onSelectionRequested;
+            blueprint.DragRequested -= onDragRequested;
+
+            selectionBlueprints.Remove(blueprint);
+        }
+
+        private void addBlueprintFor(DrawableHitObject hitObject)
         {
             refreshTool();
 
@@ -95,25 +128,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             selectionBlueprints.Add(blueprint);
         }
 
-        /// <summary>
-        /// Removes a blueprint for a <see cref="DrawableHitObject"/>.
-        /// </summary>
-        /// <param name="hitObject">The <see cref="DrawableHitObject"/> for which to remove the blueprint.</param>
-        public void RemoveBlueprintFor(DrawableHitObject hitObject)
-        {
-            var blueprint = selectionBlueprints.Single(m => m.HitObject == hitObject);
-            if (blueprint == null)
-                return;
-
-            blueprint.Deselect();
-
-            blueprint.Selected -= onBlueprintSelected;
-            blueprint.Deselected -= onBlueprintDeselected;
-            blueprint.SelectionRequested -= onSelectionRequested;
-            blueprint.DragRequested -= onDragRequested;
-
-            selectionBlueprints.Remove(blueprint);
-        }
+        private void removeBlueprintFor(DrawableHitObject hitObject) => removeBlueprintFor(hitObject.HitObject);
 
         protected override bool OnClick(ClickEvent e)
         {
@@ -183,6 +198,17 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         private void onDragRequested(SelectionBlueprint blueprint, DragEvent dragEvent) => selectionHandler.HandleDrag(blueprint, dragEvent);
 
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (beatmap != null)
+            {
+                beatmap.HitObjectAdded -= addBlueprintFor;
+                beatmap.HitObjectRemoved -= removeBlueprintFor;
+            }
+        }
+
         private class SelectionBlueprintContainer : Container<SelectionBlueprint>
         {
             protected override int Compare(Drawable x, Drawable y)

osu.Game/Screens/Edit/Compose/ComposeScreen.cs

@@ -9,15 +9,13 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Logging;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK.Graphics;
 
 namespace osu.Game.Screens.Edit.Compose
 {
-    [Cached(Type = typeof(IPlacementHandler))]
-    public class ComposeScreen : EditorScreen, IPlacementHandler
+    public class ComposeScreen : EditorScreen
     {
         private const float vertical_margins = 10;
         private const float horizontal_margins = 20;
@@ -119,13 +117,5 @@ namespace osu.Game.Screens.Edit.Compose
 
             composerContainer.Child = composer;
         }
-
-        public void BeginPlacement(HitObject hitObject)
-        {
-        }
-
-        public void EndPlacement(HitObject hitObject) => composer.Add(hitObject);
-
-        public void Delete(HitObject hitObject) => composer.Remove(hitObject);
     }
 }

osu.Game/Screens/Edit/EditorBeatmap.cs

@@ -0,0 +1,83 @@
+// 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 osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit
+{
+    public class EditorBeatmap<T> : IEditorBeatmap<T>
+        where T : HitObject
+    {
+        public event Action<HitObject> HitObjectAdded;
+        public event Action<HitObject> HitObjectRemoved;
+
+        private readonly Beatmap<T> beatmap;
+
+        public EditorBeatmap(Beatmap<T> beatmap)
+        {
+            this.beatmap = beatmap;
+        }
+
+        public BeatmapInfo BeatmapInfo
+        {
+            get => beatmap.BeatmapInfo;
+            set => beatmap.BeatmapInfo = value;
+        }
+
+        public BeatmapMetadata Metadata => beatmap.Metadata;
+
+        public ControlPointInfo ControlPointInfo => beatmap.ControlPointInfo;
+
+        public List<BreakPeriod> Breaks => beatmap.Breaks;
+
+        public double TotalBreakTime => beatmap.TotalBreakTime;
+
+        IReadOnlyList<T> IBeatmap<T>.HitObjects => beatmap.HitObjects;
+
+        IReadOnlyList<HitObject> IBeatmap.HitObjects => beatmap.HitObjects;
+
+        public IEnumerable<BeatmapStatistic> GetStatistics() => beatmap.GetStatistics();
+
+        public IBeatmap Clone() => (EditorBeatmap<T>)MemberwiseClone();
+
+        /// <summary>
+        /// Adds a <see cref="HitObject"/> to this <see cref="EditorBeatmap{T}"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
+        public void Add(T hitObject)
+        {
+            // Preserve existing sorting order in the beatmap
+            var insertionIndex = beatmap.HitObjects.FindLastIndex(h => h.StartTime <= hitObject.StartTime);
+            beatmap.HitObjects.Insert(insertionIndex + 1, hitObject);
+
+            HitObjectAdded?.Invoke(hitObject);
+        }
+
+        /// <summary>
+        /// Removes a <see cref="HitObject"/> from this <see cref="EditorBeatmap{T}"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
+        public void Remove(T hitObject)
+        {
+            if (beatmap.HitObjects.Remove(hitObject))
+                HitObjectRemoved?.Invoke(hitObject);
+        }
+
+        /// <summary>
+        /// Adds a <see cref="HitObject"/> to this <see cref="EditorBeatmap{T}"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
+        public void Add(HitObject hitObject) => Add((T)hitObject);
+
+        /// <summary>
+        /// Removes a <see cref="HitObject"/> from this <see cref="EditorBeatmap{T}"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to add.</param>
+        public void Remove(HitObject hitObject) => Remove((T)hitObject);
+    }
+}

osu.Game/Screens/Edit/EditorWorkingBeatmap.cs

@@ -0,0 +1,46 @@
+// 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.Collections.Generic;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Skinning;
+using osu.Game.Storyboards;
+
+namespace osu.Game.Screens.Edit
+{
+    /// <summary>
+    /// Encapsulates a <see cref="WorkingBeatmap"/> while providing an overridden <see cref="Beatmap{TObject}"/>.
+    /// </summary>
+    /// <typeparam name="TObject"></typeparam>
+    public class EditorWorkingBeatmap<TObject> : IWorkingBeatmap
+        where TObject : HitObject
+    {
+        private readonly Beatmap<TObject> playableBeatmap;
+        private readonly WorkingBeatmap workingBeatmap;
+
+        public EditorWorkingBeatmap(Beatmap<TObject> playableBeatmap, WorkingBeatmap workingBeatmap)
+        {
+            this.playableBeatmap = playableBeatmap;
+            this.workingBeatmap = workingBeatmap;
+        }
+
+        public IBeatmap Beatmap => workingBeatmap.Beatmap;
+
+        public Texture Background => workingBeatmap.Background;
+
+        public Track Track => workingBeatmap.Track;
+
+        public Waveform Waveform => workingBeatmap.Waveform;
+
+        public Storyboard Storyboard => workingBeatmap.Storyboard;
+
+        public ISkin Skin => workingBeatmap.Skin;
+
+        public IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods) => playableBeatmap;
+    }
+}

osu.Game/Screens/Edit/IEditorBeatmap.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 System;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit
+{
+    /// <summary>
+    /// Interface for the <see cref="IBeatmap"/> contained by the see <see cref="HitObjectComposer"/>.
+    /// Children of <see cref="HitObjectComposer"/> may resolve the beatmap via <see cref="IEditorBeatmap"/> or <see cref="IEditorBeatmap{T}"/>.
+    /// </summary>
+    public interface IEditorBeatmap : IBeatmap
+    {
+        /// <summary>
+        /// Invoked when a <see cref="HitObject"/> is added to this <see cref="IEditorBeatmap"/>.
+        /// </summary>
+        event Action<HitObject> HitObjectAdded;
+
+        /// <summary>
+        /// Invoked when a <see cref="HitObject"/> is removed from this <see cref="IEditorBeatmap"/>.
+        /// </summary>
+        event Action<HitObject> HitObjectRemoved;
+    }
+
+    /// <summary>
+    /// Interface for the <see cref="IBeatmap"/> contained by the see <see cref="HitObjectComposer"/>.
+    /// Children of <see cref="HitObjectComposer"/> may resolve the beatmap via <see cref="IEditorBeatmap"/> or <see cref="IEditorBeatmap{T}"/>.
+    /// </summary>
+    public interface IEditorBeatmap<out T> : IEditorBeatmap, IBeatmap<T>
+        where T : HitObject
+    {
+    }
+}

osu.Game/Screens/Loader.cs

@@ -9,6 +9,8 @@ using osu.Framework.Graphics.Shaders;
 using osu.Game.Screens.Menu;
 using osuTK;
 using osu.Framework.Screens;
+using osu.Game.Configuration;
+using IntroSequence = osu.Game.Configuration.IntroSequence;
 
 namespace osu.Game.Screens
 {
@@ -45,6 +47,8 @@ namespace osu.Game.Screens
         private OsuScreen loadableScreen;
         private ShaderPrecompiler precompiler;
 
+        private IntroSequence introSequence;
+
         protected virtual OsuScreen CreateLoadableScreen()
         {
             if (showDisclaimer)
@@ -53,7 +57,17 @@ namespace osu.Game.Screens
             return getIntroSequence();
         }
 
-        private IntroScreen getIntroSequence() => new IntroCircles();
+        private IntroScreen getIntroSequence()
+        {
+            switch (introSequence)
+            {
+                case IntroSequence.Circles:
+                    return new IntroCircles();
+
+                default:
+                    return new IntroTriangles();
+            }
+        }
 
         protected virtual ShaderPrecompiler CreateShaderPrecompiler() => new ShaderPrecompiler();
 
@@ -79,9 +93,10 @@ namespace osu.Game.Screens
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuGameBase game)
+        private void load(OsuGameBase game, OsuConfigManager config)
         {
             showDisclaimer = game.IsDeployedBuild;
+            introSequence = config.Get<IntroSequence>(OsuSetting.IntroSequence);
         }
 
         /// <summary>

osu.Game/Screens/Menu/Button.cs

@@ -92,7 +92,7 @@ namespace osu.Game.Screens.Menu
                         {
                             EdgeSmoothness = new Vector2(1.5f, 0),
                             RelativeSizeAxes = Axes.Both,
-                            Blending = BlendingMode.Additive,
+                            Blending = BlendingParameters.Additive,
                             Colour = Color4.White,
                             Alpha = 0,
                         },