Merge branch 'master' into screen-mod-retention

.github/ISSUE_TEMPLATE/bug-issue.yml

@@ -0,0 +1,72 @@
+name: Bug report
+description: Report a very clearly broken issue.
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # osu! bug report
+
+        Important to note that your issue may have already been reported before. Please check:
+        - Pinned issues, at the top of https://github.com/ppy/osu/issues.
+        - Current open `priority:0` issues, filterable [here](https://github.com/ppy/osu/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Apriority%3A0).
+        - And most importantly, search for your issue. If you find that it already exists, respond with a reaction or add any further information that may be helpful.
+
+  - type: dropdown
+    attributes:
+      label: Type
+      options:
+        - Crash to desktop
+        - Game behaviour
+        - Performance
+        - Cosmetic
+        - Other
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Bug description
+      description: How did you find the bug? Any additional details that might help?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Screenshots or videos
+      description: Add screenshots or videos that show the bug here.
+      placeholder: Drag and drop the screenshots/videos into this box.
+    validations:
+      required: false
+  - type: input
+    attributes:
+      label: Version
+      description: The version you encountered this bug on. This is shown at the bottom of the main menu and also at the end of the settings screen.
+    validations:
+      required: true
+  - type: markdown
+    attributes:
+      value: |
+        ## Logs
+
+        Attaching log files is required for every reported bug. See instructions below on how to find them.
+
+        If the game has not yet been closed since you found the bug:
+          1. Head on to game settings and click on "Open osu! folder"
+          2. Then open the `logs` folder located there
+
+        **Logs are reset when you reopen the game.** If the game crashed or has been closed since you found the bug, retrieve the logs using the file explorer instead.
+
+        The default places to find the logs are as follows:
+          - `%AppData%/osu/logs` *on Windows*
+          - `~/.local/share/osu/logs` *on Linux & macOS*
+          - `Android/data/sh.ppy.osulazer/files/logs` *on Android*
+          - *On iOS*, they can be obtained by connecting your device to your desktop and copying the `logs` directory from the app's own document storage using iTunes. (https://support.apple.com/en-us/HT201301#copy-to-computer)
+
+        If you have selected a custom location for the game files, you can find the `logs` folder there.
+
+        After locating the `logs` folder, select all log files inside and drag them into the "Logs" box below.
+
+  - type: textarea
+    attributes:
+      label: Logs
+      placeholder: Drag and drop the log files into this box.
+    validations:
+      required: true

README.md

@@ -31,7 +31,7 @@ If you are looking to install or test osu! without setting up a development envi
 
 **Latest build:**
 
-| [Windows 8.1+ (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe) | [macOS 10.15+](https://github.com/ppy/osu/releases/latest/download/osu.app.zip) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.AppImage) | [iOS 10+](https://osu.ppy.sh/home/testflight) | [Android 5+](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
+| [Windows 8.1+ (x64)](https://github.com/ppy/osu/releases/latest/download/install.exe) | macOS 10.15+ ([Intel](https://github.com/ppy/osu/releases/latest/download/osu.app.Intel.zip), [Apple Silicon](https://github.com/ppy/osu/releases/latest/download/osu.app.Apple.Silicon.zip)) | [Linux (x64)](https://github.com/ppy/osu/releases/latest/download/osu.AppImage) | [iOS 10+](https://osu.ppy.sh/home/testflight) | [Android 5+](https://github.com/ppy/osu/releases/latest/download/sh.ppy.osulazer.apk)
 | ------------- | ------------- | ------------- | ------------- | ------------- |
 
 - The iOS testflight link may fill up (Apple has a hard limit of 10,000 users). We reset it occasionally when this happens. Please do not ask about this. Check back regularly for link resets or follow [peppy](https://twitter.com/ppy) on twitter for announcements of link resets.

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override string Description => "No need to chase the circle – the circle chases you!";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax) };
 
         private IFrameStableClock gameplayClock;
 

osu.Game.Rulesets.Osu/Mods/OsuModClassic.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 System.Linq;
 using osu.Framework.Bindables;
 using osu.Game.Configuration;
@@ -16,6 +17,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModClassic : ModClassic, IApplicableToHitObject, IApplicableToDrawableHitObject, IApplicableToDrawableRuleset<OsuHitObject>
     {
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModStrictTracking) };
+
         [SettingSource("No slider head accuracy requirement", "Scores sliders proportionally to the number of ticks hit.")]
         public Bindable<bool> NoSliderHeadAccuracy { get; } = new BindableBool(true);
 

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

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     public class OsuModRelax : ModRelax, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>, IApplicableToPlayer
     {
         public override string Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModAutopilot), typeof(OsuModAimAssist) }).ToArray();
 
         /// <summary>
         /// How early before a hitobject's start time to trigger a hit.

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

@@ -0,0 +1,148 @@
+// 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 System.Threading;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModStrictTracking : Mod, IApplicableAfterBeatmapConversion, IApplicableToDrawableHitObject, IApplicableToDrawableRuleset<OsuHitObject>
+    {
+        public override string Name => @"Strict Tracking";
+        public override string Acronym => @"ST";
+        public override IconUsage? Icon => FontAwesome.Solid.PenFancy;
+        public override ModType Type => ModType.DifficultyIncrease;
+        public override string Description => @"Follow circles just got serious...";
+        public override double ScoreMultiplier => 1.0;
+        public override Type[] IncompatibleMods => new[] { typeof(ModClassic) };
+
+        public void ApplyToDrawableHitObject(DrawableHitObject drawable)
+        {
+            if (drawable is DrawableSlider slider)
+            {
+                slider.Tracking.ValueChanged += e =>
+                {
+                    if (e.NewValue || slider.Judged) return;
+
+                    var tail = slider.NestedHitObjects.OfType<StrictTrackingDrawableSliderTail>().First();
+
+                    if (!tail.Judged)
+                        tail.MissForcefully();
+                };
+            }
+        }
+
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            var osuBeatmap = (OsuBeatmap)beatmap;
+
+            if (osuBeatmap.HitObjects.Count == 0) return;
+
+            var hitObjects = osuBeatmap.HitObjects.Select(ho =>
+            {
+                if (ho is Slider slider)
+                {
+                    var newSlider = new StrictTrackingSlider(slider);
+                    return newSlider;
+                }
+
+                return ho;
+            }).ToList();
+
+            osuBeatmap.HitObjects = hitObjects;
+        }
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            drawableRuleset.Playfield.RegisterPool<StrictTrackingSliderTailCircle, StrictTrackingDrawableSliderTail>(10, 100);
+        }
+
+        private class StrictTrackingSliderTailCircle : SliderTailCircle
+        {
+            public StrictTrackingSliderTailCircle(Slider slider)
+                : base(slider)
+            {
+            }
+
+            public override Judgement CreateJudgement() => new OsuJudgement();
+        }
+
+        private class StrictTrackingDrawableSliderTail : DrawableSliderTail
+        {
+            public override bool DisplayResult => true;
+        }
+
+        private class StrictTrackingSlider : Slider
+        {
+            public StrictTrackingSlider(Slider original)
+            {
+                StartTime = original.StartTime;
+                Samples = original.Samples;
+                Path = original.Path;
+                NodeSamples = original.NodeSamples;
+                RepeatCount = original.RepeatCount;
+                Position = original.Position;
+                NewCombo = original.NewCombo;
+                ComboOffset = original.ComboOffset;
+                LegacyLastTickOffset = original.LegacyLastTickOffset;
+                TickDistanceMultiplier = original.TickDistanceMultiplier;
+            }
+
+            protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
+            {
+                var sliderEvents = SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken);
+
+                foreach (var e in sliderEvents)
+                {
+                    switch (e.Type)
+                    {
+                        case SliderEventType.Head:
+                            AddNested(HeadCircle = new SliderHeadCircle
+                            {
+                                StartTime = e.Time,
+                                Position = Position,
+                                StackHeight = StackHeight,
+                            });
+                            break;
+
+                        case SliderEventType.LegacyLastTick:
+                            AddNested(TailCircle = new StrictTrackingSliderTailCircle(this)
+                            {
+                                RepeatIndex = e.SpanIndex,
+                                StartTime = e.Time,
+                                Position = EndPosition,
+                                StackHeight = StackHeight
+                            });
+                            break;
+
+                        case SliderEventType.Repeat:
+                            AddNested(new SliderRepeat(this)
+                            {
+                                RepeatIndex = e.SpanIndex,
+                                StartTime = StartTime + (e.SpanIndex + 1) * SpanDuration,
+                                Position = Position + Path.PositionAt(e.PathProgress),
+                                StackHeight = StackHeight,
+                                Scale = Scale,
+                            });
+                            break;
+                    }
+                }
+
+                UpdateNestedSamples();
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Slider.cs

@@ -154,7 +154,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public Slider()
         {
-            SamplesBindable.CollectionChanged += (_, __) => updateNestedSamples();
+            SamplesBindable.CollectionChanged += (_, __) => UpdateNestedSamples();
             Path.Version.ValueChanged += _ => updateNestedPositions();
         }
 
@@ -227,7 +227,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                 }
             }
 
-            updateNestedSamples();
+            UpdateNestedSamples();
         }
 
         private void updateNestedPositions()
@@ -241,7 +241,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                 TailCircle.Position = EndPosition;
         }
 
-        private void updateNestedSamples()
+        protected void UpdateNestedSamples()
         {
             var firstSample = Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_NORMAL)
                               ?? Samples.FirstOrDefault(); // TODO: remove this when guaranteed sort is present for samples (https://github.com/ppy/osu/issues/1933)

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -159,6 +159,7 @@ namespace osu.Game.Rulesets.Osu
                         new MultiMod(new OsuModDoubleTime(), new OsuModNightcore()),
                         new OsuModHidden(),
                         new MultiMod(new OsuModFlashlight(), new OsuModBlinds()),
+                        new OsuModStrictTracking()
                     };
 
                 case ModType.Conversion:

osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 switch (osuComponent.Component)
                 {
                     case OsuSkinComponents.FollowPoint:
-                        return this.GetAnimation(component.LookupName, true, false, true, startAtCurrentTime: false);
+                        return this.GetAnimation(component.LookupName, true, true, true, startAtCurrentTime: false);
 
                     case OsuSkinComponents.SliderFollowCircle:
                         var followCircle = this.GetAnimation("sliderfollowcircle", true, true, true);

osu.Game.Tests/Database/BeatmapImporterTests.cs

@@ -590,6 +590,8 @@ namespace osu.Game.Tests.Database
 
                 Assert.IsTrue(imported.DeletePending);
 
+                var originalAddedDate = imported.DateAdded;
+
                 var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
@@ -597,6 +599,7 @@ namespace osu.Game.Tests.Database
                 Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
                 Assert.IsFalse(imported.DeletePending);
                 Assert.IsFalse(importedSecondTime.DeletePending);
+                Assert.That(importedSecondTime.DateAdded, Is.GreaterThan(originalAddedDate));
             });
         }
 
@@ -646,6 +649,8 @@ namespace osu.Game.Tests.Database
 
                 Assert.IsTrue(imported.DeletePending);
 
+                var originalAddedDate = imported.DateAdded;
+
                 var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
@@ -653,6 +658,7 @@ namespace osu.Game.Tests.Database
                 Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
                 Assert.IsFalse(imported.DeletePending);
                 Assert.IsFalse(importedSecondTime.DeletePending);
+                Assert.That(importedSecondTime.DateAdded, Is.GreaterThan(originalAddedDate));
             });
         }
 

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

@@ -18,9 +18,11 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Skinning.Legacy;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
 using osu.Game.Storyboards;
+using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -37,6 +39,12 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached(typeof(HealthProcessor))]
         private HealthProcessor healthProcessor = new DrainingHealthProcessor(0);
 
+        [Cached]
+        private GameplayState gameplayState = new GameplayState(new TestBeatmap(new OsuRuleset().RulesetInfo), new OsuRuleset());
+
+        [Cached]
+        private readonly GameplayClock gameplayClock = new GameplayClock(new FramedClock());
+
         protected override bool HasCustomSteps => true;
 
         [Test]

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

@@ -8,12 +8,14 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Framework.Timing;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Skinning;
+using osu.Game.Tests.Beatmaps;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -30,6 +32,12 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached(typeof(HealthProcessor))]
         private HealthProcessor healthProcessor = new DrainingHealthProcessor(0);
 
+        [Cached]
+        private GameplayState gameplayState = new GameplayState(new TestBeatmap(new OsuRuleset().RulesetInfo), new OsuRuleset());
+
+        [Cached]
+        private readonly GameplayClock gameplayClock = new GameplayClock(new FramedClock());
+
         // best way to check without exposing.
         private Drawable hideTarget => hudOverlay.KeyCounter;
         private FillFlowContainer<KeyCounter> keyCounterFlow => hudOverlay.KeyCounter.ChildrenOfType<FillFlowContainer<KeyCounter>>().First();

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

@@ -5,6 +5,7 @@ using System.Diagnostics;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.Sprites;
@@ -107,7 +108,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create player", () =>
             {
-                Beatmap.Value = CreateWorkingBeatmap(beatmap, storyboard);
+                Beatmap.Value = new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), Audio);
                 LoadScreen(player = new LeadInPlayer());
             });
 

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

@@ -5,11 +5,13 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Framework.Timing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Skinning.Editor;
+using osu.Game.Tests.Beatmaps;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -22,6 +24,12 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached(typeof(HealthProcessor))]
         private HealthProcessor healthProcessor = new DrainingHealthProcessor(0);
 
+        [Cached]
+        private GameplayState gameplayState = new GameplayState(new TestBeatmap(new OsuRuleset().RulesetInfo), new OsuRuleset());
+
+        [Cached]
+        private readonly GameplayClock gameplayClock = new GameplayClock(new FramedClock());
+
         [SetUpSteps]
         public void SetUpSteps()
         {

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

@@ -10,11 +10,13 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Framework.Timing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
+using osu.Game.Tests.Beatmaps;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -29,6 +31,12 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached(typeof(HealthProcessor))]
         private HealthProcessor healthProcessor = new DrainingHealthProcessor(0);
 
+        [Cached]
+        private GameplayState gameplayState = new GameplayState(new TestBeatmap(new OsuRuleset().RulesetInfo), new OsuRuleset());
+
+        [Cached]
+        private readonly GameplayClock gameplayClock = new GameplayClock(new FramedClock());
+
         private IEnumerable<HUDOverlay> hudOverlays => CreatedDrawables.OfType<HUDOverlay>();
 
         // best way to check without exposing.

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

@@ -70,6 +70,56 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
         }
 
+        [Test]
+        public void TestSeekToGameplayStartFramesArriveAfterPlayerLoad()
+        {
+            const double gameplay_start = 10000;
+
+            loadSpectatingScreen();
+
+            start();
+
+            waitForPlayer();
+
+            sendFrames(startTime: gameplay_start);
+
+            AddAssert("time is greater than seek target", () => currentFrameStableTime > gameplay_start);
+        }
+
+        /// <summary>
+        /// Tests the same as <see cref="TestSeekToGameplayStartFramesArriveAfterPlayerLoad"/> but with the frames arriving just as <see cref="Player"/> is transitioning into existence.
+        /// </summary>
+        [Test]
+        public void TestSeekToGameplayStartFramesArriveAsPlayerLoaded()
+        {
+            const double gameplay_start = 10000;
+
+            loadSpectatingScreen();
+
+            start();
+
+            AddUntilStep("wait for player loader", () => (Stack.CurrentScreen as PlayerLoader)?.IsLoaded == true);
+
+            AddUntilStep("queue send frames on player load", () =>
+            {
+                var loadingPlayer = (Stack.CurrentScreen as PlayerLoader)?.CurrentPlayer;
+
+                if (loadingPlayer == null)
+                    return false;
+
+                loadingPlayer.OnLoadComplete += _ =>
+                {
+                    spectatorClient.SendFramesFromUser(streamingUser.Id, 10, gameplay_start);
+                };
+                return true;
+            });
+
+            waitForPlayer();
+
+            AddUntilStep("state is playing", () => spectatorClient.WatchedUserStates[streamingUser.Id].State == SpectatedUserState.Playing);
+            AddAssert("time is greater than seek target", () => currentFrameStableTime > gameplay_start);
+        }
+
         [Test]
         public void TestFrameStarvationAndResume()
         {
@@ -319,9 +369,9 @@ namespace osu.Game.Tests.Visual.Gameplay
         private void checkPaused(bool state) =>
             AddUntilStep($"game is {(state ? "paused" : "playing")}", () => player.ChildrenOfType<DrawableRuleset>().First().IsPaused.Value == state);
 
-        private void sendFrames(int count = 10)
+        private void sendFrames(int count = 10, double startTime = 0)
         {
-            AddStep("send frames", () => spectatorClient.SendFramesFromUser(streamingUser.Id, count));
+            AddStep("send frames", () => spectatorClient.SendFramesFromUser(streamingUser.Id, count, startTime));
         }
 
         private void loadSpectatingScreen()

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs

@@ -11,6 +11,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
@@ -129,6 +131,25 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("item 1 not in lists", () => !inHistoryList(0) && !inQueueList(0));
         }
 
+        [Test]
+        public void TestQueueTabCount()
+        {
+            assertQueueTabCount(1);
+
+            addItemStep();
+            assertQueueTabCount(2);
+
+            addItemStep();
+            assertQueueTabCount(3);
+
+            AddStep("finish current item", () => MultiplayerClient.FinishCurrentItem().WaitSafely());
+            assertQueueTabCount(2);
+
+            AddStep("leave room", () => RoomManager.PartRoom());
+            AddUntilStep("wait for room part", () => !RoomJoined);
+            assertQueueTabCount(0);
+        }
+
         [Ignore("Expired items are initially removed from the room.")]
         [Test]
         public void TestJoinRoomWithMixedItemsAddedInCorrectLists()
@@ -213,6 +234,17 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
         }
 
+        private void assertQueueTabCount(int count)
+        {
+            string queueTabText = count > 0 ? $"Queue ({count})" : "Queue";
+            AddUntilStep($"Queue tab shows \"{queueTabText}\"", () =>
+            {
+                return this.ChildrenOfType<OsuTabControl<MultiplayerPlaylistDisplayMode>.OsuTabItem>()
+                           .Single(t => t.Value == MultiplayerPlaylistDisplayMode.Queue)
+                           .ChildrenOfType<OsuSpriteText>().Single().Text == queueTabText;
+            });
+        }
+
         private void changeDisplayModeStep(MultiplayerPlaylistDisplayMode mode) => AddStep($"change list to {mode}", () => list.DisplayMode.Value = mode);
 
         private bool inQueueList(int playlistItemId)

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerReadyButton.cs

@@ -148,7 +148,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             ClickButtonWhenEnabled<MultiplayerReadyButton>();
             AddUntilStep("user is idle (match not started)", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
-            AddAssert("ready button enabled", () => button.ChildrenOfType<OsuButton>().Single().Enabled.Value);
+            AddUntilStep("ready button enabled", () => button.ChildrenOfType<OsuButton>().Single().Enabled.Value);
         }
 
         [TestCase(true)]

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

@@ -0,0 +1,163 @@
+// 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 NUnit.Framework;
+using System.Collections.Generic;
+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.Game.Graphics.Sprites;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Chat;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Chat.ChannelList;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    [TestFixture]
+    public class TestSceneChannelListItem : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Pink);
+
+        [Cached]
+        private readonly Bindable<Channel> selected = new Bindable<Channel>();
+
+        private static readonly List<Channel> channels = new List<Channel>
+        {
+            createPublicChannel("#public-channel"),
+            createPublicChannel("#public-channel-long-name"),
+            createPrivateChannel("test user", 2),
+            createPrivateChannel("test user long name", 3),
+        };
+
+        private readonly Dictionary<Channel, ChannelListItem> channelMap = new Dictionary<Channel, ChannelListItem>();
+
+        private FillFlowContainer flow;
+        private OsuSpriteText selectedText;
+        private OsuSpriteText leaveText;
+
+        [SetUp]
+        public void SetUp()
+        {
+            Schedule(() =>
+            {
+                foreach (var item in channelMap.Values)
+                    item.Expire();
+
+                channelMap.Clear();
+
+                Child = new FillFlowContainer
+                {
+                    Direction = FillDirection.Vertical,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    AutoSizeAxes = Axes.Both,
+                    Spacing = new Vector2(10),
+                    Children = new Drawable[]
+                    {
+                        selectedText = new OsuSpriteText
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                        },
+                        leaveText = new OsuSpriteText
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            Height = 16,
+                            AlwaysPresent = true,
+                        },
+                        new Container
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            AutoSizeAxes = Axes.Y,
+                            Width = 190,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = colourProvider.Background6,
+                                },
+                                flow = new FillFlowContainer
+                                {
+                                    Direction = FillDirection.Vertical,
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                },
+                            },
+                        },
+                    },
+                };
+
+                selected.BindValueChanged(change =>
+                {
+                    selectedText.Text = $"Selected Channel: {change.NewValue?.Name ?? "[null]"}";
+                }, true);
+
+                foreach (var channel in channels)
+                {
+                    var item = new ChannelListItem(channel);
+                    flow.Add(item);
+                    channelMap.Add(channel, item);
+                    item.OnRequestSelect += c => selected.Value = c;
+                    item.OnRequestLeave += leaveChannel;
+                }
+            });
+        }
+
+        [Test]
+        public void TestVisual()
+        {
+            AddStep("Select second item", () => selected.Value = channels.Skip(1).First());
+
+            AddStep("Unread Selected", () =>
+            {
+                if (selected.Value != null)
+                    channelMap[selected.Value].Unread.Value = true;
+            });
+
+            AddStep("Read Selected", () =>
+            {
+                if (selected.Value != null)
+                    channelMap[selected.Value].Unread.Value = false;
+            });
+
+            AddStep("Add Mention Selected", () =>
+            {
+                if (selected.Value != null)
+                    channelMap[selected.Value].Mentions.Value++;
+            });
+
+            AddStep("Add 98 Mentions Selected", () =>
+            {
+                if (selected.Value != null)
+                    channelMap[selected.Value].Mentions.Value += 98;
+            });
+
+            AddStep("Clear Mentions Selected", () =>
+            {
+                if (selected.Value != null)
+                    channelMap[selected.Value].Mentions.Value = 0;
+            });
+        }
+
+        private void leaveChannel(Channel channel)
+        {
+            leaveText.Text = $"OnRequestLeave: {channel.Name}";
+            leaveText.FadeOutFromOne(1000, Easing.InQuint);
+        }
+
+        private static Channel createPublicChannel(string name) =>
+            new Channel { Name = name, Type = ChannelType.Public, Id = 1234 };
+
+        private static Channel createPrivateChannel(string username, int id)
+            => new Channel(new APIUser { Id = id, Username = username });
+    }
+}

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -9,6 +9,7 @@ using osu.Framework.Testing;
 using osu.Game.Database;
 using osu.Game.Models;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays.BeatmapSet.Scores;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using Realms;
@@ -169,7 +170,12 @@ namespace osu.Game.Beatmaps
         [Ignored]
         public APIBeatmap? OnlineInfo { get; set; }
 
+        /// <summary>
+        /// The maximum achievable combo on this beatmap, populated for online info purposes only.
+        /// Todo: This should never be used nor exist, but is still relied on in <see cref="ScoresContainer.Scores"/> since <see cref="IBeatmapInfo"/> can't be used yet. For now this is obsoleted until it is removed.
+        /// </summary>
         [Ignored]
+        [Obsolete("Use ScoreManager.GetMaximumAchievableComboAsync instead.")]
         public int? MaxCombo { get; set; }
 
         [Ignored]

osu.Game/Beatmaps/EFBeatmapInfo.cs

@@ -53,9 +53,6 @@ namespace osu.Game.Beatmaps
         [NotMapped]
         public APIBeatmap OnlineInfo { get; set; }
 
-        [NotMapped]
-        public int? MaxCombo { get; set; }
-
         /// <summary>
         /// The playable length in milliseconds of this beatmap.
         /// </summary>

osu.Game/Database/EFToRealmMigrator.cs

@@ -295,7 +295,6 @@ namespace osu.Game.Database
                                 TimelineZoom = beatmap.TimelineZoom,
                                 Countdown = beatmap.Countdown,
                                 CountdownOffset = beatmap.CountdownOffset,
-                                MaxCombo = beatmap.MaxCombo,
                                 Bookmarks = beatmap.Bookmarks,
                                 BeatmapSet = realmBeatmapSet,
                             };

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

@@ -173,7 +173,9 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
                 {
                     Text = score.MaxCombo.ToLocalisableString(@"0\x"),
                     Font = OsuFont.GetFont(size: text_size),
+#pragma warning disable 618
                     Colour = score.MaxCombo == score.BeatmapInfo.MaxCombo ? highAccuracyColour : Color4.White
+#pragma warning restore 618
                 }
             };
 

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

@@ -78,7 +78,9 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
                 // TODO: temporary. should be removed once `OrderByTotalScore` can accept `IScoreInfo`.
                 var beatmapInfo = new BeatmapInfo
                 {
+#pragma warning disable 618
                     MaxCombo = apiBeatmap.MaxCombo,
+#pragma warning restore 618
                     Status = apiBeatmap.Status,
                     MD5Hash = apiBeatmap.MD5Hash
                 };

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

@@ -0,0 +1,171 @@
+// 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 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.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.Chat;
+using osu.Game.Users.Drawables;
+using osuTK;
+
+namespace osu.Game.Overlays.Chat.ChannelList
+{
+    public class ChannelListItem : OsuClickableContainer
+    {
+        public event Action<Channel>? OnRequestSelect;
+        public event Action<Channel>? OnRequestLeave;
+
+        public readonly BindableInt Mentions = new BindableInt();
+
+        public readonly BindableBool Unread = new BindableBool();
+
+        private readonly Channel channel;
+
+        private Box? hoverBox;
+        private Box? selectBox;
+        private OsuSpriteText? text;
+        private ChannelListItemCloseButton? close;
+
+        [Resolved]
+        private Bindable<Channel> selectedChannel { get; set; } = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        public ChannelListItem(Channel channel)
+        {
+            this.channel = channel;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Height = 30;
+            RelativeSizeAxes = Axes.X;
+
+            Children = new Drawable[]
+            {
+                hoverBox = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background3,
+                    Alpha = 0f,
+                },
+                selectBox = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background4,
+                    Alpha = 0f,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Left = 18, Right = 10 },
+                    Child = new GridContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        ColumnDimensions = new[]
+                        {
+                            new Dimension(GridSizeMode.AutoSize),
+                            new Dimension(),
+                            new Dimension(GridSizeMode.AutoSize),
+                            new Dimension(GridSizeMode.AutoSize),
+                        },
+                        Content = new[]
+                        {
+                            new[]
+                            {
+                                createIcon(),
+                                text = new OsuSpriteText
+                                {
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Text = channel.Name,
+                                    Font = OsuFont.Torus.With(size: 17, weight: FontWeight.SemiBold),
+                                    Colour = colourProvider.Light3,
+                                    Margin = new MarginPadding { Bottom = 2 },
+                                    RelativeSizeAxes = Axes.X,
+                                    Truncate = true,
+                                },
+                                new ChannelListItemMentionPill
+                                {
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Margin = new MarginPadding { Right = 3 },
+                                    Mentions = { BindTarget = Mentions },
+                                },
+                                close = new ChannelListItemCloseButton
+                                {
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Margin = new MarginPadding { Right = 3 },
+                                    Action = () => OnRequestLeave?.Invoke(channel),
+                                }
+                            }
+                        },
+                    },
+                },
+            };
+
+            Action = () => OnRequestSelect?.Invoke(channel);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            selectedChannel.BindValueChanged(change =>
+            {
+                if (change.NewValue == channel)
+                    selectBox?.FadeIn(300, Easing.OutQuint);
+                else
+                    selectBox?.FadeOut(200, Easing.OutQuint);
+            }, true);
+
+            Unread.BindValueChanged(change =>
+            {
+                text!.FadeColour(change.NewValue ? colourProvider.Content1 : colourProvider.Light3, 300, Easing.OutQuint);
+            }, true);
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            hoverBox?.FadeIn(300, Easing.OutQuint);
+            close?.FadeIn(300, Easing.OutQuint);
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            hoverBox?.FadeOut(200, Easing.OutQuint);
+            close?.FadeOut(200, Easing.OutQuint);
+            base.OnHoverLost(e);
+        }
+
+        private Drawable createIcon()
+        {
+            if (channel.Type != ChannelType.PM)
+                return Drawable.Empty();
+
+            return new UpdateableAvatar(channel.Users.First(), isInteractive: false)
+            {
+                Size = new Vector2(20),
+                Margin = new MarginPadding { Right = 5 },
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.CentreLeft,
+                CornerRadius = 10,
+                Masking = true,
+            };
+        }
+    }
+}

osu.Game/Overlays/Chat/ChannelList/ChannelListItemCloseButton.cs

@@ -0,0 +1,68 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Overlays.Chat.ChannelList
+{
+    public class ChannelListItemCloseButton : OsuClickableContainer
+    {
+        private SpriteIcon icon = null!;
+
+        private Color4 normalColour;
+        private Color4 hoveredColour;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour osuColour)
+        {
+            normalColour = osuColour.Red2;
+            hoveredColour = Color4.White;
+
+            Alpha = 0f;
+            Size = new Vector2(20);
+            Add(icon = new SpriteIcon
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(0.75f),
+                Icon = FontAwesome.Solid.TimesCircle,
+                RelativeSizeAxes = Axes.Both,
+                Colour = normalColour,
+            });
+        }
+
+        // Transforms matching OsuAnimatedButton
+        protected override bool OnHover(HoverEvent e)
+        {
+            icon.FadeColour(hoveredColour, 300, Easing.OutQuint);
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            icon.FadeColour(normalColour, 300, Easing.OutQuint);
+            base.OnHoverLost(e);
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            icon.ScaleTo(0.75f, 2000, Easing.OutQuint);
+            return base.OnMouseDown(e);
+        }
+
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            icon.ScaleTo(1, 1000, Easing.OutElastic);
+            base.OnMouseUp(e);
+        }
+    }
+}

osu.Game/Overlays/Chat/ChannelList/ChannelListItemMentionPill.cs

@@ -0,0 +1,71 @@
+// 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 osu.Framework.Allocation;
+using osu.Framework.Bindables;
+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.Chat.ChannelList
+{
+    public class ChannelListItemMentionPill : CircularContainer
+    {
+        public readonly BindableInt Mentions = new BindableInt();
+
+        private OsuSpriteText countText = null!;
+
+        private Box box = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour osuColour, OverlayColourProvider colourProvider)
+        {
+            Masking = true;
+            Size = new Vector2(20, 12);
+            Alpha = 0f;
+
+            Children = new Drawable[]
+            {
+                box = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = osuColour.Orange1,
+                },
+                countText = new OsuSpriteText
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Font = OsuFont.Torus.With(size: 11, weight: FontWeight.Bold),
+                    Margin = new MarginPadding { Bottom = 1 },
+                    Colour = colourProvider.Background5,
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Mentions.BindValueChanged(change =>
+            {
+                int mentionCount = change.NewValue;
+
+                countText.Text = mentionCount > 99 ? "99+" : mentionCount.ToString();
+
+                if (mentionCount > 0)
+                {
+                    this.FadeIn(1000, Easing.OutQuint);
+                    box.FlashColour(Color4.White, 500, Easing.OutQuint);
+                }
+                else
+                    this.FadeOut(100, Easing.OutQuint);
+            }, true);
+        }
+    }
+}

osu.Game/Rulesets/Scoring/HitResult.cs

@@ -122,7 +122,19 @@ namespace osu.Game.Rulesets.Scoring
     public static class HitResultExtensions
     {
         /// <summary>
-        /// Whether a <see cref="HitResult"/> increases/decreases the combo, and affects the combo portion of the score.
+        /// Whether a <see cref="HitResult"/> increases the combo.
+        /// </summary>
+        public static bool IncreasesCombo(this HitResult result)
+            => AffectsCombo(result) && IsHit(result);
+
+        /// <summary>
+        /// Whether a <see cref="HitResult"/> breaks the combo and resets it back to zero.
+        /// </summary>
+        public static bool BreaksCombo(this HitResult result)
+            => AffectsCombo(result) && !IsHit(result);
+
+        /// <summary>
+        /// Whether a <see cref="HitResult"/> increases/breaks the combo, and affects the combo portion of the score.
         /// </summary>
         public static bool AffectsCombo(this HitResult result)
         {

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -166,20 +166,10 @@ namespace osu.Game.Rulesets.Scoring
             if (!result.Type.IsScorable())
                 return;
 
-            if (result.Type.AffectsCombo())
-            {
-                switch (result.Type)
-                {
-                    case HitResult.Miss:
-                    case HitResult.LargeTickMiss:
-                        Combo.Value = 0;
-                        break;
-
-                    default:
-                        Combo.Value++;
-                        break;
-                }
-            }
+            if (result.Type.IncreasesCombo())
+                Combo.Value++;
+            else if (result.Type.BreaksCombo())
+                Combo.Value = 0;
 
             double scoreIncrease = result.Type.IsHit() ? result.Judgement.NumericResultFor(result) : 0;
 

osu.Game/Rulesets/UI/Playfield.cs

@@ -323,7 +323,7 @@ namespace osu.Game.Rulesets.UI
         /// </param>
         /// <typeparam name="TObject">The <see cref="HitObject"/> type.</typeparam>
         /// <typeparam name="TDrawable">The <see cref="DrawableHitObject"/> receiver for <typeparamref name="TObject"/>s.</typeparam>
-        protected void RegisterPool<TObject, TDrawable>(int initialSize, int? maximumSize = null)
+        public void RegisterPool<TObject, TDrawable>(int initialSize, int? maximumSize = null)
             where TObject : HitObject
             where TDrawable : DrawableHitObject, new()
             => RegisterPool<TObject, TDrawable>(new DrawablePool<TDrawable>(initialSize, maximumSize));

osu.Game/Scoring/ScoreInfo.cs

@@ -157,7 +157,7 @@ namespace osu.Game.Scoring
         public LocalisableString DisplayAccuracy => Accuracy.FormatAccuracy();
 
         /// <summary>
-        /// Whether this <see cref="EFScoreInfo"/> represents a legacy (osu!stable) score.
+        /// Whether this <see cref="ScoreInfo"/> represents a legacy (osu!stable) score.
         /// </summary>
         [Ignored]
         public bool IsLegacyScore => Mods.OfType<ModClassic>().Any();

osu.Game/Scoring/ScoreManager.cs

@@ -134,35 +134,9 @@ namespace osu.Game.Scoring
             if (string.IsNullOrEmpty(score.BeatmapInfo.MD5Hash))
                 return score.TotalScore;
 
-            int beatmapMaxCombo;
-
-            if (score.IsLegacyScore)
-            {
-                // This score is guaranteed to be an osu!stable score.
-                // The combo must be determined through either the beatmap's max combo value or the difficulty calculator, as lazer's scoring has changed and the score statistics cannot be used.
-                if (score.BeatmapInfo.MaxCombo != null)
-                    beatmapMaxCombo = score.BeatmapInfo.MaxCombo.Value;
-                else
-                {
-                    if (difficulties == null)
-                        return score.TotalScore;
-
-                    // We can compute the max combo locally after the async beatmap difficulty computation.
-                    var difficulty = await difficulties().GetDifficultyAsync(score.BeatmapInfo, score.Ruleset, score.Mods, cancellationToken).ConfigureAwait(false);
-
-                    // Something failed during difficulty calculation. Fall back to provided score.
-                    if (difficulty == null)
-                        return score.TotalScore;
-
-                    beatmapMaxCombo = difficulty.Value.MaxCombo;
-                }
-            }
-            else
-            {
-                // This is guaranteed to be a non-legacy score.
-                // The combo must be determined through the score's statistics, as both the beatmap's max combo and the difficulty calculator will provide osu!stable combo values.
-                beatmapMaxCombo = Enum.GetValues(typeof(HitResult)).OfType<HitResult>().Where(r => r.AffectsCombo()).Select(r => score.Statistics.GetValueOrDefault(r)).Sum();
-            }
+            int? beatmapMaxCombo = await GetMaximumAchievableComboAsync(score, cancellationToken).ConfigureAwait(false);
+            if (beatmapMaxCombo == null)
+                return score.TotalScore;
 
             if (beatmapMaxCombo == 0)
                 return 0;
@@ -171,7 +145,37 @@ namespace osu.Game.Scoring
             var scoreProcessor = ruleset.CreateScoreProcessor();
             scoreProcessor.Mods.Value = score.Mods;
 
-            return (long)Math.Round(scoreProcessor.ComputeFinalLegacyScore(mode, score, beatmapMaxCombo));
+            return (long)Math.Round(scoreProcessor.ComputeFinalLegacyScore(mode, score, beatmapMaxCombo.Value));
+        }
+
+        /// <summary>
+        /// Retrieves the maximum achievable combo for the provided score.
+        /// </summary>
+        /// <param name="score">The <see cref="ScoreInfo"/> to compute the maximum achievable combo for.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> to cancel the process.</param>
+        /// <returns>The maximum achievable combo. A <see langword="null"/> return value indicates the difficulty cache has failed to retrieve the combo.</returns>
+        public async Task<int?> GetMaximumAchievableComboAsync([NotNull] ScoreInfo score, CancellationToken cancellationToken = default)
+        {
+            if (score.IsLegacyScore)
+            {
+                // This score is guaranteed to be an osu!stable score.
+                // The combo must be determined through either the beatmap's max combo value or the difficulty calculator, as lazer's scoring has changed and the score statistics cannot be used.
+#pragma warning disable CS0618
+                if (score.BeatmapInfo.MaxCombo != null)
+                    return score.BeatmapInfo.MaxCombo.Value;
+#pragma warning restore CS0618
+
+                if (difficulties == null)
+                    return null;
+
+                // We can compute the max combo locally after the async beatmap difficulty computation.
+                var difficulty = await difficulties().GetDifficultyAsync(score.BeatmapInfo, score.Ruleset, score.Mods, cancellationToken).ConfigureAwait(false);
+                return difficulty?.MaxCombo;
+            }
+
+            // This is guaranteed to be a non-legacy score.
+            // The combo must be determined through the score's statistics, as both the beatmap's max combo and the difficulty calculator will provide osu!stable combo values.
+            return Enum.GetValues(typeof(HitResult)).OfType<HitResult>().Where(r => r.AffectsCombo()).Select(r => score.Statistics.GetValueOrDefault(r)).Sum();
         }
 
         /// <summary>

osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerPlaylist.cs

@@ -7,7 +7,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 
@@ -25,6 +24,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
         /// </summary>
         public Action<PlaylistItem> RequestEdit;
 
+        private MultiplayerPlaylistTabControl playlistTabControl;
         private MultiplayerQueueList queueList;
         private MultiplayerHistoryList historyList;
         private bool firstPopulation = true;
@@ -36,7 +36,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
 
             InternalChildren = new Drawable[]
             {
-                new OsuTabControl<MultiplayerPlaylistDisplayMode>
+                playlistTabControl = new MultiplayerPlaylistTabControl
                 {
                     RelativeSizeAxes = Axes.X,
                     Height = tab_control_height,
@@ -64,6 +64,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
                     }
                 }
             };
+
+            playlistTabControl.QueueItems.BindTarget = queueList.Items;
         }
 
         protected override void LoadComplete()

osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerPlaylistTabControl.cs

@@ -0,0 +1,39 @@
+// 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.Bindables;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Rooms;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
+{
+    public class MultiplayerPlaylistTabControl : OsuTabControl<MultiplayerPlaylistDisplayMode>
+    {
+        public readonly IBindableList<PlaylistItem> QueueItems = new BindableList<PlaylistItem>();
+
+        protected override TabItem<MultiplayerPlaylistDisplayMode> CreateTabItem(MultiplayerPlaylistDisplayMode value)
+        {
+            if (value == MultiplayerPlaylistDisplayMode.Queue)
+                return new QueueTabItem { QueueItems = { BindTarget = QueueItems } };
+
+            return base.CreateTabItem(value);
+        }
+
+        private class QueueTabItem : OsuTabItem
+        {
+            public readonly IBindableList<PlaylistItem> QueueItems = new BindableList<PlaylistItem>();
+
+            public QueueTabItem()
+                : base(MultiplayerPlaylistDisplayMode.Queue)
+            {
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                QueueItems.BindCollectionChanged((_, __) => Text.Text = QueueItems.Count > 0 ? $"Queue ({QueueItems.Count})" : "Queue", true);
+            }
+        }
+    }
+}

osu.Game/Screens/Play/HUD/HitErrorMeters/BarHitErrorMeter.cs

@@ -4,12 +4,16 @@
 using System;
 using System.Linq;
 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.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osuTK;
@@ -19,11 +23,27 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
     public class BarHitErrorMeter : HitErrorMeter
     {
         private const int judgement_line_width = 14;
-        private const int judgement_line_height = 4;
+
+        [SettingSource("Judgement line thickness", "How thick the individual lines should be.")]
+        public BindableNumber<float> JudgementLineThickness { get; } = new BindableNumber<float>(4)
+        {
+            MinValue = 1,
+            MaxValue = 8,
+            Precision = 0.1f,
+        };
+
+        [SettingSource("Show moving average arrow", "Whether an arrow should move beneath the bar showing the average error.")]
+        public Bindable<bool> ShowMovingAverage { get; } = new BindableBool(true);
+
+        [SettingSource("Centre marker style", "How to signify the centre of the display")]
+        public Bindable<CentreMarkerStyles> CentreMarkerStyle { get; } = new Bindable<CentreMarkerStyles>(CentreMarkerStyles.Circle);
+
+        [SettingSource("Label style", "How to show early/late extremities")]
+        public Bindable<LabelStyles> LabelStyle { get; } = new Bindable<LabelStyles>(LabelStyles.Icons);
 
         private SpriteIcon arrow;
-        private SpriteIcon iconEarly;
-        private SpriteIcon iconLate;
+        private Drawable labelEarly;
+        private Drawable labelLate;
 
         private Container colourBarsEarly;
         private Container colourBarsLate;
@@ -32,6 +52,18 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
 
         private double maxHitWindow;
 
+        private double floatingAverage;
+        private Container colourBars;
+        private Container arrowContainer;
+
+        private (HitResult result, double length)[] hitWindows;
+
+        private const int max_concurrent_judgements = 50;
+
+        private Drawable[] centreMarkerDrawables;
+
+        private const int centre_marker_size = 8;
+
         public BarHitErrorMeter()
         {
             AutoSizeAxes = Axes.Both;
@@ -40,13 +72,11 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
         [BackgroundDependencyLoader]
         private void load()
         {
-            const int centre_marker_size = 8;
             const int bar_height = 200;
             const int bar_width = 2;
             const float chevron_size = 8;
-            const float icon_size = 14;
 
-            var hitWindows = HitWindows.GetAllAvailableWindows().ToArray();
+            hitWindows = HitWindows.GetAllAvailableWindows().ToArray();
 
             InternalChild = new Container
             {
@@ -65,22 +95,6 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
                         RelativeSizeAxes = Axes.Y,
                         Children = new Drawable[]
                         {
-                            iconEarly = new SpriteIcon
-                            {
-                                Y = -10,
-                                Size = new Vector2(icon_size),
-                                Icon = FontAwesome.Solid.ShippingFast,
-                                Anchor = Anchor.TopCentre,
-                                Origin = Anchor.Centre,
-                            },
-                            iconLate = new SpriteIcon
-                            {
-                                Y = 10,
-                                Size = new Vector2(icon_size),
-                                Icon = FontAwesome.Solid.Bicycle,
-                                Anchor = Anchor.BottomCentre,
-                                Origin = Anchor.Centre,
-                            },
                             colourBarsEarly = new Container
                             {
                                 Anchor = Anchor.Centre,
@@ -98,14 +112,6 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
                                 RelativeSizeAxes = Axes.Y,
                                 Height = 0.5f,
                             },
-                            new Circle
-                            {
-                                Name = "middle marker behind",
-                                Colour = GetColourForHitResult(hitWindows.Last().result),
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Size = new Vector2(centre_marker_size),
-                            },
                             judgementsContainer = new Container
                             {
                                 Name = "judgements",
@@ -114,24 +120,18 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
                                 RelativeSizeAxes = Axes.Y,
                                 Width = judgement_line_width,
                             },
-                            new Circle
-                            {
-                                Name = "middle marker in front",
-                                Colour = GetColourForHitResult(hitWindows.Last().result).Darken(0.3f),
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Size = new Vector2(centre_marker_size),
-                                Scale = new Vector2(0.5f),
-                            },
                         }
                     },
-                    new Container
+                    arrowContainer = new Container
                     {
                         Name = "average chevron",
                         Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
+                        Origin = Anchor.CentreRight,
                         Width = chevron_size,
+                        X = chevron_size,
                         RelativeSizeAxes = Axes.Y,
+                        Alpha = 0,
+                        Scale = new Vector2(0, 1),
                         Child = arrow = new SpriteIcon
                         {
                             Anchor = Anchor.TopCentre,
@@ -155,8 +155,180 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
             colourBars.Height = 0;
             colourBars.ResizeHeightTo(1, 800, Easing.OutQuint);
 
-            arrow.Alpha = 0;
-            arrow.Delay(200).FadeInFromZero(600);
+            CentreMarkerStyle.BindValueChanged(style => recreateCentreMarker(style.NewValue), true);
+            LabelStyle.BindValueChanged(style => recreateLabels(style.NewValue), true);
+
+            // delay the appearance animations for only the initial appearance.
+            using (arrowContainer.BeginDelayedSequence(450))
+            {
+                ShowMovingAverage.BindValueChanged(visible =>
+                {
+                    arrowContainer.FadeTo(visible.NewValue ? 1 : 0, 250, Easing.OutQuint);
+                    arrowContainer.ScaleTo(visible.NewValue ? new Vector2(1) : new Vector2(0, 1), 250, Easing.OutQuint);
+                }, true);
+            }
+        }
+
+        private void recreateCentreMarker(CentreMarkerStyles style)
+        {
+            if (centreMarkerDrawables != null)
+            {
+                foreach (var d in centreMarkerDrawables)
+                {
+                    d.ScaleTo(0, 500, Easing.OutQuint)
+                     .FadeOut(500, Easing.OutQuint);
+
+                    d.Expire();
+                }
+
+                centreMarkerDrawables = null;
+            }
+
+            switch (style)
+            {
+                case CentreMarkerStyles.None:
+                    break;
+
+                case CentreMarkerStyles.Circle:
+                    centreMarkerDrawables = new Drawable[]
+                    {
+                        new Circle
+                        {
+                            Name = "middle marker behind",
+                            Colour = GetColourForHitResult(hitWindows.Last().result),
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Depth = float.MaxValue,
+                            Size = new Vector2(centre_marker_size),
+                        },
+                        new Circle
+                        {
+                            Name = "middle marker in front",
+                            Colour = GetColourForHitResult(hitWindows.Last().result).Darken(0.3f),
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Depth = float.MinValue,
+                            Size = new Vector2(centre_marker_size / 2f),
+                        },
+                    };
+                    break;
+
+                case CentreMarkerStyles.Line:
+                    const float border_size = 1.5f;
+
+                    centreMarkerDrawables = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Name = "middle marker behind",
+                            Colour = GetColourForHitResult(hitWindows.Last().result),
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Depth = float.MaxValue,
+                            Size = new Vector2(judgement_line_width, centre_marker_size / 3f),
+                        },
+                        new Box
+                        {
+                            Name = "middle marker in front",
+                            Colour = GetColourForHitResult(hitWindows.Last().result).Darken(0.3f),
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Depth = float.MinValue,
+                            Size = new Vector2(judgement_line_width - border_size, centre_marker_size / 3f - border_size),
+                        },
+                    };
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(style), style, null);
+            }
+
+            if (centreMarkerDrawables != null)
+            {
+                foreach (var d in centreMarkerDrawables)
+                {
+                    colourBars.Add(d);
+
+                    d.FadeInFromZero(500, Easing.OutQuint)
+                     .ScaleTo(0).ScaleTo(1, 1000, Easing.OutElasticHalf);
+                }
+            }
+        }
+
+        private void recreateLabels(LabelStyles style)
+        {
+            const float icon_size = 14;
+
+            labelEarly?.Expire();
+            labelEarly = null;
+
+            labelLate?.Expire();
+            labelLate = null;
+
+            switch (style)
+            {
+                case LabelStyles.None:
+                    break;
+
+                case LabelStyles.Icons:
+                    labelEarly = new SpriteIcon
+                    {
+                        Y = -10,
+                        Size = new Vector2(icon_size),
+                        Icon = FontAwesome.Solid.ShippingFast,
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.Centre,
+                    };
+
+                    labelLate = new SpriteIcon
+                    {
+                        Y = 10,
+                        Size = new Vector2(icon_size),
+                        Icon = FontAwesome.Solid.Bicycle,
+                        Anchor = Anchor.BottomCentre,
+                        Origin = Anchor.Centre,
+                    };
+
+                    break;
+
+                case LabelStyles.Text:
+                    labelEarly = new OsuSpriteText
+                    {
+                        Y = -10,
+                        Text = "Early",
+                        Font = OsuFont.Default.With(size: 10),
+                        Height = 12,
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.Centre,
+                    };
+
+                    labelLate = new OsuSpriteText
+                    {
+                        Y = 10,
+                        Text = "Late",
+                        Font = OsuFont.Default.With(size: 10),
+                        Height = 12,
+                        Anchor = Anchor.BottomCentre,
+                        Origin = Anchor.Centre,
+                    };
+
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(style), style, null);
+            }
+
+            if (labelEarly != null)
+            {
+                colourBars.Add(labelEarly);
+                labelEarly.FadeInFromZero(500);
+            }
+
+            if (labelLate != null)
+            {
+                colourBars.Add(labelLate);
+                labelLate.FadeInFromZero(500);
+            }
         }
 
         protected override void Update()
@@ -164,8 +336,8 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
             base.Update();
 
             // undo any layout rotation to display icons in the correct orientation
-            iconEarly.Rotation = -Rotation;
-            iconLate.Rotation = -Rotation;
+            if (labelEarly != null) labelEarly.Rotation = -Rotation;
+            if (labelLate != null) labelLate.Rotation = -Rotation;
         }
 
         private void createColourBars((HitResult result, double length)[] windows)
@@ -224,11 +396,6 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
             }
         }
 
-        private double floatingAverage;
-        private Container colourBars;
-
-        private const int max_concurrent_judgements = 50;
-
         protected override void OnNewJudgement(JudgementResult judgement)
         {
             const int arrow_move_duration = 800;
@@ -255,6 +422,7 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
 
             judgementsContainer.Add(new JudgementLine
             {
+                JudgementLineThickness = { BindTarget = JudgementLineThickness },
                 Y = getRelativeJudgementPosition(judgement.TimeOffset),
                 Colour = GetColourForHitResult(judgement.Type),
             });
@@ -268,11 +436,12 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
 
         internal class JudgementLine : CompositeDrawable
         {
+            public readonly BindableNumber<float> JudgementLineThickness = new BindableFloat();
+
             public JudgementLine()
             {
                 RelativeSizeAxes = Axes.X;
                 RelativePositionAxes = Axes.Y;
-                Height = judgement_line_height;
 
                 Blending = BlendingParameters.Additive;
 
@@ -295,6 +464,8 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
                 Alpha = 0;
                 Width = 0;
 
+                JudgementLineThickness.BindValueChanged(thickness => Height = thickness.NewValue, true);
+
                 this
                     .FadeTo(0.6f, judgement_fade_in_duration, Easing.OutQuint)
                     .ResizeWidthTo(1, judgement_fade_in_duration, Easing.OutQuint)
@@ -306,5 +477,19 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
         }
 
         public override void Clear() => judgementsContainer.Clear();
+
+        public enum CentreMarkerStyles
+        {
+            None,
+            Circle,
+            Line
+        }
+
+        public enum LabelStyles
+        {
+            None,
+            Icons,
+            Text
+        }
     }
 }

osu.Game/Screens/Play/HUD/HoldForMenuButton.cs

@@ -84,7 +84,7 @@ namespace osu.Game.Screens.Play.HUD
 
         protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            positionalAdjust = Vector2.Distance(e.ScreenSpaceMousePosition, button.ScreenSpaceDrawQuad.Centre) / 200;
+            positionalAdjust = Vector2.Distance(e.MousePosition, button.ToSpaceOfOtherDrawable(button.DrawRectangle.Centre, Parent)) / 100;
             return base.OnMouseMove(e);
         }
 

osu.Game/Screens/Play/HUD/PerformancePointsCounter.cs

@@ -42,12 +42,10 @@ namespace osu.Game.Screens.Play.HUD
 
         private const float alpha_when_invalid = 0.3f;
 
-        [CanBeNull]
-        [Resolved(CanBeNull = true)]
+        [Resolved]
         private ScoreProcessor scoreProcessor { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        [CanBeNull]
+        [Resolved]
         private GameplayState gameplayState { get; set; }
 
         [CanBeNull]

osu.Game/Screens/Play/Player.cs

@@ -615,16 +615,22 @@ namespace osu.Game.Screens.Play
         /// <param name="time">The destination time to seek to.</param>
         internal void NonFrameStableSeek(double time)
         {
-            if (frameStablePlaybackResetDelegate?.Cancelled == false && !frameStablePlaybackResetDelegate.Completed)
-                frameStablePlaybackResetDelegate.RunTask();
+            // TODO: This schedule should not be required and is a temporary hotfix.
+            // See https://github.com/ppy/osu/issues/17267 for the issue.
+            // See https://github.com/ppy/osu/pull/17302 for a better fix which needs some more time.
+            ScheduleAfterChildren(() =>
+            {
+                if (frameStablePlaybackResetDelegate?.Cancelled == false && !frameStablePlaybackResetDelegate.Completed)
+                    frameStablePlaybackResetDelegate.RunTask();
 
-            bool wasFrameStable = DrawableRuleset.FrameStablePlayback;
-            DrawableRuleset.FrameStablePlayback = false;
+                bool wasFrameStable = DrawableRuleset.FrameStablePlayback;
+                DrawableRuleset.FrameStablePlayback = false;
 
-            Seek(time);
+                Seek(time);
 
-            // Delay resetting frame-stable playback for one frame to give the FrameStabilityContainer a chance to seek.
-            frameStablePlaybackResetDelegate = ScheduleAfterChildren(() => DrawableRuleset.FrameStablePlayback = wasFrameStable);
+                // Delay resetting frame-stable playback for one frame to give the FrameStabilityContainer a chance to seek.
+                frameStablePlaybackResetDelegate = ScheduleAfterChildren(() => DrawableRuleset.FrameStablePlayback = wasFrameStable);
+            });
         }
 
         /// <summary>

osu.Game/Screens/Play/PlayerLoader.cs

@@ -1,10 +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.
 
+#nullable enable
+
 using System;
 using System.Diagnostics;
 using System.Threading.Tasks;
-using JetBrains.Annotations;
 using ManagedBass.Fx;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -48,31 +49,31 @@ namespace osu.Game.Screens.Play
         public override bool HandlePositionalInput => true;
 
         // We show the previous screen status
-        protected override UserActivity InitialActivity => null;
+        protected override UserActivity? InitialActivity => null;
 
         protected override bool PlayResumeSound => false;
 
-        protected BeatmapMetadataDisplay MetadataInfo { get; private set; }
+        protected BeatmapMetadataDisplay MetadataInfo { get; private set; } = null!;
 
         /// <summary>
         /// A fill flow containing the player settings groups, exposed for the ability to hide it from inheritors of the player loader.
         /// </summary>
-        protected FillFlowContainer<PlayerSettingsGroup> PlayerSettings { get; private set; }
+        protected FillFlowContainer<PlayerSettingsGroup> PlayerSettings { get; private set; } = null!;
 
-        protected VisualSettings VisualSettings { get; private set; }
+        protected VisualSettings VisualSettings { get; private set; } = null!;
 
-        protected AudioSettings AudioSettings { get; private set; }
+        protected AudioSettings AudioSettings { get; private set; } = null!;
 
-        protected Task LoadTask { get; private set; }
+        protected Task? LoadTask { get; private set; }
 
-        protected Task DisposalTask { get; private set; }
+        protected Task? DisposalTask { get; private set; }
 
         private bool backgroundBrightnessReduction;
 
         private readonly BindableDouble volumeAdjustment = new BindableDouble(1);
 
-        private AudioFilter lowPassFilter;
-        private AudioFilter highPassFilter;
+        private AudioFilter lowPassFilter = null!;
+        private AudioFilter highPassFilter = null!;
 
         protected bool BackgroundBrightnessReduction
         {
@@ -90,47 +91,49 @@ namespace osu.Game.Screens.Play
         private bool readyForPush =>
             !playerConsumed
             // don't push unless the player is completely loaded
-            && player?.LoadState == LoadState.Ready
+            && CurrentPlayer?.LoadState == LoadState.Ready
             // don't push if the user is hovering one of the panes, unless they are idle.
             && (IsHovered || idleTracker.IsIdle.Value)
             // don't push if the user is dragging a slider or otherwise.
-            && inputManager?.DraggedDrawable == null
+            && inputManager.DraggedDrawable == null
             // don't push if a focused overlay is visible, like settings.
-            && inputManager?.FocusedDrawable == null;
+            && inputManager.FocusedDrawable == null;
 
         private readonly Func<Player> createPlayer;
 
-        private Player player;
+        /// <summary>
+        /// The <see cref="Player"/> instance being loaded by this screen.
+        /// </summary>
+        public Player? CurrentPlayer { get; private set; }
 
         /// <summary>
-        /// Whether the curent player instance has been consumed via <see cref="consumePlayer"/>.
+        /// Whether the current player instance has been consumed via <see cref="consumePlayer"/>.
         /// </summary>
         private bool playerConsumed;
 
-        private LogoTrackingContainer content;
+        private LogoTrackingContainer content = null!;
 
         private bool hideOverlays;
 
-        private InputManager inputManager;
+        private InputManager inputManager = null!;
 
-        private IdleTracker idleTracker;
+        private IdleTracker idleTracker = null!;
 
-        private ScheduledDelegate scheduledPushPlayer;
+        private ScheduledDelegate? scheduledPushPlayer;
 
-        [CanBeNull]
-        private EpilepsyWarning epilepsyWarning;
+        private EpilepsyWarning? epilepsyWarning;
 
         [Resolved(CanBeNull = true)]
-        private NotificationOverlay notificationOverlay { get; set; }
+        private NotificationOverlay? notificationOverlay { get; set; }
 
         [Resolved(CanBeNull = true)]
-        private VolumeOverlay volumeOverlay { get; set; }
+        private VolumeOverlay? volumeOverlay { get; set; }
 
         [Resolved]
-        private AudioManager audioManager { get; set; }
+        private AudioManager audioManager { get; set; } = null!;
 
         [Resolved(CanBeNull = true)]
-        private BatteryInfo batteryInfo { get; set; }
+        private BatteryInfo? batteryInfo { get; set; }
 
         public PlayerLoader(Func<Player> createPlayer)
         {
@@ -237,12 +240,14 @@ namespace osu.Game.Screens.Play
         {
             base.OnResuming(last);
 
-            var lastScore = player.Score;
+            Debug.Assert(CurrentPlayer != null);
+
+            var lastScore = CurrentPlayer.Score;
 
             AudioSettings.ReferenceScore.Value = lastScore?.ScoreInfo;
 
             // prepare for a retry.
-            player = null;
+            CurrentPlayer = null;
             playerConsumed = false;
             cancelLoad();
 
@@ -344,9 +349,10 @@ namespace osu.Game.Screens.Play
         private Player consumePlayer()
         {
             Debug.Assert(!playerConsumed);
+            Debug.Assert(CurrentPlayer != null);
 
             playerConsumed = true;
-            return player;
+            return CurrentPlayer;
         }
 
         private void prepareNewPlayer()
@@ -354,11 +360,11 @@ namespace osu.Game.Screens.Play
             if (!this.IsCurrentScreen())
                 return;
 
-            player = createPlayer();
-            player.RestartCount = restartCount++;
-            player.RestartRequested = restartRequested;
+            CurrentPlayer = createPlayer();
+            CurrentPlayer.RestartCount = restartCount++;
+            CurrentPlayer.RestartRequested = restartRequested;
 
-            LoadTask = LoadComponentAsync(player, _ => MetadataInfo.Loading = false);
+            LoadTask = LoadComponentAsync(CurrentPlayer, _ => MetadataInfo.Loading = false);
         }
 
         private void restartRequested()
@@ -472,7 +478,7 @@ namespace osu.Game.Screens.Play
             if (isDisposing)
             {
                 // if the player never got pushed, we should explicitly dispose it.
-                DisposalTask = LoadTask?.ContinueWith(_ => player?.Dispose());
+                DisposalTask = LoadTask?.ContinueWith(_ => CurrentPlayer?.Dispose());
             }
         }
 
@@ -480,7 +486,7 @@ namespace osu.Game.Screens.Play
 
         #region Mute warning
 
-        private Bindable<bool> muteWarningShownOnce;
+        private Bindable<bool> muteWarningShownOnce = null!;
 
         private int restartCount;
 
@@ -535,7 +541,7 @@ namespace osu.Game.Screens.Play
 
         #region Low battery warning
 
-        private Bindable<bool> batteryWarningShownOnce;
+        private Bindable<bool> batteryWarningShownOnce = null!;
 
         private void showBatteryWarningIfNeeded()
         {

osu.Game/Screens/Play/SongProgress.cs

@@ -73,9 +73,12 @@ namespace osu.Game.Screens.Play
         [Resolved(canBeNull: true)]
         private Player player { get; set; }
 
-        [Resolved(canBeNull: true)]
+        [Resolved]
         private GameplayClock gameplayClock { get; set; }
 
+        [Resolved(canBeNull: true)]
+        private DrawableRuleset drawableRuleset { get; set; }
+
         private IClock referenceClock;
 
         public bool UsesFixedAnchor { get; set; }
@@ -113,7 +116,7 @@ namespace osu.Game.Screens.Play
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(OsuColour colours, OsuConfigManager config, DrawableRuleset drawableRuleset)
+        private void load(OsuColour colours, OsuConfigManager config)
         {
             base.LoadComplete();
 

osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs

@@ -65,10 +65,12 @@ namespace osu.Game.Screens.Ranking.Expanded
             var metadata = beatmap.BeatmapSet?.Metadata ?? beatmap.Metadata;
             string creator = metadata.Author.Username;
 
+            int? beatmapMaxCombo = scoreManager.GetMaximumAchievableComboAsync(score).GetResultSafely();
+
             var topStatistics = new List<StatisticDisplay>
             {
                 new AccuracyStatistic(score.Accuracy),
-                new ComboStatistic(score.MaxCombo, !score.Statistics.TryGetValue(HitResult.Miss, out int missCount) || missCount == 0),
+                new ComboStatistic(score.MaxCombo, beatmapMaxCombo),
                 new PerformanceStatistic(score),
             };
 
@@ -80,8 +82,6 @@ namespace osu.Game.Screens.Ranking.Expanded
             statisticDisplays.AddRange(topStatistics);
             statisticDisplays.AddRange(bottomStatistics);
 
-            var starDifficulty = beatmapDifficultyCache.GetDifficultyAsync(beatmap, score.Ruleset, score.Mods).GetResultSafely();
-
             AddInternal(new FillFlowContainer
             {
                 RelativeSizeAxes = Axes.Both,
@@ -224,6 +224,8 @@ namespace osu.Game.Screens.Ranking.Expanded
             if (score.Date != default)
                 AddInternal(new PlayedOnText(score.Date));
 
+            var starDifficulty = beatmapDifficultyCache.GetDifficultyAsync(beatmap, score.Ruleset, score.Mods).GetResultSafely();
+
             if (starDifficulty != null)
             {
                 starAndModDisplay.Add(new StarRatingDisplay(starDifficulty.Value)

osu.Game/Screens/Ranking/Expanded/Statistics/ComboStatistic.cs

@@ -25,11 +25,11 @@ namespace osu.Game.Screens.Ranking.Expanded.Statistics
         /// Creates a new <see cref="ComboStatistic"/>.
         /// </summary>
         /// <param name="combo">The combo to be displayed.</param>
-        /// <param name="isPerfect">Whether this is a perfect combo.</param>
-        public ComboStatistic(int combo, bool isPerfect)
-            : base("combo", combo)
+        /// <param name="maxCombo">The maximum value of <paramref name="combo"/>.</param>
+        public ComboStatistic(int combo, int? maxCombo)
+            : base("combo", combo, maxCombo)
         {
-            this.isPerfect = isPerfect;
+            isPerfect = combo == maxCombo;
         }
 
         public override void Appear()

osu.Game/Skinning/Editor/SkinComponentToolbox.cs

@@ -2,24 +2,17 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Events;
-using osu.Framework.Utils;
-using osu.Game.Beatmaps;
+using osu.Framework.Logging;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Difficulty;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Components;
 using osuTK;
 
@@ -29,26 +22,19 @@ namespace osu.Game.Skinning.Editor
     {
         public Action<Type> RequestPlacement;
 
-        [Cached]
-        private ScoreProcessor scoreProcessor = new ScoreProcessor(new DummyRuleset())
-        {
-            Combo = { Value = RNG.Next(1, 1000) },
-            TotalScore = { Value = RNG.Next(1000, 10000000) }
-        };
+        private readonly CompositeDrawable target;
 
-        [Cached(typeof(HealthProcessor))]
-        private HealthProcessor healthProcessor = new DrainingHealthProcessor(0);
-
-        public SkinComponentToolbox()
+        public SkinComponentToolbox(CompositeDrawable target = null)
             : base("Components")
         {
+            this.target = target;
         }
 
+        private FillFlowContainer fill;
+
         [BackgroundDependencyLoader]
         private void load()
         {
-            FillFlowContainer fill;
-
             Child = fill = new FillFlowContainer
             {
                 RelativeSizeAxes = Axes.X,
@@ -57,25 +43,24 @@ namespace osu.Game.Skinning.Editor
                 Spacing = new Vector2(2)
             };
 
+            reloadComponents();
+        }
+
+        private void reloadComponents()
+        {
+            fill.Clear();
+
             var skinnableTypes = typeof(OsuGame).Assembly.GetTypes()
-                                                .Where(t => !t.IsInterface)
+                                                .Where(t => !t.IsInterface && !t.IsAbstract)
                                                 .Where(t => typeof(ISkinnableDrawable).IsAssignableFrom(t))
                                                 .OrderBy(t => t.Name)
                                                 .ToArray();
 
             foreach (var type in skinnableTypes)
-            {
-                var component = attemptAddComponent(type);
-
-                if (component != null)
-                {
-                    component.RequestPlacement = t => RequestPlacement?.Invoke(t);
-                    fill.Add(component);
-                }
-            }
+                attemptAddComponent(type);
         }
 
-        private static ToolboxComponentButton attemptAddComponent(Type type)
+        private void attemptAddComponent(Type type)
         {
             try
             {
@@ -83,14 +68,21 @@ namespace osu.Game.Skinning.Editor
 
                 Debug.Assert(instance != null);
 
-                if (!((ISkinnableDrawable)instance).IsEditable)
-                    return null;
+                if (!((ISkinnableDrawable)instance).IsEditable) return;
 
-                return new ToolboxComponentButton(instance);
+                fill.Add(new ToolboxComponentButton(instance, target)
+                {
+                    RequestPlacement = t => RequestPlacement?.Invoke(t)
+                });
             }
-            catch
+            catch (DependencyNotRegisteredException)
             {
-                return null;
+                // This loading code relies on try-catching any dependency injection errors to know which components are valid for the current target screen.
+                // If a screen can't provide the required dependencies, a skinnable component should not be displayed in the list.
+            }
+            catch (Exception e)
+            {
+                Logger.Error(e, $"Skin component {type} could not be loaded in the editor component list due to an error");
             }
         }
 
@@ -101,6 +93,7 @@ namespace osu.Game.Skinning.Editor
             public override bool PropagateNonPositionalInputSubTree => false;
 
             private readonly Drawable component;
+            private readonly CompositeDrawable dependencySource;
 
             public Action<Type> RequestPlacement;
 
@@ -109,9 +102,10 @@ namespace osu.Game.Skinning.Editor
             private const float contracted_size = 60;
             private const float expanded_size = 120;
 
-            public ToolboxComponentButton(Drawable component)
+            public ToolboxComponentButton(Drawable component, CompositeDrawable dependencySource)
             {
                 this.component = component;
+                this.dependencySource = dependencySource;
 
                 Enabled.Value = true;
 
@@ -143,7 +137,7 @@ namespace osu.Game.Skinning.Editor
                         RelativeSizeAxes = Axes.Both,
                         Padding = new MarginPadding(10) { Bottom = 20 },
                         Masking = true,
-                        Child = innerContainer = new Container
+                        Child = innerContainer = new DependencyBorrowingContainer(dependencySource)
                         {
                             RelativeSizeAxes = Axes.Both,
                             Anchor = Anchor.Centre,
@@ -186,14 +180,17 @@ namespace osu.Game.Skinning.Editor
             }
         }
 
-        private class DummyRuleset : Ruleset
+        public class DependencyBorrowingContainer : Container
         {
-            public override IEnumerable<Mod> GetModsFor(ModType type) => throw new NotImplementedException();
-            public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => throw new NotImplementedException();
-            public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => throw new NotImplementedException();
-            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => throw new NotImplementedException();
-            public override string Description => string.Empty;
-            public override string ShortName => string.Empty;
+            private readonly CompositeDrawable donor;
+
+            public DependencyBorrowingContainer(CompositeDrawable donor)
+            {
+                this.donor = donor;
+            }
+
+            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
+                new DependencyContainer(donor?.Dependencies ?? base.CreateChildDependencies(parent));
         }
     }
 }

osu.Game/Skinning/Editor/SkinEditor.cs

@@ -49,6 +49,7 @@ namespace osu.Game.Skinning.Editor
 
         private Container content;
 
+        private EditorSidebar componentsSidebar;
         private EditorSidebar settingsSidebar;
 
         public SkinEditor()
@@ -145,16 +146,7 @@ namespace osu.Game.Skinning.Editor
                                 {
                                     new Drawable[]
                                     {
-                                        new EditorSidebar
-                                        {
-                                            Children = new[]
-                                            {
-                                                new SkinComponentToolbox
-                                                {
-                                                    RequestPlacement = placeComponent
-                                                },
-                                            }
-                                        },
+                                        componentsSidebar = new EditorSidebar(),
                                         content = new Container
                                         {
                                             Depth = float.MaxValue,
@@ -200,7 +192,15 @@ namespace osu.Game.Skinning.Editor
             Scheduler.AddOnce(loadBlueprintContainer);
             Scheduler.AddOnce(populateSettings);
 
-            void loadBlueprintContainer() => content.Child = new SkinBlueprintContainer(targetScreen);
+            void loadBlueprintContainer()
+            {
+                content.Child = new SkinBlueprintContainer(targetScreen);
+
+                componentsSidebar.Child = new SkinComponentToolbox(getFirstTarget() as CompositeDrawable)
+                {
+                    RequestPlacement = placeComponent
+                };
+            }
         }
 
         private void skinChanged()
@@ -227,12 +227,7 @@ namespace osu.Game.Skinning.Editor
 
         private void placeComponent(Type type)
         {
-            var target = availableTargets.FirstOrDefault()?.Target;
-
-            if (target == null)
-                return;
-
-            var targetContainer = getTarget(target.Value);
+            var targetContainer = getFirstTarget();
 
             if (targetContainer == null)
                 return;
@@ -263,6 +258,8 @@ namespace osu.Game.Skinning.Editor
 
         private IEnumerable<ISkinnableTarget> availableTargets => targetScreen.ChildrenOfType<ISkinnableTarget>();
 
+        private ISkinnableTarget getFirstTarget() => availableTargets.FirstOrDefault();
+
         private ISkinnableTarget getTarget(SkinnableTarget target)
         {
             return availableTargets.FirstOrDefault(c => c.Target == target);

osu.Game/Skinning/Editor/SkinEditorSceneLibrary.cs

@@ -94,7 +94,7 @@ namespace osu.Game.Skinning.Editor
 
                                         var replayGeneratingMod = ruleset.Value.CreateInstance().GetAutoplayMod();
                                         if (replayGeneratingMod != null)
-                                            screen.Push(new ReplayPlayer((beatmap, mods) => replayGeneratingMod.CreateReplayScore(beatmap, mods)));
+                                            screen.Push(new PlayerLoader(() => new ReplayPlayer((beatmap, mods) => replayGeneratingMod.CreateReplayScore(beatmap, mods))));
                                     }, new[] { typeof(Player), typeof(SongSelect) })
                                 },
                             }

osu.Game/Stores/BeatmapImporter.cs

@@ -163,6 +163,12 @@ namespace osu.Game.Stores
             return existing.OnlineID == import.OnlineID && existingIds.SequenceEqual(importIds);
         }
 
+        protected override void UndeleteForReuse(BeatmapSetInfo existing)
+        {
+            base.UndeleteForReuse(existing);
+            existing.DateAdded = DateTimeOffset.UtcNow;
+        }
+
         public override bool IsAvailableLocally(BeatmapSetInfo model)
         {
             return Realm.Run(realm => realm.All<BeatmapSetInfo>().Any(s => s.OnlineID == model.OnlineID));

osu.Game/Stores/RealmArchiveModelImporter.cs

@@ -351,7 +351,8 @@ namespace osu.Game.Stores
 
                             using (var transaction = realm.BeginWrite())
                             {
-                                existing.DeletePending = false;
+                                if (existing.DeletePending)
+                                    UndeleteForReuse(existing);
                                 transaction.Commit();
                             }
 
@@ -387,7 +388,9 @@ namespace osu.Game.Stores
                             {
                                 LogForModel(item, @$"Found existing {HumanisedModelName} for {item} (ID {existing.ID}) – skipping import.");
 
-                                existing.DeletePending = false;
+                                if (existing.DeletePending)
+                                    UndeleteForReuse(existing);
+
                                 transaction.Commit();
 
                                 return existing.ToLive(Realm);
@@ -527,6 +530,15 @@ namespace osu.Game.Stores
         private bool checkAllFilesExist(TModel model) =>
             model.Files.All(f => Files.Storage.Exists(f.File.GetStoragePath()));
 
+        /// <summary>
+        /// Called when an existing model is in a soft deleted state but being recovered.
+        /// </summary>
+        /// <param name="existing">The existing model.</param>
+        protected virtual void UndeleteForReuse(TModel existing)
+        {
+            existing.DeletePending = false;
+        }
+
         /// <summary>
         /// Whether this specified path should be removed after successful import.
         /// </summary>

osu.Game/Tests/Visual/Spectator/TestSpectatorClient.cs

@@ -88,7 +88,8 @@ namespace osu.Game.Tests.Visual.Spectator
         /// </summary>
         /// <param name="userId">The user to send frames for.</param>
         /// <param name="count">The total number of frames to send.</param>
-        public void SendFramesFromUser(int userId, int count)
+        /// <param name="startTime">The time to start gameplay frames from.</param>
+        public void SendFramesFromUser(int userId, int count, double startTime = 0)
         {
             var frames = new List<LegacyReplayFrame>();
 
@@ -102,7 +103,7 @@ namespace osu.Game.Tests.Visual.Spectator
                     flush();
 
                 var buttonState = currentFrameIndex == lastFrameIndex ? ReplayButtonState.None : ReplayButtonState.Left1;
-                frames.Add(new LegacyReplayFrame(currentFrameIndex * 100, RNG.Next(0, 512), RNG.Next(0, 512), buttonState));
+                frames.Add(new LegacyReplayFrame(currentFrameIndex * 100 + startTime, RNG.Next(0, 512), RNG.Next(0, 512), buttonState));
             }
 
             flush();

osu.Game/Updater/SimpleUpdateManager.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using osu.Framework;
 using osu.Framework.Allocation;
@@ -82,7 +83,8 @@ namespace osu.Game.Updater
                     break;
 
                 case RuntimeInfo.Platform.macOS:
-                    bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".app.zip", StringComparison.Ordinal));
+                    string arch = RuntimeInformation.OSArchitecture == Architecture.Arm64 ? "Apple.Silicon" : "Intel";
+                    bestAsset = release.Assets?.Find(f => f.Name.EndsWith($".app.{arch}.zip", StringComparison.Ordinal));
                     break;
 
                 case RuntimeInfo.Platform.Linux: