Merge pull request #9593 from peppy/editor-show-selected-count

Show count of selected objects in selection box

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.714.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.715.0" />
     <PackageReference Include="ppy.osu.Framework.Android" Version="2020.714.1" />
   </ItemGroup>
 </Project>

osu.Game.Rulesets.Catch.Tests/TestSceneCatchModHidden.cs

@@ -0,0 +1,56 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Catch.Mods;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    public class TestSceneCatchModHidden : ModTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            LocalConfig.Set(OsuSetting.IncreaseFirstObjectVisibility, false);
+        }
+
+        [Test]
+        public void TestJuiceStream()
+        {
+            CreateModTest(new ModTestData
+            {
+                Beatmap = new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new JuiceStream
+                        {
+                            StartTime = 1000,
+                            Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(0, -192) }),
+                            X = CatchPlayfield.WIDTH / 2
+                        }
+                    }
+                },
+                Mod = new CatchModHidden(),
+                PassCondition = () => Player.Results.Count > 0
+                                      && Player.ChildrenOfType<DrawableJuiceStream>().Single().Alpha > 0
+                                      && Player.ChildrenOfType<DrawableFruit>().Last().Alpha > 0
+            });
+        }
+
+        protected override Ruleset CreatePlayerRuleset() => new CatchRuleset();
+    }
+}

osu.Game.Rulesets.Catch.Tests/TestSceneCatcherArea.cs

@@ -9,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
@@ -25,6 +26,11 @@ namespace osu.Game.Rulesets.Catch.Tests
     {
         private RulesetInfo catchRuleset;
 
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        private Catcher catcher => this.ChildrenOfType<CatcherArea>().First().MovableCatcher;
+
         public TestSceneCatcherArea()
         {
             AddSliderStep<float>("CircleSize", 0, 8, 5, createCatcher);
@@ -34,24 +40,43 @@ namespace osu.Game.Rulesets.Catch.Tests
 
             AddRepeatStep("catch fruit", () => catchFruit(new TestFruit(false)
             {
-                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X
+                X = catcher.X
             }), 20);
             AddRepeatStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
             {
-                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X,
+                X = catcher.X,
                 LastInCombo = true,
             }), 20);
             AddRepeatStep("catch kiai fruit", () => catchFruit(new TestFruit(true)
             {
-                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X,
+                X = catcher.X
             }), 20);
             AddRepeatStep("miss fruit", () => catchFruit(new Fruit
             {
-                X = this.ChildrenOfType<CatcherArea>().First().MovableCatcher.X + 100,
+                X = catcher.X + 100,
                 LastInCombo = true,
             }, true), 20);
         }
 
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestHitLighting(bool enable)
+        {
+            AddStep("create catcher", () => createCatcher(5));
+
+            AddStep("toggle hit lighting", () => config.Set(OsuSetting.HitLighting, enable));
+            AddStep("catch fruit", () => catchFruit(new TestFruit(false)
+            {
+                X = catcher.X
+            }));
+            AddStep("catch fruit last in combo", () => catchFruit(new TestFruit(false)
+            {
+                X = catcher.X,
+                LastInCombo = true
+            }));
+            AddAssert("check hit explosion", () => catcher.ChildrenOfType<HitExplosion>().Any() == enable);
+        }
+
         private void catchFruit(Fruit fruit, bool miss = false)
         {
             this.ChildrenOfType<CatcherArea>().ForEach(area =>

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

@@ -35,22 +35,25 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> createDrawableRepresentation)
         {
-            Container explodingFruitContainer;
-
-            InternalChildren = new Drawable[]
+            var explodingFruitContainer = new Container
             {
-                explodingFruitContainer = new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                },
-                CatcherArea = new CatcherArea(difficulty)
-                {
-                    CreateDrawableRepresentation = createDrawableRepresentation,
-                    ExplodingFruitTarget = explodingFruitContainer,
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.TopLeft,
-                },
-                HitObjectContainer
+                RelativeSizeAxes = Axes.Both,
+            };
+
+            CatcherArea = new CatcherArea(difficulty)
+            {
+                CreateDrawableRepresentation = createDrawableRepresentation,
+                ExplodingFruitTarget = explodingFruitContainer,
+                Anchor = Anchor.BottomLeft,
+                Origin = Anchor.TopLeft,
+            };
+
+            InternalChildren = new[]
+            {
+                explodingFruitContainer,
+                CatcherArea.MovableCatcher.CreateProxiedContent(),
+                HitObjectContainer,
+                CatcherArea
             };
         }
 

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

@@ -5,12 +5,14 @@ using System;
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Skinning;
@@ -46,6 +48,12 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public Container ExplodingFruitTarget;
 
+        private Container<DrawableHitObject> caughtFruitContainer { get; } = new Container<DrawableHitObject>
+        {
+            Anchor = Anchor.TopCentre,
+            Origin = Anchor.BottomCentre,
+        };
+
         [NotNull]
         private readonly Container trailsTarget;
 
@@ -83,8 +91,6 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         private readonly float catchWidth;
 
-        private Container<DrawableHitObject> caughtFruit;
-
         private CatcherSprite catcherIdle;
         private CatcherSprite catcherKiai;
         private CatcherSprite catcherFail;
@@ -99,6 +105,7 @@ namespace osu.Game.Rulesets.Catch.UI
         private double hyperDashModifier = 1;
         private int hyperDashDirection;
         private float hyperDashTargetPosition;
+        private Bindable<bool> hitLighting;
 
         public Catcher([NotNull] Container trailsTarget, BeatmapDifficulty difficulty = null)
         {
@@ -114,15 +121,13 @@ namespace osu.Game.Rulesets.Catch.UI
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OsuConfigManager config)
         {
+            hitLighting = config.GetBindable<bool>(OsuSetting.HitLighting);
+
             InternalChildren = new Drawable[]
             {
-                caughtFruit = new Container<DrawableHitObject>
-                {
-                    Anchor = Anchor.TopCentre,
-                    Origin = Anchor.BottomCentre,
-                },
+                caughtFruitContainer,
                 catcherIdle = new CatcherSprite(CatcherAnimationState.Idle)
                 {
                     Anchor = Anchor.TopCentre,
@@ -145,6 +150,11 @@ namespace osu.Game.Rulesets.Catch.UI
             updateCatcher();
         }
 
+        /// <summary>
+        /// Creates proxied content to be displayed beneath hitobjects.
+        /// </summary>
+        public Drawable CreateProxiedContent() => caughtFruitContainer.CreateProxy();
+
         /// <summary>
         /// Calculates the scale of the catcher based off the provided beatmap difficulty.
         /// </summary>
@@ -176,7 +186,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
             const float allowance = 10;
 
-            while (caughtFruit.Any(f =>
+            while (caughtFruitContainer.Any(f =>
                 f.LifetimeEnd == double.MaxValue &&
                 Vector2Extensions.Distance(f.Position, fruit.Position) < (ourRadius + (theirRadius = f.DrawSize.X / 2 * f.Scale.X)) / (allowance / 2)))
             {
@@ -187,13 +197,16 @@ namespace osu.Game.Rulesets.Catch.UI
 
             fruit.X = Math.Clamp(fruit.X, -CatcherArea.CATCHER_SIZE / 2, CatcherArea.CATCHER_SIZE / 2);
 
-            caughtFruit.Add(fruit);
+            caughtFruitContainer.Add(fruit);
 
-            AddInternal(new HitExplosion(fruit)
+            if (hitLighting.Value)
             {
-                X = fruit.X,
-                Scale = new Vector2(fruit.HitObject.Scale)
-            });
+                AddInternal(new HitExplosion(fruit)
+                {
+                    X = fruit.X,
+                    Scale = new Vector2(fruit.HitObject.Scale)
+                });
+            }
         }
 
         /// <summary>
@@ -342,7 +355,7 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         public void Drop()
         {
-            foreach (var f in caughtFruit.ToArray())
+            foreach (var f in caughtFruitContainer.ToArray())
                 Drop(f);
         }
 
@@ -351,7 +364,7 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         public void Explode()
         {
-            foreach (var f in caughtFruit.ToArray())
+            foreach (var f in caughtFruitContainer.ToArray())
                 Explode(f);
         }
 
@@ -450,9 +463,9 @@ namespace osu.Game.Rulesets.Catch.UI
             if (ExplodingFruitTarget != null)
             {
                 fruit.Anchor = Anchor.TopLeft;
-                fruit.Position = caughtFruit.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
+                fruit.Position = caughtFruitContainer.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
 
-                if (!caughtFruit.Remove(fruit))
+                if (!caughtFruitContainer.Remove(fruit))
                     // we may have already been removed by a previous operation (due to the weird OnLoadComplete scheduling).
                     // this avoids a crash on potentially attempting to Add a fruit to ExplodingFruitTarget twice.
                     return;

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

@@ -22,6 +22,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> CreateDrawableRepresentation;
 
+        public readonly Catcher MovableCatcher;
+
         public Container ExplodingFruitTarget
         {
             set => MovableCatcher.ExplodingFruitTarget = value;
@@ -104,7 +106,5 @@ namespace osu.Game.Rulesets.Catch.UI
             if (state?.CatcherX != null)
                 MovableCatcher.X = state.CatcherX.Value;
         }
-
-        protected internal readonly Catcher MovableCatcher;
     }
 }

osu.Game.Rulesets.Mania.Tests/TestScenePlayfieldCoveringContainer.cs

@@ -0,0 +1,56 @@
+// 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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestScenePlayfieldCoveringContainer : OsuTestScene
+    {
+        private readonly ScrollingTestContainer scrollingContainer;
+        private readonly PlayfieldCoveringWrapper cover;
+
+        public TestScenePlayfieldCoveringContainer()
+        {
+            Child = scrollingContainer = new ScrollingTestContainer(ScrollingDirection.Down)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(300, 500),
+                Child = cover = new PlayfieldCoveringWrapper(new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Orange
+                })
+                {
+                    RelativeSizeAxes = Axes.Both,
+                }
+            };
+        }
+
+        [Test]
+        public void TestScrollingDownwards()
+        {
+            AddStep("set down scroll", () => scrollingContainer.Direction = ScrollingDirection.Down);
+            AddStep("set coverage = 0.5", () => cover.Coverage = 0.5f);
+            AddStep("set coverage = 0.8f", () => cover.Coverage = 0.8f);
+            AddStep("set coverage = 0.2f", () => cover.Coverage = 0.2f);
+        }
+
+        [Test]
+        public void TestScrollingUpwards()
+        {
+            AddStep("set up scroll", () => scrollingContainer.Direction = ScrollingDirection.Up);
+            AddStep("set coverage = 0.5", () => cover.Coverage = 0.5f);
+            AddStep("set coverage = 0.8f", () => cover.Coverage = 0.8f);
+            AddStep("set coverage = 0.2f", () => cover.Coverage = 0.2f);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Mods/ManiaModFadeIn.cs

@@ -1,23 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModFadeIn : Mod
+    public class ManiaModFadeIn : ManiaModHidden
     {
         public override string Name => "Fade In";
         public override string Acronym => "FI";
         public override IconUsage? Icon => OsuIcon.ModHidden;
-        public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => @"Keys appear out of nowhere!";
-        public override double ScoreMultiplier => 1;
-        public override bool Ranked => true;
-        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight<ManiaHitObject>) };
+
+        protected override CoverExpandDirection ExpandDirection => CoverExpandDirection.AlongScroll;
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModHidden.cs

@@ -2,15 +2,44 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModHidden : ModHidden
+    public class ManiaModHidden : ModHidden, IApplicableToDrawableRuleset<ManiaHitObject>
     {
         public override string Description => @"Keys fade out before you hit them!";
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight<ManiaHitObject>) };
+
+        /// <summary>
+        /// The direction in which the cover should expand.
+        /// </summary>
+        protected virtual CoverExpandDirection ExpandDirection => CoverExpandDirection.AgainstScroll;
+
+        public virtual void ApplyToDrawableRuleset(DrawableRuleset<ManiaHitObject> drawableRuleset)
+        {
+            ManiaPlayfield maniaPlayfield = (ManiaPlayfield)drawableRuleset.Playfield;
+
+            foreach (Column column in maniaPlayfield.Stages.SelectMany(stage => stage.Columns))
+            {
+                HitObjectContainer hoc = column.HitObjectArea.HitObjectContainer;
+                Container hocParent = (Container)hoc.Parent;
+
+                hocParent.Remove(hoc);
+                hocParent.Add(new PlayfieldCoveringWrapper(hoc).With(c =>
+                {
+                    c.RelativeSizeAxes = Axes.Both;
+                    c.Direction = ExpandDirection;
+                    c.Coverage = 0.5f;
+                }));
+            }
+        }
     }
 }

osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs

@@ -7,6 +7,10 @@ namespace osu.Game.Rulesets.Mania.Scoring
 {
     internal class ManiaScoreProcessor : ScoreProcessor
     {
+        protected override double DefaultAccuracyPortion => 0.8;
+
+        protected override double DefaultComboPortion => 0.2;
+
         public override HitWindows CreateHitWindows() => new ManiaHitWindows();
     }
 }

osu.Game.Rulesets.Mania/Skinning/LegacyBodyPiece.cs

@@ -5,6 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -31,7 +32,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
             string imageName = GetColumnSkinConfig<string>(skin, LegacyManiaSkinConfigurationLookups.HoldNoteBodyImage)?.Value
                                ?? $"mania-note{FallbackColumnIndex}L";
 
-            sprite = skin.GetAnimation(imageName, true, true).With(d =>
+            sprite = skin.GetAnimation(imageName, WrapMode.ClampToEdge, WrapMode.ClampToEdge, true, true).With(d =>
             {
                 if (d == null)
                     return;

osu.Game.Rulesets.Mania/Skinning/LegacyNotePiece.cs

@@ -5,6 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -92,7 +93,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
             string noteImage = GetColumnSkinConfig<string>(skin, lookup)?.Value
                                ?? $"mania-note{FallbackColumnIndex}{suffix}";
 
-            return skin.GetTexture(noteImage);
+            return skin.GetTexture(noteImage, WrapMode.ClampToEdge, WrapMode.ClampToEdge);
         }
     }
 }

osu.Game.Rulesets.Mania/UI/Column.cs

@@ -33,11 +33,11 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public readonly Bindable<ManiaAction> Action = new Bindable<ManiaAction>();
 
-        private readonly ColumnHitObjectArea hitObjectArea;
+        public readonly ColumnHitObjectArea HitObjectArea;
 
         internal readonly Container TopLevelContainer;
 
-        public Container UnderlayElements => hitObjectArea.UnderlayElements;
+        public Container UnderlayElements => HitObjectArea.UnderlayElements;
 
         public Column(int index)
         {
@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Mania.UI
             {
                 // For input purposes, the background is added at the highest depth, but is then proxied back below all other elements
                 background.CreateProxy(),
-                hitObjectArea = new ColumnHitObjectArea(Index, HitObjectContainer) { RelativeSizeAxes = Axes.Both },
+                HitObjectArea = new ColumnHitObjectArea(Index, HitObjectContainer) { RelativeSizeAxes = Axes.Both },
                 new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.KeyArea, Index), _ => new DefaultKeyArea())
                 {
                     RelativeSizeAxes = Axes.Both
@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Mania.UI
                 TopLevelContainer = new Container { RelativeSizeAxes = Axes.Both }
             };
 
-            TopLevelContainer.Add(hitObjectArea.Explosions.CreateProxy());
+            TopLevelContainer.Add(HitObjectArea.Explosions.CreateProxy());
         }
 
         public override Axes RelativeSizeAxes => Axes.Y;
@@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Mania.UI
                 RelativeSizeAxes = Axes.Both
             };
 
-            hitObjectArea.Explosions.Add(explosion);
+            HitObjectArea.Explosions.Add(explosion);
 
             explosion.Delay(200).Expire(true);
         }

osu.Game.Rulesets.Mania/UI/Components/HitObjectArea.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Mania.Skinning;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -14,12 +15,14 @@ namespace osu.Game.Rulesets.Mania.UI.Components
     public class HitObjectArea : SkinReloadableDrawable
     {
         protected readonly IBindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+        public readonly HitObjectContainer HitObjectContainer;
 
         public HitObjectArea(HitObjectContainer hitObjectContainer)
         {
-            InternalChildren = new[]
+            InternalChild = new Container
             {
-                hitObjectContainer,
+                RelativeSizeAxes = Axes.Both,
+                Child = HitObjectContainer = hitObjectContainer
             };
         }
 

osu.Game.Rulesets.Mania/UI/PlayfieldCoveringWrapper.cs

@@ -0,0 +1,133 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    /// <summary>
+    /// A <see cref="Container"/> that has its contents partially hidden by an adjustable "cover". This is intended to be used in a playfield.
+    /// </summary>
+    public class PlayfieldCoveringWrapper : CompositeDrawable
+    {
+        /// <summary>
+        /// The complete cover, including gradient and fill.
+        /// </summary>
+        private readonly Drawable cover;
+
+        /// <summary>
+        /// The gradient portion of the cover.
+        /// </summary>
+        private readonly Box gradient;
+
+        /// <summary>
+        /// The fully-opaque portion of the cover.
+        /// </summary>
+        private readonly Box filled;
+
+        private readonly IBindable<ScrollingDirection> scrollDirection = new Bindable<ScrollingDirection>();
+
+        public PlayfieldCoveringWrapper(Drawable content)
+        {
+            InternalChild = new BufferedContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new[]
+                {
+                    content,
+                    cover = new Container
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
+                        Blending = new BlendingParameters
+                        {
+                            // Don't change the destination colour.
+                            RGBEquation = BlendingEquation.Add,
+                            Source = BlendingType.Zero,
+                            Destination = BlendingType.One,
+                            // Subtract the cover's alpha from the destination (points with alpha 1 should make the destination completely transparent).
+                            AlphaEquation = BlendingEquation.Add,
+                            SourceAlpha = BlendingType.Zero,
+                            DestinationAlpha = BlendingType.OneMinusSrcAlpha
+                        },
+                        Children = new Drawable[]
+                        {
+                            gradient = new Box
+                            {
+                                Anchor = Anchor.BottomLeft,
+                                Origin = Anchor.BottomLeft,
+                                RelativeSizeAxes = Axes.Both,
+                                RelativePositionAxes = Axes.Both,
+                                Height = 0.25f,
+                                Colour = ColourInfo.GradientVertical(
+                                    Color4.White.Opacity(0f),
+                                    Color4.White.Opacity(1f)
+                                )
+                            },
+                            filled = new Box
+                            {
+                                Anchor = Anchor.BottomLeft,
+                                Origin = Anchor.BottomLeft,
+                                RelativeSizeAxes = Axes.Both,
+                                Height = 0
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            scrollDirection.BindTo(scrollingInfo.Direction);
+            scrollDirection.BindValueChanged(onScrollDirectionChanged, true);
+        }
+
+        private void onScrollDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
+            => cover.Rotation = direction.NewValue == ScrollingDirection.Up ? 0 : 180f;
+
+        /// <summary>
+        /// The relative area that should be completely covered. This does not include the fade.
+        /// </summary>
+        public float Coverage
+        {
+            set
+            {
+                filled.Height = value;
+                gradient.Y = -value;
+            }
+        }
+
+        /// <summary>
+        /// The direction in which the cover expands.
+        /// </summary>
+        public CoverExpandDirection Direction
+        {
+            set => cover.Scale = value == CoverExpandDirection.AlongScroll ? Vector2.One : new Vector2(1, -1);
+        }
+    }
+
+    public enum CoverExpandDirection
+    {
+        /// <summary>
+        /// The cover expands along the scrolling direction.
+        /// </summary>
+        AlongScroll,
+
+        /// <summary>
+        /// The cover expands against the scrolling direction.
+        /// </summary>
+        AgainstScroll
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestSceneCursorTrail.cs

@@ -8,6 +8,7 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Testing.Input;
 using osu.Game.Audio;
@@ -79,7 +80,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             public Drawable GetDrawableComponent(ISkinComponent component) => throw new NotImplementedException();
 
-            public Texture GetTexture(string componentName)
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
             {
                 switch (componentName)
                 {

osu.Game.Rulesets.Osu.Tests/TestSceneSkinFallbacks.cs

@@ -9,6 +9,7 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Timing;
@@ -131,7 +132,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 };
             }
 
-            public Texture GetTexture(string componentName) => null;
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => null;
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => null;
 

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

@@ -20,6 +20,8 @@ namespace osu.Game.Rulesets.Taiko.Tests
         [TestCase("basic")]
         [TestCase("slider-generating-drumroll")]
         [TestCase("sample-to-type-conversions")]
+        [TestCase("slider-conversion-v6")]
+        [TestCase("slider-conversion-v14")]
         public void Test(string name) => base.Test(name);
 
         protected override IEnumerable<ConvertValue> CreateConvertValue(HitObject hitObject)

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -10,6 +10,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Formats;
 
 namespace osu.Game.Rulesets.Taiko.Beatmaps
 {
@@ -82,37 +83,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             {
                 case IHasDistance distanceData:
                 {
-                    // Number of spans of the object - one for the initial length and for each repeat
-                    int spans = (obj as IHasRepeats)?.SpanCount() ?? 1;
-
-                    TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(obj.StartTime);
-                    DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(obj.StartTime);
-
-                    double speedAdjustment = difficultyPoint.SpeedMultiplier;
-                    double speedAdjustedBeatLength = timingPoint.BeatLength / speedAdjustment;
-
-                    // The true distance, accounting for any repeats. This ends up being the drum roll distance later
-                    double distance = distanceData.Distance * spans * LEGACY_VELOCITY_MULTIPLIER;
-
-                    // The velocity of the taiko hit object - calculated as the velocity of a drum roll
-                    double taikoVelocity = taiko_base_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier / speedAdjustedBeatLength;
-                    // The duration of the taiko hit object
-                    double taikoDuration = distance / taikoVelocity;
-
-                    // The velocity of the osu! hit object - calculated as the velocity of a slider
-                    double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier / speedAdjustedBeatLength;
-                    // The duration of the osu! hit object
-                    double osuDuration = distance / osuVelocity;
-
-                    // osu-stable always uses the speed-adjusted beatlength to determine the velocities, but
-                    // only uses it for tick rate if beatmap version < 8
-                    if (beatmap.BeatmapInfo.BeatmapVersion >= 8)
-                        speedAdjustedBeatLength *= speedAdjustment;
-
-                    // If the drum roll is to be split into hit circles, assume the ticks are 1/8 spaced within the duration of one beat
-                    double tickSpacing = Math.Min(speedAdjustedBeatLength / beatmap.BeatmapInfo.BaseDifficulty.SliderTickRate, taikoDuration / spans);
-
-                    if (!isForCurrentRuleset && tickSpacing > 0 && osuDuration < 2 * speedAdjustedBeatLength)
+                    if (shouldConvertSliderToHits(obj, beatmap, distanceData, out var taikoDuration, out var tickSpacing))
                     {
                         List<IList<HitSampleInfo>> allSamples = obj is IHasPathWithRepeats curveData ? curveData.NodeSamples : new List<IList<HitSampleInfo>>(new[] { samples });
 
@@ -184,6 +155,52 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             }
         }
 
+        private bool shouldConvertSliderToHits(HitObject obj, IBeatmap beatmap, IHasDistance distanceData, out double taikoDuration, out double tickSpacing)
+        {
+            // DO NOT CHANGE OR REFACTOR ANYTHING IN HERE WITHOUT TESTING AGAINST _ALL_ BEATMAPS.
+            // Some of these calculations look redundant, but they are not - extremely small floating point errors are introduced to maintain 1:1 compatibility with stable.
+            // Rounding cannot be used as an alternative since the error deltas have been observed to be between 1e-2 and 1e-6.
+
+            // The true distance, accounting for any repeats. This ends up being the drum roll distance later
+            int spans = (obj as IHasRepeats)?.SpanCount() ?? 1;
+            double distance = distanceData.Distance * spans * LEGACY_VELOCITY_MULTIPLIER;
+
+            TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(obj.StartTime);
+            DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(obj.StartTime);
+
+            double beatLength;
+#pragma warning disable 618
+            if (difficultyPoint is LegacyBeatmapDecoder.LegacyDifficultyControlPoint legacyDifficultyPoint)
+#pragma warning restore 618
+                beatLength = timingPoint.BeatLength * legacyDifficultyPoint.BpmMultiplier;
+            else
+                beatLength = timingPoint.BeatLength / difficultyPoint.SpeedMultiplier;
+
+            double sliderScoringPointDistance = osu_base_scoring_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier / beatmap.BeatmapInfo.BaseDifficulty.SliderTickRate;
+
+            // The velocity and duration of the taiko hit object - calculated as the velocity of a drum roll.
+            double taikoVelocity = sliderScoringPointDistance * beatmap.BeatmapInfo.BaseDifficulty.SliderTickRate;
+            taikoDuration = distance / taikoVelocity * beatLength;
+
+            if (isForCurrentRuleset)
+            {
+                tickSpacing = 0;
+                return false;
+            }
+
+            double osuVelocity = taikoVelocity * (1000f / beatLength);
+
+            // osu-stable always uses the speed-adjusted beatlength to determine the osu! velocity, but only uses it for conversion if beatmap version < 8
+            if (beatmap.BeatmapInfo.BeatmapVersion >= 8)
+                beatLength = timingPoint.BeatLength;
+
+            // If the drum roll is to be split into hit circles, assume the ticks are 1/8 spaced within the duration of one beat
+            tickSpacing = Math.Min(beatLength / beatmap.BeatmapInfo.BaseDifficulty.SliderTickRate, taikoDuration / spans);
+
+            return tickSpacing > 0
+                   && distance / osuVelocity * 1000 < 2 * beatLength;
+        }
+
         protected override Beatmap<TaikoHitObject> CreateBeatmap() => new TaikoBeatmap();
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/Skills/Strain.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
             double addition = 1;
 
             // We get an extra addition if we are not a slider or spinner
-            if (current.LastObject is Hit && current.BaseObject is Hit && current.DeltaTime < 1000)
+            if (current.LastObject is Hit && current.BaseObject is Hit && current.BaseObject.StartTime - current.LastObject.StartTime < 1000)
             {
                 if (hasColourChange(current))
                     addition += 0.75;

osu.Game.Rulesets.Taiko/Resources/Testing/Beatmaps/slider-conversion-v14-expected-conversion.json

@@ -0,0 +1,379 @@
+{
+    "Mappings": [{
+            "StartTime": 2000,
+            "Objects": [{
+                    "StartTime": 2000,
+                    "EndTime": 2000,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": true
+                },
+                {
+                    "StartTime": 2173,
+                    "EndTime": 2173,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                }
+            ]
+        },
+        {
+            "StartTime": 4000,
+            "Objects": [{
+                    "StartTime": 4000,
+                    "EndTime": 4000,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 4173,
+                    "EndTime": 4173,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                }
+            ]
+        },
+        {
+            "StartTime": 6000,
+            "Objects": [{
+                    "StartTime": 6000,
+                    "EndTime": 6000,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 6271,
+                    "EndTime": 6271,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 6542,
+                    "EndTime": 6542,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                }
+            ]
+        },
+        {
+            "StartTime": 8000,
+            "Objects": [{
+                    "StartTime": 8000,
+                    "EndTime": 8000,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8026,
+                    "EndTime": 8026,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8053,
+                    "EndTime": 8053,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8080,
+                    "EndTime": 8080,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8107,
+                    "EndTime": 8107,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8133,
+                    "EndTime": 8133,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8160,
+                    "EndTime": 8160,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8187,
+                    "EndTime": 8187,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8214,
+                    "EndTime": 8214,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8241,
+                    "EndTime": 8241,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8267,
+                    "EndTime": 8267,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8294,
+                    "EndTime": 8294,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8321,
+                    "EndTime": 8321,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8348,
+                    "EndTime": 8348,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8374,
+                    "EndTime": 8374,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8401,
+                    "EndTime": 8401,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8428,
+                    "EndTime": 8428,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8455,
+                    "EndTime": 8455,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8482,
+                    "EndTime": 8482,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8508,
+                    "EndTime": 8508,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8535,
+                    "EndTime": 8535,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8562,
+                    "EndTime": 8562,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8589,
+                    "EndTime": 8589,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8615,
+                    "EndTime": 8615,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8642,
+                    "EndTime": 8642,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8669,
+                    "EndTime": 8669,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8696,
+                    "EndTime": 8696,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8723,
+                    "EndTime": 8723,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8749,
+                    "EndTime": 8749,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8776,
+                    "EndTime": 8776,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8803,
+                    "EndTime": 8803,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8830,
+                    "EndTime": 8830,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 8857,
+                    "EndTime": 8857,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                }
+            ]
+        }
+    ]
+}

osu.Game.Rulesets.Taiko/Resources/Testing/Beatmaps/slider-conversion-v14.osu

@@ -0,0 +1,32 @@
+osu file format v14
+
+[General]
+Mode: 0
+
+[Difficulty]
+HPDrainRate:7
+CircleSize:4
+OverallDifficulty:8
+ApproachRate:9.2
+SliderMultiplier:2.3
+SliderTickRate:1
+
+[TimingPoints]
+0,333.333333333333,4,1,0,50,1,0
+2000,-100,4,2,0,80,0,0
+
+6000,389.61038961039,4,2,1,60,1,0
+
+8000,428.571428571429,4,3,1,65,1,0
+8000,-133.333333333333,4,1,1,45,0,0
+
+[HitObjects]
+// Should convert.
+48,32,2000,6,0,B|168:32,1,120,4|2
+312,68,4000,2,0,B|288:52|256:44|216:52|200:68,1,120,0|8
+
+// Should convert.
+184,224,6000,2,0,L|336:308,2,160,2|2|0,0:0|0:0|0:0,0:0:0:0:
+
+// Should convert.
+328,36,8000,6,0,L|332:16,32,10.7812504112721,0|0,0:0,0:0:0:0:

osu.Game.Rulesets.Taiko/Resources/Testing/Beatmaps/slider-conversion-v6-expected-conversion.json

@@ -0,0 +1,137 @@
+{
+    "Mappings": [{
+            "StartTime": 0,
+            "Objects": [{
+                    "StartTime": 0,
+                    "EndTime": 0,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": true
+                },
+                {
+                    "StartTime": 162,
+                    "EndTime": 162,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 325,
+                    "EndTime": 325,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": true
+                },
+                {
+                    "StartTime": 487,
+                    "EndTime": 487,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 650,
+                    "EndTime": 650,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": true
+                },
+                {
+                    "StartTime": 813,
+                    "EndTime": 813,
+                    "IsRim": false,
+                    "IsCentre": true,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 975,
+                    "EndTime": 975,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": true
+                }
+            ]
+        },
+        {
+            "StartTime": 2000,
+            "Objects": [{
+                    "StartTime": 2000,
+                    "EndTime": 2000,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 2162,
+                    "EndTime": 2162,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 2325,
+                    "EndTime": 2325,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": true
+                },
+                {
+                    "StartTime": 2487,
+                    "EndTime": 2487,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 2650,
+                    "EndTime": 2650,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                },
+                {
+                    "StartTime": 2813,
+                    "EndTime": 2813,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": true
+                },
+                {
+                    "StartTime": 2975,
+                    "EndTime": 2975,
+                    "IsRim": true,
+                    "IsCentre": false,
+                    "IsDrumRoll": false,
+                    "IsSwell": false,
+                    "IsStrong": false
+                }
+            ]
+        }
+    ]
+}

osu.Game.Rulesets.Taiko/Resources/Testing/Beatmaps/slider-conversion-v6.osu

@@ -0,0 +1,20 @@
+osu file format v6
+
+[General]
+Mode: 0
+
+[Difficulty]
+HPDrainRate:3
+CircleSize:4
+OverallDifficulty:1
+SliderMultiplier:1.2
+SliderTickRate:3
+
+[TimingPoints]
+0,487.884208814441,4,1,0,60,1,0
+2000,-100,4,1,0,65,0,1
+
+[HitObjects]
+// Should convert.
+376,64,0,6,0,B|256:32|136:64,1,240,6|0
+256,120,2000,6,8,C|264:192|336:192,2,120,8|8|6

osu.Game.Rulesets.Taiko/Scoring/TaikoScoreProcessor.cs

@@ -7,6 +7,10 @@ namespace osu.Game.Rulesets.Taiko.Scoring
 {
     internal class TaikoScoreProcessor : ScoreProcessor
     {
+        protected override double DefaultAccuracyPortion => 0.75;
+
+        protected override double DefaultComboPortion => 0.25;
+
         public override HitWindows CreateHitWindows() => new TaikoHitWindows();
     }
 }

osu.Game.Rulesets.Taiko/Skinning/LegacyDrumRoll.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Skinning;
@@ -34,13 +35,13 @@ namespace osu.Game.Rulesets.Taiko.Skinning
                     Anchor = Anchor.CentreRight,
                     Origin = Anchor.CentreLeft,
                     RelativeSizeAxes = Axes.Both,
-                    Texture = skin.GetTexture("taiko-roll-end"),
+                    Texture = skin.GetTexture("taiko-roll-end", WrapMode.ClampToEdge, WrapMode.ClampToEdge),
                     FillMode = FillMode.Fit,
                 },
                 body = new Sprite
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Texture = skin.GetTexture("taiko-roll-middle"),
+                    Texture = skin.GetTexture("taiko-roll-middle", WrapMode.ClampToEdge, WrapMode.ClampToEdge),
                 },
                 headCircle = new LegacyCirclePiece
                 {

osu.Game.Tests/Gameplay/TestSceneHitObjectAccentColour.cs

@@ -8,6 +8,7 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Testing;
 using osu.Game.Audio;
@@ -118,7 +119,7 @@ namespace osu.Game.Tests.Gameplay
 
             public Drawable GetDrawableComponent(ISkinComponent component) => throw new NotImplementedException();
 
-            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 

osu.Game.Tests/Skins/TestSceneSkinConfigurationLookup.cs

@@ -10,6 +10,7 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Testing;
 using osu.Game.Audio;
@@ -216,7 +217,7 @@ namespace osu.Game.Tests.Skins
 
             public Drawable GetDrawableComponent(ISkinComponent component) => skin.GetDrawableComponent(component);
 
-            public Texture GetTexture(string componentName) => skin.GetTexture(componentName);
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => skin.GetTexture(componentName, wrapModeS, wrapModeT);
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => skin.GetSample(sampleInfo);
 

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

@@ -175,13 +175,13 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("Time = 50", () => Clock.CurrentTime == 50);
             AddStep("Seek(49.999)", () => Clock.Seek(49.999));
             AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
-            AddAssert("Time = 50", () => Clock.CurrentTime == 50);
+            AddAssert("Time = 100", () => Clock.CurrentTime == 100);
             AddStep("Seek(99)", () => Clock.Seek(99));
             AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
             AddAssert("Time = 100", () => Clock.CurrentTime == 100);
             AddStep("Seek(99.999)", () => Clock.Seek(99.999));
             AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
-            AddAssert("Time = 100", () => Clock.CurrentTime == 100);
+            AddAssert("Time = 100", () => Clock.CurrentTime == 150);
             AddStep("Seek(174)", () => Clock.Seek(174));
             AddStep("SeekForward, Snap", () => Clock.SeekForward(true));
             AddAssert("Time = 175", () => Clock.CurrentTime == 175);

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

@@ -3,6 +3,7 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Timing;
@@ -13,6 +14,7 @@ namespace osu.Game.Tests.Visual.Editing
     public class TestSceneTimingScreen : EditorClockTestScene
     {
         [Cached(typeof(EditorBeatmap))]
+        [Cached(typeof(IBeatSnapProvider))]
         private readonly EditorBeatmap editorBeatmap;
 
         public TestSceneTimingScreen()

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

@@ -11,6 +11,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.Break;
 using osu.Game.Screens.Ranking;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -35,6 +36,18 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("rewind", () => Player.GameplayClockContainer.Seek(-80000));
             AddUntilStep("key counter reset", () => Player.HUDOverlay.KeyCounter.Children.All(kc => kc.CountPresses == 0));
 
+            double? time = null;
+
+            AddStep("store time", () => time = Player.GameplayClockContainer.GameplayClock.CurrentTime);
+
+            // test seek via keyboard
+            AddStep("seek with right arrow key", () => press(Key.Right));
+            AddAssert("time seeked forward", () => Player.GameplayClockContainer.GameplayClock.CurrentTime > time + 2000);
+
+            AddStep("store time", () => time = Player.GameplayClockContainer.GameplayClock.CurrentTime);
+            AddStep("seek with left arrow key", () => press(Key.Left));
+            AddAssert("time seeked backward", () => Player.GameplayClockContainer.GameplayClock.CurrentTime < time);
+
             seekToBreak(0);
             seekToBreak(1);
 
@@ -54,5 +67,11 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             BreakPeriod destBreak() => Beatmap.Value.Beatmap.Breaks.ElementAt(breakIndex);
         }
+
+        private void press(Key key)
+        {
+            InputManager.PressKey(key);
+            InputManager.ReleaseKey(key);
+        }
     }
 }

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

@@ -10,6 +10,7 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
@@ -295,7 +296,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                     }
                     : null;
 
-            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
@@ -306,7 +307,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             public Drawable GetDrawableComponent(ISkinComponent componentName) => new SecondarySourceBox();
 
-            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
@@ -318,7 +319,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             public Drawable GetDrawableComponent(ISkinComponent componentName) => new BaseSourceBox();
 
-            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => throw new NotImplementedException();
 
             public SampleChannel GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 

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

@@ -15,6 +15,7 @@ using osu.Game.Rulesets.Catch;
 using osu.Framework.Allocation;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Rankings;
 
 namespace osu.Game.Tests.Visual.Online
 {
@@ -105,7 +106,7 @@ namespace osu.Game.Tests.Visual.Online
         {
             onLoadStarted();
 
-            request = new GetSpotlightRankingsRequest(ruleset, spotlight);
+            request = new GetSpotlightRankingsRequest(ruleset, spotlight, RankingsSortCriteria.All);
             ((GetSpotlightRankingsRequest)request).Success += rankings => Schedule(() =>
             {
                 var table = new ScoresTable(1, rankings.Users);

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

@@ -0,0 +1,67 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Overlays.Comments.Buttons;
+using osu.Framework.Graphics;
+using osu.Framework.Allocation;
+using osu.Game.Overlays;
+using osu.Framework.Graphics.Containers;
+using osuTK;
+using NUnit.Framework;
+using System.Linq;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneCommentRepliesButton : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        private readonly TestButton button;
+
+        public TestSceneCommentRepliesButton()
+        {
+            Child = new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 10),
+                Children = new Drawable[]
+                {
+                    button = new TestButton(),
+                    new LoadRepliesButton
+                    {
+                        Action = () => { }
+                    },
+                    new ShowRepliesButton(1),
+                    new ShowRepliesButton(2)
+                }
+            };
+        }
+
+        [Test]
+        public void TestArrowDirection()
+        {
+            AddStep("Set upwards", () => button.SetIconDirection(true));
+            AddAssert("Icon facing upwards", () => button.Icon.Scale.Y == -1);
+            AddStep("Set downwards", () => button.SetIconDirection(false));
+            AddAssert("Icon facing downwards", () => button.Icon.Scale.Y == 1);
+        }
+
+        private class TestButton : CommentRepliesButton
+        {
+            public SpriteIcon Icon => this.ChildrenOfType<SpriteIcon>().First();
+
+            public TestButton()
+            {
+                Text = "sample text";
+            }
+
+            public new void SetIconDirection(bool upwards) => base.SetIconDirection(upwards);
+        }
+    }
+}

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

@@ -0,0 +1,46 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    [TestFixture]
+    public class TestSceneHueAnimation : OsuTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load(LargeTextureStore textures)
+        {
+            HueAnimation anim2;
+
+            Add(anim2 = new HueAnimation
+            {
+                RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit,
+                Texture = textures.Get("Intro/Triangles/logo-highlight"),
+                Colour = Colour4.White,
+            });
+
+            HueAnimation anim;
+
+            Add(anim = new HueAnimation
+            {
+                RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit,
+                Texture = textures.Get("Intro/Triangles/logo-background"),
+                Colour = OsuColour.Gray(0.6f),
+            });
+
+            AddSliderStep("Progress", 0f, 1f, 0f, newValue =>
+            {
+                anim2.AnimationProgress = newValue;
+                anim.AnimationProgress = newValue;
+            });
+        }
+    }
+}

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

@@ -13,6 +13,8 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
@@ -99,6 +101,12 @@ namespace osu.Game.Tests.Visual.UserInterface
         public void TestManiaMods()
         {
             changeRuleset(3);
+
+            var mania = new ManiaRuleset();
+
+            testModsWithSameBaseType(
+                mania.GetAllMods().Single(m => m.GetType() == typeof(ManiaModFadeIn)),
+                mania.GetAllMods().Single(m => m.GetType() == typeof(ManiaModHidden)));
         }
 
         [Test]
@@ -197,6 +205,18 @@ namespace osu.Game.Tests.Visual.UserInterface
             checkLabelColor(() => Color4.White);
         }
 
+        private void testModsWithSameBaseType(Mod modA, Mod modB)
+        {
+            selectNext(modA);
+            checkSelected(modA);
+            selectNext(modB);
+            checkSelected(modB);
+
+            // Backwards
+            selectPrevious(modA);
+            checkSelected(modA);
+        }
+
         private void selectNext(Mod mod) => AddStep($"left click {mod.Name}", () => modSelect.GetModButton(mod)?.SelectNext(1));
 
         private void selectPrevious(Mod mod) => AddStep($"right click {mod.Name}", () => modSelect.GetModButton(mod)?.SelectNext(-1));

osu.Game/Beatmaps/BeatmapConverter.cs

@@ -57,7 +57,7 @@ namespace osu.Game.Beatmaps
 
             beatmap.BeatmapInfo = original.BeatmapInfo;
             beatmap.ControlPointInfo = original.ControlPointInfo;
-            beatmap.HitObjects = convertHitObjects(original.HitObjects, original);
+            beatmap.HitObjects = convertHitObjects(original.HitObjects, original).OrderBy(s => s.StartTime).ToList();
             beatmap.Breaks = original.Breaks;
 
             return beatmap;

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -369,7 +369,9 @@ namespace osu.Game.Beatmaps.Formats
                 addControlPoint(time, controlPoint, true);
             }
 
-            addControlPoint(time, new LegacyDifficultyControlPoint
+#pragma warning disable 618
+            addControlPoint(time, new LegacyDifficultyControlPoint(beatLength)
+#pragma warning restore 618
             {
                 SpeedMultiplier = speedMultiplier,
             }, timingChange);

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -159,11 +159,20 @@ namespace osu.Game.Beatmaps.Formats
             Mania,
         }
 
-        internal class LegacyDifficultyControlPoint : DifficultyControlPoint
+        [Obsolete("Do not use unless you're a legacy ruleset and 100% sure.")]
+        public class LegacyDifficultyControlPoint : DifficultyControlPoint
         {
-            public LegacyDifficultyControlPoint()
+            /// <summary>
+            /// Legacy BPM multiplier that introduces floating-point errors for rulesets that depend on it.
+            /// DO NOT USE THIS UNLESS 100% SURE.
+            /// </summary>
+            public readonly float BpmMultiplier;
+
+            public LegacyDifficultyControlPoint(double beatLength)
             {
                 SpeedMultiplierBindable.Precision = double.Epsilon;
+
+                BpmMultiplier = beatLength < 0 ? Math.Clamp((float)-beatLength, 10, 10000) / 100f : 1;
             }
         }
 

osu.Game/Graphics/Sprites/HueAnimation.cs

@@ -0,0 +1,69 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Vertices;
+using osu.Framework.Graphics.Shaders;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+
+namespace osu.Game.Graphics.Sprites
+{
+    public class HueAnimation : Sprite
+    {
+        [BackgroundDependencyLoader]
+        private void load(ShaderManager shaders, TextureStore textures)
+        {
+            TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, @"HueAnimation");
+            RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, @"HueAnimation"); // Masking isn't supported for now
+        }
+
+        private float animationProgress;
+
+        public float AnimationProgress
+        {
+            get => animationProgress;
+            set
+            {
+                if (animationProgress == value) return;
+
+                animationProgress = value;
+                Invalidate(Invalidation.DrawInfo);
+            }
+        }
+
+        public override bool IsPresent => true;
+
+        protected override DrawNode CreateDrawNode() => new HueAnimationDrawNode(this);
+
+        private class HueAnimationDrawNode : SpriteDrawNode
+        {
+            private HueAnimation source => (HueAnimation)Source;
+
+            private float progress;
+
+            public HueAnimationDrawNode(HueAnimation source)
+                : base(source)
+            {
+            }
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                progress = source.animationProgress;
+            }
+
+            protected override void Blit(Action<TexturedVertex2D> vertexAction)
+            {
+                Shader.GetUniform<float>("progress").UpdateValue(ref progress);
+
+                base.Blit(vertexAction);
+            }
+
+            protected override bool CanDrawOpaqueInterior => false;
+        }
+    }
+}

osu.Game/Input/Bindings/GlobalActionContainer.cs

@@ -57,6 +57,7 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(new[] { InputKey.Control, InputKey.Tilde }, GlobalAction.QuickExit),
             new KeyBinding(new[] { InputKey.Control, InputKey.Plus }, GlobalAction.IncreaseScrollSpeed),
             new KeyBinding(new[] { InputKey.Control, InputKey.Minus }, GlobalAction.DecreaseScrollSpeed),
+            new KeyBinding(InputKey.MouseMiddle, GlobalAction.PauseGameplay),
         };
 
         public IEnumerable<KeyBinding> AudioControlKeyBindings => new[]
@@ -160,6 +161,9 @@ namespace osu.Game.Input.Bindings
         Home,
 
         [Description("Toggle notifications")]
-        ToggleNotifications
+        ToggleNotifications,
+
+        [Description("Pause")]
+        PauseGameplay,
     }
 }

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.IO.Network;
+using osu.Game.Overlays.Rankings;
 using osu.Game.Rulesets;
 
 namespace osu.Game.Online.API.Requests
@@ -9,11 +10,13 @@ namespace osu.Game.Online.API.Requests
     public class GetSpotlightRankingsRequest : GetRankingsRequest<GetSpotlightRankingsResponse>
     {
         private readonly int spotlight;
+        private readonly RankingsSortCriteria sort;
 
-        public GetSpotlightRankingsRequest(RulesetInfo ruleset, int spotlight)
+        public GetSpotlightRankingsRequest(RulesetInfo ruleset, int spotlight, RankingsSortCriteria sort)
             : base(ruleset, 1)
         {
             this.spotlight = spotlight;
+            this.sort = sort;
         }
 
         protected override WebRequest CreateWebRequest()
@@ -21,6 +24,7 @@ namespace osu.Game.Online.API.Requests
             var req = base.CreateWebRequest();
 
             req.AddParameter("spotlight", spotlight.ToString());
+            req.AddParameter("filter", sort.ToString().ToLower());
 
             return req;
         }

osu.Game/OsuGame.cs

@@ -573,7 +573,9 @@ namespace osu.Game
                             Origin = Anchor.BottomLeft,
                             Action = () =>
                             {
-                                if ((ScreenStack.CurrentScreen as IOsuScreen)?.AllowBackButton == true)
+                                var currentScreen = ScreenStack.CurrentScreen as IOsuScreen;
+
+                                if (currentScreen?.AllowBackButton == true && !currentScreen.OnBackButton())
                                     ScreenStack.Exit();
                             }
                         },

osu.Game/OsuGameBase.cs

@@ -152,6 +152,7 @@ namespace osu.Game
             AddFont(Resources, @"Fonts/Noto-Hangul");
             AddFont(Resources, @"Fonts/Noto-CJK-Basic");
             AddFont(Resources, @"Fonts/Noto-CJK-Compatibility");
+            AddFont(Resources, @"Fonts/Noto-Thai");
 
             AddFont(Resources, @"Fonts/Venera-Light");
             AddFont(Resources, @"Fonts/Venera-Bold");

osu.Game/Overlays/Chat/ChatLine.cs

@@ -10,6 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
@@ -114,21 +115,26 @@ namespace osu.Game.Overlays.Chat
                         Colour = Color4.Black.Opacity(0.3f),
                         Type = EdgeEffectType.Shadow,
                     },
-                    // Drop shadow effect
                     Child = new Container
                     {
                         AutoSizeAxes = Axes.Both,
+                        Y = 3,
                         Masking = true,
                         CornerRadius = 4,
-                        EdgeEffect = new EdgeEffectParameters
+                        Children = new Drawable[]
                         {
-                            Radius = 1,
-                            Colour = Color4Extensions.FromHex(message.Sender.Colour),
-                            Type = EdgeEffectType.Shadow,
-                        },
-                        Padding = new MarginPadding { Left = 3, Right = 3, Bottom = 1, Top = -3 },
-                        Y = 3,
-                        Child = username,
+                            new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Colour = Color4Extensions.FromHex(message.Sender.Colour),
+                            },
+                            new Container
+                            {
+                                AutoSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Left = 4, Right = 4, Bottom = 1, Top = -2 },
+                                Child = username
+                            }
+                        }
                     }
                 };
             }

osu.Game/Overlays/Comments/Buttons/CommentRepliesButton.cs

@@ -0,0 +1,117 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osuTK;
+
+namespace osu.Game.Overlays.Comments.Buttons
+{
+    public abstract class CommentRepliesButton : CompositeDrawable
+    {
+        protected string Text
+        {
+            get => text.Text;
+            set => text.Text = value;
+        }
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; }
+
+        private readonly SpriteIcon icon;
+        private readonly Box background;
+        private readonly OsuSpriteText text;
+
+        protected CommentRepliesButton()
+        {
+            AutoSizeAxes = Axes.Both;
+            Margin = new MarginPadding
+            {
+                Vertical = 2
+            };
+            InternalChildren = new Drawable[]
+            {
+                new CircularContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Masking = true,
+                    Children = new Drawable[]
+                    {
+                        background = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        },
+                        new Container
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Margin = new MarginPadding
+                            {
+                                Vertical = 5,
+                                Horizontal = 10,
+                            },
+                            Child = new FillFlowContainer
+                            {
+                                AutoSizeAxes = Axes.Both,
+                                Direction = FillDirection.Horizontal,
+                                Spacing = new Vector2(15, 0),
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Children = new Drawable[]
+                                {
+                                    text = new OsuSpriteText
+                                    {
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.CentreLeft,
+                                        AlwaysPresent = true,
+                                        Font = OsuFont.GetFont(size: 12, weight: FontWeight.SemiBold)
+                                    },
+                                    icon = new SpriteIcon
+                                    {
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.CentreLeft,
+                                        Size = new Vector2(7.5f),
+                                        Icon = FontAwesome.Solid.ChevronDown
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                new HoverClickSounds(),
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            background.Colour = colourProvider.Background2;
+            icon.Colour = colourProvider.Foreground1;
+        }
+
+        protected void SetIconDirection(bool upwards) => icon.ScaleTo(new Vector2(1, upwards ? -1 : 1));
+
+        public void ToggleTextVisibility(bool visible) => text.FadeTo(visible ? 1 : 0, 200, Easing.OutQuint);
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            base.OnHover(e);
+            background.FadeColour(colourProvider.Background1, 200, Easing.OutQuint);
+            icon.FadeColour(colourProvider.Light1, 200, Easing.OutQuint);
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            background.FadeColour(colourProvider.Background2, 200, Easing.OutQuint);
+            icon.FadeColour(colourProvider.Foreground1, 200, Easing.OutQuint);
+        }
+    }
+}

osu.Game/Overlays/Comments/Buttons/LoadRepliesButton.cs

@@ -0,0 +1,32 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Overlays.Comments.Buttons
+{
+    public class LoadRepliesButton : LoadingButton
+    {
+        private ButtonContent content;
+
+        public LoadRepliesButton()
+        {
+            AutoSizeAxes = Axes.Both;
+        }
+
+        protected override Drawable CreateContent() => content = new ButtonContent();
+
+        protected override void OnLoadStarted() => content.ToggleTextVisibility(false);
+
+        protected override void OnLoadFinished() => content.ToggleTextVisibility(true);
+
+        private class ButtonContent : CommentRepliesButton
+        {
+            public ButtonContent()
+            {
+                Text = "load replies";
+            }
+        }
+    }
+}

osu.Game/Overlays/Comments/Buttons/ShowRepliesButton.cs

@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using Humanizer;
+using osu.Framework.Bindables;
+using osu.Framework.Input.Events;
+
+namespace osu.Game.Overlays.Comments.Buttons
+{
+    public class ShowRepliesButton : CommentRepliesButton
+    {
+        public readonly BindableBool Expanded = new BindableBool(true);
+
+        public ShowRepliesButton(int count)
+        {
+            Text = "reply".ToQuantity(count);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Expanded.BindValueChanged(expanded => SetIconDirection(expanded.NewValue), true);
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            Expanded.Toggle();
+            return true;
+        }
+    }
+}

osu.Game/Overlays/Comments/DrawableComment.cs

@@ -16,12 +16,12 @@ using System.Linq;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Online.Chat;
 using osu.Framework.Allocation;
-using osuTK.Graphics;
 using System.Collections.Generic;
 using System;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using System.Collections.Specialized;
+using osu.Game.Overlays.Comments.Buttons;
 
 namespace osu.Game.Overlays.Comments
 {
@@ -46,9 +46,9 @@ namespace osu.Game.Overlays.Comments
 
         private FillFlowContainer childCommentsVisibilityContainer;
         private FillFlowContainer childCommentsContainer;
-        private LoadMoreCommentsButton loadMoreCommentsButton;
+        private LoadRepliesButton loadRepliesButton;
         private ShowMoreButton showMoreButton;
-        private RepliesButton repliesButton;
+        private ShowRepliesButton showRepliesButton;
         private ChevronButton chevronButton;
         private DeletedCommentsCounter deletedCommentsCounter;
 
@@ -81,7 +81,7 @@ namespace osu.Game.Overlays.Comments
                         {
                             RelativeSizeAxes = Axes.X,
                             AutoSizeAxes = Axes.Y,
-                            Padding = new MarginPadding(margin) { Left = margin + 5 },
+                            Padding = new MarginPadding(margin) { Left = margin + 5, Top = Comment.IsTopLevel ? 10 : 0 },
                             Child = content = new GridContainer
                             {
                                 RelativeSizeAxes = Axes.X,
@@ -163,26 +163,34 @@ namespace osu.Game.Overlays.Comments
                                                     AutoSizeAxes = Axes.Y,
                                                     Padding = new MarginPadding { Right = 40 }
                                                 },
-                                                info = new FillFlowContainer
+                                                new FillFlowContainer
                                                 {
                                                     AutoSizeAxes = Axes.Both,
-                                                    Direction = FillDirection.Horizontal,
-                                                    Spacing = new Vector2(10, 0),
+                                                    Direction = FillDirection.Vertical,
                                                     Children = new Drawable[]
                                                     {
-                                                        new OsuSpriteText
+                                                        info = new FillFlowContainer
                                                         {
-                                                            Anchor = Anchor.CentreLeft,
-                                                            Origin = Anchor.CentreLeft,
-                                                            Font = OsuFont.GetFont(size: 12),
-                                                            Colour = OsuColour.Gray(0.7f),
-                                                            Text = HumanizerUtils.Humanize(Comment.CreatedAt)
+                                                            AutoSizeAxes = Axes.Both,
+                                                            Direction = FillDirection.Horizontal,
+                                                            Spacing = new Vector2(10, 0),
+                                                            Children = new Drawable[]
+                                                            {
+                                                                new OsuSpriteText
+                                                                {
+                                                                    Anchor = Anchor.CentreLeft,
+                                                                    Origin = Anchor.CentreLeft,
+                                                                    Font = OsuFont.GetFont(size: 12),
+                                                                    Colour = OsuColour.Gray(0.7f),
+                                                                    Text = HumanizerUtils.Humanize(Comment.CreatedAt)
+                                                                },
+                                                            }
                                                         },
-                                                        repliesButton = new RepliesButton(Comment.RepliesCount)
+                                                        showRepliesButton = new ShowRepliesButton(Comment.RepliesCount)
                                                         {
                                                             Expanded = { BindTarget = childrenExpanded }
                                                         },
-                                                        loadMoreCommentsButton = new LoadMoreCommentsButton
+                                                        loadRepliesButton = new LoadRepliesButton
                                                         {
                                                             Action = () => RepliesRequested(this, ++currentPage)
                                                         }
@@ -339,14 +347,14 @@ namespace osu.Game.Overlays.Comments
             var loadedReplesCount = loadedReplies.Count;
             var hasUnloadedReplies = loadedReplesCount != Comment.RepliesCount;
 
-            loadMoreCommentsButton.FadeTo(hasUnloadedReplies && loadedReplesCount == 0 ? 1 : 0);
+            loadRepliesButton.FadeTo(hasUnloadedReplies && loadedReplesCount == 0 ? 1 : 0);
             showMoreButton.FadeTo(hasUnloadedReplies && loadedReplesCount > 0 ? 1 : 0);
-            repliesButton.FadeTo(loadedReplesCount != 0 ? 1 : 0);
+            showRepliesButton.FadeTo(loadedReplesCount != 0 ? 1 : 0);
 
             if (Comment.IsTopLevel)
                 chevronButton.FadeTo(loadedReplesCount != 0 ? 1 : 0);
 
-            showMoreButton.IsLoading = loadMoreCommentsButton.IsLoading = false;
+            showMoreButton.IsLoading = loadRepliesButton.IsLoading = false;
         }
 
         private class ChevronButton : ShowChildrenButton
@@ -367,38 +375,6 @@ namespace osu.Game.Overlays.Comments
             }
         }
 
-        private class RepliesButton : ShowChildrenButton
-        {
-            private readonly SpriteText text;
-            private readonly int count;
-
-            public RepliesButton(int count)
-            {
-                this.count = count;
-
-                Child = text = new OsuSpriteText
-                {
-                    Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold),
-                };
-            }
-
-            protected override void OnExpandedChanged(ValueChangedEvent<bool> expanded)
-            {
-                text.Text = $@"{(expanded.NewValue ? "[-]" : "[+]")} replies ({count})";
-            }
-        }
-
-        private class LoadMoreCommentsButton : GetCommentRepliesButton
-        {
-            public LoadMoreCommentsButton()
-            {
-                IdleColour = OsuColour.Gray(0.7f);
-                HoverColour = Color4.White;
-            }
-
-            protected override string GetText() => @"[+] load replies";
-        }
-
         private class ShowMoreButton : GetCommentRepliesButton
         {
             [BackgroundDependencyLoader]

osu.Game/Overlays/Mods/ModSection.cs

@@ -132,7 +132,7 @@ namespace osu.Game.Overlays.Mods
         {
             foreach (var button in buttons)
             {
-                int i = Array.FindIndex(button.Mods, m => modTypes.Any(t => t.IsInstanceOfType(m)));
+                int i = Array.FindIndex(button.Mods, m => modTypes.Any(t => t == m.GetType()));
 
                 if (i >= 0)
                     button.SelectAt(i);

osu.Game/Overlays/Mods/ModSelectOverlay.cs

@@ -19,6 +19,7 @@ using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Input.Bindings;
 using osu.Game.Overlays.Mods.Sections;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens;
@@ -403,6 +404,8 @@ namespace osu.Game.Overlays.Mods
             return base.OnKeyDown(e);
         }
 
+        public override bool OnPressed(GlobalAction action) => false; // handled by back button
+
         private void availableModsChanged(ValueChangedEvent<Dictionary<ModType, IReadOnlyList<Mod>>> mods)
         {
             if (mods.NewValue == null) return;

osu.Game/Overlays/Rankings/SpotlightSelector.cs

@@ -22,10 +22,8 @@ namespace osu.Game.Overlays.Rankings
     {
         private const int duration = 300;
 
-        private readonly Box background;
-        private readonly SpotlightsDropdown dropdown;
-
         private readonly BindableWithCurrent<APISpotlight> current = new BindableWithCurrent<APISpotlight>();
+        public readonly Bindable<RankingsSortCriteria> Sort = new Bindable<RankingsSortCriteria>();
 
         public Bindable<APISpotlight> Current
         {
@@ -41,19 +39,22 @@ namespace osu.Game.Overlays.Rankings
 
         protected override bool StartHidden => true;
 
+        private readonly Box background;
+        private readonly Container content;
+        private readonly SpotlightsDropdown dropdown;
         private readonly InfoColumn startDateColumn;
         private readonly InfoColumn endDateColumn;
         private readonly InfoColumn mapCountColumn;
         private readonly InfoColumn participantsColumn;
-        private readonly Container content;
 
         public SpotlightSelector()
         {
             RelativeSizeAxes = Axes.X;
-            Height = 100;
+            AutoSizeAxes = Axes.Y;
             Add(content = new Container
             {
-                RelativeSizeAxes = Axes.Both,
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
                 Children = new Drawable[]
                 {
                     background = new Box
@@ -62,31 +63,55 @@ namespace osu.Game.Overlays.Rankings
                     },
                     new Container
                     {
-                        RelativeSizeAxes = Axes.Both,
-                        Padding = new MarginPadding { Horizontal = UserProfileOverlay.CONTENT_X_MARGIN, Vertical = 10 },
-                        Children = new Drawable[]
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Padding = new MarginPadding { Horizontal = UserProfileOverlay.CONTENT_X_MARGIN },
+                        Child = new FillFlowContainer
                         {
-                            dropdown = new SpotlightsDropdown
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Vertical,
+                            Children = new Drawable[]
                             {
-                                Anchor = Anchor.TopCentre,
-                                Origin = Anchor.TopCentre,
-                                RelativeSizeAxes = Axes.X,
-                                Current = Current,
-                                Depth = -float.MaxValue
-                            },
-                            new FillFlowContainer
-                            {
-                                Anchor = Anchor.BottomRight,
-                                Origin = Anchor.BottomRight,
-                                AutoSizeAxes = Axes.Both,
-                                Direction = FillDirection.Horizontal,
-                                Spacing = new Vector2(15, 0),
-                                Children = new Drawable[]
+                                new Container
                                 {
-                                    startDateColumn = new InfoColumn(@"Start Date"),
-                                    endDateColumn = new InfoColumn(@"End Date"),
-                                    mapCountColumn = new InfoColumn(@"Map Count"),
-                                    participantsColumn = new InfoColumn(@"Participants")
+                                    Margin = new MarginPadding { Vertical = 20 },
+                                    RelativeSizeAxes = Axes.X,
+                                    Height = 40,
+                                    Depth = -float.MaxValue,
+                                    Child = dropdown = new SpotlightsDropdown
+                                    {
+                                        RelativeSizeAxes = Axes.X,
+                                        Current = Current
+                                    }
+                                },
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Children = new Drawable[]
+                                    {
+                                        new FillFlowContainer
+                                        {
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Spacing = new Vector2(10, 0),
+                                            Margin = new MarginPadding { Bottom = 5 },
+                                            Children = new Drawable[]
+                                            {
+                                                startDateColumn = new InfoColumn(@"Start Date"),
+                                                endDateColumn = new InfoColumn(@"End Date"),
+                                                mapCountColumn = new InfoColumn(@"Map Count"),
+                                                participantsColumn = new InfoColumn(@"Participants")
+                                            }
+                                        },
+                                        new RankingsSortTabControl
+                                        {
+                                            Anchor = Anchor.CentreRight,
+                                            Origin = Anchor.CentreRight,
+                                            Current = Sort
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -128,12 +153,13 @@ namespace osu.Game.Overlays.Rankings
             {
                 AutoSizeAxes = Axes.Both;
                 Direction = FillDirection.Vertical;
+                Margin = new MarginPadding { Vertical = 10 };
                 Children = new Drawable[]
                 {
                     new OsuSpriteText
                     {
                         Text = name,
-                        Font = OsuFont.GetFont(size: 10),
+                        Font = OsuFont.GetFont(size: 10, weight: FontWeight.Regular),
                     },
                     new Container
                     {
@@ -143,7 +169,7 @@ namespace osu.Game.Overlays.Rankings
                         {
                             Anchor = Anchor.BottomLeft,
                             Origin = Anchor.BottomLeft,
-                            Font = OsuFont.GetFont(size: 18, weight: FontWeight.Light),
+                            Font = OsuFont.GetFont(size: 20, weight: FontWeight.Light),
                         }
                     }
                 };

osu.Game/Overlays/Rankings/SpotlightsLayout.cs

@@ -24,6 +24,7 @@ namespace osu.Game.Overlays.Rankings
         public readonly Bindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
 
         private readonly Bindable<APISpotlight> selectedSpotlight = new Bindable<APISpotlight>();
+        private readonly Bindable<RankingsSortCriteria> sort = new Bindable<RankingsSortCriteria>();
 
         [Resolved]
         private IAPIProvider api { get; set; }
@@ -72,6 +73,8 @@ namespace osu.Game.Overlays.Rankings
                     }
                 }
             };
+
+            sort.BindTo(selector.Sort);
         }
 
         protected override void LoadComplete()
@@ -80,7 +83,8 @@ namespace osu.Game.Overlays.Rankings
 
             selector.Show();
 
-            selectedSpotlight.BindValueChanged(onSpotlightChanged);
+            selectedSpotlight.BindValueChanged(_ => onSpotlightChanged());
+            sort.BindValueChanged(_ => onSpotlightChanged());
             Ruleset.BindValueChanged(onRulesetChanged);
 
             getSpotlights();
@@ -101,14 +105,14 @@ namespace osu.Game.Overlays.Rankings
             selectedSpotlight.TriggerChange();
         }
 
-        private void onSpotlightChanged(ValueChangedEvent<APISpotlight> spotlight)
+        private void onSpotlightChanged()
         {
             loading.Show();
 
             cancellationToken?.Cancel();
             getRankingsRequest?.Cancel();
 
-            getRankingsRequest = new GetSpotlightRankingsRequest(Ruleset.Value, spotlight.NewValue.Id);
+            getRankingsRequest = new GetSpotlightRankingsRequest(Ruleset.Value, selectedSpotlight.Value.Id, sort.Value);
             getRankingsRequest.Success += onSuccess;
             api.Queue(getRankingsRequest);
         }

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

@@ -147,8 +147,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
             samplesBindable = HitObject.SamplesBindable.GetBoundCopy();
             samplesBindable.CollectionChanged += (_, __) => loadSamples();
 
-            updateState(ArmedState.Idle, true);
             apply(HitObject);
+
+            updateState(ArmedState.Idle, true);
         }
 
         private void loadSamples()

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -7,6 +7,7 @@ using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -16,8 +17,6 @@ namespace osu.Game.Rulesets.Scoring
 {
     public class ScoreProcessor : JudgementProcessor
     {
-        private const double base_portion = 0.3;
-        private const double combo_portion = 0.7;
         private const double max_score = 1000000;
 
         /// <summary>
@@ -55,8 +54,20 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         public readonly Bindable<ScoringMode> Mode = new Bindable<ScoringMode>();
 
-        private double maxHighestCombo;
+        /// <summary>
+        /// The default portion of <see cref="max_score"/> awarded for hitting <see cref="HitObject"/>s accurately. Defaults to 30%.
+        /// </summary>
+        protected virtual double DefaultAccuracyPortion => 0.3;
 
+        /// <summary>
+        /// The default portion of <see cref="max_score"/> awarded for achieving a high combo. Default to 70%.
+        /// </summary>
+        protected virtual double DefaultComboPortion => 0.7;
+
+        private readonly double accuracyPortion;
+        private readonly double comboPortion;
+
+        private double maxHighestCombo;
         private double maxBaseScore;
         private double rollingMaxBaseScore;
         private double baseScore;
@@ -69,7 +80,11 @@ namespace osu.Game.Rulesets.Scoring
 
         public ScoreProcessor()
         {
-            Debug.Assert(base_portion + combo_portion == 1.0);
+            accuracyPortion = DefaultAccuracyPortion;
+            comboPortion = DefaultComboPortion;
+
+            if (!Precision.AlmostEquals(1.0, accuracyPortion + comboPortion))
+                throw new InvalidOperationException($"{nameof(DefaultAccuracyPortion)} + {nameof(DefaultComboPortion)} must equal 1.");
 
             Combo.ValueChanged += combo => HighestCombo.Value = Math.Max(HighestCombo.Value, combo.NewValue);
             Accuracy.ValueChanged += accuracy =>
@@ -189,7 +204,10 @@ namespace osu.Game.Rulesets.Scoring
             {
                 default:
                 case ScoringMode.Standardised:
-                    return (max_score * (base_portion * baseScore / maxBaseScore + combo_portion * HighestCombo.Value / maxHighestCombo) + bonusScore) * scoreMultiplier;
+                    double accuracyScore = accuracyPortion * baseScore / maxBaseScore;
+                    double comboScore = comboPortion * HighestCombo.Value / maxHighestCombo;
+
+                    return (max_score * (accuracyScore + comboScore) + bonusScore) * scoreMultiplier;
 
                 case ScoringMode.Classic:
                     // should emulate osu-stable's scoring as closely as we can (https://osu.ppy.sh/help/wiki/Score/ScoreV1)

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

@@ -64,6 +64,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 DragBox = CreateDragBox(select),
                 selectionHandler,
                 SelectionBlueprints = CreateSelectionBlueprintContainer(),
+                selectionHandler.CreateProxy(),
                 DragBox.CreateProxy().With(p => p.Depth = float.MinValue)
             });
 
@@ -121,14 +122,19 @@ namespace osu.Game.Screens.Edit.Compose.Components
             return e.Button == MouseButton.Left;
         }
 
+        private SelectionBlueprint clickedBlueprint;
+
         protected override bool OnClick(ClickEvent e)
         {
             if (e.Button == MouseButton.Right)
                 return false;
 
+            // store for double-click handling
+            clickedBlueprint = selectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered);
+
             // Deselection should only occur if no selected blueprints are hovered
             // A special case for when a blueprint was selected via this click is added since OnClick() may occur outside the hitobject and should not trigger deselection
-            if (endClickSelection() || selectionHandler.SelectedBlueprints.Any(b => b.IsHovered))
+            if (endClickSelection() || clickedBlueprint != null)
                 return true;
 
             deselectAll();
@@ -140,9 +146,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
             if (e.Button == MouseButton.Right)
                 return false;
 
-            SelectionBlueprint clickedBlueprint = selectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered);
-
-            if (clickedBlueprint == null)
+            // ensure the blueprint which was hovered for the first click is still the hovered blueprint.
+            if (clickedBlueprint == null || selectionHandler.SelectedBlueprints.FirstOrDefault(b => b.IsHovered) != clickedBlueprint)
                 return false;
 
             editorClock?.SeekTo(clickedBlueprint.HitObject.StartTime);

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

@@ -15,6 +15,7 @@ using osu.Framework.Input.Bindings;
 using osu.Framework.Input.States;
 using osu.Game.Audio;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
@@ -35,7 +36,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         public IEnumerable<HitObject> SelectedHitObjects => selectedBlueprints.Select(b => b.HitObject);
 
-        private Drawable outline;
+        private Drawable content;
+
+        private OsuSpriteText selectionDetailsText;
 
         [Resolved(CanBeNull = true)]
         protected EditorBeatmap EditorBeatmap { get; private set; }
@@ -55,16 +58,42 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            InternalChild = outline = new Container
+            InternalChild = content = new Container
             {
-                Masking = true,
-                BorderThickness = BORDER_RADIUS,
-                BorderColour = colours.Yellow,
-                Child = new Box
+                Children = new Drawable[]
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    AlwaysPresent = true,
-                    Alpha = 0
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        BorderThickness = BORDER_RADIUS,
+                        BorderColour = colours.YellowDark,
+                        Child = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            AlwaysPresent = true,
+                            Alpha = 0
+                        }
+                    },
+                    new Container
+                    {
+                        Name = "info text",
+                        AutoSizeAxes = Axes.Both,
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                Colour = colours.YellowDark,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            selectionDetailsText = new OsuSpriteText
+                            {
+                                Padding = new MarginPadding(2),
+                                Colour = colours.Gray0,
+                                Font = OsuFont.Default.With(size: 11)
+                            }
+                        }
+                    }
                 }
             };
         }
@@ -131,9 +160,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             selectedBlueprints.Remove(blueprint);
             EditorBeatmap.SelectedHitObjects.Remove(blueprint.HitObject);
 
-            // We don't want to update visibility if > 0, since we may be deselecting blueprints during drag-selection
-            if (selectedBlueprints.Count == 0)
-                UpdateVisibility();
+            UpdateVisibility();
         }
 
         /// <summary>
@@ -179,7 +206,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </summary>
         internal void UpdateVisibility()
         {
-            if (selectedBlueprints.Count > 0)
+            int count = selectedBlueprints.Count;
+
+            selectionDetailsText.Text = count > 0 ? count.ToString() : string.Empty;
+
+            if (count > 0)
                 Show();
             else
                 Hide();
@@ -205,8 +236,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
             topLeft -= new Vector2(5);
             bottomRight += new Vector2(5);
 
-            outline.Size = bottomRight - topLeft;
-            outline.Position = topLeft;
+            content.Size = bottomRight - topLeft;
+            content.Position = topLeft;
         }
 
         #endregion

osu.Game/Screens/Edit/Editor.cs

@@ -275,11 +275,22 @@ namespace osu.Game.Screens.Edit
 
         protected override bool OnScroll(ScrollEvent e)
         {
-            scrollAccumulation += (e.ScrollDelta.X + e.ScrollDelta.Y) * (e.IsPrecise ? 0.1 : 1);
+            const double precision = 1;
 
-            const int precision = 1;
+            double scrollComponent = e.ScrollDelta.X + e.ScrollDelta.Y;
 
-            while (Math.Abs(scrollAccumulation) > precision)
+            double scrollDirection = Math.Sign(scrollComponent);
+
+            // this is a special case to handle the "pivot" scenario.
+            // if we are precise scrolling in one direction then change our mind and scroll backwards,
+            // the existing accumulation should be applied in the inverse direction to maintain responsiveness.
+            if (Math.Sign(scrollAccumulation) != scrollDirection)
+                scrollAccumulation = scrollDirection * (precision - Math.Abs(scrollAccumulation));
+
+            scrollAccumulation += scrollComponent * (e.IsPrecise ? 0.1 : 1);
+
+            // because we are doing snapped seeking, we need to add up precise scrolls until they accumulate to an arbitrary cut-off.
+            while (Math.Abs(scrollAccumulation) >= precision)
             {
                 if (scrollAccumulation > 0)
                     seek(e, -1);

osu.Game/Screens/Edit/EditorClock.cs

@@ -118,9 +118,14 @@ namespace osu.Game.Screens.Edit
 
             seekTime = timingPoint.Time + closestBeat * seekAmount;
 
+            // limit forward seeking to only up to the next timing point's start time.
+            var nextTimingPoint = ControlPointInfo.TimingPoints.FirstOrDefault(t => t.Time > timingPoint.Time);
+            if (seekTime > nextTimingPoint?.Time)
+                seekTime = nextTimingPoint.Time;
+
             // Due to the rounding above, we may end up on the current beat. This will effectively cause 0 seeking to happen, but we don't want this.
             // Instead, we'll go to the next beat in the direction when this is the case
-            if (Precision.AlmostEquals(current, seekTime))
+            if (Precision.AlmostEquals(current, seekTime, 0.5f))
             {
                 closestBeat += direction > 0 ? 1 : -1;
                 seekTime = timingPoint.Time + closestBeat * seekAmount;
@@ -129,10 +134,6 @@ namespace osu.Game.Screens.Edit
             if (seekTime < timingPoint.Time && timingPoint != ControlPointInfo.TimingPoints.First())
                 seekTime = timingPoint.Time;
 
-            var nextTimingPoint = ControlPointInfo.TimingPoints.FirstOrDefault(t => t.Time > timingPoint.Time);
-            if (seekTime > nextTimingPoint?.Time)
-                seekTime = nextTimingPoint.Time;
-
             // Ensure the sought point is within the boundaries
             seekTime = Math.Clamp(seekTime, 0, TrackLength);
             SeekTo(seekTime);

osu.Game/Screens/IOsuScreen.cs

@@ -56,5 +56,14 @@ namespace osu.Game.Screens
         /// Whether mod rate adjustments are allowed to be applied.
         /// </summary>
         bool AllowRateAdjustments { get; }
+
+        /// <summary>
+        /// Invoked when the back button has been pressed to close any overlays before exiting this <see cref="IOsuScreen"/>.
+        /// </summary>
+        /// <remarks>
+        /// Return <c>true</c> to block this <see cref="IOsuScreen"/> from being exited after closing an overlay.
+        /// Return <c>false</c> if this <see cref="IOsuScreen"/> should continue exiting.
+        /// </remarks>
+        bool OnBackButton();
     }
 }

osu.Game/Screens/Menu/IntroTriangles.cs

@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -12,7 +11,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Video;
 using osu.Framework.Utils;
 using osu.Framework.Timing;
 using osu.Game.Graphics;
@@ -88,7 +86,7 @@ namespace osu.Game.Screens.Menu
             private RulesetFlow rulesets;
             private Container rulesetsScale;
             private Container logoContainerSecondary;
-            private Drawable lazerLogo;
+            private LazerLogo lazerLogo;
 
             private GlitchingTriangles triangles;
 
@@ -139,10 +137,10 @@ namespace osu.Game.Screens.Menu
                         RelativeSizeAxes = Axes.Both,
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Child = lazerLogo = new LazerLogo(textures.GetStream("Menu/logo-triangles.mp4"))
+                        Child = lazerLogo = new LazerLogo
                         {
                             Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
+                            Origin = Anchor.Centre
                         }
                     },
                 };
@@ -218,6 +216,9 @@ namespace osu.Game.Screens.Menu
 
                         // matching flyte curve y = 0.25x^2 + (max(0, x - 0.7) / 0.3) ^ 5
                         lazerLogo.FadeIn().ScaleTo(scale_start).Then().Delay(logo_scale_duration * 0.7f).ScaleTo(scale_start - scale_adjust, logo_scale_duration * 0.3f, Easing.InQuint);
+
+                        lazerLogo.TransformTo(nameof(LazerLogo.Progress), 1f, logo_scale_duration);
+
                         logoContainerSecondary.ScaleTo(scale_start).Then().ScaleTo(scale_start - scale_adjust * 0.25f, logo_scale_duration, Easing.InQuad);
                     }
 
@@ -259,20 +260,40 @@ namespace osu.Game.Screens.Menu
 
             private class LazerLogo : CompositeDrawable
             {
-                private readonly Stream videoStream;
+                private HueAnimation highlight, background;
 
-                public LazerLogo(Stream videoStream)
+                public float Progress
+                {
+                    get => background.AnimationProgress;
+                    set
+                    {
+                        background.AnimationProgress = value;
+                        highlight.AnimationProgress = value;
+                    }
+                }
+
+                public LazerLogo()
                 {
-                    this.videoStream = videoStream;
                     Size = new Vector2(960);
                 }
 
                 [BackgroundDependencyLoader]
-                private void load()
+                private void load(TextureStore textures)
                 {
-                    InternalChild = new Video(videoStream)
+                    InternalChildren = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both,
+                        highlight = new HueAnimation
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Texture = textures.Get(@"Intro/Triangles/logo-highlight"),
+                            Colour = Color4.White,
+                        },
+                        background = new HueAnimation
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Texture = textures.Get(@"Intro/Triangles/logo-background"),
+                            Colour = OsuColour.Gray(0.6f),
+                        },
                     };
                 }
             }

osu.Game/Screens/Multi/Multiplayer.cs

@@ -250,12 +250,6 @@ namespace osu.Game.Screens.Multi
         {
             roomManager.PartRoom();
 
-            if (screenStack.CurrentScreen != null && !(screenStack.CurrentScreen is LoungeSubScreen))
-            {
-                screenStack.Exit();
-                return true;
-            }
-
             waves.Hide();
 
             this.Delay(WaveContainer.DISAPPEAR_DURATION).FadeOut();
@@ -269,6 +263,20 @@ namespace osu.Game.Screens.Multi
             return false;
         }
 
+        public override bool OnBackButton()
+        {
+            if ((screenStack.CurrentScreen as IMultiplayerSubScreen)?.OnBackButton() == true)
+                return true;
+
+            if (screenStack.CurrentScreen != null && !(screenStack.CurrentScreen is LoungeSubScreen))
+            {
+                screenStack.Exit();
+                return true;
+            }
+
+            return false;
+        }
+
         protected override void LogoExiting(OsuLogo logo)
         {
             base.LogoExiting(logo);

osu.Game/Screens/OsuScreen.cs

@@ -258,5 +258,7 @@ namespace osu.Game.Screens
         /// Note that the instance created may not be the used instance if it matches the BackgroundMode equality clause.
         /// </summary>
         protected virtual BackgroundScreen CreateBackground() => null;
+
+        public virtual bool OnBackButton() => false;
     }
 }

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

@@ -251,6 +251,7 @@ namespace osu.Game.Screens.Play.HUD
                 switch (action)
                 {
                     case GlobalAction.Back:
+                    case GlobalAction.PauseGameplay: // in the future this behaviour will differ for replays etc.
                         if (!pendingAnimation)
                             BeginConfirm();
                         return true;
@@ -264,6 +265,7 @@ namespace osu.Game.Screens.Play.HUD
                 switch (action)
                 {
                     case GlobalAction.Back:
+                    case GlobalAction.PauseGameplay:
                         AbortConfirm();
                         break;
                 }

osu.Game/Screens/Play/SongProgressBar.cs

@@ -57,6 +57,8 @@ namespace osu.Game.Screens.Play
             set => CurrentNumber.Value = value;
         }
 
+        protected override bool AllowKeyboardInputWhenNotHovered => true;
+
         public SongProgressBar(float barHeight, float handleBarHeight, Vector2 handleSize)
         {
             CurrentNumber.MinValue = 0;

osu.Game/Screens/Ranking/Expanded/Accuracy/RankText.cs

@@ -77,11 +77,10 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
                     Origin = Anchor.Centre,
                     BlurSigma = new Vector2(35),
                     BypassAutoSizeAxes = Axes.Both,
-                    RelativeSizeAxes = Axes.Both,
+                    Size = new Vector2(200),
                     CacheDrawnFrameBuffer = true,
                     Blending = BlendingParameters.Additive,
                     Alpha = 0,
-                    Size = new Vector2(2f), // increase buffer size to allow for scale
                     Scale = new Vector2(1.8f),
                     Children = new[]
                     {
@@ -122,15 +121,18 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
             }
 
             flash.Colour = OsuColour.ForRank(rank);
-            flash.FadeIn().Then().FadeOut(1200, Easing.OutQuint);
 
             if (rank >= ScoreRank.S)
                 rankText.ScaleTo(1.05f).ScaleTo(1, 3000, Easing.OutQuint);
 
             if (rank >= ScoreRank.X)
             {
-                flash.FadeIn().Then().FadeOut(3000);
-                superFlash.FadeIn().Then().FadeOut(800, Easing.OutQuint);
+                flash.FadeOutFromOne(3000);
+                superFlash.FadeOutFromOne(800, Easing.OutQuint);
+            }
+            else
+            {
+                flash.FadeOutFromOne(1200, Easing.OutQuint);
             }
         }
     }

osu.Game/Screens/Ranking/ResultsScreen.cs

@@ -194,6 +194,13 @@ namespace osu.Game.Screens.Ranking
         }
 
         public override bool OnExiting(IScreen next)
+        {
+            Background.FadeTo(1, 250);
+
+            return base.OnExiting(next);
+        }
+
+        public override bool OnBackButton()
         {
             if (statisticsPanel.State.Value == Visibility.Visible)
             {
@@ -201,9 +208,7 @@ namespace osu.Game.Screens.Ranking
                 return true;
             }
 
-            Background.FadeTo(1, 250);
-
-            return base.OnExiting(next);
+            return false;
         }
 
         private void addScore(ScoreInfo score)

osu.Game/Screens/Select/SongSelect.cs

@@ -599,12 +599,6 @@ namespace osu.Game.Screens.Select
 
         public override bool OnExiting(IScreen next)
         {
-            if (ModSelect.State.Value == Visibility.Visible)
-            {
-                ModSelect.Hide();
-                return true;
-            }
-
             if (base.OnExiting(next))
                 return true;
 
@@ -620,6 +614,17 @@ namespace osu.Game.Screens.Select
             return false;
         }
 
+        public override bool OnBackButton()
+        {
+            if (ModSelect.State.Value == Visibility.Visible)
+            {
+                ModSelect.Hide();
+                return true;
+            }
+
+            return false;
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);

osu.Game/Skinning/DefaultSkin.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
 using osuTK.Graphics;
@@ -21,7 +22,7 @@ namespace osu.Game.Skinning
 
         public override Drawable GetDrawableComponent(ISkinComponent component) => null;
 
-        public override Texture GetTexture(string componentName) => null;
+        public override Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => null;
 
         public override SampleChannel GetSample(ISampleInfo sampleInfo) => null;
 

osu.Game/Skinning/IAnimationTimeReference.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Timing;
 
 namespace osu.Game.Skinning
@@ -11,7 +12,7 @@ namespace osu.Game.Skinning
     /// </summary>
     /// <remarks>
     /// This should not be used to start an animation immediately at the current time.
-    /// To do so, use <see cref="LegacySkinExtensions.GetAnimation"/> with <code>startAtCurrentTime = true</code> instead.
+    /// To do so, use <see cref="LegacySkinExtensions.GetAnimation(ISkin, string, WrapMode, WrapMode, bool, bool, bool, string, bool, double?)"/> with <code>startAtCurrentTime = true</code> instead.
     /// </remarks>
     [Cached]
     public interface IAnimationTimeReference

osu.Game/Skinning/ISkin.cs

@@ -5,6 +5,7 @@ using JetBrains.Annotations;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
 
@@ -29,7 +30,17 @@ namespace osu.Game.Skinning
         /// <param name="componentName">The requested texture.</param>
         /// <returns>A matching texture, or null if unavailable.</returns>
         [CanBeNull]
-        Texture GetTexture(string componentName);
+        Texture GetTexture(string componentName) => GetTexture(componentName, default, default);
+
+        /// <summary>
+        /// Retrieve a <see cref="Texture"/>.
+        /// </summary>
+        /// <param name="componentName">The requested texture.</param>
+        /// <param name="wrapModeS">The texture wrap mode in horizontal direction.</param>
+        /// <param name="wrapModeT">The texture wrap mode in vertical direction.</param>
+        /// <returns>A matching texture, or null if unavailable.</returns>
+        [CanBeNull]
+        Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT);
 
         /// <summary>
         /// Retrieve a <see cref="SampleChannel"/>.

osu.Game/Skinning/LegacySkin.cs

@@ -11,6 +11,7 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Game.Audio;
@@ -311,17 +312,17 @@ namespace osu.Game.Skinning
             return this.GetAnimation(component.LookupName, false, false);
         }
 
-        public override Texture GetTexture(string componentName)
+        public override Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
         {
             foreach (var name in getFallbackNames(componentName))
             {
                 float ratio = 2;
-                var texture = Textures?.Get($"{name}@2x");
+                var texture = Textures?.Get($"{name}@2x", wrapModeS, wrapModeT);
 
                 if (texture == null)
                 {
                     ratio = 1;
-                    texture = Textures?.Get(name);
+                    texture = Textures?.Get(name, wrapModeS, wrapModeT);
                 }
 
                 if (texture == null)

osu.Game/Skinning/LegacySkinExtensions.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 
@@ -15,6 +16,11 @@ namespace osu.Game.Skinning
     {
         public static Drawable GetAnimation(this ISkin source, string componentName, bool animatable, bool looping, bool applyConfigFrameRate = false, string animationSeparator = "-",
                                             bool startAtCurrentTime = true, double? frameLength = null)
+            => source.GetAnimation(componentName, default, default, animatable, looping, applyConfigFrameRate, animationSeparator, startAtCurrentTime, frameLength);
+
+        public static Drawable GetAnimation(this ISkin source, string componentName, WrapMode wrapModeS, WrapMode wrapModeT, bool animatable, bool looping, bool applyConfigFrameRate = false,
+                                            string animationSeparator = "-",
+                                            bool startAtCurrentTime = true, double? frameLength = null)
         {
             Texture texture;
 
@@ -38,7 +44,7 @@ namespace osu.Game.Skinning
             }
 
             // if an animation was not allowed or not found, fall back to a sprite retrieval.
-            if ((texture = source.GetTexture(componentName)) != null)
+            if ((texture = source.GetTexture(componentName, wrapModeS, wrapModeT)) != null)
                 return new Sprite { Texture = texture };
 
             return null;
@@ -47,7 +53,7 @@ namespace osu.Game.Skinning
             {
                 for (int i = 0; true; i++)
                 {
-                    if ((texture = source.GetTexture($"{componentName}{animationSeparator}{i}")) == null)
+                    if ((texture = source.GetTexture($"{componentName}{animationSeparator}{i}", wrapModeS, wrapModeT)) == null)
                         break;
 
                     yield return texture;

osu.Game/Skinning/LegacySkinTransformer.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
 using osu.Game.Rulesets.Objects.Legacy;
@@ -27,7 +28,10 @@ namespace osu.Game.Skinning
 
         public abstract Drawable GetDrawableComponent(ISkinComponent component);
 
-        public Texture GetTexture(string componentName) => Source.GetTexture(componentName);
+        public Texture GetTexture(string componentName) => GetTexture(componentName, default, default);
+
+        public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
+            => Source.GetTexture(componentName, wrapModeS, wrapModeT);
 
         public virtual SampleChannel GetSample(ISampleInfo sampleInfo)
         {

osu.Game/Skinning/Skin.cs

@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
 
@@ -20,7 +21,9 @@ namespace osu.Game.Skinning
 
         public abstract SampleChannel GetSample(ISampleInfo sampleInfo);
 
-        public abstract Texture GetTexture(string componentName);
+        public Texture GetTexture(string componentName) => GetTexture(componentName, default, default);
+
+        public abstract Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT);
 
         public abstract IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup);
 

osu.Game/Skinning/SkinManager.cs

@@ -13,6 +13,7 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Framework.Platform;
@@ -130,7 +131,7 @@ namespace osu.Game.Skinning
 
         public Drawable GetDrawableComponent(ISkinComponent component) => CurrentSkin.Value.GetDrawableComponent(component);
 
-        public Texture GetTexture(string componentName) => CurrentSkin.Value.GetTexture(componentName);
+        public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => CurrentSkin.Value.GetTexture(componentName, wrapModeS, wrapModeT);
 
         public SampleChannel GetSample(ISampleInfo sampleInfo) => CurrentSkin.Value.GetSample(sampleInfo);
 

osu.Game/Skinning/SkinProvidingContainer.cs

@@ -7,6 +7,7 @@ using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Textures;
 using osu.Game.Audio;
 
@@ -47,13 +48,13 @@ namespace osu.Game.Skinning
             return fallbackSource?.GetDrawableComponent(component);
         }
 
-        public Texture GetTexture(string componentName)
+        public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
         {
             Texture sourceTexture;
-            if (AllowTextureLookup(componentName) && (sourceTexture = skin?.GetTexture(componentName)) != null)
+            if (AllowTextureLookup(componentName) && (sourceTexture = skin?.GetTexture(componentName, wrapModeS, wrapModeT)) != null)
                 return sourceTexture;
 
-            return fallbackSource?.GetTexture(componentName);
+            return fallbackSource?.GetTexture(componentName, wrapModeS, wrapModeT);
         }
 
         public SampleChannel GetSample(ISampleInfo sampleInfo)

osu.Game/Storyboards/Drawables/DrawableStoryboardVideo.cs

@@ -55,10 +55,11 @@ namespace osu.Game.Storyboards.Drawables
 
             if (video == null) return;
 
-            video.PlaybackPosition = Clock.CurrentTime - Video.StartTime;
-
-            using (video.BeginAbsoluteSequence(0))
+            using (video.BeginAbsoluteSequence(Video.StartTime))
+            {
+                Schedule(() => video.PlaybackPosition = Time.Current - Video.StartTime);
                 video.FadeIn(500);
+            }
         }
     }
 }

osu.Game/Tests/Visual/SkinnableTestScene.cs

@@ -9,6 +9,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
@@ -157,7 +158,7 @@ namespace osu.Game.Tests.Visual
                 this.extrapolateAnimations = extrapolateAnimations;
             }
 
-            public override Texture GetTexture(string componentName)
+            public override Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
             {
                 // extrapolate frames to test longer animations
                 if (extrapolateAnimations)
@@ -165,10 +166,10 @@ namespace osu.Game.Tests.Visual
                     var match = Regex.Match(componentName, "-([0-9]*)");
 
                     if (match.Length > 0 && int.TryParse(match.Groups[1].Value, out var number) && number < 60)
-                        return base.GetTexture(componentName.Replace($"-{number}", $"-{number % 2}"));
+                        return base.GetTexture(componentName.Replace($"-{number}", $"-{number % 2}"), wrapModeS, wrapModeT);
                 }
 
-                return base.GetTexture(componentName);
+                return base.GetTexture(componentName, wrapModeS, wrapModeT);
             }
         }
     }

osu.Game/osu.Game.csproj

@@ -25,7 +25,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     <PackageReference Include="ppy.osu.Framework" Version="2020.714.1" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.714.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.715.0" />
     <PackageReference Include="Sentry" Version="2.1.4" />
     <PackageReference Include="SharpCompress" Version="0.25.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />

osu.iOS.props

@@ -71,7 +71,7 @@
   </ItemGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.714.1" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.714.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.715.0" />
   </ItemGroup>
   <!-- Xamarin.iOS does not automatically handle transitive dependencies from NuGet packages. -->
   <ItemGroup Label="Transitive Dependencies">

osu.sln.DotSettings

@@ -783,6 +783,7 @@ See the LICENCE file in the repository root for full licence text.
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
+	<s:String x:Key="/Default/Environment/UnitTesting/NUnitProvider/SetCurrentDirectoryTo/@EntryValue">TestFolder</s:String>
 	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=28A2A5FC43E07C488A4BC7430879479E/@KeyIndexDefined">True</s:Boolean>
 	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=28A2A5FC43E07C488A4BC7430879479E/Applicability/=Live/@EntryIndexedValue">True</s:Boolean>
 	<s:String x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=28A2A5FC43E07C488A4BC7430879479E/Description/@EntryValue">o!f – Object Initializer: Anchor&amp;Origin</s:String>