Merge branch 'master' into ruleset-leaderboard-unavailable

osu.Game.Rulesets.Taiko/Mods/TaikoModDifficultyAdjust.cs

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
         {
             get
             {
-                string scrollSpeed = ScrollSpeed.IsDefault ? string.Empty : $"Scroll x{ScrollSpeed.Value:N1}";
+                string scrollSpeed = ScrollSpeed.IsDefault ? string.Empty : $"Scroll x{ScrollSpeed.Value:N2}";
 
                 return string.Join(", ", new[]
                 {

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

@@ -4,11 +4,9 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit;
-using osu.Game.Screens.Edit.Components.Menus;
 
 namespace osu.Game.Tests.Visual.Editing
 {
@@ -22,7 +20,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("switch between all screens at once", () =>
             {
                 foreach (var screen in Enum.GetValues(typeof(EditorScreenMode)).Cast<EditorScreenMode>())
-                    Editor.ChildrenOfType<EditorMenuBar>().Single().Mode.Value = screen;
+                    Editor.Mode.Value = screen;
             });
         }
     }

osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs

@@ -0,0 +1,74 @@
+// 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 NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Overlays.Settings;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play.PlayerSettings;
+using osu.Game.Tests.Visual.Ranking;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneBeatmapOffsetControl : OsuTestScene
+    {
+        private BeatmapOffsetControl offsetControl;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create control", () =>
+            {
+                Child = new PlayerSettingsGroup("Some settings")
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        offsetControl = new BeatmapOffsetControl()
+                    }
+                };
+            });
+        }
+
+        [Test]
+        public void TestTooShortToDisplay()
+        {
+            AddStep("Set short reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(0, 2)
+                };
+            });
+
+            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
+        }
+
+        [Test]
+        public void TestDisplay()
+        {
+            const double average_error = -4.5;
+
+            AddAssert("Offset is neutral", () => offsetControl.Current.Value == 0);
+            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
+            AddStep("Set reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error)
+                };
+            });
+
+            AddAssert("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+            AddStep("Press button", () => offsetControl.ChildrenOfType<SettingsButton>().Single().TriggerClick());
+            AddAssert("Offset is adjusted", () => offsetControl.Current.Value == -average_error);
+
+            AddAssert("Button is disabled", () => !offsetControl.ChildrenOfType<SettingsButton>().Single().Enabled.Value);
+            AddStep("Remove reference score", () => offsetControl.ReferenceScore.Value = null);
+            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs

@@ -131,9 +131,9 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public double GameplayClockTime => GameplayClockContainer.GameplayClock.CurrentTime;
 
-            protected override void Update()
+            protected override void UpdateAfterChildren()
             {
-                base.Update();
+                base.UpdateAfterChildren();
 
                 if (!FirstFrameClockTime.HasValue)
                 {

osu.Game.Tests/Visual/Ranking/TestSceneHitEventTimingDistributionGraph.cs

@@ -71,16 +71,16 @@ namespace osu.Game.Tests.Visual.Ranking
             };
         });
 
-        public static List<HitEvent> CreateDistributedHitEvents()
+        public static List<HitEvent> CreateDistributedHitEvents(double centre = 0, double range = 25)
         {
             var hitEvents = new List<HitEvent>();
 
-            for (int i = 0; i < 50; i++)
+            for (int i = 0; i < range * 2; i++)
             {
-                int count = (int)(Math.Pow(25 - Math.Abs(i - 25), 2));
+                int count = (int)(Math.Pow(range - Math.Abs(i - range), 2));
 
                 for (int j = 0; j < count; j++)
-                    hitEvents.Add(new HitEvent(i - 25, HitResult.Perfect, new HitCircle(), new HitCircle(), null));
+                    hitEvents.Add(new HitEvent(centre + i - range, HitResult.Perfect, new HitCircle(), new HitCircle(), null));
             }
 
             return hitEvents;

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

@@ -0,0 +1,187 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Taiko;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    [TestFixture]
+    public class TestSceneModColumn : OsuManualInputManagerTestScene
+    {
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Green);
+
+        [TestCase(ModType.DifficultyReduction)]
+        [TestCase(ModType.DifficultyIncrease)]
+        [TestCase(ModType.Conversion)]
+        [TestCase(ModType.Automation)]
+        [TestCase(ModType.Fun)]
+        public void TestBasic(ModType modType)
+        {
+            AddStep("create content", () => Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Padding = new MarginPadding(30),
+                Child = new ModColumn(modType, false)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                }
+            });
+
+            AddStep("change ruleset to osu!", () => Ruleset.Value = new OsuRuleset().RulesetInfo);
+            AddStep("change ruleset to taiko", () => Ruleset.Value = new TaikoRuleset().RulesetInfo);
+            AddStep("change ruleset to catch", () => Ruleset.Value = new CatchRuleset().RulesetInfo);
+            AddStep("change ruleset to mania", () => Ruleset.Value = new ManiaRuleset().RulesetInfo);
+        }
+
+        [Test]
+        public void TestMultiSelection()
+        {
+            ModColumn column = null;
+            AddStep("create content", () => Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Padding = new MarginPadding(30),
+                Child = column = new ModColumn(ModType.DifficultyIncrease, true)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                }
+            });
+
+            AddUntilStep("wait for panel load", () => column.IsLoaded && column.ItemsLoaded);
+
+            clickToggle();
+            AddUntilStep("all panels selected", () => this.ChildrenOfType<ModPanel>().All(panel => panel.Active.Value));
+
+            clickToggle();
+            AddUntilStep("all panels deselected", () => this.ChildrenOfType<ModPanel>().All(panel => !panel.Active.Value));
+
+            AddStep("manually activate all panels", () => this.ChildrenOfType<ModPanel>().ForEach(panel => panel.Active.Value = true));
+            AddUntilStep("checkbox selected", () => this.ChildrenOfType<OsuCheckbox>().Single().Current.Value);
+
+            AddStep("deselect first panel", () => this.ChildrenOfType<ModPanel>().First().Active.Value = false);
+            AddUntilStep("checkbox not selected", () => !this.ChildrenOfType<OsuCheckbox>().Single().Current.Value);
+
+            void clickToggle() => AddStep("click toggle", () =>
+            {
+                var checkbox = this.ChildrenOfType<OsuCheckbox>().Single();
+                InputManager.MoveMouseTo(checkbox);
+                InputManager.Click(MouseButton.Left);
+            });
+        }
+
+        [Test]
+        public void TestFiltering()
+        {
+            TestModColumn column = null;
+
+            AddStep("create content", () => Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Padding = new MarginPadding(30),
+                Child = column = new TestModColumn(ModType.Fun, true)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                }
+            });
+
+            AddStep("set filter", () => column.Filter = mod => mod.Name.Contains("Wind", StringComparison.CurrentCultureIgnoreCase));
+            AddUntilStep("two panels visible", () => column.ChildrenOfType<ModPanel>().Count(panel => !panel.Filtered.Value) == 2);
+
+            clickToggle();
+            AddUntilStep("wait for animation", () => !column.SelectionAnimationRunning);
+            AddAssert("only visible items selected", () => column.ChildrenOfType<ModPanel>().Where(panel => panel.Active.Value).All(panel => !panel.Filtered.Value));
+
+            AddStep("unset filter", () => column.Filter = null);
+            AddUntilStep("all panels visible", () => column.ChildrenOfType<ModPanel>().All(panel => !panel.Filtered.Value));
+            AddAssert("checkbox not selected", () => !column.ChildrenOfType<OsuCheckbox>().Single().Current.Value);
+
+            AddStep("set filter", () => column.Filter = mod => mod.Name.Contains("Wind", StringComparison.CurrentCultureIgnoreCase));
+            AddUntilStep("two panels visible", () => column.ChildrenOfType<ModPanel>().Count(panel => !panel.Filtered.Value) == 2);
+            AddAssert("checkbox selected", () => column.ChildrenOfType<OsuCheckbox>().Single().Current.Value);
+
+            AddStep("filter out everything", () => column.Filter = _ => false);
+            AddUntilStep("no panels visible", () => column.ChildrenOfType<ModPanel>().All(panel => panel.Filtered.Value));
+            AddUntilStep("checkbox hidden", () => !column.ChildrenOfType<OsuCheckbox>().Single().IsPresent);
+
+            AddStep("inset filter", () => column.Filter = null);
+            AddUntilStep("all panels visible", () => column.ChildrenOfType<ModPanel>().All(panel => !panel.Filtered.Value));
+            AddUntilStep("checkbox visible", () => column.ChildrenOfType<OsuCheckbox>().Single().IsPresent);
+
+            void clickToggle() => AddStep("click toggle", () =>
+            {
+                var checkbox = this.ChildrenOfType<OsuCheckbox>().Single();
+                InputManager.MoveMouseTo(checkbox);
+                InputManager.Click(MouseButton.Left);
+            });
+        }
+
+        [Test]
+        public void TestKeyboardSelection()
+        {
+            ModColumn column = null;
+            AddStep("create content", () => Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Padding = new MarginPadding(30),
+                Child = column = new ModColumn(ModType.DifficultyReduction, true, new[] { Key.Q, Key.W, Key.E, Key.R, Key.T, Key.Y, Key.U, Key.I, Key.O, Key.P })
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                }
+            });
+
+            AddUntilStep("wait for panel load", () => column.IsLoaded && column.ItemsLoaded);
+
+            AddStep("press W", () => InputManager.Key(Key.W));
+            AddAssert("NF panel selected", () => this.ChildrenOfType<ModPanel>().Single(panel => panel.Mod.Acronym == "NF").Active.Value);
+
+            AddStep("press W again", () => InputManager.Key(Key.W));
+            AddAssert("NF panel deselected", () => !this.ChildrenOfType<ModPanel>().Single(panel => panel.Mod.Acronym == "NF").Active.Value);
+
+            AddStep("set filter to NF", () => column.Filter = mod => mod.Acronym == "NF");
+
+            AddStep("press W", () => InputManager.Key(Key.W));
+            AddAssert("NF panel selected", () => this.ChildrenOfType<ModPanel>().Single(panel => panel.Mod.Acronym == "NF").Active.Value);
+
+            AddStep("press W again", () => InputManager.Key(Key.W));
+            AddAssert("NF panel deselected", () => !this.ChildrenOfType<ModPanel>().Single(panel => panel.Mod.Acronym == "NF").Active.Value);
+
+            AddStep("filter out everything", () => column.Filter = _ => false);
+
+            AddStep("press W", () => InputManager.Key(Key.W));
+            AddAssert("NF panel not selected", () => !this.ChildrenOfType<ModPanel>().Single(panel => panel.Mod.Acronym == "NF").Active.Value);
+
+            AddStep("clear filter", () => column.Filter = null);
+        }
+
+        private class TestModColumn : ModColumn
+        {
+            public new bool SelectionAnimationRunning => base.SelectionAnimationRunning;
+
+            public TestModColumn(ModType modType, bool allowBulkSelection)
+                : base(modType, allowBulkSelection)
+            {
+            }
+        }
+    }
+}

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -40,6 +40,8 @@ namespace osu.Game.Beatmaps
         [Backlink(nameof(ScoreInfo.BeatmapInfo))]
         public IQueryable<ScoreInfo> Scores { get; } = null!;
 
+        public BeatmapUserSettings UserSettings { get; set; } = null!;
+
         public BeatmapInfo(RulesetInfo? ruleset = null, BeatmapDifficulty? difficulty = null, BeatmapMetadata? metadata = null)
         {
             ID = Guid.NewGuid();
@@ -51,6 +53,7 @@ namespace osu.Game.Beatmaps
             };
             Difficulty = difficulty ?? new BeatmapDifficulty();
             Metadata = metadata ?? new BeatmapMetadata();
+            UserSettings = new BeatmapUserSettings();
         }
 
         [UsedImplicitly]

osu.Game/Beatmaps/BeatmapUserSettings.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+using Realms;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// User settings overrides that are attached to a beatmap.
+    /// </summary>
+    public class BeatmapUserSettings : EmbeddedObject
+    {
+        /// <summary>
+        /// An audio offset that can be used for timing adjustments.
+        /// </summary>
+        public double Offset { get; set; }
+    }
+}

osu.Game/Database/RealmAccess.cs

@@ -54,8 +54,9 @@ namespace osu.Game.Database
         /// 11   2021-11-22    Use ShortName instead of RulesetID for ruleset key bindings.
         /// 12   2021-11-24    Add Status to RealmBeatmapSet.
         /// 13   2022-01-13    Final migration of beatmaps and scores to realm (multiple new storage fields).
+        /// 14   2022-03-01    Added BeatmapUserSettings to BeatmapInfo.
         /// </summary>
-        private const int schema_version = 13;
+        private const int schema_version = 14;
 
         /// <summary>
         /// Lock object which is held during <see cref="BlockAllOperations"/> sections, blocking realm retrieval during blocking periods.
@@ -564,6 +565,11 @@ namespace osu.Game.Database
                     }
 
                     break;
+
+                case 14:
+                    foreach (var beatmap in migration.NewRealm.All<BeatmapInfo>())
+                        beatmap.UserSettings = new BeatmapUserSettings();
+                    break;
             }
         }
 

osu.Game/Database/RealmObjectExtensions.cs

@@ -38,6 +38,7 @@ namespace osu.Game.Database
             c.CreateMap<BeatmapInfo, BeatmapInfo>()
              .ForMember(s => s.Ruleset, cc => cc.Ignore())
              .ForMember(s => s.Metadata, cc => cc.Ignore())
+             .ForMember(s => s.UserSettings, cc => cc.Ignore())
              .ForMember(s => s.Difficulty, cc => cc.Ignore())
              .ForMember(s => s.BeatmapSet, cc => cc.Ignore())
              .AfterMap((s, d) =>
@@ -154,6 +155,7 @@ namespace osu.Game.Database
 
             c.CreateMap<RealmKeyBinding, RealmKeyBinding>();
             c.CreateMap<BeatmapMetadata, BeatmapMetadata>();
+            c.CreateMap<BeatmapUserSettings, BeatmapUserSettings>();
             c.CreateMap<BeatmapDifficulty, BeatmapDifficulty>();
             c.CreateMap<RulesetInfo, RulesetInfo>();
             c.CreateMap<ScoreInfo, ScoreInfo>();

osu.Game/Localisation/BeatmapOffsetControlStrings.cs

@@ -0,0 +1,34 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Localisation;
+
+namespace osu.Game.Localisation
+{
+    public static class BeatmapOffsetControlStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.BeatmapOffsetControl";
+
+        /// <summary>
+        /// "Beatmap offset"
+        /// </summary>
+        public static LocalisableString BeatmapOffset => new TranslatableString(getKey(@"beatmap_offset"), @"Beatmap offset");
+
+        /// <summary>
+        /// "Previous play:"
+        /// </summary>
+        public static LocalisableString PreviousPlay => new TranslatableString(getKey(@"previous_play"), @"Previous play:");
+
+        /// <summary>
+        /// "Previous play too short to use for calibration"
+        /// </summary>
+        public static LocalisableString PreviousPlayTooShortToUseForCalibration => new TranslatableString(getKey(@"previous_play_too_short_to_use_for_calibration"), @"Previous play too short to use for calibration");
+
+        /// <summary>
+        /// "Calibrate using last play"
+        /// </summary>
+        public static LocalisableString CalibrateUsingLastPlay => new TranslatableString(getKey(@"calibrate_using_last_play"), @"Calibrate using last play");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}

osu.Game/Overlays/Mods/ModColumn.cs

@@ -0,0 +1,426 @@
+// 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;
+using System.Threading.Tasks;
+using Humanizer;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+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.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Utils;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+
+#nullable enable
+
+namespace osu.Game.Overlays.Mods
+{
+    public class ModColumn : CompositeDrawable
+    {
+        private Func<Mod, bool>? filter;
+
+        /// <summary>
+        /// Function determining whether each mod in the column should be displayed.
+        /// A return value of <see langword="true"/> means that the mod is not filtered and therefore its corresponding panel should be displayed.
+        /// A return value of <see langword="false"/> means that the mod is filtered out and therefore its corresponding panel should be hidden.
+        /// </summary>
+        public Func<Mod, bool>? Filter
+        {
+            get => filter;
+            set
+            {
+                filter = value;
+                updateFilter();
+            }
+        }
+
+        private readonly ModType modType;
+        private readonly Key[]? toggleKeys;
+
+        private readonly Bindable<Dictionary<ModType, IReadOnlyList<Mod>>> availableMods = new Bindable<Dictionary<ModType, IReadOnlyList<Mod>>>();
+
+        private readonly TextFlowContainer headerText;
+        private readonly Box headerBackground;
+        private readonly Container contentContainer;
+        private readonly Box contentBackground;
+        private readonly FillFlowContainer<ModPanel> panelFlow;
+        private readonly ToggleAllCheckbox? toggleAllCheckbox;
+
+        private Colour4 accentColour;
+
+        private Task? latestLoadTask;
+        internal bool ItemsLoaded => latestLoadTask == null;
+
+        private const float header_height = 42;
+
+        public ModColumn(ModType modType, bool allowBulkSelection, Key[]? toggleKeys = null)
+        {
+            this.modType = modType;
+            this.toggleKeys = toggleKeys;
+
+            Width = 320;
+            RelativeSizeAxes = Axes.Y;
+            Shear = new Vector2(ModPanel.SHEAR_X, 0);
+            CornerRadius = ModPanel.CORNER_RADIUS;
+            Masking = true;
+
+            Container controlContainer;
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = header_height + ModPanel.CORNER_RADIUS,
+                    Children = new Drawable[]
+                    {
+                        headerBackground = new Box
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Height = header_height + ModPanel.CORNER_RADIUS
+                        },
+                        headerText = new OsuTextFlowContainer(t =>
+                        {
+                            t.Font = OsuFont.TorusAlternate.With(size: 17);
+                            t.Shadow = false;
+                            t.Colour = Colour4.Black;
+                        })
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Shear = new Vector2(-ModPanel.SHEAR_X, 0),
+                            Padding = new MarginPadding
+                            {
+                                Horizontal = 17,
+                                Bottom = ModPanel.CORNER_RADIUS
+                            }
+                        }
+                    }
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = header_height },
+                    Child = contentContainer = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        CornerRadius = ModPanel.CORNER_RADIUS,
+                        BorderThickness = 3,
+                        Children = new Drawable[]
+                        {
+                            contentBackground = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both
+                            },
+                            new GridContainer
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                RowDimensions = new[]
+                                {
+                                    new Dimension(GridSizeMode.AutoSize),
+                                    new Dimension()
+                                },
+                                Content = new[]
+                                {
+                                    new Drawable[]
+                                    {
+                                        controlContainer = new Container
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+                                            Padding = new MarginPadding { Horizontal = 14 }
+                                        }
+                                    },
+                                    new Drawable[]
+                                    {
+                                        new OsuScrollContainer
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            ScrollbarOverlapsContent = false,
+                                            Child = panelFlow = new FillFlowContainer<ModPanel>
+                                            {
+                                                RelativeSizeAxes = Axes.X,
+                                                AutoSizeAxes = Axes.Y,
+                                                Spacing = new Vector2(0, 7),
+                                                Padding = new MarginPadding(7)
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            createHeaderText();
+
+            if (allowBulkSelection)
+            {
+                controlContainer.Height = 35;
+                controlContainer.Add(toggleAllCheckbox = new ToggleAllCheckbox(this)
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Scale = new Vector2(0.8f),
+                    RelativeSizeAxes = Axes.X,
+                    LabelText = "Enable All",
+                    Shear = new Vector2(-ModPanel.SHEAR_X, 0)
+                });
+                panelFlow.Padding = new MarginPadding
+                {
+                    Top = 0,
+                    Bottom = 7,
+                    Horizontal = 7
+                };
+            }
+        }
+
+        private void createHeaderText()
+        {
+            IEnumerable<string> headerTextWords = modType.Humanize(LetterCasing.Title).Split(' ');
+
+            if (headerTextWords.Count() > 1)
+            {
+                headerText.AddText($"{headerTextWords.First()} ", t => t.Font = t.Font.With(weight: FontWeight.SemiBold));
+                headerTextWords = headerTextWords.Skip(1);
+            }
+
+            headerText.AddText(string.Join(' ', headerTextWords));
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGameBase game, OverlayColourProvider colourProvider, OsuColour colours)
+        {
+            availableMods.BindTo(game.AvailableMods);
+
+            headerBackground.Colour = accentColour = colours.ForModType(modType);
+
+            if (toggleAllCheckbox != null)
+            {
+                toggleAllCheckbox.AccentColour = accentColour;
+                toggleAllCheckbox.AccentHoverColour = accentColour.Lighten(0.3f);
+            }
+
+            contentContainer.BorderColour = ColourInfo.GradientVertical(colourProvider.Background4, colourProvider.Background3);
+            contentBackground.Colour = colourProvider.Background4;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            availableMods.BindValueChanged(_ => Scheduler.AddOnce(updateMods));
+            updateMods();
+        }
+
+        private CancellationTokenSource? cancellationTokenSource;
+
+        private void updateMods()
+        {
+            var newMods = ModUtils.FlattenMods(availableMods.Value.GetValueOrDefault(modType) ?? Array.Empty<Mod>()).ToList();
+
+            if (newMods.SequenceEqual(panelFlow.Children.Select(p => p.Mod)))
+                return;
+
+            cancellationTokenSource?.Cancel();
+
+            var panels = newMods.Select(mod => new ModPanel(mod)
+            {
+                Shear = new Vector2(-ModPanel.SHEAR_X, 0)
+            });
+
+            Task? loadTask;
+
+            latestLoadTask = loadTask = LoadComponentsAsync(panels, loaded =>
+            {
+                panelFlow.ChildrenEnumerable = loaded;
+
+                foreach (var panel in panelFlow)
+                    panel.Active.BindValueChanged(_ => updateToggleState());
+                updateToggleState();
+
+                updateFilter();
+            }, (cancellationTokenSource = new CancellationTokenSource()).Token);
+            loadTask.ContinueWith(_ =>
+            {
+                if (loadTask == latestLoadTask)
+                    latestLoadTask = null;
+            });
+        }
+
+        #region Bulk select / deselect
+
+        private const double initial_multiple_selection_delay = 120;
+
+        private double selectionDelay = initial_multiple_selection_delay;
+        private double lastSelection;
+
+        private readonly Queue<Action> pendingSelectionOperations = new Queue<Action>();
+
+        protected bool SelectionAnimationRunning => pendingSelectionOperations.Count > 0;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (selectionDelay == initial_multiple_selection_delay || Time.Current - lastSelection >= selectionDelay)
+            {
+                if (pendingSelectionOperations.TryDequeue(out var dequeuedAction))
+                {
+                    dequeuedAction();
+
+                    // each time we play an animation, we decrease the time until the next animation (to ramp the visual and audible elements).
+                    selectionDelay = Math.Max(30, selectionDelay * 0.8f);
+                    lastSelection = Time.Current;
+                }
+                else
+                {
+                    // reset the selection delay after all animations have been completed.
+                    // this will cause the next action to be immediately performed.
+                    selectionDelay = initial_multiple_selection_delay;
+                }
+            }
+        }
+
+        private void updateToggleState()
+        {
+            if (toggleAllCheckbox != null && !SelectionAnimationRunning)
+            {
+                toggleAllCheckbox.Alpha = panelFlow.Any(panel => !panel.Filtered.Value) ? 1 : 0;
+                toggleAllCheckbox.Current.Value = panelFlow.Where(panel => !panel.Filtered.Value).All(panel => panel.Active.Value);
+            }
+        }
+
+        /// <summary>
+        /// Selects all mods.
+        /// </summary>
+        public void SelectAll()
+        {
+            pendingSelectionOperations.Clear();
+
+            foreach (var button in panelFlow.Where(b => !b.Active.Value && !b.Filtered.Value))
+                pendingSelectionOperations.Enqueue(() => button.Active.Value = true);
+        }
+
+        /// <summary>
+        /// Deselects all mods.
+        /// </summary>
+        public void DeselectAll()
+        {
+            pendingSelectionOperations.Clear();
+
+            foreach (var button in panelFlow.Where(b => b.Active.Value && !b.Filtered.Value))
+                pendingSelectionOperations.Enqueue(() => button.Active.Value = false);
+        }
+
+        private class ToggleAllCheckbox : OsuCheckbox
+        {
+            private Color4 accentColour;
+
+            public Color4 AccentColour
+            {
+                get => accentColour;
+                set
+                {
+                    accentColour = value;
+                    updateState();
+                }
+            }
+
+            private Color4 accentHoverColour;
+
+            public Color4 AccentHoverColour
+            {
+                get => accentHoverColour;
+                set
+                {
+                    accentHoverColour = value;
+                    updateState();
+                }
+            }
+
+            private readonly ModColumn column;
+
+            public ToggleAllCheckbox(ModColumn column)
+                : base(false)
+            {
+                this.column = column;
+            }
+
+            protected override void ApplyLabelParameters(SpriteText text)
+            {
+                base.ApplyLabelParameters(text);
+                text.Font = text.Font.With(weight: FontWeight.SemiBold);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                updateState();
+            }
+
+            private void updateState()
+            {
+                Nub.AccentColour = AccentColour;
+                Nub.GlowingAccentColour = AccentHoverColour;
+                Nub.GlowColour = AccentHoverColour.Opacity(0.2f);
+            }
+
+            protected override void OnUserChange(bool value)
+            {
+                if (value)
+                    column.SelectAll();
+                else
+                    column.DeselectAll();
+            }
+        }
+
+        #endregion
+
+        #region Filtering support
+
+        private void updateFilter()
+        {
+            foreach (var modPanel in panelFlow)
+                modPanel.ApplyFilter(Filter);
+
+            updateToggleState();
+        }
+
+        #endregion
+
+        #region Keyboard selection support
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.ControlPressed || e.AltPressed) return false;
+            if (toggleKeys == null) return false;
+
+            int index = Array.IndexOf(toggleKeys, e.Key);
+            if (index < 0) return false;
+
+            var panel = panelFlow.ElementAtOrDefault(index);
+            if (panel == null || panel.Filtered.Value) return false;
+
+            panel.Active.Toggle();
+            return true;
+        }
+
+        #endregion
+    }
+}

osu.Game/Overlays/Mods/ModPanel.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;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -28,6 +29,7 @@ namespace osu.Game.Overlays.Mods
     {
         public Mod Mod { get; }
         public BindableBool Active { get; } = new BindableBool();
+        public BindableBool Filtered { get; } = new BindableBool();
 
         protected readonly Box Background;
         protected readonly Container SwitchContainer;
@@ -40,10 +42,10 @@ namespace osu.Game.Overlays.Mods
 
         protected const double TRANSITION_DURATION = 150;
 
-        protected const float SHEAR_X = 0.2f;
+        public const float SHEAR_X = 0.2f;
+        public const float CORNER_RADIUS = 7;
 
         protected const float HEIGHT = 42;
-        protected const float CORNER_RADIUS = 7;
         protected const float IDLE_SWITCH_WIDTH = 54;
         protected const float EXPANDED_SWITCH_WIDTH = 70;
 
@@ -157,6 +159,7 @@ namespace osu.Game.Overlays.Mods
                 playStateChangeSamples();
                 UpdateState();
             });
+            Filtered.BindValueChanged(_ => updateFilterState());
 
             UpdateState();
             FinishTransforms(true);
@@ -190,7 +193,7 @@ namespace osu.Game.Overlays.Mods
                 mouseDown = true;
 
             UpdateState();
-            return true;
+            return false;
         }
 
         protected override void OnMouseUp(MouseUpEvent e)
@@ -235,5 +238,19 @@ namespace osu.Game.Overlays.Mods
             TextBackground.FadeColour(textBackgroundColour, transitionDuration, Easing.OutQuint);
             TextFlow.FadeColour(textColour, transitionDuration, Easing.OutQuint);
         }
+
+        #region Filtering support
+
+        public void ApplyFilter(Func<Mod, bool>? filter)
+        {
+            Filtered.Value = filter != null && !filter.Invoke(Mod);
+        }
+
+        private void updateFilterState()
+        {
+            this.FadeTo(Filtered.Value ? 0 : 1);
+        }
+
+        #endregion
     }
 }

osu.Game/Rulesets/Scoring/HitEventExtensions.cs

@@ -29,8 +29,15 @@ namespace osu.Game.Rulesets.Scoring
         /// A non-null <see langword="double"/> value if unstable rate could be calculated,
         /// and <see langword="null"/> if unstable rate cannot be calculated due to <paramref name="hitEvents"/> being empty.
         /// </returns>
-        public static double? CalculateAverageHitError(this IEnumerable<HitEvent> hitEvents) =>
+        public static double? CalculateAverageHitError(this IEnumerable<HitEvent> hitEvents)
-            hitEvents.Where(affectsUnstableRate).Select(ev => ev.TimeOffset).Average();
+        {
+            double[] timeOffsets = hitEvents.Where(affectsUnstableRate).Select(ev => ev.TimeOffset).ToArray();
+
+            if (timeOffsets.Length == 0)
+                return null;
+
+            return timeOffsets.Average();
+        }
 
         private static bool affectsUnstableRate(HitEvent e) => !(e.HitObject.HitWindows is HitWindows.EmptyHitWindows) && e.Result.IsHit();
 

osu.Game/Scoring/Legacy/LegacyScoreEncoder.cs

@@ -8,9 +8,14 @@ using System.Text;
 using osu.Framework.Extensions;
 using osu.Game.Beatmaps;
 using osu.Game.IO.Legacy;
+using osu.Game.Replays.Legacy;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using SharpCompress.Compressors.LZMA;
 
+#nullable enable
+
 namespace osu.Game.Scoring.Legacy
 {
     public class LegacyScoreEncoder
@@ -27,15 +32,24 @@ namespace osu.Game.Scoring.Legacy
         public const int FIRST_LAZER_VERSION = 30000000;
 
         private readonly Score score;
-        private readonly IBeatmap beatmap;
+        private readonly IBeatmap? beatmap;
 
-        public LegacyScoreEncoder(Score score, IBeatmap beatmap)
+        /// <summary>
+        /// Create a new score encoder for a specific score.
+        /// </summary>
+        /// <param name="score">The score to be encoded.</param>
+        /// <param name="beatmap">The beatmap used to convert frames for the score. May be null if the frames are already <see cref="LegacyReplayFrame"/>s.</param>
+        /// <exception cref="ArgumentException"></exception>
+        public LegacyScoreEncoder(Score score, IBeatmap? beatmap)
         {
             this.score = score;
             this.beatmap = beatmap;
 
-            if (score.ScoreInfo.BeatmapInfo.Ruleset.OnlineID < 0 || score.ScoreInfo.BeatmapInfo.Ruleset.OnlineID > 3)
+            if (beatmap == null && !score.Replay.Frames.All(f => f is LegacyReplayFrame))
-                throw new ArgumentException("Only scores in the osu, taiko, catch, or mania rulesets can be encoded to the legacy score format.", nameof(score));
+                throw new ArgumentException(@"Beatmap must be provided if frames are not already legacy frames.", nameof(beatmap));
+
+            if (score.ScoreInfo.Ruleset.OnlineID < 0 || score.ScoreInfo.Ruleset.OnlineID > ILegacyRuleset.MAX_LEGACY_RULESET_ID)
+                throw new ArgumentException(@"Only scores in the osu, taiko, catch, or mania rulesets can be encoded to the legacy score format.", nameof(score));
         }
 
         public void Encode(Stream stream)
@@ -101,11 +115,13 @@ namespace osu.Game.Scoring.Legacy
                 {
                     int lastTime = 0;
 
-                    foreach (var f in score.Replay.Frames.OfType<IConvertibleReplayFrame>().Select(f => f.ToLegacy(beatmap)))
+                    foreach (var f in score.Replay.Frames)
                     {
+                        var legacyFrame = getLegacyFrame(f);
+
                         // Rounding because stable could only parse integral values
-                        int time = (int)Math.Round(f.Time);
+                        int time = (int)Math.Round(legacyFrame.Time);
-                        replayData.Append(FormattableString.Invariant($"{time - lastTime}|{f.MouseX ?? 0}|{f.MouseY ?? 0}|{(int)f.ButtonState},"));
+                        replayData.Append(FormattableString.Invariant($"{time - lastTime}|{legacyFrame.MouseX ?? 0}|{legacyFrame.MouseY ?? 0}|{(int)legacyFrame.ButtonState},"));
                         lastTime = time;
                     }
                 }
@@ -117,6 +133,21 @@ namespace osu.Game.Scoring.Legacy
             }
         }
 
+        private LegacyReplayFrame getLegacyFrame(ReplayFrame replayFrame)
+        {
+            switch (replayFrame)
+            {
+                case LegacyReplayFrame legacyFrame:
+                    return legacyFrame;
+
+                case IConvertibleReplayFrame convertibleFrame:
+                    return convertibleFrame.ToLegacy(beatmap);
+
+                default:
+                    throw new ArgumentException(@"Frame could not be converted to legacy frames", nameof(replayFrame));
+            }
+        }
+
         private string getHpGraphFormatted()
         {
             // todo: implement, maybe?

osu.Game/Screens/Edit/Components/Menus/EditorMenuBar.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -18,8 +17,6 @@ namespace osu.Game.Screens.Edit.Components.Menus
 {
     public class EditorMenuBar : OsuMenu
     {
-        public readonly Bindable<EditorScreenMode> Mode = new Bindable<EditorScreenMode>();
-
         public EditorMenuBar()
             : base(Direction.Horizontal, true)
         {
@@ -28,25 +25,6 @@ namespace osu.Game.Screens.Edit.Components.Menus
             MaskingContainer.CornerRadius = 0;
             ItemsContainer.Padding = new MarginPadding { Left = 100 };
             BackgroundColour = Color4Extensions.FromHex("111");
-
-            ScreenSelectionTabControl tabControl;
-            AddRangeInternal(new Drawable[]
-            {
-                tabControl = new ScreenSelectionTabControl
-                {
-                    Anchor = Anchor.BottomRight,
-                    Origin = Anchor.BottomRight,
-                    X = -15
-                }
-            });
-
-            Mode.BindTo(tabControl.Current);
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            Mode.TriggerChange();
         }
 
         protected override Framework.Graphics.UserInterface.Menu CreateSubMenu() => new SubMenu();

osu.Game/Screens/Edit/Editor.cs

@@ -89,6 +89,8 @@ namespace osu.Game.Screens.Edit
         [Resolved(canBeNull: true)]
         private NotificationOverlay notifications { get; set; }
 
+        public readonly Bindable<EditorScreenMode> Mode = new Bindable<EditorScreenMode>();
+
         public IBindable<bool> SamplePlaybackDisabled => samplePlaybackDisabled;
 
         private readonly Bindable<bool> samplePlaybackDisabled = new Bindable<bool>();
@@ -115,8 +117,6 @@ namespace osu.Game.Screens.Edit
         [CanBeNull] // Should be non-null once it can support custom rulesets.
         private EditorChangeHandler changeHandler;
 
-        private EditorMenuBar menuBar;
-
         private DependencyContainer dependencies;
 
         private TestGameplayButton testGameplayButton;
@@ -239,40 +239,49 @@ namespace osu.Game.Screens.Edit
                         Name = "Top bar",
                         RelativeSizeAxes = Axes.X,
                         Height = 40,
-                        Child = menuBar = new EditorMenuBar
+                        Children = new Drawable[]
                         {
-                            Anchor = Anchor.CentreLeft,
+                            new EditorMenuBar
-                            Origin = Anchor.CentreLeft,
-                            RelativeSizeAxes = Axes.Both,
-                            Mode = { Value = isNewBeatmap ? EditorScreenMode.SongSetup : EditorScreenMode.Compose },
-                            Items = new[]
                             {
-                                new MenuItem("File")
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                RelativeSizeAxes = Axes.Both,
+                                Items = new[]
                                 {
-                                    Items = createFileMenuItems()
+                                    new MenuItem("File")
-                                },
-                                new MenuItem("Edit")
-                                {
-                                    Items = new[]
                                     {
-                                        undoMenuItem = new EditorMenuItem("Undo", MenuItemType.Standard, Undo),
+                                        Items = createFileMenuItems()
-                                        redoMenuItem = new EditorMenuItem("Redo", MenuItemType.Standard, Redo),
+                                    },
-                                        new EditorMenuItemSpacer(),
+                                    new MenuItem("Edit")
-                                        cutMenuItem = new EditorMenuItem("Cut", MenuItemType.Standard, Cut),
-                                        copyMenuItem = new EditorMenuItem("Copy", MenuItemType.Standard, Copy),
-                                        pasteMenuItem = new EditorMenuItem("Paste", MenuItemType.Standard, Paste),
-                                    }
-                                },
-                                new MenuItem("View")
-                                {
-                                    Items = new MenuItem[]
                                     {
-                                        new WaveformOpacityMenuItem(config.GetBindable<float>(OsuSetting.EditorWaveformOpacity)),
+                                        Items = new[]
-                                        new HitAnimationsMenuItem(config.GetBindable<bool>(OsuSetting.EditorHitAnimations))
+                                        {
+                                            undoMenuItem = new EditorMenuItem("Undo", MenuItemType.Standard, Undo),
+                                            redoMenuItem = new EditorMenuItem("Redo", MenuItemType.Standard, Redo),
+                                            new EditorMenuItemSpacer(),
+                                            cutMenuItem = new EditorMenuItem("Cut", MenuItemType.Standard, Cut),
+                                            copyMenuItem = new EditorMenuItem("Copy", MenuItemType.Standard, Copy),
+                                            pasteMenuItem = new EditorMenuItem("Paste", MenuItemType.Standard, Paste),
+                                        }
+                                    },
+                                    new MenuItem("View")
+                                    {
+                                        Items = new MenuItem[]
+                                        {
+                                            new WaveformOpacityMenuItem(config.GetBindable<float>(OsuSetting.EditorWaveformOpacity)),
+                                            new HitAnimationsMenuItem(config.GetBindable<bool>(OsuSetting.EditorHitAnimations))
+                                        }
                                     }
                                 }
-                            }
+                            },
-                        }
+                            new ScreenSelectionTabControl
+                            {
+                                Anchor = Anchor.BottomRight,
+                                Origin = Anchor.BottomRight,
+                                X = -15,
+                                Current = Mode,
+                            },
+                        },
                     },
                     new Container
                     {
@@ -340,14 +349,15 @@ namespace osu.Game.Screens.Edit
 
             changeHandler?.CanUndo.BindValueChanged(v => undoMenuItem.Action.Disabled = !v.NewValue, true);
             changeHandler?.CanRedo.BindValueChanged(v => redoMenuItem.Action.Disabled = !v.NewValue, true);
-
-            menuBar.Mode.ValueChanged += onModeChanged;
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
             setUpClipboardActionAvailability();
+
+            Mode.Value = isNewBeatmap ? EditorScreenMode.SongSetup : EditorScreenMode.Compose;
+            Mode.BindValueChanged(onModeChanged, true);
         }
 
         /// <summary>
@@ -517,23 +527,23 @@ namespace osu.Game.Screens.Edit
                     return true;
 
                 case GlobalAction.EditorComposeMode:
-                    menuBar.Mode.Value = EditorScreenMode.Compose;
+                    Mode.Value = EditorScreenMode.Compose;
                     return true;
 
                 case GlobalAction.EditorDesignMode:
-                    menuBar.Mode.Value = EditorScreenMode.Design;
+                    Mode.Value = EditorScreenMode.Design;
                     return true;
 
                 case GlobalAction.EditorTimingMode:
-                    menuBar.Mode.Value = EditorScreenMode.Timing;
+                    Mode.Value = EditorScreenMode.Timing;
                     return true;
 
                 case GlobalAction.EditorSetupMode:
-                    menuBar.Mode.Value = EditorScreenMode.SongSetup;
+                    Mode.Value = EditorScreenMode.SongSetup;
                     return true;
 
                 case GlobalAction.EditorVerifyMode:
-                    menuBar.Mode.Value = EditorScreenMode.Verify;
+                    Mode.Value = EditorScreenMode.Verify;
                     return true;
 
                 case GlobalAction.EditorTestGameplay:

osu.Game/Screens/Play/MasterGameplayClockContainer.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using osu.Framework;
 using osu.Framework.Allocation;
@@ -13,6 +14,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Database;
 
 namespace osu.Game.Screens.Play
 {
@@ -43,7 +45,7 @@ namespace osu.Game.Screens.Play
             Precision = 0.1,
         };
 
-        private double totalAppliedOffset => userOffsetClock.RateAdjustedOffset + platformOffsetClock.RateAdjustedOffset;
+        private double totalAppliedOffset => userBeatmapOffsetClock.RateAdjustedOffset + userGlobalOffsetClock.RateAdjustedOffset + platformOffsetClock.RateAdjustedOffset;
 
         private readonly BindableDouble pauseFreqAdjust = new BindableDouble(1);
 
@@ -52,12 +54,21 @@ namespace osu.Game.Screens.Play
         private readonly bool startAtGameplayStart;
         private readonly double firstHitObjectTime;
 
-        private HardwareCorrectionOffsetClock userOffsetClock;
+        private HardwareCorrectionOffsetClock userGlobalOffsetClock;
+        private HardwareCorrectionOffsetClock userBeatmapOffsetClock;
         private HardwareCorrectionOffsetClock platformOffsetClock;
         private MasterGameplayClock masterGameplayClock;
         private Bindable<double> userAudioOffset;
         private double startOffset;
 
+        private IDisposable beatmapOffsetSubscription;
+
+        [Resolved]
+        private RealmAccess realm { get; set; }
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
         public MasterGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStartTime, bool startAtGameplayStart = false)
             : base(beatmap.Track)
         {
@@ -68,11 +79,33 @@ namespace osu.Game.Screens.Play
             firstHitObjectTime = beatmap.Beatmap.HitObjects.First().StartTime;
         }
 
-        [BackgroundDependencyLoader]
+        protected override void LoadComplete()
-        private void load(OsuConfigManager config)
         {
+            base.LoadComplete();
+
             userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
-            userAudioOffset.BindValueChanged(offset => userOffsetClock.Offset = offset.NewValue, true);
+            userAudioOffset.BindValueChanged(offset => userGlobalOffsetClock.Offset = offset.NewValue, true);
+
+            beatmapOffsetSubscription = realm.RegisterCustomSubscription(r =>
+            {
+                var userSettings = r.Find<BeatmapInfo>(beatmap.BeatmapInfo.ID)?.UserSettings;
+
+                if (userSettings == null) // only the case for tests.
+                    return null;
+
+                void onUserSettingsOnPropertyChanged(object sender, PropertyChangedEventArgs args)
+                {
+                    if (args.PropertyName == nameof(BeatmapUserSettings.Offset))
+                        updateOffset();
+                }
+
+                updateOffset();
+                userSettings.PropertyChanged += onUserSettingsOnPropertyChanged;
+
+                return new InvokeOnDisposal(() => userSettings.PropertyChanged -= onUserSettingsOnPropertyChanged);
+
+                void updateOffset() => userBeatmapOffsetClock.Offset = userSettings.Offset;
+            });
 
             // sane default provided by ruleset.
             startOffset = gameplayStartTime;
@@ -161,9 +194,10 @@ namespace osu.Game.Screens.Play
             platformOffsetClock = new HardwareCorrectionOffsetClock(source, pauseFreqAdjust) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
 
             // the final usable gameplay clock with user-set offsets applied.
-            userOffsetClock = new HardwareCorrectionOffsetClock(platformOffsetClock, pauseFreqAdjust);
+            userGlobalOffsetClock = new HardwareCorrectionOffsetClock(platformOffsetClock, pauseFreqAdjust);
+            userBeatmapOffsetClock = new HardwareCorrectionOffsetClock(userGlobalOffsetClock, pauseFreqAdjust);
 
-            return masterGameplayClock = new MasterGameplayClock(userOffsetClock);
+            return masterGameplayClock = new MasterGameplayClock(userBeatmapOffsetClock);
         }
 
         /// <summary>
@@ -209,6 +243,7 @@ namespace osu.Game.Screens.Play
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
+            beatmapOffsetSubscription?.Dispose();
             removeSourceClockAdjustments();
         }
 

osu.Game/Screens/Play/Player.cs

@@ -136,7 +136,11 @@ namespace osu.Game.Screens.Play
 
         public readonly PlayerConfiguration Configuration;
 
-        protected Score Score { get; private set; }
+        /// <summary>
+        /// The score for the current play session.
+        /// Available only after the player is loaded.
+        /// </summary>
+        public Score Score { get; private set; }
 
         /// <summary>
         /// Create a new player instance.

osu.Game/Screens/Play/PlayerLoader.cs

@@ -61,6 +61,8 @@ namespace osu.Game.Screens.Play
 
         protected VisualSettings VisualSettings { get; private set; }
 
+        protected AudioSettings AudioSettings { get; private set; }
+
         protected Task LoadTask { get; private set; }
 
         protected Task DisposalTask { get; private set; }
@@ -167,6 +169,7 @@ namespace osu.Game.Screens.Play
                         Children = new PlayerSettingsGroup[]
                         {
                             VisualSettings = new VisualSettings(),
+                            AudioSettings = new AudioSettings(),
                             new InputSettings()
                         }
                     },
@@ -225,6 +228,10 @@ namespace osu.Game.Screens.Play
         {
             base.OnResuming(last);
 
+            var lastScore = player.Score;
+
+            AudioSettings.ReferenceScore.Value = lastScore?.ScoreInfo;
+
             // prepare for a retry.
             player = null;
             playerConsumed = false;

osu.Game/Screens/Play/PlayerSettings/AudioSettings.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 osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Configuration;
+using osu.Game.Scoring;
+
+namespace osu.Game.Screens.Play.PlayerSettings
+{
+    public class AudioSettings : PlayerSettingsGroup
+    {
+        public Bindable<ScoreInfo> ReferenceScore { get; } = new Bindable<ScoreInfo>();
+
+        private readonly PlayerCheckbox beatmapHitsoundsToggle;
+
+        public AudioSettings()
+            : base("Audio Settings")
+        {
+            Children = new Drawable[]
+            {
+                beatmapHitsoundsToggle = new PlayerCheckbox { LabelText = "Beatmap hitsounds" },
+                new BeatmapOffsetControl
+                {
+                    ReferenceScore = { BindTarget = ReferenceScore },
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            beatmapHitsoundsToggle.Current = config.GetBindable<bool>(OsuSetting.BeatmapHitsounds);
+        }
+    }
+}

osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs

@@ -0,0 +1,213 @@
+// 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.ComponentModel;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Localisation;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.Ranking.Statistics;
+using osuTK;
+
+#nullable enable
+
+namespace osu.Game.Screens.Play.PlayerSettings
+{
+    public class BeatmapOffsetControl : CompositeDrawable
+    {
+        public Bindable<ScoreInfo> ReferenceScore { get; } = new Bindable<ScoreInfo>();
+
+        public BindableDouble Current { get; } = new BindableDouble
+        {
+            Default = 0,
+            Value = 0,
+            MinValue = -50,
+            MaxValue = 50,
+            Precision = 0.1,
+        };
+
+        private readonly FillFlowContainer referenceScoreContainer;
+
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        [Resolved]
+        private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        private double lastPlayAverage;
+
+        private SettingsButton? useAverageButton;
+
+        private IDisposable? beatmapOffsetSubscription;
+
+        private Task? realmWriteTask;
+
+        public BeatmapOffsetControl()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            InternalChild = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(10),
+                Children = new Drawable[]
+                {
+                    new PlayerSliderBar<double>
+                    {
+                        KeyboardStep = 5,
+                        LabelText = BeatmapOffsetControlStrings.BeatmapOffset,
+                        Current = Current,
+                    },
+                    referenceScoreContainer = new FillFlowContainer
+                    {
+                        Spacing = new Vector2(10),
+                        Direction = FillDirection.Vertical,
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                    },
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            ReferenceScore.BindValueChanged(scoreChanged, true);
+
+            beatmapOffsetSubscription = realm.RegisterCustomSubscription(r =>
+            {
+                var userSettings = r.Find<BeatmapInfo>(beatmap.Value.BeatmapInfo.ID)?.UserSettings;
+
+                if (userSettings == null) // only the case for tests.
+                    return null;
+
+                Current.Value = userSettings.Offset;
+                userSettings.PropertyChanged += onUserSettingsOnPropertyChanged;
+
+                return new InvokeOnDisposal(() => userSettings.PropertyChanged -= onUserSettingsOnPropertyChanged);
+
+                void onUserSettingsOnPropertyChanged(object sender, PropertyChangedEventArgs args)
+                {
+                    if (args.PropertyName == nameof(BeatmapUserSettings.Offset))
+                        Current.Value = userSettings.Offset;
+                }
+            });
+
+            Current.BindValueChanged(currentChanged);
+        }
+
+        private void currentChanged(ValueChangedEvent<double> offset)
+        {
+            Scheduler.AddOnce(updateOffset);
+
+            void updateOffset()
+            {
+                // ensure the previous write has completed. ignoring performance concerns, if we don't do this, the async writes could be out of sequence.
+                if (realmWriteTask?.IsCompleted == false)
+                {
+                    Scheduler.AddOnce(updateOffset);
+                    return;
+                }
+
+                if (useAverageButton != null)
+                    useAverageButton.Enabled.Value = !Precision.AlmostEquals(lastPlayAverage, -Current.Value, Current.Precision / 2);
+
+                realmWriteTask = realm.WriteAsync(r =>
+                {
+                    var settings = r.Find<BeatmapInfo>(beatmap.Value.BeatmapInfo.ID)?.UserSettings;
+
+                    if (settings == null) // only the case for tests.
+                        return;
+
+                    if (settings.Offset == Current.Value)
+                        return;
+
+                    settings.Offset = Current.Value;
+                });
+            }
+        }
+
+        private void scoreChanged(ValueChangedEvent<ScoreInfo> score)
+        {
+            referenceScoreContainer.Clear();
+
+            if (score.NewValue == null)
+                return;
+
+            if (score.NewValue.Mods.Any(m => !m.UserPlayable))
+                return;
+
+            var hitEvents = score.NewValue.HitEvents;
+
+            if (!(hitEvents.CalculateAverageHitError() is double average))
+                return;
+
+            referenceScoreContainer.Children = new Drawable[]
+            {
+                new OsuSpriteText
+                {
+                    Text = BeatmapOffsetControlStrings.PreviousPlay
+                },
+            };
+
+            if (hitEvents.Count < 10)
+            {
+                referenceScoreContainer.AddRange(new Drawable[]
+                {
+                    new OsuTextFlowContainer
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Colour = colours.Red1,
+                        Text = BeatmapOffsetControlStrings.PreviousPlayTooShortToUseForCalibration
+                    },
+                });
+
+                return;
+            }
+
+            lastPlayAverage = average;
+
+            referenceScoreContainer.AddRange(new Drawable[]
+            {
+                new HitEventTimingDistributionGraph(hitEvents)
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = 50,
+                },
+                new AverageHitError(hitEvents),
+                useAverageButton = new SettingsButton
+                {
+                    Text = BeatmapOffsetControlStrings.CalibrateUsingLastPlay,
+                    Action = () => Current.Value = -lastPlayAverage
+                },
+            });
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            beatmapOffsetSubscription?.Dispose();
+        }
+    }
+}

osu.Game/Screens/Play/PlayerSettings/VisualSettings.cs

@@ -15,7 +15,6 @@ namespace osu.Game.Screens.Play.PlayerSettings
         private readonly PlayerCheckbox showStoryboardToggle;
         private readonly PlayerCheckbox beatmapSkinsToggle;
         private readonly PlayerCheckbox beatmapColorsToggle;
-        private readonly PlayerCheckbox beatmapHitsoundsToggle;
 
         public VisualSettings()
             : base("Visual Settings")
@@ -45,7 +44,6 @@ namespace osu.Game.Screens.Play.PlayerSettings
                 showStoryboardToggle = new PlayerCheckbox { LabelText = "Storyboard / Video" },
                 beatmapSkinsToggle = new PlayerCheckbox { LabelText = "Beatmap skins" },
                 beatmapColorsToggle = new PlayerCheckbox { LabelText = "Beatmap colours" },
-                beatmapHitsoundsToggle = new PlayerCheckbox { LabelText = "Beatmap hitsounds" }
             };
         }
 
@@ -57,7 +55,6 @@ namespace osu.Game.Screens.Play.PlayerSettings
             showStoryboardToggle.Current = config.GetBindable<bool>(OsuSetting.ShowStoryboard);
             beatmapSkinsToggle.Current = config.GetBindable<bool>(OsuSetting.BeatmapSkins);
             beatmapColorsToggle.Current = config.GetBindable<bool>(OsuSetting.BeatmapColours);
-            beatmapHitsoundsToggle.Current = config.GetBindable<bool>(OsuSetting.BeatmapHitsounds);
         }
     }
 }

osu.Game/Screens/Ranking/Statistics/HitEventTimingDistributionGraph.cs

@@ -160,8 +160,6 @@ namespace osu.Game.Screens.Ranking.Statistics
 
                 RelativeSizeAxes = Axes.Both;
 
-                Padding = new MarginPadding { Horizontal = 1 };
-
                 InternalChild = new Circle
                 {
                     RelativeSizeAxes = Axes.Both,

osu.Game/Skinning/Editor/SkinEditor.cs

@@ -8,14 +8,14 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Testing;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Resources.Localisation.Web;
+using osu.Game.Screens.Edit.Components.Menus;
-using osuTK;
 
 namespace osu.Game.Skinning.Editor
 {
@@ -57,13 +57,43 @@ namespace osu.Game.Skinning.Editor
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
                 {
-                    headerText = new OsuTextFlowContainer
+                    new Container
                     {
-                        TextAnchor = Anchor.TopCentre,
+                        Name = "Top bar",
-                        Padding = new MarginPadding(20),
+                        RelativeSizeAxes = Axes.X,
-                        Anchor = Anchor.TopCentre,
+                        Depth = float.MinValue,
-                        Origin = Anchor.TopCentre,
+                        Height = 40,
-                        RelativeSizeAxes = Axes.X
+                        Children = new Drawable[]
+                        {
+                            new EditorMenuBar
+                            {
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                RelativeSizeAxes = Axes.Both,
+                                Items = new[]
+                                {
+                                    new MenuItem("File")
+                                    {
+                                        Items = new[]
+                                        {
+                                            new EditorMenuItem("Save", MenuItemType.Standard, Save),
+                                            new EditorMenuItem("Revert to default", MenuItemType.Destructive, revert),
+                                            new EditorMenuItemSpacer(),
+                                            new EditorMenuItem("Exit", MenuItemType.Standard, Hide),
+                                        },
+                                    },
+                                }
+                            },
+                            headerText = new OsuTextFlowContainer
+                            {
+                                TextAnchor = Anchor.TopRight,
+                                Padding = new MarginPadding(5),
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                                AutoSizeAxes = Axes.X,
+                                RelativeSizeAxes = Axes.Y,
+                            },
+                        },
                     },
                     new GridContainer
                     {
@@ -89,46 +119,6 @@ namespace osu.Game.Skinning.Editor
                                     Children = new Drawable[]
                                     {
                                         new SkinBlueprintContainer(targetScreen),
-                                        new TriangleButton
-                                        {
-                                            Margin = new MarginPadding(10),
-                                            Text = CommonStrings.ButtonsClose,
-                                            Width = 100,
-                                            Action = Hide,
-                                        },
-                                        new FillFlowContainer
-                                        {
-                                            Direction = FillDirection.Horizontal,
-                                            AutoSizeAxes = Axes.Both,
-                                            Anchor = Anchor.TopRight,
-                                            Origin = Anchor.TopRight,
-                                            Spacing = new Vector2(5),
-                                            Padding = new MarginPadding
-                                            {
-                                                Top = 10,
-                                                Left = 10,
-                                            },
-                                            Margin = new MarginPadding
-                                            {
-                                                Right = 10,
-                                                Bottom = 10,
-                                            },
-                                            Children = new Drawable[]
-                                            {
-                                                new TriangleButton
-                                                {
-                                                    Text = "Save Changes",
-                                                    Width = 140,
-                                                    Action = Save,
-                                                },
-                                                new DangerousTriangleButton
-                                                {
-                                                    Text = "Revert to default",
-                                                    Width = 140,
-                                                    Action = revert,
-                                                },
-                                            }
-                                        },
                                     }
                                 },
                             }
@@ -161,7 +151,7 @@ namespace osu.Game.Skinning.Editor
         {
             headerText.Clear();
 
-            headerText.AddParagraph("Skin editor", cp => cp.Font = OsuFont.Default.With(size: 24));
+            headerText.AddParagraph("Skin editor", cp => cp.Font = OsuFont.Default.With(size: 16));
             headerText.NewParagraph();
             headerText.AddText("Currently editing ", cp =>
             {