Merge remote-tracking branch 'refs/remotes/ppy/master' into kudosu-info

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.15.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableCatchHitObject.cs

@@ -58,14 +58,12 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                 ApplyResult(r => r.Type = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss);
         }
 
-        protected override bool UseTransformStateManagement => false;
+        protected sealed override double InitialLifetimeOffset => HitObject.TimePreempt;
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateInitialTransforms() => this.FadeIn(200);
+
+        protected override void UpdateStateTransforms(ArmedState state)
         {
-            // TODO: update to use new state management.
-            using (BeginAbsoluteSequence(HitObject.StartTime - HitObject.TimePreempt))
-                this.FadeIn(200);
-
             var endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
 
             using (BeginAbsoluteSequence(endTime, true))

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 if (lastPlateableFruit == null)
                     return;
 
-                // this is required to make this run after the last caught fruit runs UpdateState at least once.
+                // this is required to make this run after the last caught fruit runs updateState() at least once.
                 // TODO: find a better alternative
                 if (lastPlateableFruit.IsLoaded)
                     action();

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.15.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableBarLine.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 Alpha = 0.2f;
         }
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
         }
     }

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs

@@ -8,6 +8,7 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI.Scrolling;
 
@@ -104,6 +105,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             bodyPiece.Height = DrawHeight - Head.Height / 2 + Tail.Height / 2;
         }
 
+        protected override void UpdateStateTransforms(ArmedState state)
+        {
+            using (BeginDelayedSequence(HitObject.Duration, true))
+                base.UpdateStateTransforms(state);
+        }
+
         protected void BeginHold()
         {
             holdStartTime = Time.Current;

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableManiaHitObject.cs

@@ -45,24 +45,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             Anchor = Origin = e.NewValue == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
         }
-    }
 
-    public abstract class DrawableManiaHitObject<TObject> : DrawableManiaHitObject
+        protected override void UpdateInitialTransforms() => this.FadeIn();
-        where TObject : ManiaHitObject
+
+        protected override void UpdateStateTransforms(ArmedState state)
         {
-        public new readonly TObject HitObject;
-
-        protected DrawableManiaHitObject(TObject hitObject)
-            : base(hitObject)
-        {
-            HitObject = hitObject;
-        }
-
-        protected override bool UseTransformStateManagement => false;
-
-        protected override void UpdateState(ArmedState state)
-        {
-            // TODO: update to use new state management.
             switch (state)
             {
                 case ArmedState.Miss:
@@ -75,4 +62,16 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             }
         }
     }
+
+    public abstract class DrawableManiaHitObject<TObject> : DrawableManiaHitObject
+        where TObject : ManiaHitObject
+    {
+        public new readonly TObject HitObject;
+
+        protected DrawableManiaHitObject(TObject hitObject)
+            : base(hitObject)
+        {
+            HitObject = hitObject;
+        }
+    }
 }

osu.Game.Rulesets.Mania/Replays/ManiaAutoGenerator.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Replays;
 
@@ -77,13 +78,37 @@ namespace osu.Game.Rulesets.Mania.Replays
 
         private IEnumerable<IActionPoint> generateActionPoints()
         {
-            foreach (var obj in Beatmap.HitObjects)
+            for (int i = 0; i < Beatmap.HitObjects.Count; i++)
             {
-                yield return new HitPoint { Time = obj.StartTime, Column = obj.Column };
+                var currentObject = Beatmap.HitObjects[i];
-                yield return new ReleasePoint { Time = ((obj as IHasEndTime)?.EndTime ?? obj.StartTime) + RELEASE_DELAY, Column = obj.Column };
+                var nextObjectInColumn = GetNextObject(i); // Get the next object that requires pressing the same button
+
+                double endTime = (currentObject as IHasEndTime)?.EndTime ?? currentObject.StartTime;
+
+                bool canDelayKeyUp = nextObjectInColumn == null ||
+                                     nextObjectInColumn.StartTime > endTime + RELEASE_DELAY;
+
+                double calculatedDelay = canDelayKeyUp ? RELEASE_DELAY : (nextObjectInColumn.StartTime - endTime) * 0.9;
+
+                yield return new HitPoint { Time = currentObject.StartTime, Column = currentObject.Column };
+
+                yield return new ReleasePoint { Time = endTime + calculatedDelay, Column = currentObject.Column };
             }
         }
 
+        protected override HitObject GetNextObject(int currentIndex)
+        {
+            int desiredColumn = Beatmap.HitObjects[currentIndex].Column;
+
+            for (int i = currentIndex + 1; i < Beatmap.HitObjects.Count; i++)
+            {
+                if (Beatmap.HitObjects[i].Column == desiredColumn)
+                    return Beatmap.HitObjects[i];
+            }
+
+            return null;
+        }
+
         private interface IActionPoint
         {
             double Time { get; set; }

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.15.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoPlayfield.cs

@@ -247,10 +247,6 @@ namespace osu.Game.Rulesets.Taiko.Tests
                 : base(hitObject)
             {
             }
-
-            protected override void UpdateState(ArmedState state)
-            {
-            }
         }
     }
 }

osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.15.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableBarLine.cs

@@ -53,9 +53,5 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 Alpha = 0.75f
             });
         }
-
-        protected override void UpdateState(ArmedState state)
-        {
-        }
     }
 }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRoll.cs

@@ -88,13 +88,13 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 ApplyResult(r => r.Type = HitResult.Miss);
         }
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
             switch (state)
             {
                 case ArmedState.Hit:
                 case ArmedState.Miss:
-                    this.FadeOut(100).Expire();
+                    this.Delay(HitObject.Duration).FadeOut(100).Expire();
                     break;
             }
         }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRollTick.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             ApplyResult(r => r.Type = HitResult.Great);
         }
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
             switch (state)
             {

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs

@@ -92,17 +92,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             Size = BaseSize * Parent.RelativeChildSize;
         }
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateStateTransforms(ArmedState state)
         {
-            // TODO: update to use new state management.
+            switch (state)
-            var circlePiece = MainPiece as CirclePiece;
-            circlePiece?.FlashBox.FinishTransforms();
-
-            var offset = !AllJudged ? 0 : Time.Current - HitObject.StartTime;
-
-            using (BeginDelayedSequence(HitObject.StartTime - Time.Current + offset, true))
-            {
-                switch (State.Value)
             {
                 case ArmedState.Idle:
                     validActionPressed = false;
@@ -120,13 +112,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                     // If we're far enough away from the left stage, we should bring outselves in front of it
                     ProxyContent();
 
-                        var flash = circlePiece?.FlashBox;
+                    var flash = (MainPiece as CirclePiece)?.FlashBox;
-
+                    flash?.FadeTo(0.9f).FadeOut(300);
-                        if (flash != null)
-                        {
-                            flash.FadeTo(0.9f);
-                            flash.FadeOut(300);
-                        }
 
                     const float gravity_time = 300;
                     const float gravity_travel_height = 200;
@@ -143,7 +130,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                     break;
             }
         }
-        }
 
         protected override DrawableStrongNestedHit CreateStrongHit(StrongHitObject hitObject) => new StrongNestedHit(hitObject, this);
 

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableStrongNestedHit.cs

@@ -18,9 +18,5 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
             MainObject = mainObject;
         }
-
-        protected override void UpdateState(ArmedState state)
-        {
-        }
     }
 }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs

@@ -25,6 +25,11 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         private const float target_ring_scale = 5f;
         private const float inner_ring_alpha = 0.65f;
 
+        /// <summary>
+        /// Offset away from the start time of the swell at which the ring starts appearing.
+        /// </summary>
+        private const double ring_appear_offset = 100;
+
         private readonly List<DrawableSwellTick> ticks = new List<DrawableSwellTick>();
 
         private readonly Container bodyContainer;
@@ -179,26 +184,34 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             }
         }
 
-        protected override void UpdateState(ArmedState state)
+        protected override void UpdateInitialTransforms()
         {
-            const float preempt = 100;
+            base.UpdateInitialTransforms();
-            const float out_transition_time = 300;
+
+            using (BeginAbsoluteSequence(HitObject.StartTime - ring_appear_offset, true))
+                targetRing.ScaleTo(target_ring_scale, 400, Easing.OutQuint);
+        }
+
+        protected override void UpdateStateTransforms(ArmedState state)
+        {
+            const double transition_duration = 300;
 
             switch (state)
             {
                 case ArmedState.Idle:
-                    UnproxyContent();
                     expandingRing.FadeTo(0);
-                    using (BeginAbsoluteSequence(HitObject.StartTime - preempt, true))
-                        targetRing.ScaleTo(target_ring_scale, preempt * 4, Easing.OutQuint);
                     break;
 
                 case ArmedState.Miss:
                 case ArmedState.Hit:
-                    this.FadeOut(out_transition_time, Easing.Out);
+                    using (BeginAbsoluteSequence(Time.Current, true))
-                    bodyContainer.ScaleTo(1.4f, out_transition_time);
+                    {
+                        this.FadeOut(transition_duration, Easing.Out);
+                        bodyContainer.ScaleTo(1.4f, transition_duration);
 
                         Expire();
+                    }
+
                     break;
             }
         }
@@ -212,9 +225,10 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             // Make the swell stop at the hit target
             X = Math.Max(0, X);
 
-            double t = Math.Min(HitObject.StartTime, Time.Current);
+            if (Time.Current >= HitObject.StartTime - ring_appear_offset)
-            if (t == HitObject.StartTime)
                 ProxyContent();
+            else
+                UnproxyContent();
         }
 
         private bool? lastWasCentre;

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwellTick.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
@@ -21,10 +20,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
         }
 
-        protected override void UpdateState(ArmedState state)
-        {
-        }
-
         public override bool OnPressed(TaikoAction action) => false;
     }
 }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs

@@ -78,10 +78,31 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         public abstract bool OnPressed(TaikoAction action);
         public virtual bool OnReleased(TaikoAction action) => false;
 
+        protected override void UpdateInitialTransforms() => this.FadeIn();
+
+        public override double LifetimeStart
+        {
+            get => base.LifetimeStart;
+            set
+            {
+                base.LifetimeStart = value;
+                proxiedContent.LifetimeStart = value;
+            }
+        }
+
+        public override double LifetimeEnd
+        {
+            get => base.LifetimeEnd;
+            set
+            {
+                base.LifetimeEnd = value;
+                proxiedContent.LifetimeEnd = value;
+            }
+        }
+
         private class ProxiedContentContainer : Container
         {
-            public override double LifetimeStart => Parent?.LifetimeStart ?? base.LifetimeStart;
+            public override bool RemoveWhenNotAlive => false;
-            public override double LifetimeEnd => Parent?.LifetimeEnd ?? base.LifetimeEnd;
         }
     }
 
@@ -121,8 +142,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             }
         }
 
-        protected override bool UseTransformStateManagement => false;
-
         // Normal and clap samples are handled by the drum
         protected override IEnumerable<HitSampleInfo> GetSamples() => HitObject.Samples.Where(s => s.Name != HitSampleInfo.HIT_NORMAL && s.Name != HitSampleInfo.HIT_CLAP);
 

osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs

@@ -10,6 +10,7 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Replays
 {
@@ -113,7 +114,13 @@ namespace osu.Game.Rulesets.Taiko.Replays
                 else
                     throw new InvalidOperationException("Unknown hit object type.");
 
-                Frames.Add(new TaikoReplayFrame(endTime + KEY_UP_DELAY));
+                var nextHitObject = GetNextObject(i); // Get the next object that requires pressing the same button
+
+                bool canDelayKeyUp = nextHitObject == null || nextHitObject.StartTime > endTime + KEY_UP_DELAY;
+
+                double calculatedDelay = canDelayKeyUp ? KEY_UP_DELAY : (nextHitObject.StartTime - endTime) * 0.9;
+
+                Frames.Add(new TaikoReplayFrame(endTime + calculatedDelay));
 
                 if (i < Beatmap.HitObjects.Count - 1)
                 {
@@ -127,5 +134,24 @@ namespace osu.Game.Rulesets.Taiko.Replays
 
             return Replay;
         }
+
+        protected override HitObject GetNextObject(int currentIndex)
+        {
+            Type desiredType = Beatmap.HitObjects[currentIndex].GetType();
+
+            for (int i = currentIndex + 1; i < Beatmap.HitObjects.Count; i++)
+            {
+                var currentObj = Beatmap.HitObjects[i];
+
+                if (currentObj.GetType() == desiredType ||
+                    // Un-press all keys before a DrumRoll or Swell
+                    currentObj is DrumRoll || currentObj is Swell)
+                {
+                    return Beatmap.HitObjects[i];
+                }
+            }
+
+            return null;
+        }
     }
 }

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

@@ -200,10 +200,6 @@ namespace osu.Game.Tests.Visual.Gameplay
                         break;
                 }
             }
-
-            protected override void UpdateState(ArmedState state)
-            {
-            }
         }
 
         private class TestDrawableHitObject : DrawableHitObject<HitObject>
@@ -216,10 +212,6 @@ namespace osu.Game.Tests.Visual.Gameplay
 
                 AddInternal(new Box { Size = new Vector2(75) });
             }
-
-            protected override void UpdateState(ArmedState state)
-            {
-            }
         }
     }
 }

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

@@ -135,6 +135,9 @@ namespace osu.Game.Tests.Visual.Online
             });
 
             downloadAssert(true);
+
+            AddStep("show many difficulties", () => overlay.ShowBeatmapSet(createManyDifficultiesBeatmapSet()));
+            downloadAssert(true);
         }
 
         [Test]
@@ -222,6 +225,56 @@ namespace osu.Game.Tests.Visual.Online
             AddStep(@"show without reload", overlay.Show);
         }
 
+        private BeatmapSetInfo createManyDifficultiesBeatmapSet()
+        {
+            var beatmaps = new List<BeatmapInfo>();
+
+            for (int i = 1; i < 41; i++)
+            {
+                beatmaps.Add(new BeatmapInfo
+                {
+                    OnlineBeatmapID = i * 10,
+                    Version = $"Test #{i}",
+                    Ruleset = Ruleset.Value,
+                    StarDifficulty = 2 + i * 0.1,
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        OverallDifficulty = 3.5f,
+                    },
+                    OnlineInfo = new BeatmapOnlineInfo(),
+                    Metrics = new BeatmapMetrics
+                    {
+                        Fails = Enumerable.Range(1, 100).Select(j => j % 12 - 6).ToArray(),
+                        Retries = Enumerable.Range(-2, 100).Select(j => j % 12 - 6).ToArray(),
+                    },
+                });
+            }
+
+            return new BeatmapSetInfo
+            {
+                OnlineBeatmapSetID = 123,
+                Metadata = new BeatmapMetadata
+                {
+                    Title = @"many difficulties beatmap",
+                    Artist = @"none",
+                    Author = new User
+                    {
+                        Username = @"BanchoBot",
+                        Id = 3,
+                    },
+                },
+                OnlineInfo = new BeatmapSetOnlineInfo
+                {
+                    Preview = @"https://b.ppy.sh/preview/123.mp3",
+                    HasVideo = true,
+                    HasStoryboard = true,
+                    Covers = new BeatmapSetOnlineCovers(),
+                },
+                Metrics = new BeatmapSetMetrics { Ratings = Enumerable.Range(0, 11).ToArray() },
+                Beatmaps = beatmaps,
+            };
+        }
+
         private void downloadAssert(bool shown)
         {
             AddAssert($"is download button {(shown ? "shown" : "hidden")}", () => overlay.DownloadButtonsVisible == shown);

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

@@ -9,7 +9,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays.Direct;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
 using osu.Game.Users;
 using osuTK;
 
@@ -24,7 +23,7 @@ namespace osu.Game.Tests.Visual.Online
             typeof(IconPill)
         };
 
-        private BeatmapSetInfo getUndownloadableBeatmapSet(RulesetInfo ruleset) => new BeatmapSetInfo
+        private BeatmapSetInfo getUndownloadableBeatmapSet() => new BeatmapSetInfo
         {
             OnlineBeatmapSetID = 123,
             Metadata = new BeatmapMetadata
@@ -56,23 +55,62 @@ namespace osu.Game.Tests.Visual.Online
             {
                 new BeatmapInfo
                 {
-                    Ruleset = ruleset,
+                    Ruleset = Ruleset.Value,
                     Version = "Test",
                     StarDifficulty = 6.42,
                 }
             }
         };
 
-        [BackgroundDependencyLoader]
+        private BeatmapSetInfo getManyDifficultiesBeatmapSet(RulesetStore rulesets)
-        private void load()
         {
-            var ruleset = new OsuRuleset().RulesetInfo;
+            var beatmaps = new List<BeatmapInfo>();
 
-            var normal = CreateWorkingBeatmap(ruleset).BeatmapSetInfo;
+            for (int i = 0; i < 100; i++)
+            {
+                beatmaps.Add(new BeatmapInfo
+                {
+                    Ruleset = rulesets.GetRuleset(i % 4),
+                    StarDifficulty = 2 + i % 4 * 2,
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        OverallDifficulty = 3.5f,
+                    }
+                });
+            }
+
+            return new BeatmapSetInfo
+            {
+                OnlineBeatmapSetID = 1,
+                Metadata = new BeatmapMetadata
+                {
+                    Title = "many difficulties beatmap",
+                    Artist = "test",
+                    Author = new User
+                    {
+                        Username = "BanchoBot",
+                        Id = 3,
+                    }
+                },
+                OnlineInfo = new BeatmapSetOnlineInfo
+                {
+                    HasVideo = true,
+                    HasStoryboard = true,
+                    Covers = new BeatmapSetOnlineCovers(),
+                },
+                Beatmaps = beatmaps,
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            var normal = CreateWorkingBeatmap(Ruleset.Value).BeatmapSetInfo;
             normal.OnlineInfo.HasVideo = true;
             normal.OnlineInfo.HasStoryboard = true;
 
-            var undownloadable = getUndownloadableBeatmapSet(ruleset);
+            var undownloadable = getUndownloadableBeatmapSet();
+            var manyDifficulties = getManyDifficultiesBeatmapSet(rulesets);
 
             Child = new BasicScrollContainer
             {
@@ -81,15 +119,17 @@ namespace osu.Game.Tests.Visual.Online
                 {
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
-                    Direction = FillDirection.Vertical,
+                    Direction = FillDirection.Full,
                     Padding = new MarginPadding(20),
-                    Spacing = new Vector2(0, 20),
+                    Spacing = new Vector2(5, 20),
                     Children = new Drawable[]
                     {
                         new DirectGridPanel(normal),
-                        new DirectListPanel(normal),
                         new DirectGridPanel(undownloadable),
+                        new DirectGridPanel(manyDifficulties),
+                        new DirectListPanel(normal),
                         new DirectListPanel(undownloadable),
+                        new DirectListPanel(manyDifficulties),
                     },
                 },
             };

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs

@@ -516,6 +516,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                     OnlineBeatmapID = b * 10,
                     Path = $"extra{b}.osu",
                     Version = $"Extra {b}",
+                    Ruleset = rulesets.GetRuleset((b - 1) % 4),
                     StarDifficulty = 2,
                     BaseDifficulty = new BeatmapDifficulty
                     {

osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs

@@ -15,6 +15,7 @@ using osu.Framework.MathUtils;
 using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
@@ -79,8 +80,12 @@ namespace osu.Game.Tests.Visual.SongSelect
             Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, defaultBeatmap = Beatmap.Default));
 
             Beatmap.SetDefault();
+
+            Dependencies.Cache(config = new OsuConfigManager(LocalStorage));
         }
 
+        private OsuConfigManager config;
+
         [SetUp]
         public virtual void SetUp() => Schedule(() =>
         {
@@ -111,13 +116,15 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
 
-            AddStep(@"Sort by Artist", delegate { songSelect.FilterControl.Sort = SortMode.Artist; });
+            var sortMode = config.GetBindable<SortMode>(OsuSetting.SongSelectSortingMode);
-            AddStep(@"Sort by Title", delegate { songSelect.FilterControl.Sort = SortMode.Title; });
+
-            AddStep(@"Sort by Author", delegate { songSelect.FilterControl.Sort = SortMode.Author; });
+            AddStep(@"Sort by Artist", delegate { sortMode.Value = SortMode.Artist; });
-            AddStep(@"Sort by DateAdded", delegate { songSelect.FilterControl.Sort = SortMode.DateAdded; });
+            AddStep(@"Sort by Title", delegate { sortMode.Value = SortMode.Title; });
-            AddStep(@"Sort by BPM", delegate { songSelect.FilterControl.Sort = SortMode.BPM; });
+            AddStep(@"Sort by Author", delegate { sortMode.Value = SortMode.Author; });
-            AddStep(@"Sort by Length", delegate { songSelect.FilterControl.Sort = SortMode.Length; });
+            AddStep(@"Sort by DateAdded", delegate { sortMode.Value = SortMode.DateAdded; });
-            AddStep(@"Sort by Difficulty", delegate { songSelect.FilterControl.Sort = SortMode.Difficulty; });
+            AddStep(@"Sort by BPM", delegate { sortMode.Value = SortMode.BPM; });
+            AddStep(@"Sort by Length", delegate { sortMode.Value = SortMode.Length; });
+            AddStep(@"Sort by Difficulty", delegate { sortMode.Value = SortMode.Difficulty; });
         }
 
         [Test]

osu.Game.Tests/osu.Game.Tests.csproj

@@ -5,7 +5,7 @@
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.15.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Tournament.Tests/osu.Game.Tournament.Tests.csproj

@@ -7,7 +7,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.15.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game/Beatmaps/BeatmapManager_WorkingBeatmap.cs

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

osu.Game/Beatmaps/Drawables/DifficultyIcon.cs

@@ -19,23 +19,33 @@ using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.Drawables
 {
-    public class DifficultyIcon : Container, IHasCustomTooltip
+    public class DifficultyIcon : CompositeDrawable, IHasCustomTooltip
     {
         private readonly BeatmapInfo beatmap;
         private readonly RulesetInfo ruleset;
 
+        private readonly Container iconContainer;
+
+        /// <summary>
+        /// Size of this difficulty icon.
+        /// </summary>
+        public new Vector2 Size
+        {
+            get => iconContainer.Size;
+            set => iconContainer.Size = value;
+        }
+
         public DifficultyIcon(BeatmapInfo beatmap, RulesetInfo ruleset = null, bool shouldShowTooltip = true)
         {
-            if (beatmap == null)
+            this.beatmap = beatmap ?? throw new ArgumentNullException(nameof(beatmap));
-                throw new ArgumentNullException(nameof(beatmap));
-
-            this.beatmap = beatmap;
 
             this.ruleset = ruleset ?? beatmap.Ruleset;
             if (shouldShowTooltip)
                 TooltipContent = beatmap;
 
-            Size = new Vector2(20);
+            AutoSizeAxes = Axes.Both;
+
+            InternalChild = iconContainer = new Container { Size = new Vector2(20f) };
         }
 
         public string TooltipText { get; set; }
@@ -47,7 +57,7 @@ namespace osu.Game.Beatmaps.Drawables
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            Children = new Drawable[]
+            iconContainer.Children = new Drawable[]
             {
                 new CircularContainer
                 {

osu.Game/Beatmaps/Drawables/GroupedDifficultyIcon.cs

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

osu.Game/Configuration/OsuConfigManager.cs

@@ -8,6 +8,7 @@ using osu.Framework.Platform;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
 
 namespace osu.Game.Configuration
 {
@@ -25,6 +26,9 @@ namespace osu.Game.Configuration
             Set(OsuSetting.DisplayStarsMinimum, 0.0, 0, 10, 0.1);
             Set(OsuSetting.DisplayStarsMaximum, 10.0, 0, 10, 0.1);
 
+            Set(OsuSetting.SongSelectGroupingMode, GroupMode.All);
+            Set(OsuSetting.SongSelectSortingMode, SortMode.Title);
+
             Set(OsuSetting.RandomSelectAlgorithm, RandomSelectAlgorithm.RandomPermutation);
 
             Set(OsuSetting.ChatDisplayHeight, ChatOverlay.DEFAULT_HEIGHT, 0.2, 1);
@@ -150,6 +154,8 @@ namespace osu.Game.Configuration
         SaveUsername,
         DisplayStarsMinimum,
         DisplayStarsMaximum,
+        SongSelectGroupingMode,
+        SongSelectSortingMode,
         RandomSelectAlgorithm,
         ShowFpsDisplay,
         ChatDisplayHeight,

osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs

@@ -91,7 +91,8 @@ namespace osu.Game.Overlays.BeatmapSet
                     {
                         difficulties = new DifficultiesContainer
                         {
-                            AutoSizeAxes = Axes.Both,
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
                             Margin = new MarginPadding { Left = -(tile_icon_padding + tile_spacing / 2) },
                             OnLostHover = () =>
                             {

osu.Game/Overlays/Direct/DirectGridPanel.cs

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

osu.Game/Overlays/Direct/DirectListPanel.cs

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

osu.Game/Overlays/Direct/DirectPanel.cs

@@ -28,6 +28,7 @@ namespace osu.Game.Overlays.Direct
         public readonly BeatmapSetInfo SetInfo;
 
         private const double hover_transition_time = 400;
+        private const int maximum_difficulty_icons = 15;
 
         private Container content;
 
@@ -138,10 +139,16 @@ namespace osu.Game.Overlays.Direct
             };
         }
 
-        protected List<DifficultyIcon> GetDifficultyIcons()
+        protected List<DifficultyIcon> GetDifficultyIcons(OsuColour colours)
         {
             var icons = new List<DifficultyIcon>();
 
+            if (SetInfo.Beatmaps.Count > maximum_difficulty_icons)
+            {
+                foreach (var ruleset in SetInfo.Beatmaps.Select(b => b.Ruleset).Distinct())
+                    icons.Add(new GroupedDifficultyIcon(SetInfo.Beatmaps.FindAll(b => b.Ruleset.Equals(ruleset)), ruleset, this is DirectListPanel ? Color4.White : colours.Gray5));
+            }
+            else
                 foreach (var b in SetInfo.Beatmaps.OrderBy(beatmap => beatmap.StarDifficulty))
                     icons.Add(new DifficultyIcon(b));
 

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

@@ -132,6 +132,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </summary>
         public event Action<DrawableHitObject, ArmedState> ApplyCustomUpdateState;
 
+#pragma warning disable 618 // (legacy state management) - can be removed 20200227
+
         /// <summary>
         /// Enables automatic transform management of this hitobject. Implementation of transforms should be done in <see cref="UpdateInitialTransforms"/> and <see cref="UpdateStateTransforms"/> only. Rewinding and removing previous states is done automatically.
         /// </summary>
@@ -139,6 +141,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// Going forward, this is the preferred way of implementing <see cref="DrawableHitObject"/>s. Previous functionality
         /// is offered as a compatibility layer until all rulesets have been migrated across.
         /// </remarks>
+        [Obsolete("Use UpdateInitialTransforms()/UpdateStateTransforms() instead")] // can be removed 20200227
         protected virtual bool UseTransformStateManagement => true;
 
         protected override void ClearInternal(bool disposeChildren = true) => throw new InvalidOperationException($"Should never clear a {nameof(DrawableHitObject)}");
@@ -219,10 +222,13 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// Should generally not be used when <see cref="UseTransformStateManagement"/> is true; use <see cref="UpdateStateTransforms"/> instead.
         /// </summary>
         /// <param name="state">The new armed state.</param>
+        [Obsolete("Use UpdateInitialTransforms()/UpdateStateTransforms() instead")] // can be removed 20200227
         protected virtual void UpdateState(ArmedState state)
         {
         }
 
+#pragma warning restore 618
+
         #endregion
 
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)

osu.Game/Rulesets/Replays/AutoGenerator.cs

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

osu.Game/Rulesets/RulesetConfigCache.cs

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

osu.Game/Rulesets/UI/DrawableRuleset.cs

@@ -62,13 +62,20 @@ namespace osu.Game.Rulesets.UI
 
         public override GameplayClock FrameStableClock => frameStabilityContainer.GameplayClock;
 
+        private bool frameStablePlayback = true;
+
         /// <summary>
         /// Whether to enable frame-stable playback.
         /// </summary>
         internal bool FrameStablePlayback
         {
-            get => frameStabilityContainer.FrameStablePlayback;
+            get => frameStablePlayback;
-            set => frameStabilityContainer.FrameStablePlayback = value;
+            set
+            {
+                frameStablePlayback = false;
+                if (frameStabilityContainer != null)
+                    frameStabilityContainer.FrameStablePlayback = value;
+            }
         }
 
         /// <summary>
@@ -156,6 +163,7 @@ namespace osu.Game.Rulesets.UI
             {
                 frameStabilityContainer = new FrameStabilityContainer(GameplayStartTime)
                 {
+                    FrameStablePlayback = FrameStablePlayback,
                     Child = KeyBindingInputManager
                         .WithChild(CreatePlayfieldAdjustmentContainer()
                             .WithChild(Playfield)

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

@@ -12,8 +12,13 @@ namespace osu.Game.Rulesets.UI.Scrolling
 {
     public class ScrollingHitObjectContainer : HitObjectContainer
     {
-        private readonly IBindable<double> timeRange = new BindableDouble();
+        /// <summary>
+        /// A multiplier applied to the length of the scrolling area to determine a safe default lifetime end for hitobjects.
+        /// This is only used to limit the lifetime end within reason, as proper lifetime management should be implemented on hitobjects themselves.
+        /// </summary>
+        private const float safe_lifetime_end_multiplier = 2;
 
+        private readonly IBindable<double> timeRange = new BindableDouble();
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
         [Resolved]
@@ -88,24 +93,29 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
         private void computeInitialStateRecursive(DrawableHitObject hitObject)
         {
-            hitObject.LifetimeStart = scrollingInfo.Algorithm.GetDisplayStartTime(hitObject.HitObject.StartTime, timeRange.Value);
+            double endTime = hitObject.HitObject.StartTime;
 
-            if (hitObject.HitObject is IHasEndTime endTime)
+            if (hitObject.HitObject is IHasEndTime e)
             {
+                endTime = e.EndTime;
+
                 switch (direction.Value)
                 {
                     case ScrollingDirection.Up:
                     case ScrollingDirection.Down:
-                        hitObject.Height = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, timeRange.Value, scrollLength);
+                        hitObject.Height = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime, timeRange.Value, scrollLength);
                         break;
 
                     case ScrollingDirection.Left:
                     case ScrollingDirection.Right:
-                        hitObject.Width = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, timeRange.Value, scrollLength);
+                        hitObject.Width = scrollingInfo.Algorithm.GetLength(hitObject.HitObject.StartTime, endTime, timeRange.Value, scrollLength);
                         break;
                 }
             }
 
+            hitObject.LifetimeStart = scrollingInfo.Algorithm.GetDisplayStartTime(hitObject.HitObject.StartTime, timeRange.Value);
+            hitObject.LifetimeEnd = scrollingInfo.Algorithm.TimeAt(scrollLength * safe_lifetime_end_multiplier, endTime, timeRange.Value, scrollLength);
+
             foreach (var obj in hitObject.NestedHitObjects)
             {
                 computeInitialStateRecursive(obj);

osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs

@@ -19,6 +19,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
+using osu.Game.Rulesets;
 using osuTK;
 using osuTK.Graphics;
 
@@ -95,11 +96,11 @@ namespace osu.Game.Screens.Select.Carousel
                                     TextPadding = new MarginPadding { Horizontal = 8, Vertical = 2 },
                                     Status = beatmapSet.Status
                                 },
-                                new FillFlowContainer<FilterableDifficultyIcon>
+                                new FillFlowContainer<DifficultyIcon>
                                 {
                                     AutoSizeAxes = Axes.Both,
                                     Spacing = new Vector2(3),
-                                    Children = ((CarouselBeatmapSet)Item).Beatmaps.Select(b => new FilterableDifficultyIcon(b)).ToList()
+                                    ChildrenEnumerable = getDifficultyIcons(),
                                 },
                             }
                         }
@@ -108,6 +109,17 @@ namespace osu.Game.Screens.Select.Carousel
             };
         }
 
+        private const int maximum_difficulty_icons = 18;
+
+        private IEnumerable<DifficultyIcon> getDifficultyIcons()
+        {
+            var beatmaps = ((CarouselBeatmapSet)Item).Beatmaps.ToList();
+
+            return beatmaps.Count > maximum_difficulty_icons
+                ? (IEnumerable<DifficultyIcon>)beatmaps.GroupBy(b => b.Beatmap.Ruleset).Select(group => new FilterableGroupedDifficultyIcon(group.ToList(), group.Key))
+                : beatmaps.Select(b => new FilterableDifficultyIcon(b));
+        }
+
         public MenuItem[] ContextMenuItems
         {
             get
@@ -205,5 +217,27 @@ namespace osu.Game.Screens.Select.Carousel
                 filtered.TriggerChange();
             }
         }
+
+        public class FilterableGroupedDifficultyIcon : GroupedDifficultyIcon
+        {
+            private readonly List<CarouselBeatmap> items;
+
+            public FilterableGroupedDifficultyIcon(List<CarouselBeatmap> items, RulesetInfo ruleset)
+                : base(items.Select(i => i.Beatmap).ToList(), ruleset, Color4.White)
+            {
+                this.items = items;
+
+                foreach (var item in items)
+                    item.Filtered.BindValueChanged(_ => Scheduler.AddOnce(updateFilteredDisplay));
+
+                updateFilteredDisplay();
+            }
+
+            private void updateFilteredDisplay()
+            {
+                // for now, fade the whole group based on the ratio of hidden items.
+                this.FadeTo(1 - 0.9f * ((float)items.Count(i => i.Filtered.Value) / items.Count), 100);
+            }
+        }
     }
 }

osu.Game/Screens/Select/FilterControl.cs

@@ -29,40 +29,14 @@ namespace osu.Game.Screens.Select
 
         private readonly TabControl<GroupMode> groupTabs;
 
-        private SortMode sort = SortMode.Title;
+        private Bindable<SortMode> sortMode;
 
-        public SortMode Sort
+        private Bindable<GroupMode> groupMode;
-        {
-            get => sort;
-            set
-            {
-                if (sort != value)
-                {
-                    sort = value;
-                    FilterChanged?.Invoke(CreateCriteria());
-                }
-            }
-        }
-
-        private GroupMode group = GroupMode.All;
-
-        public GroupMode Group
-        {
-            get => group;
-            set
-            {
-                if (group != value)
-                {
-                    group = value;
-                    FilterChanged?.Invoke(CreateCriteria());
-                }
-            }
-        }
 
         public FilterCriteria CreateCriteria() => new FilterCriteria
         {
-            Group = group,
+            Group = groupMode.Value,
-            Sort = sort,
+            Sort = sortMode.Value,
             SearchText = searchTextBox.Text,
             AllowConvertedBeatmaps = showConverted.Value,
             Ruleset = ruleset.Value
@@ -122,7 +96,6 @@ namespace osu.Game.Screens.Select
                                     Height = 24,
                                     Width = 0.5f,
                                     AutoSort = true,
-                                    Current = { Value = GroupMode.Title }
                                 },
                                 //spriteText = new OsuSpriteText
                                 //{
@@ -141,7 +114,6 @@ namespace osu.Game.Screens.Select
                                     Width = 0.5f,
                                     Height = 24,
                                     AutoSort = true,
-                                    Current = { Value = SortMode.Title }
                                 }
                             }
                         },
@@ -153,8 +125,6 @@ namespace osu.Game.Screens.Select
 
             groupTabs.PinItem(GroupMode.All);
             groupTabs.PinItem(GroupMode.RecentlyPlayed);
-            groupTabs.Current.ValueChanged += group => Group = group.NewValue;
-            sortTabs.Current.ValueChanged += sort => Sort = sort.NewValue;
         }
 
         public void Deactivate()
@@ -184,7 +154,18 @@ namespace osu.Game.Screens.Select
             showConverted.ValueChanged += _ => updateCriteria();
 
             ruleset.BindTo(parentRuleset);
-            ruleset.BindValueChanged(_ => updateCriteria(), true);
+            ruleset.BindValueChanged(_ => updateCriteria());
+
+            sortMode = config.GetBindable<SortMode>(OsuSetting.SongSelectSortingMode);
+            groupMode = config.GetBindable<GroupMode>(OsuSetting.SongSelectGroupingMode);
+
+            sortTabs.Current.BindTo(sortMode);
+            groupTabs.Current.BindTo(groupMode);
+
+            groupMode.BindValueChanged(_ => updateCriteria());
+            sortMode.BindValueChanged(_ => updateCriteria());
+
+            updateCriteria();
         }
 
         private void updateCriteria() => FilterChanged?.Invoke(CreateCriteria());

osu.Game/Skinning/LegacySkin.cs

@@ -160,6 +160,35 @@ namespace osu.Game.Skinning
             return getAnimation(componentName, animatable, looping);
         }
 
+        public override Texture GetTexture(string componentName)
+        {
+            componentName = getFallbackName(componentName);
+
+            float ratio = 2;
+            var texture = Textures.Get($"{componentName}@2x");
+
+            if (texture == null)
+            {
+                ratio = 1;
+                texture = Textures.Get(componentName);
+            }
+
+            if (texture != null)
+                texture.ScaleAdjust = ratio;
+
+            return texture;
+        }
+
+        public override SampleChannel GetSample(string sampleName) => Samples.Get(getFallbackName(sampleName));
+
+        private bool hasFont(string fontName) => GetTexture($"{fontName}-0") != null;
+
+        private string getFallbackName(string componentName)
+        {
+            string lastPiece = componentName.Split('/').Last();
+            return componentName.StartsWith("Gameplay/taiko/") ? "taiko-" + lastPiece : lastPiece;
+        }
+
         private Drawable getAnimation(string componentName, bool animatable, bool looping, string animationSeparator = "-")
         {
             Texture texture;
@@ -195,27 +224,6 @@ namespace osu.Game.Skinning
             return null;
         }
 
-        public override Texture GetTexture(string componentName)
-        {
-            float ratio = 2;
-            var texture = Textures.Get($"{componentName}@2x");
-
-            if (texture == null)
-            {
-                ratio = 1;
-                texture = Textures.Get(componentName);
-            }
-
-            if (texture != null)
-                texture.ScaleAdjust = ratio;
-
-            return texture;
-        }
-
-        public override SampleChannel GetSample(string sampleName) => Samples.Get(sampleName);
-
-        private bool hasFont(string fontName) => GetTexture($"{fontName}-0") != null;
-
         protected class LegacySkinResourceStore<T> : IResourceStore<byte[]>
             where T : INamedFileInfo
         {
@@ -226,11 +234,8 @@ namespace osu.Game.Skinning
             {
                 bool hasExtension = filename.Contains('.');
 
-                string lastPiece = filename.Split('/').Last();
-                var legacyName = filename.StartsWith("Gameplay/taiko/") ? "taiko-" + lastPiece : lastPiece;
-
                 var file = source.Files.Find(f =>
-                    string.Equals(hasExtension ? f.Filename : Path.ChangeExtension(f.Filename, null), legacyName, StringComparison.InvariantCultureIgnoreCase));
+                    string.Equals(hasExtension ? f.Filename : Path.ChangeExtension(f.Filename, null), filename, StringComparison.InvariantCultureIgnoreCase));
                 return file?.FileInfo.StoragePath;
             }