Merge branch 'master' into morth-taiko-changes

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.727.1" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.723.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.731.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.810.0" />
   </ItemGroup>
 </Project>

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

osu.Game.Rulesets.Catch/Objects/Banana.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using osu.Game.Audio;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Judgements;
 
@@ -8,8 +10,27 @@ namespace osu.Game.Rulesets.Catch.Objects
 {
     public class Banana : Fruit
     {
+        /// <summary>
+        /// Index of banana in current shower.
+        /// </summary>
+        public int BananaIndex;
+
         public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
 
         public override Judgement CreateJudgement() => new CatchBananaJudgement();
+
+        private static readonly List<HitSampleInfo> samples = new List<HitSampleInfo> { new BananaHitSampleInfo() };
+
+        public Banana()
+        {
+            Samples = samples;
+        }
+
+        private class BananaHitSampleInfo : HitSampleInfo
+        {
+            private static string[] lookupNames { get; } = { "metronomelow", "catch-banana" };
+
+            public override IEnumerable<string> LookupNames => lookupNames;
+        }
     }
 }

osu.Game.Rulesets.Catch/Objects/BananaShower.cs

@@ -30,15 +30,21 @@ namespace osu.Game.Rulesets.Catch.Objects
             if (spacing <= 0)
                 return;
 
-            for (double i = StartTime; i <= EndTime; i += spacing)
+            double time = StartTime;
+            int i = 0;
+
+            while (time <= EndTime)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
                 AddNested(new Banana
                 {
-                    Samples = Samples,
-                    StartTime = i
+                    StartTime = time,
+                    BananaIndex = i,
                 });
+
+                time += spacing;
+                i++;
             }
         }
 

osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBanana.cs

@@ -40,6 +40,13 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             float getRandomAngle() => 180 * (RNG.NextSingle() * 2 - 1);
         }
 
+        public override void PlaySamples()
+        {
+            base.PlaySamples();
+            if (Samples != null)
+                Samples.Frequency.Value = 0.77f + ((Banana)HitObject).BananaIndex * 0.006f;
+        }
+
         private Color4 getBananaColour()
         {
             switch (RNG.Next(0, 3))

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneHitExplosion.cs

@@ -1,23 +1,27 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Skinning;
+using osu.Game.Rulesets.Objects;
 using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Tests.Skinning
 {
     [TestFixture]
     public class TestSceneHitExplosion : ManiaSkinnableTestScene
     {
+        private readonly List<DrawablePool<PoolableHitExplosion>> hitExplosionPools = new List<DrawablePool<PoolableHitExplosion>>();
+
         public TestSceneHitExplosion()
         {
             int runcount = 0;
@@ -29,28 +33,40 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
                 if (runcount % 15 > 12)
                     return;
 
-                CreatedDrawables.OfType<Container>().ForEach(c =>
+                int poolIndex = 0;
+
+                foreach (var c in CreatedDrawables.OfType<Container>())
                 {
-                    c.Add(new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HitExplosion, 0),
-                        _ => new DefaultHitExplosion((runcount / 15) % 2 == 0 ? new Color4(94, 0, 57, 255) : new Color4(6, 84, 0, 255), runcount % 6 != 0)
-                        {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                        }));
-                });
+                    c.Add(hitExplosionPools[poolIndex].Get(e =>
+                    {
+                        e.Apply(new JudgementResult(new HitObject(), runcount % 6 == 0 ? new HoldNoteTickJudgement() : new ManiaJudgement()));
+
+                        e.Anchor = Anchor.Centre;
+                        e.Origin = Anchor.Centre;
+                    }));
+
+                    poolIndex++;
+                }
             }, 100);
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            SetContents(() => new ColumnTestContainer(0, ManiaAction.Key1)
+            SetContents(() =>
             {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                RelativePositionAxes = Axes.Y,
-                Y = -0.25f,
-                Size = new Vector2(Column.COLUMN_WIDTH, DefaultNotePiece.NOTE_HEIGHT),
+                var pool = new DrawablePool<PoolableHitExplosion>(5);
+                hitExplosionPools.Add(pool);
+
+                return new ColumnTestContainer(0, ManiaAction.Key1)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativePositionAxes = Axes.Y,
+                    Y = -0.25f,
+                    Size = new Vector2(Column.COLUMN_WIDTH, DefaultNotePiece.NOTE_HEIGHT),
+                    Child = pool
+                };
             });
         }
     }

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -6,13 +6,15 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Skinning
 {
-    public class LegacyHitExplosion : LegacyManiaColumnElement
+    public class LegacyHitExplosion : LegacyManiaColumnElement, IHitExplosion
     {
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
@@ -62,9 +64,9 @@ namespace osu.Game.Rulesets.Mania.Skinning
                 explosion.Anchor = direction.NewValue == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
         }
 
-        protected override void LoadComplete()
+        public void Animate(JudgementResult result)
         {
-            base.LoadComplete();
+            (explosion as IFramedAnimation)?.GotoFrame(0);
 
             explosion?.FadeInFromZero(80)
                      .Then().FadeOut(120);

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

@@ -9,9 +9,9 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics.Pooling;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
@@ -34,8 +34,8 @@ namespace osu.Game.Rulesets.Mania.UI
         public readonly Bindable<ManiaAction> Action = new Bindable<ManiaAction>();
 
         public readonly ColumnHitObjectArea HitObjectArea;
-
         internal readonly Container TopLevelContainer;
+        private readonly DrawablePool<PoolableHitExplosion> hitExplosionPool;
 
         public Container UnderlayElements => HitObjectArea.UnderlayElements;
 
@@ -53,6 +53,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             InternalChildren = new[]
             {
+                hitExplosionPool = new DrawablePool<PoolableHitExplosion>(5),
                 // 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 },
@@ -108,15 +109,7 @@ namespace osu.Game.Rulesets.Mania.UI
             if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 
-            var explosion = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HitExplosion, Index), _ =>
-                new DefaultHitExplosion(judgedObject.AccentColour.Value, judgedObject is DrawableHoldNoteTick))
-            {
-                RelativeSizeAxes = Axes.Both
-            };
-
-            HitObjectArea.Explosions.Add(explosion);
-
-            explosion.Delay(200).Expire(true);
+            HitObjectArea.Explosions.Add(hitExplosionPool.Get(e => e.Apply(result)));
         }
 
         public bool OnPressed(ManiaAction action)

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

@@ -8,6 +8,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Utils;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
@@ -15,35 +17,36 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class DefaultHitExplosion : CompositeDrawable
+    public class DefaultHitExplosion : CompositeDrawable, IHitExplosion
     {
+        private const float default_large_faint_size = 0.8f;
+
         public override bool RemoveWhenNotAlive => true;
 
+        [Resolved]
+        private Column column { get; set; }
+
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
-        private readonly CircularContainer largeFaint;
-        private readonly CircularContainer mainGlow1;
+        private CircularContainer largeFaint;
+        private CircularContainer mainGlow1;
 
-        public DefaultHitExplosion(Color4 objectColour, bool isSmall = false)
+        public DefaultHitExplosion()
         {
             Origin = Anchor.Centre;
 
             RelativeSizeAxes = Axes.X;
             Height = DefaultNotePiece.NOTE_HEIGHT;
+        }
 
-            // scale roughly in-line with visual appearance of notes
-            Scale = new Vector2(1f, 0.6f);
-
-            if (isSmall)
-                Scale *= 0.5f;
-
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
             const float angle_variangle = 15; // should be less than 45
-
             const float roundness = 80;
-
             const float initial_height = 10;
 
-            var colour = Interpolation.ValueAt(0.4f, objectColour, Color4.White, 0, 1);
+            var colour = Interpolation.ValueAt(0.4f, column.AccentColour, Color4.White, 0, 1);
 
             InternalChildren = new Drawable[]
             {
@@ -54,12 +57,12 @@ namespace osu.Game.Rulesets.Mania.UI
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,
                     // we want our size to be very small so the glow dominates it.
-                    Size = new Vector2(0.8f),
+                    Size = new Vector2(default_large_faint_size),
                     Blending = BlendingParameters.Additive,
                     EdgeEffect = new EdgeEffectParameters
                     {
                         Type = EdgeEffectType.Glow,
-                        Colour = Interpolation.ValueAt(0.1f, objectColour, Color4.White, 0, 1).Opacity(0.3f),
+                        Colour = Interpolation.ValueAt(0.1f, column.AccentColour, Color4.White, 0, 1).Opacity(0.3f),
                         Roundness = 160,
                         Radius = 200,
                     },
@@ -74,7 +77,7 @@ namespace osu.Game.Rulesets.Mania.UI
                     EdgeEffect = new EdgeEffectParameters
                     {
                         Type = EdgeEffectType.Glow,
-                        Colour = Interpolation.ValueAt(0.6f, objectColour, Color4.White, 0, 1),
+                        Colour = Interpolation.ValueAt(0.6f, column.AccentColour, Color4.White, 0, 1),
                         Roundness = 20,
                         Radius = 50,
                     },
@@ -114,30 +117,11 @@ namespace osu.Game.Rulesets.Mania.UI
                     },
                 }
             };
-        }
 
-        [BackgroundDependencyLoader]
-        private void load(IScrollingInfo scrollingInfo)
-        {
             direction.BindTo(scrollingInfo.Direction);
             direction.BindValueChanged(onDirectionChanged, true);
         }
 
-        protected override void LoadComplete()
-        {
-            const double duration = 200;
-
-            base.LoadComplete();
-
-            largeFaint
-                .ResizeTo(largeFaint.Size * new Vector2(5, 1), duration, Easing.OutQuint)
-                .FadeOut(duration * 2);
-
-            mainGlow1.ScaleTo(1.4f, duration, Easing.OutQuint);
-
-            this.FadeOut(duration, Easing.Out);
-        }
-
         private void onDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
         {
             if (direction.NewValue == ScrollingDirection.Up)
@@ -151,5 +135,29 @@ namespace osu.Game.Rulesets.Mania.UI
                 Y = -DefaultNotePiece.NOTE_HEIGHT / 2;
             }
         }
+
+        public void Animate(JudgementResult result)
+        {
+            // scale roughly in-line with visual appearance of notes
+            Vector2 scale = new Vector2(1, 0.6f);
+
+            if (result.Judgement is HoldNoteTickJudgement)
+                scale *= 0.5f;
+
+            this.ScaleTo(scale);
+
+            largeFaint
+                .ResizeTo(default_large_faint_size)
+                .Then()
+                .ResizeTo(default_large_faint_size * new Vector2(5, 1), PoolableHitExplosion.DURATION, Easing.OutQuint)
+                .FadeOut(PoolableHitExplosion.DURATION * 2);
+
+            mainGlow1
+                .ScaleTo(1)
+                .Then()
+                .ScaleTo(1.4f, PoolableHitExplosion.DURATION, Easing.OutQuint);
+
+            this.FadeOutFromOne(PoolableHitExplosion.DURATION, Easing.Out);
+        }
     }
 }

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

@@ -15,6 +15,10 @@ namespace osu.Game.Rulesets.Mania.UI
         {
         }
 
+        public DrawableManiaJudgement()
+        {
+        }
+
         [BackgroundDependencyLoader]
         private void load()
         {

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

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Judgements;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    /// <summary>
+    /// Common interface for all hit explosion bodies.
+    /// </summary>
+    public interface IHitExplosion
+    {
+        /// <summary>
+        /// Begins animating this <see cref="IHitExplosion"/>.
+        /// </summary>
+        /// <param name="result">The type of <see cref="JudgementResult"/> that caused this explosion.</param>
+        void Animate(JudgementResult result);
+    }
+}

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

@@ -0,0 +1,51 @@
+// 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.Pooling;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class PoolableHitExplosion : PoolableDrawable
+    {
+        public const double DURATION = 200;
+
+        public JudgementResult Result { get; private set; }
+
+        [Resolved]
+        private Column column { get; set; }
+
+        private SkinnableDrawable skinnableExplosion;
+
+        public PoolableHitExplosion()
+        {
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChild = skinnableExplosion = new SkinnableDrawable(new ManiaSkinComponent(ManiaSkinComponents.HitExplosion, column.Index), _ => new DefaultHitExplosion())
+            {
+                RelativeSizeAxes = Axes.Both
+            };
+        }
+
+        public void Apply(JudgementResult result)
+        {
+            Result = result;
+        }
+
+        protected override void PrepareForUse()
+        {
+            base.PrepareForUse();
+
+            (skinnableExplosion?.Drawable as IHitExplosion)?.Animate(Result);
+
+            this.Delay(DURATION).Then().Expire();
+        }
+    }
+}

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

@@ -6,6 +6,7 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
@@ -33,8 +34,8 @@ namespace osu.Game.Rulesets.Mania.UI
         public IReadOnlyList<Column> Columns => columnFlow.Children;
         private readonly FillFlowContainer<Column> columnFlow;
 
-        public Container<DrawableManiaJudgement> Judgements => judgements;
         private readonly JudgementContainer<DrawableManiaJudgement> judgements;
+        private readonly DrawablePool<DrawableManiaJudgement> judgementPool;
 
         private readonly Drawable barLineContainer;
         private readonly Container topLevelContainer;
@@ -63,6 +64,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             InternalChildren = new Drawable[]
             {
+                judgementPool = new DrawablePool<DrawableManiaJudgement>(2),
                 new Container
                 {
                     Anchor = Anchor.TopCentre,
@@ -208,12 +210,14 @@ namespace osu.Game.Rulesets.Mania.UI
             if (!judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 
-            judgements.Clear();
-            judgements.Add(new DrawableManiaJudgement(result, judgedObject)
+            judgements.Clear(false);
+            judgements.Add(judgementPool.Get(j =>
             {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-            });
+                j.Apply(result, judgedObject);
+
+                j.Anchor = Anchor.Centre;
+                j.Origin = Anchor.Centre;
+            }));
         }
 
         protected override void Update()

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

@@ -1,12 +1,27 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     public abstract class OsuSkinnableTestScene : SkinnableTestScene
     {
+        private Container content;
+
+        protected override Container<Drawable> Content
+        {
+            get
+            {
+                if (content == null)
+                    base.Content.Add(content = new OsuInputManager(new RulesetInfo { ID = 0 }));
+
+                return content;
+            }
+        }
+
         protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
     }
 }

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

@@ -3,7 +3,6 @@
 
 using System.Collections.Generic;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -26,19 +25,6 @@ namespace osu.Game.Rulesets.Osu.Tests
     [TestFixture]
     public class TestSceneSlider : OsuSkinnableTestScene
     {
-        private Container content;
-
-        protected override Container<Drawable> Content
-        {
-            get
-            {
-                if (content == null)
-                    base.Content.Add(content = new OsuInputManager(new RulesetInfo { ID = 0 }));
-
-                return content;
-            }
-        }
-
         private int depthIndex;
 
         public TestSceneSlider()

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

@@ -4,57 +4,76 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
-    public class TestSceneSpinner : OsuTestScene
+    public class TestSceneSpinner : OsuSkinnableTestScene
     {
-        private readonly Container content;
-        protected override Container<Drawable> Content => content;
-
         private int depthIndex;
 
-        public TestSceneSpinner()
-        {
-            base.Content.Add(content = new OsuInputManager(new RulesetInfo { ID = 0 }));
+        private TestDrawableSpinner drawableSpinner;
 
-            AddStep("Miss Big", () => testSingle(2));
-            AddStep("Miss Medium", () => testSingle(5));
-            AddStep("Miss Small", () => testSingle(7));
-            AddStep("Hit Big", () => testSingle(2, true));
-            AddStep("Hit Medium", () => testSingle(5, true));
-            AddStep("Hit Small", () => testSingle(7, true));
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestVariousSpinners(bool autoplay)
+        {
+            string term = autoplay ? "Hit" : "Miss";
+            AddStep($"{term} Big", () => SetContents(() => testSingle(2, autoplay)));
+            AddStep($"{term} Medium", () => SetContents(() => testSingle(5, autoplay)));
+            AddStep($"{term} Small", () => SetContents(() => testSingle(7, autoplay)));
         }
 
-        private void testSingle(float circleSize, bool auto = false)
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestLongSpinner(bool autoplay)
         {
-            var spinner = new Spinner { StartTime = Time.Current + 2000, EndTime = Time.Current + 5000 };
+            AddStep("Very short spinner", () => SetContents(() => testSingle(5, autoplay, 2000)));
+            AddUntilStep("Wait for completion", () => drawableSpinner.Result.HasResult);
+            AddUntilStep("Check correct progress", () => drawableSpinner.Progress == (autoplay ? 1 : 0));
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestSuperShortSpinner(bool autoplay)
+        {
+            AddStep("Very short spinner", () => SetContents(() => testSingle(5, autoplay, 200)));
+            AddUntilStep("Wait for completion", () => drawableSpinner.Result.HasResult);
+            AddUntilStep("Short spinner implicitly completes", () => drawableSpinner.Progress == 1);
+        }
+
+        private Drawable testSingle(float circleSize, bool auto = false, double length = 3000)
+        {
+            const double delay = 2000;
+
+            var spinner = new Spinner
+            {
+                StartTime = Time.Current + delay,
+                EndTime = Time.Current + delay + length
+            };
 
             spinner.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = circleSize });
 
-            var drawable = new TestDrawableSpinner(spinner, auto)
+            drawableSpinner = new TestDrawableSpinner(spinner, auto)
             {
                 Anchor = Anchor.Centre,
                 Depth = depthIndex++
             };
 
             foreach (var mod in SelectedMods.Value.OfType<IApplicableToDrawableHitObjects>())
-                mod.ApplyToDrawableHitObjects(new[] { drawable });
+                mod.ApplyToDrawableHitObjects(new[] { drawableSpinner });
 
-            Add(drawable);
+            return drawableSpinner;
         }
 
         private class TestDrawableSpinner : DrawableSpinner
         {
-            private bool auto;
+            private readonly bool auto;
 
             public TestDrawableSpinner(Spinner s, bool auto)
                 : base(s)
@@ -62,16 +81,11 @@ namespace osu.Game.Rulesets.Osu.Tests
                 this.auto = auto;
             }
 
-            protected override void CheckForResult(bool userTriggered, double timeOffset)
+            protected override void Update()
             {
-                if (auto && !userTriggered && Time.Current > Spinner.StartTime + Spinner.Duration / 2 && Progress < 1)
-                {
-                    // force completion only once to not break human interaction
-                    Disc.CumulativeRotation = Spinner.SpinsRequired * 360;
-                    auto = false;
-                }
-
-                base.CheckForResult(userTriggered, timeOffset);
+                base.Update();
+                if (auto)
+                    RotationTracker.AddRotation((float)(Clock.ElapsedFrameTime * 3));
             }
         }
     }

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

@@ -1,11 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
@@ -60,66 +62,75 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Test]
         public void TestSpinnerRewindingRotation()
         {
+            double trackerRotationTolerance = 0;
+
             addSeekStep(5000);
-            AddAssert("is disc rotation not almost 0", () => !Precision.AlmostEquals(drawableSpinner.Disc.Rotation, 0, 100));
-            AddAssert("is disc rotation absolute not almost 0", () => !Precision.AlmostEquals(drawableSpinner.Disc.CumulativeRotation, 0, 100));
+            AddStep("calculate rotation tolerance", () =>
+            {
+                trackerRotationTolerance = Math.Abs(drawableSpinner.RotationTracker.Rotation * 0.1f);
+            });
+            AddAssert("is disc rotation not almost 0", () => !Precision.AlmostEquals(drawableSpinner.RotationTracker.Rotation, 0, 100));
+            AddAssert("is disc rotation absolute not almost 0", () => !Precision.AlmostEquals(drawableSpinner.RotationTracker.RateAdjustedRotation, 0, 100));
 
             addSeekStep(0);
-            AddAssert("is disc rotation almost 0", () => Precision.AlmostEquals(drawableSpinner.Disc.Rotation, 0, 100));
-            AddAssert("is disc rotation absolute almost 0", () => Precision.AlmostEquals(drawableSpinner.Disc.CumulativeRotation, 0, 100));
+            AddAssert("is disc rotation almost 0", () => Precision.AlmostEquals(drawableSpinner.RotationTracker.Rotation, 0, trackerRotationTolerance));
+            AddAssert("is disc rotation absolute almost 0", () => Precision.AlmostEquals(drawableSpinner.RotationTracker.RateAdjustedRotation, 0, 100));
         }
 
         [Test]
         public void TestSpinnerMiddleRewindingRotation()
         {
-            double finalAbsoluteDiscRotation = 0, finalRelativeDiscRotation = 0, finalSpinnerSymbolRotation = 0;
+            double finalCumulativeTrackerRotation = 0;
+            double finalTrackerRotation = 0, trackerRotationTolerance = 0;
+            double finalSpinnerSymbolRotation = 0, spinnerSymbolRotationTolerance = 0;
 
             addSeekStep(5000);
-            AddStep("retrieve disc relative rotation", () => finalRelativeDiscRotation = drawableSpinner.Disc.Rotation);
-            AddStep("retrieve disc absolute rotation", () => finalAbsoluteDiscRotation = drawableSpinner.Disc.CumulativeRotation);
-            AddStep("retrieve spinner symbol rotation", () => finalSpinnerSymbolRotation = spinnerSymbol.Rotation);
+            AddStep("retrieve disc rotation", () =>
+            {
+                finalTrackerRotation = drawableSpinner.RotationTracker.Rotation;
+                trackerRotationTolerance = Math.Abs(finalTrackerRotation * 0.05f);
+            });
+            AddStep("retrieve spinner symbol rotation", () =>
+            {
+                finalSpinnerSymbolRotation = spinnerSymbol.Rotation;
+                spinnerSymbolRotationTolerance = Math.Abs(finalSpinnerSymbolRotation * 0.05f);
+            });
+            AddStep("retrieve cumulative disc rotation", () => finalCumulativeTrackerRotation = drawableSpinner.RotationTracker.RateAdjustedRotation);
 
             addSeekStep(2500);
-            AddUntilStep("disc rotation rewound",
+            AddAssert("disc rotation rewound",
                 // we want to make sure that the rotation at time 2500 is in the same direction as at time 5000, but about half-way in.
-                () => Precision.AlmostEquals(drawableSpinner.Disc.Rotation, finalRelativeDiscRotation / 2, 100));
-            AddUntilStep("symbol rotation rewound",
-                () => Precision.AlmostEquals(spinnerSymbol.Rotation, finalSpinnerSymbolRotation / 2, 100));
+                // due to the exponential damping applied we're allowing a larger margin of error of about 10%
+                // (5% relative to the final rotation value, but we're half-way through the spin).
+                () => Precision.AlmostEquals(drawableSpinner.RotationTracker.Rotation, finalTrackerRotation / 2, trackerRotationTolerance));
+            AddAssert("symbol rotation rewound",
+                () => Precision.AlmostEquals(spinnerSymbol.Rotation, finalSpinnerSymbolRotation / 2, spinnerSymbolRotationTolerance));
+            AddAssert("is cumulative rotation rewound",
+                // cumulative rotation is not damped, so we're treating it as the "ground truth" and allowing a comparatively smaller margin of error.
+                () => Precision.AlmostEquals(drawableSpinner.RotationTracker.RateAdjustedRotation, finalCumulativeTrackerRotation / 2, 100));
 
             addSeekStep(5000);
             AddAssert("is disc rotation almost same",
-                () => Precision.AlmostEquals(drawableSpinner.Disc.Rotation, finalRelativeDiscRotation, 100));
+                () => Precision.AlmostEquals(drawableSpinner.RotationTracker.Rotation, finalTrackerRotation, trackerRotationTolerance));
             AddAssert("is symbol rotation almost same",
-                () => Precision.AlmostEquals(spinnerSymbol.Rotation, finalSpinnerSymbolRotation, 100));
-            AddAssert("is disc rotation absolute almost same",
-                () => Precision.AlmostEquals(drawableSpinner.Disc.CumulativeRotation, finalAbsoluteDiscRotation, 100));
+                () => Precision.AlmostEquals(spinnerSymbol.Rotation, finalSpinnerSymbolRotation, spinnerSymbolRotationTolerance));
+            AddAssert("is cumulative rotation almost same",
+                () => Precision.AlmostEquals(drawableSpinner.RotationTracker.RateAdjustedRotation, finalCumulativeTrackerRotation, 100));
         }
 
         [Test]
         public void TestRotationDirection([Values(true, false)] bool clockwise)
         {
             if (clockwise)
-            {
-                AddStep("flip replay", () =>
-                {
-                    var drawableRuleset = this.ChildrenOfType<DrawableOsuRuleset>().Single();
-                    var score = drawableRuleset.ReplayScore;
-                    var scoreWithFlippedReplay = new Score
-                    {
-                        ScoreInfo = score.ScoreInfo,
-                        Replay = flipReplay(score.Replay)
-                    };
-                    drawableRuleset.SetReplayScore(scoreWithFlippedReplay);
-                });
-            }
+                transformReplay(flip);
 
             addSeekStep(5000);
 
-            AddAssert("disc spin direction correct", () => clockwise ? drawableSpinner.Disc.Rotation > 0 : drawableSpinner.Disc.Rotation < 0);
+            AddAssert("disc spin direction correct", () => clockwise ? drawableSpinner.RotationTracker.Rotation > 0 : drawableSpinner.RotationTracker.Rotation < 0);
             AddAssert("spinner symbol direction correct", () => clockwise ? spinnerSymbol.Rotation > 0 : spinnerSymbol.Rotation < 0);
         }
 
-        private Replay flipReplay(Replay scoreReplay) => new Replay
+        private Replay flip(Replay scoreReplay) => new Replay
         {
             Frames = scoreReplay
                      .Frames
@@ -142,7 +153,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 // multipled by 2 to nullify the score multiplier. (autoplay mod selected)
                 var totalScore = ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value * 2;
-                return totalScore == (int)(drawableSpinner.Disc.CumulativeRotation / 360) * SpinnerTick.SCORE_PER_TICK;
+                return totalScore == (int)(drawableSpinner.RotationTracker.RateAdjustedRotation / 360) * SpinnerTick.SCORE_PER_TICK;
             });
 
             addSeekStep(0);
@@ -174,6 +185,49 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("spm still valid", () => Precision.AlmostEquals(drawableSpinner.SpmCounter.SpinsPerMinute, estimatedSpm, 1.0));
         }
 
+        [TestCase(0.5)]
+        [TestCase(2.0)]
+        public void TestSpinUnaffectedByClockRate(double rate)
+        {
+            double expectedProgress = 0;
+            double expectedSpm = 0;
+
+            addSeekStep(1000);
+            AddStep("retrieve spinner state", () =>
+            {
+                expectedProgress = drawableSpinner.Progress;
+                expectedSpm = drawableSpinner.SpmCounter.SpinsPerMinute;
+            });
+
+            addSeekStep(0);
+
+            AddStep("adjust track rate", () => track.AddAdjustment(AdjustableProperty.Tempo, new BindableDouble(rate)));
+            // autoplay replay frames use track time;
+            // if a spin takes 1000ms in track time and we're playing with a 2x rate adjustment, the spin will take 500ms of *real* time.
+            // therefore we need to apply the rate adjustment to the replay itself to change from track time to real time,
+            // as real time is what we care about for spinners
+            // (so we're making the spin take 1000ms in real time *always*, regardless of the track clock's rate).
+            transformReplay(replay => applyRateAdjustment(replay, rate));
+
+            addSeekStep(1000);
+            AddAssert("progress almost same", () => Precision.AlmostEquals(expectedProgress, drawableSpinner.Progress, 0.05));
+            AddAssert("spm almost same", () => Precision.AlmostEquals(expectedSpm, drawableSpinner.SpmCounter.SpinsPerMinute, 2.0));
+        }
+
+        private Replay applyRateAdjustment(Replay scoreReplay, double rate) => new Replay
+        {
+            Frames = scoreReplay
+                     .Frames
+                     .Cast<OsuReplayFrame>()
+                     .Select(replayFrame =>
+                     {
+                         var adjustedTime = replayFrame.Time * rate;
+                         return new OsuReplayFrame(adjustedTime, replayFrame.Position, replayFrame.Actions.ToArray());
+                     })
+                     .Cast<ReplayFrame>()
+                     .ToList()
+        };
+
         private void addSeekStep(double time)
         {
             AddStep($"seek to {time}", () => track.Seek(time));
@@ -181,6 +235,18 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddUntilStep("wait for seek to finish", () => Precision.AlmostEquals(time, Player.DrawableRuleset.FrameStableClock.CurrentTime, 100));
         }
 
+        private void transformReplay(Func<Replay, Replay> replayTransformation) => AddStep("set replay", () =>
+        {
+            var drawableRuleset = this.ChildrenOfType<DrawableOsuRuleset>().Single();
+            var score = drawableRuleset.ReplayScore;
+            var transformedScore = new Score
+            {
+                ScoreInfo = score.ScoreInfo,
+                Replay = replayTransformation.Invoke(score.Replay)
+            };
+            drawableRuleset.SetReplayScore(transformedScore);
+        });
+
         protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new Beatmap
         {
             HitObjects = new List<HitObject>

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -82,9 +82,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
                 case DrawableSpinner spinner:
                     // hide elements we don't care about.
-                    spinner.Disc.Hide();
-                    spinner.Ticks.Hide();
-                    spinner.Background.Hide();
+                    // todo: hide background
 
                     using (spinner.BeginAbsoluteSequence(fadeOutStartTime + longFadeDuration, true))
                         spinner.FadeOut(fadeOutDuration);

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

@@ -40,8 +40,8 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             var spinner = (DrawableSpinner)drawable;
 
-            spinner.Disc.Tracking = true;
-            spinner.Disc.Rotate(MathUtils.RadiansToDegrees((float)spinner.Clock.ElapsedFrameTime * 0.03f));
+            spinner.RotationTracker.Tracking = true;
+            spinner.RotationTracker.AddRotation(MathUtils.RadiansToDegrees((float)spinner.Clock.ElapsedFrameTime * 0.03f));
         }
     }
 }

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

@@ -43,6 +43,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             var h = drawableOsu.HitObject;
 
+            //todo: expose and hide spinner background somehow
+
             switch (drawable)
             {
                 case DrawableHitCircle circle:
@@ -56,11 +58,6 @@ namespace osu.Game.Rulesets.Osu.Mods
                     slider.Body.OnSkinChanged += () => applySliderState(slider);
                     applySliderState(slider);
                     break;
-
-                case DrawableSpinner spinner:
-                    spinner.Disc.Hide();
-                    spinner.Background.Hide();
-                    break;
             }
         }
 

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs

@@ -14,8 +14,8 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Scoring;
-using osuTK;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -3,21 +3,19 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using osuTK;
-using osuTK.Graphics;
-using osu.Game.Graphics;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics.Sprites;
-using osu.Game.Rulesets.Objects;
-using osu.Framework.Utils;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Ranking;
+using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -27,28 +25,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private readonly Container<DrawableSpinnerTick> ticks;
 
-        public readonly SpinnerDisc Disc;
-        public readonly SpinnerTicks Ticks;
+        public readonly SpinnerRotationTracker RotationTracker;
         public readonly SpinnerSpmCounter SpmCounter;
         private readonly SpinnerBonusDisplay bonusDisplay;
 
-        private readonly Container mainContainer;
-
-        public readonly SpinnerBackground Background;
-        private readonly Container circleContainer;
-        private readonly CirclePiece circle;
-        private readonly GlowPiece glow;
-
-        private readonly SpriteIcon symbol;
-
-        private readonly Color4 baseColour = Color4Extensions.FromHex(@"002c3c");
-        private readonly Color4 fillColour = Color4Extensions.FromHex(@"005b7c");
-
         private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
 
-        private Color4 normalColour;
-        private Color4 completeColour;
-
         public DrawableSpinner(Spinner s)
             : base(s)
         {
@@ -57,66 +39,20 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             RelativeSizeAxes = Axes.Both;
 
-            // we are slightly bigger than our parent, to clip the top and bottom of the circle
-            Height = 1.3f;
-
             Spinner = s;
 
             InternalChildren = new Drawable[]
             {
                 ticks = new Container<DrawableSpinnerTick>(),
-                circleContainer = new Container
-                {
-                    AutoSizeAxes = Axes.Both,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Children = new Drawable[]
-                    {
-                        glow = new GlowPiece(),
-                        circle = new CirclePiece
-                        {
-                            Position = Vector2.Zero,
-                            Anchor = Anchor.Centre,
-                        },
-                        new RingPiece(),
-                        symbol = new SpriteIcon
-                        {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                            Size = new Vector2(48),
-                            Icon = FontAwesome.Solid.Asterisk,
-                            Shadow = false,
-                        },
-                    }
-                },
-                mainContainer = new AspectContainer
+                new AspectContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Y,
-                    Children = new[]
+                    Children = new Drawable[]
                     {
-                        Background = new SpinnerBackground
-                        {
-                            Disc =
-                            {
-                                Alpha = 0f,
-                            },
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                        },
-                        Disc = new SpinnerDisc(Spinner)
-                        {
-                            Scale = Vector2.Zero,
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                        },
-                        circleContainer.CreateProxy(),
-                        Ticks = new SpinnerTicks
-                        {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                        },
+                        new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SpinnerBody), _ => new DefaultSpinnerDisc()),
+                        RotationTracker = new SpinnerRotationTracker(Spinner)
                     }
                 },
                 SpmCounter = new SpinnerSpmCounter
@@ -135,6 +71,58 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             };
         }
 
+        private Bindable<bool> isSpinning;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            isSpinning = RotationTracker.IsSpinning.GetBoundCopy();
+            isSpinning.BindValueChanged(updateSpinningSample);
+        }
+
+        private SkinnableSound spinningSample;
+
+        private const float minimum_volume = 0.0001f;
+
+        protected override void LoadSamples()
+        {
+            base.LoadSamples();
+
+            spinningSample?.Expire();
+            spinningSample = null;
+
+            var firstSample = HitObject.Samples.FirstOrDefault();
+
+            if (firstSample != null)
+            {
+                var clone = HitObject.SampleControlPoint.ApplyTo(firstSample);
+                clone.Name = "spinnerspin";
+
+                AddInternal(spinningSample = new SkinnableSound(clone)
+                {
+                    Volume = { Value = minimum_volume },
+                    Looping = true,
+                });
+            }
+        }
+
+        private void updateSpinningSample(ValueChangedEvent<bool> tracking)
+        {
+            // note that samples will not start playing if exiting a seek operation in the middle of a spinner.
+            // may be something we want to address at a later point, but not so easy to make happen right now
+            // (SkinnableSound would need to expose whether the sample is already playing and this logic would need to run in Update).
+            if (tracking.NewValue && ShouldPlaySamples)
+            {
+                spinningSample?.Play();
+                spinningSample?.VolumeTo(1, 200);
+            }
+            else
+            {
+                spinningSample?.VolumeTo(minimum_volume, 200).Finally(_ => spinningSample.Stop());
+            }
+        }
+
         protected override void AddNestedHitObject(DrawableHitObject hitObject)
         {
             base.AddNestedHitObject(hitObject);
@@ -147,6 +135,17 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
+        protected override void UpdateStateTransforms(ArmedState state)
+        {
+            base.UpdateStateTransforms(state);
+
+            using (BeginDelayedSequence(Spinner.Duration, true))
+                this.FadeOut(160);
+
+            // skin change does a rewind of transforms, which will stop the spinning sound from playing if it's currently in playback.
+            isSpinning?.TriggerChange();
+        }
+
         protected override void ClearNestedHitObjects()
         {
             base.ClearNestedHitObjects();
@@ -170,31 +169,31 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            normalColour = baseColour;
-            completeColour = colours.YellowLight;
-
-            Background.AccentColour = normalColour;
-            Ticks.AccentColour = normalColour;
-
-            Disc.AccentColour = fillColour;
-            circle.Colour = colours.BlueDark;
-            glow.Colour = colours.BlueDark;
-
             positionBindable.BindValueChanged(pos => Position = pos.NewValue);
             positionBindable.BindTo(HitObject.PositionBindable);
         }
 
-        public float Progress => Math.Clamp(Disc.CumulativeRotation / 360 / Spinner.SpinsRequired, 0, 1);
+        /// <summary>
+        /// The completion progress of this spinner from 0..1 (clamped).
+        /// </summary>
+        public float Progress
+        {
+            get
+            {
+                if (Spinner.SpinsRequired == 0)
+                    // some spinners are so short they can't require an integer spin count.
+                    // these become implicitly hit.
+                    return 1;
+
+                return Math.Clamp(RotationTracker.RateAdjustedRotation / 360 / Spinner.SpinsRequired, 0, 1);
+            }
+        }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (Time.Current < HitObject.StartTime) return;
 
-            if (Progress >= 1 && !Disc.Complete)
-            {
-                Disc.Complete = true;
-                transformFillColour(completeColour, 200);
-            }
+            RotationTracker.Complete.Value = Progress >= 1;
 
             if (userTriggered || Time.Current < Spinner.EndTime)
                 return;
@@ -219,29 +218,24 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected override void Update()
         {
             base.Update();
+
             if (HandleUserInput)
-                Disc.Tracking = OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false;
+                RotationTracker.Tracking = !Result.HasResult && (OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
+
+            if (spinningSample != null)
+                // todo: implement SpinnerFrequencyModulate
+                spinningSample.Frequency.Value = 0.5f + Progress;
         }
 
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
 
-            if (!SpmCounter.IsPresent && Disc.Tracking)
+            if (!SpmCounter.IsPresent && RotationTracker.Tracking)
                 SpmCounter.FadeIn(HitObject.TimeFadeIn);
-
-            circle.Rotation = Disc.Rotation;
-            Ticks.Rotation = Disc.Rotation;
-
-            SpmCounter.SetRotation(Disc.CumulativeRotation);
+            SpmCounter.SetRotation(RotationTracker.RateAdjustedRotation);
 
             updateBonusScore();
-
-            float relativeCircleScale = Spinner.Scale * circle.DrawHeight / mainContainer.DrawHeight;
-            float targetScale = relativeCircleScale + (1 - relativeCircleScale) * Progress;
-            Disc.Scale = new Vector2((float)Interpolation.Lerp(Disc.Scale.X, targetScale, Math.Clamp(Math.Abs(Time.Elapsed) / 100, 0, 1)));
-
-            symbol.Rotation = (float)Interpolation.Lerp(symbol.Rotation, Disc.Rotation / 2, Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
         }
 
         private int wholeSpins;
@@ -251,7 +245,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (ticks.Count == 0)
                 return;
 
-            int spins = (int)(Disc.CumulativeRotation / 360);
+            int spins = (int)(RotationTracker.RateAdjustedRotation / 360);
 
             if (spins < wholeSpins)
             {
@@ -275,64 +269,5 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 wholeSpins++;
             }
         }
-
-        protected override void UpdateInitialTransforms()
-        {
-            base.UpdateInitialTransforms();
-
-            circleContainer.ScaleTo(0);
-            mainContainer.ScaleTo(0);
-
-            using (BeginDelayedSequence(HitObject.TimePreempt / 2, true))
-            {
-                float phaseOneScale = Spinner.Scale * 0.7f;
-
-                circleContainer.ScaleTo(phaseOneScale, HitObject.TimePreempt / 4, Easing.OutQuint);
-
-                mainContainer
-                    .ScaleTo(phaseOneScale * circle.DrawHeight / DrawHeight * 1.6f, HitObject.TimePreempt / 4, Easing.OutQuint)
-                    .RotateTo((float)(25 * Spinner.Duration / 2000), HitObject.TimePreempt + Spinner.Duration);
-
-                using (BeginDelayedSequence(HitObject.TimePreempt / 2, true))
-                {
-                    circleContainer.ScaleTo(Spinner.Scale, 400, Easing.OutQuint);
-                    mainContainer.ScaleTo(1, 400, Easing.OutQuint);
-                }
-            }
-        }
-
-        protected override void UpdateStateTransforms(ArmedState state)
-        {
-            base.UpdateStateTransforms(state);
-
-            using (BeginDelayedSequence(Spinner.Duration, true))
-            {
-                this.FadeOut(160);
-
-                switch (state)
-                {
-                    case ArmedState.Hit:
-                        transformFillColour(completeColour, 0);
-                        this.ScaleTo(Scale * 1.2f, 320, Easing.Out);
-                        mainContainer.RotateTo(mainContainer.Rotation + 180, 320);
-                        break;
-
-                    case ArmedState.Miss:
-                        this.ScaleTo(Scale * 0.8f, 320, Easing.In);
-                        break;
-                }
-            }
-        }
-
-        private void transformFillColour(Colour4 colour, double duration)
-        {
-            Disc.FadeAccent(colour, duration);
-
-            Background.FadeAccent(colour.Darken(1), duration);
-            Ticks.FadeAccent(colour, duration);
-
-            circle.FadeColour(colour, duration);
-            glow.FadeColour(colour, duration);
-        }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/DefaultSpinnerDisc.cs

@@ -0,0 +1,189 @@
+// 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.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class DefaultSpinnerDisc : CompositeDrawable
+    {
+        private DrawableSpinner drawableSpinner;
+
+        private Spinner spinner;
+
+        private const float idle_alpha = 0.2f;
+        private const float tracking_alpha = 0.4f;
+
+        private Color4 normalColour;
+        private Color4 completeColour;
+
+        private SpinnerTicks ticks;
+
+        private int wholeRotationCount;
+
+        private SpinnerFill fill;
+        private Container mainContainer;
+        private SpinnerCentreLayer centre;
+        private SpinnerBackgroundLayer background;
+
+        public DefaultSpinnerDisc()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            // we are slightly bigger than our parent, to clip the top and bottom of the circle
+            // this should probably be revisited when scaled spinners are a thing.
+            Scale = new Vector2(1.3f);
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, DrawableHitObject drawableHitObject)
+        {
+            drawableSpinner = (DrawableSpinner)drawableHitObject;
+            spinner = (Spinner)drawableSpinner.HitObject;
+
+            normalColour = colours.BlueDark;
+            completeColour = colours.YellowLight;
+
+            InternalChildren = new Drawable[]
+            {
+                mainContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        background = new SpinnerBackgroundLayer(),
+                        fill = new SpinnerFill
+                        {
+                            Alpha = idle_alpha,
+                            AccentColour = normalColour
+                        },
+                        ticks = new SpinnerTicks
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            AccentColour = normalColour
+                        },
+                    }
+                },
+                centre = new SpinnerCentreLayer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            drawableSpinner.RotationTracker.Complete.BindValueChanged(complete => updateComplete(complete.NewValue, 200));
+            drawableSpinner.State.BindValueChanged(updateStateTransforms, true);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (drawableSpinner.RotationTracker.Complete.Value)
+            {
+                if (checkNewRotationCount)
+                {
+                    fill.FinishTransforms(false, nameof(Alpha));
+                    fill
+                        .FadeTo(tracking_alpha + 0.2f, 60, Easing.OutExpo)
+                        .Then()
+                        .FadeTo(tracking_alpha, 250, Easing.OutQuint);
+                }
+            }
+            else
+            {
+                fill.Alpha = (float)Interpolation.Damp(fill.Alpha, drawableSpinner.RotationTracker.Tracking ? tracking_alpha : idle_alpha, 0.98f, (float)Math.Abs(Clock.ElapsedFrameTime));
+            }
+
+            const float initial_scale = 0.2f;
+            float targetScale = initial_scale + (1 - initial_scale) * drawableSpinner.Progress;
+
+            fill.Scale = new Vector2((float)Interpolation.Lerp(fill.Scale.X, targetScale, Math.Clamp(Math.Abs(Time.Elapsed) / 100, 0, 1)));
+            mainContainer.Rotation = drawableSpinner.RotationTracker.Rotation;
+        }
+
+        private void updateStateTransforms(ValueChangedEvent<ArmedState> state)
+        {
+            centre.ScaleTo(0);
+            mainContainer.ScaleTo(0);
+
+            using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt / 2, true))
+            {
+                // constant ambient rotation to give the spinner "spinning" character.
+                this.RotateTo((float)(25 * spinner.Duration / 2000), spinner.TimePreempt + spinner.Duration);
+
+                centre.ScaleTo(0.3f, spinner.TimePreempt / 4, Easing.OutQuint);
+                mainContainer.ScaleTo(0.2f, spinner.TimePreempt / 4, Easing.OutQuint);
+
+                using (BeginDelayedSequence(spinner.TimePreempt / 2, true))
+                {
+                    centre.ScaleTo(0.5f, spinner.TimePreempt / 2, Easing.OutQuint);
+                    mainContainer.ScaleTo(1, spinner.TimePreempt / 2, Easing.OutQuint);
+                }
+            }
+
+            // transforms we have from completing the spinner will be rolled back, so reapply immediately.
+            updateComplete(state.NewValue == ArmedState.Hit, 0);
+
+            using (BeginDelayedSequence(spinner.Duration, true))
+            {
+                switch (state.NewValue)
+                {
+                    case ArmedState.Hit:
+                        this.ScaleTo(Scale * 1.2f, 320, Easing.Out);
+                        this.RotateTo(mainContainer.Rotation + 180, 320);
+                        break;
+
+                    case ArmedState.Miss:
+                        this.ScaleTo(Scale * 0.8f, 320, Easing.In);
+                        break;
+                }
+            }
+        }
+
+        private void updateComplete(bool complete, double duration)
+        {
+            var colour = complete ? completeColour : normalColour;
+
+            ticks.FadeAccent(colour.Darken(1), duration);
+            fill.FadeAccent(colour.Darken(1), duration);
+
+            background.FadeAccent(colour, duration);
+            centre.FadeAccent(colour, duration);
+        }
+
+        private bool checkNewRotationCount
+        {
+            get
+            {
+                int rotations = (int)(drawableSpinner.RotationTracker.RateAdjustedRotation / 360);
+
+                if (wholeRotationCount == rotations) return false;
+
+                wholeRotationCount = rotations;
+                return true;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerFill.cs

@@ -10,7 +10,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class SpinnerBackground : CircularContainer, IHasAccentColour
+    public class SpinnerFill : CircularContainer, IHasAccentColour
     {
         public readonly Box Disc;
 
@@ -31,11 +31,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             }
         }
 
-        public SpinnerBackground()
+        public SpinnerFill()
         {
             RelativeSizeAxes = Axes.Both;
             Masking = true;
 
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
             Children = new Drawable[]
             {
                 Disc = new Box

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerRotationTracker.cs

@@ -2,89 +2,62 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Events;
-using osu.Game.Graphics;
-using osuTK;
-using osuTK.Graphics;
 using osu.Framework.Utils;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class SpinnerDisc : CircularContainer, IHasAccentColour
+    public class SpinnerRotationTracker : CircularContainer
     {
         private readonly Spinner spinner;
 
-        public Color4 AccentColour
-        {
-            get => background.AccentColour;
-            set => background.AccentColour = value;
-        }
-
-        private readonly SpinnerBackground background;
-
-        private const float idle_alpha = 0.2f;
-        private const float tracking_alpha = 0.4f;
-
         public override bool IsPresent => true; // handle input when hidden
 
-        public SpinnerDisc(Spinner s)
+        public SpinnerRotationTracker(Spinner s)
         {
             spinner = s;
 
             RelativeSizeAxes = Axes.Both;
-
-            Children = new Drawable[]
-            {
-                background = new SpinnerBackground { Alpha = idle_alpha },
-            };
         }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
-        private bool tracking;
+        public bool Tracking { get; set; }
 
-        public bool Tracking
-        {
-            get => tracking;
-            set
-            {
-                if (value == tracking) return;
-
-                tracking = value;
-
-                background.FadeTo(tracking ? tracking_alpha : idle_alpha, 100);
-            }
-        }
-
-        private bool complete;
-
-        public bool Complete
-        {
-            get => complete;
-            set
-            {
-                if (value == complete) return;
-
-                complete = value;
-
-                updateCompleteTick();
-            }
-        }
+        public readonly BindableBool Complete = new BindableBool();
 
         /// <summary>
-        /// The total rotation performed on the spinner disc, disregarding the spin direction.
+        /// The total rotation performed on the spinner disc, disregarding the spin direction,
+        /// adjusted for the track's playback rate.
         /// </summary>
         /// <remarks>
+        /// <para>
         /// This value is always non-negative and is monotonically increasing with time
         /// (i.e. will only increase if time is passing forward, but can decrease during rewind).
+        /// </para>
+        /// <para>
+        /// The rotation from each frame is multiplied by the clock's current playback rate.
+        /// The reason this is done is to ensure that spinners give the same score and require the same number of spins
+        /// regardless of whether speed-modifying mods are applied.
+        /// </para>
         /// </remarks>
         /// <example>
-        /// If the spinner is spun 360 degrees clockwise and then 360 degrees counter-clockwise,
+        /// Assuming no speed-modifying mods are active,
+        /// if the spinner is spun 360 degrees clockwise and then 360 degrees counter-clockwise,
         /// this property will return the value of 720 (as opposed to 0 for <see cref="Drawable.Rotation"/>).
+        /// If Double Time is active instead (with a speed multiplier of 1.5x),
+        /// in the same scenario the property will return 720 * 1.5 = 1080.
         /// </example>
-        public float CumulativeRotation;
+        public float RateAdjustedRotation { get; private set; }
+
+        /// <summary>
+        /// Whether the spinning is spinning at a reasonable speed to be considered visually spinning.
+        /// </summary>
+        public readonly BindableBool IsSpinning = new BindableBool();
 
         /// <summary>
         /// Whether currently in the correct time range to allow spinning.
@@ -101,9 +74,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
         private float lastAngle;
         private float currentRotation;
-        private int completeTick;
-
-        private bool updateCompleteTick() => completeTick != (completeTick = (int)(CumulativeRotation / 360));
 
         private bool rotationTransferred;
 
@@ -114,21 +84,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
             var delta = thisAngle - lastAngle;
 
-            if (tracking)
-                Rotate(delta);
+            if (Tracking)
+                AddRotation(delta);
 
             lastAngle = thisAngle;
 
-            if (Complete && updateCompleteTick())
-            {
-                background.FinishTransforms(false, nameof(Alpha));
-                background
-                    .FadeTo(tracking_alpha + 0.2f, 60, Easing.OutExpo)
-                    .Then()
-                    .FadeTo(tracking_alpha, 250, Easing.OutQuint);
-            }
+            IsSpinning.Value = isSpinnableTime && Math.Abs(currentRotation / 2 - Rotation) > 5f;
 
-            Rotation = (float)Interpolation.Lerp(Rotation, currentRotation / 2, Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
+            Rotation = (float)Interpolation.Damp(Rotation, currentRotation / 2, 0.99, Math.Abs(Time.Elapsed));
         }
 
         /// <summary>
@@ -138,7 +101,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         /// Will be a no-op if not a valid time to spin.
         /// </remarks>
         /// <param name="angle">The delta angle.</param>
-        public void Rotate(float angle)
+        public void AddRotation(float angle)
         {
             if (!isSpinnableTime)
                 return;
@@ -161,7 +124,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             }
 
             currentRotation += angle;
-            CumulativeRotation += Math.Abs(angle) * Math.Sign(Clock.ElapsedFrameTime);
+            // rate has to be applied each frame, because it's not guaranteed to be constant throughout playback
+            // (see: ModTimeRamp)
+            RateAdjustedRotation += (float)(Math.Abs(angle) * Clock.Rate);
         }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/SpinnerBackgroundLayer.cs

@@ -0,0 +1,22 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class SpinnerBackgroundLayer : SpinnerFill
+    {
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, DrawableHitObject drawableHitObject)
+        {
+            Disc.Alpha = 0;
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/SpinnerCentreLayer.cs

@@ -0,0 +1,71 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class SpinnerCentreLayer : CompositeDrawable, IHasAccentColour
+    {
+        private DrawableSpinner spinner;
+
+        private CirclePiece circle;
+        private GlowPiece glow;
+        private SpriteIcon symbol;
+
+        [BackgroundDependencyLoader]
+        private void load(DrawableHitObject drawableHitObject)
+        {
+            spinner = (DrawableSpinner)drawableHitObject;
+
+            InternalChildren = new Drawable[]
+            {
+                glow = new GlowPiece(),
+                circle = new CirclePiece
+                {
+                    Position = Vector2.Zero,
+                    Anchor = Anchor.Centre,
+                },
+                new RingPiece(),
+                symbol = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(48),
+                    Icon = FontAwesome.Solid.Asterisk,
+                    Shadow = false,
+                },
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            symbol.Rotation = (float)Interpolation.Lerp(symbol.Rotation, spinner.RotationTracker.Rotation / 2, Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
+        }
+
+        private Color4 accentColour;
+
+        public Color4 AccentColour
+        {
+            get => accentColour;
+            set
+            {
+                accentColour = value;
+
+                circle.Colour = accentColour;
+                glow.Colour = accentColour;
+            }
+        }
+    }
+}

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

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
@@ -45,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
             double minimumRotationsPerSecond = stable_matching_fudge * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5);
 
-            SpinsRequired = (int)Math.Max(1, (secondsDuration * minimumRotationsPerSecond));
+            SpinsRequired = (int)(secondsDuration * minimumRotationsPerSecond);
             MaximumBonusSpins = (int)((maximum_rotations_per_second - minimumRotationsPerSecond) * secondsDuration);
         }
 

osu.Game.Rulesets.Osu/OsuSkinComponents.cs

@@ -17,5 +17,6 @@ namespace osu.Game.Rulesets.Osu
         SliderFollowCircle,
         SliderBall,
         SliderBody,
+        SpinnerBody
     }
 }

osu.Game.Rulesets.Osu/Skinning/LegacyMainCirclePiece.cs

@@ -14,6 +14,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
+using static osu.Game.Skinning.LegacySkinConfiguration;
 
 namespace osu.Game.Rulesets.Osu.Skinning
 {
@@ -28,53 +29,67 @@ namespace osu.Game.Rulesets.Osu.Skinning
             Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
         }
 
+        private Container<Sprite> circleSprites;
+        private Sprite hitCircleSprite;
+        private Sprite hitCircleOverlay;
+
+        private SkinnableSpriteText hitCircleText;
+
         private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
         private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
         private readonly IBindable<int> indexInCurrentCombo = new Bindable<int>();
 
+        [Resolved]
+        private ISkinSource skin { get; set; }
+
         [BackgroundDependencyLoader]
-        private void load(DrawableHitObject drawableObject, ISkinSource skin)
+        private void load(DrawableHitObject drawableObject)
         {
             OsuHitObject osuObject = (OsuHitObject)drawableObject.HitObject;
 
-            Sprite hitCircleSprite;
-            SkinnableSpriteText hitCircleText;
-
             InternalChildren = new Drawable[]
             {
-                hitCircleSprite = new Sprite
+                circleSprites = new Container<Sprite>
                 {
-                    Texture = getTextureWithFallback(string.Empty),
-                    Colour = drawableObject.AccentColour.Value,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new[]
+                    {
+                        hitCircleSprite = new Sprite
+                        {
+                            Texture = getTextureWithFallback(string.Empty),
+                            Colour = drawableObject.AccentColour.Value,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                        hitCircleOverlay = new Sprite
+                        {
+                            Texture = getTextureWithFallback("overlay"),
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        }
+                    }
                 },
                 hitCircleText = new SkinnableSpriteText(new OsuSkinComponent(OsuSkinComponents.HitCircleText), _ => new OsuSpriteText
                 {
                     Font = OsuFont.Numeric.With(size: 40),
                     UseFullGlyphHeight = false,
-                }, confineMode: ConfineMode.NoScaling),
-                new Sprite
+                }, confineMode: ConfineMode.NoScaling)
                 {
-                    Texture = getTextureWithFallback("overlay"),
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                }
+                },
             };
 
             bool overlayAboveNumber = skin.GetConfig<OsuSkinConfiguration, bool>(OsuSkinConfiguration.HitCircleOverlayAboveNumber)?.Value ?? true;
 
-            if (!overlayAboveNumber)
-                ChangeInternalChildDepth(hitCircleText, -float.MaxValue);
+            if (overlayAboveNumber)
+                AddInternal(hitCircleOverlay.CreateProxy());
 
             state.BindTo(drawableObject.State);
-            state.BindValueChanged(updateState, true);
-
             accentColour.BindTo(drawableObject.AccentColour);
-            accentColour.BindValueChanged(colour => hitCircleSprite.Colour = colour.NewValue, true);
-
             indexInCurrentCombo.BindTo(osuObject.IndexInCurrentComboBindable);
-            indexInCurrentCombo.BindValueChanged(index => hitCircleText.Text = (index.NewValue + 1).ToString(), true);
 
             Texture getTextureWithFallback(string name)
             {
@@ -87,6 +102,15 @@ namespace osu.Game.Rulesets.Osu.Skinning
             }
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            state.BindValueChanged(updateState, true);
+            accentColour.BindValueChanged(colour => hitCircleSprite.Colour = colour.NewValue, true);
+            indexInCurrentCombo.BindValueChanged(index => hitCircleText.Text = (index.NewValue + 1).ToString(), true);
+        }
+
         private void updateState(ValueChangedEvent<ArmedState> state)
         {
             const double legacy_fade_duration = 240;
@@ -94,8 +118,21 @@ namespace osu.Game.Rulesets.Osu.Skinning
             switch (state.NewValue)
             {
                 case ArmedState.Hit:
-                    this.FadeOut(legacy_fade_duration, Easing.Out);
-                    this.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
+                    circleSprites.FadeOut(legacy_fade_duration, Easing.Out);
+                    circleSprites.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
+
+                    var legacyVersion = skin.GetConfig<LegacySetting, decimal>(LegacySetting.Version)?.Value;
+
+                    if (legacyVersion >= 2.0m)
+                        // legacy skins of version 2.0 and newer only apply very short fade out to the number piece.
+                        hitCircleText.FadeOut(legacy_fade_duration / 4, Easing.Out);
+                    else
+                    {
+                        // old skins scale and fade it normally along other pieces.
+                        hitCircleText.FadeOut(legacy_fade_duration, Easing.Out);
+                        hitCircleText.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
+                    }
+
                     break;
             }
         }

osu.Game.Rulesets.Osu/Skinning/LegacyNewStyleSpinner.cs

@@ -0,0 +1,99 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Skinning;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Skinning
+{
+    /// <summary>
+    /// Legacy skinned spinner with two main spinning layers, one fixed overlay and one final spinning overlay.
+    /// No background layer.
+    /// </summary>
+    public class LegacyNewStyleSpinner : CompositeDrawable
+    {
+        private Sprite discBottom;
+        private Sprite discTop;
+        private Sprite spinningMiddle;
+        private Sprite fixedMiddle;
+
+        private DrawableSpinner drawableSpinner;
+
+        private const float final_scale = 0.625f;
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource source, DrawableHitObject drawableObject)
+        {
+            drawableSpinner = (DrawableSpinner)drawableObject;
+
+            Scale = new Vector2(final_scale);
+
+            InternalChildren = new Drawable[]
+            {
+                discBottom = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Texture = source.GetTexture("spinner-bottom")
+                },
+                discTop = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Texture = source.GetTexture("spinner-top")
+                },
+                fixedMiddle = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Texture = source.GetTexture("spinner-middle")
+                },
+                spinningMiddle = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Texture = source.GetTexture("spinner-middle2")
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            this.FadeOut();
+            drawableSpinner.State.BindValueChanged(updateStateTransforms, true);
+        }
+
+        private void updateStateTransforms(ValueChangedEvent<ArmedState> state)
+        {
+            var spinner = (Spinner)drawableSpinner.HitObject;
+
+            using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt / 2, true))
+                this.FadeInFromZero(spinner.TimePreempt / 2);
+
+            fixedMiddle.FadeColour(Color4.White);
+            using (BeginAbsoluteSequence(spinner.StartTime, true))
+                fixedMiddle.FadeColour(Color4.Red, spinner.Duration);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            spinningMiddle.Rotation = discTop.Rotation = drawableSpinner.RotationTracker.Rotation;
+            discBottom.Rotation = discTop.Rotation / 3;
+
+            Scale = new Vector2(final_scale * (0.8f + (float)Interpolation.ApplyEasing(Easing.Out, drawableSpinner.Progress) * 0.2f));
+        }
+    }
+}

osu.Game.Rulesets.Osu/Skinning/LegacyOldStyleSpinner.cs

@@ -0,0 +1,114 @@
+// 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.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Skinning
+{
+    /// <summary>
+    /// Legacy skinned spinner with one main spinning layer and a background layer.
+    /// </summary>
+    public class LegacyOldStyleSpinner : CompositeDrawable
+    {
+        private DrawableSpinner drawableSpinner;
+        private Sprite disc;
+        private Container metre;
+
+        private const float background_y_offset = 20;
+
+        private const float sprite_scale = 1 / 1.6f;
+
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource source, DrawableHitObject drawableObject)
+        {
+            drawableSpinner = (DrawableSpinner)drawableObject;
+
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                new Sprite
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    Texture = source.GetTexture("spinner-background"),
+                    Y = background_y_offset,
+                    Scale = new Vector2(sprite_scale)
+                },
+                disc = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Texture = source.GetTexture("spinner-circle"),
+                    Scale = new Vector2(sprite_scale)
+                },
+                metre = new Container
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    Y = background_y_offset,
+                    Masking = true,
+                    Child = new Sprite
+                    {
+                        Texture = source.GetTexture("spinner-metre"),
+                        Anchor = Anchor.BottomCentre,
+                        Origin = Anchor.BottomCentre,
+                    },
+                    Scale = new Vector2(0.625f)
+                }
+            };
+        }
+
+        private Vector2 metreFinalSize;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            this.FadeOut();
+            drawableSpinner.State.BindValueChanged(updateStateTransforms, true);
+
+            metreFinalSize = metre.Size = metre.Child.Size;
+        }
+
+        private void updateStateTransforms(ValueChangedEvent<ArmedState> state)
+        {
+            var spinner = drawableSpinner.HitObject;
+
+            using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt / 2, true))
+                this.FadeInFromZero(spinner.TimePreempt / 2);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            disc.Rotation = drawableSpinner.RotationTracker.Rotation;
+            metre.Height = getMetreHeight(drawableSpinner.Progress);
+        }
+
+        private const int total_bars = 10;
+
+        private float getMetreHeight(float progress)
+        {
+            progress = Math.Min(99, progress * 100);
+
+            int barCount = (int)progress / 10;
+
+            // todo: add SpinnerNoBlink support
+            if (RNG.NextBool(((int)progress % 10) / 10f))
+                barCount++;
+
+            return (float)barCount / total_bars * metreFinalSize.Y;
+        }
+    }
+}

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

@@ -102,6 +102,16 @@ namespace osu.Game.Rulesets.Osu.Skinning
                             Scale = new Vector2(0.8f),
                             Spacing = new Vector2(-overlap, 0)
                         };
+
+                case OsuSkinComponents.SpinnerBody:
+                    bool hasBackground = Source.GetTexture("spinner-background") != null;
+
+                    if (Source.GetTexture("spinner-top") != null && !hasBackground)
+                        return new LegacyNewStyleSpinner();
+                    else if (hasBackground)
+                        return new LegacyOldStyleSpinner();
+
+                    return null;
             }
 
             return null;

osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs

@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override PassThroughInputManager CreateInputManager() => new OsuInputManager(Ruleset.RulesetInfo);
 
-        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new OsuPlayfieldAdjustmentContainer();
+        public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new OsuPlayfieldAdjustmentContainer { AlignWithStoryboard = true };
 
         protected override ResumeOverlay CreateResumeOverlay() => new OsuResumeOverlay();
 

osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs

@@ -23,7 +23,8 @@ namespace osu.Game.Rulesets.Osu.UI
 {
     public class OsuPlayfield : Playfield
     {
-        private readonly ApproachCircleProxyContainer approachCircles;
+        private readonly ProxyContainer approachCircles;
+        private readonly ProxyContainer spinnerProxies;
         private readonly JudgementContainer<DrawableOsuJudgement> judgementLayer;
         private readonly FollowPointRenderer followPoints;
         private readonly OrderedHitPolicy hitPolicy;
@@ -38,6 +39,10 @@ namespace osu.Game.Rulesets.Osu.UI
         {
             InternalChildren = new Drawable[]
             {
+                spinnerProxies = new ProxyContainer
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
                 followPoints = new FollowPointRenderer
                 {
                     RelativeSizeAxes = Axes.Both,
@@ -54,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.UI
                 {
                     Child = HitObjectContainer,
                 },
-                approachCircles = new ApproachCircleProxyContainer
+                approachCircles = new ProxyContainer
                 {
                     RelativeSizeAxes = Axes.Both,
                     Depth = -1,
@@ -76,6 +81,9 @@ namespace osu.Game.Rulesets.Osu.UI
             h.OnNewResult += onNewResult;
             h.OnLoadComplete += d =>
             {
+                if (d is DrawableSpinner)
+                    spinnerProxies.Add(d.CreateProxy());
+
                 if (d is IDrawableHitObjectWithProxiedApproach c)
                     approachCircles.Add(c.ProxiedLayer.CreateProxy());
             };
@@ -113,9 +121,9 @@ namespace osu.Game.Rulesets.Osu.UI
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => HitObjectContainer.ReceivePositionalInputAt(screenSpacePos);
 
-        private class ApproachCircleProxyContainer : LifetimeManagementContainer
+        private class ProxyContainer : LifetimeManagementContainer
         {
-            public void Add(Drawable approachCircleProxy) => AddInternal(approachCircleProxy);
+            public void Add(Drawable proxy) => AddInternal(proxy);
         }
 
         private class DrawableJudgementPool : DrawablePool<DrawableOsuJudgement>

osu.Game.Rulesets.Osu/UI/OsuPlayfieldAdjustmentContainer.cs

@@ -11,10 +11,19 @@ namespace osu.Game.Rulesets.Osu.UI
     public class OsuPlayfieldAdjustmentContainer : PlayfieldAdjustmentContainer
     {
         protected override Container<Drawable> Content => content;
-        private readonly Container content;
+        private readonly ScalingContainer content;
 
         private const float playfield_size_adjust = 0.8f;
 
+        /// <summary>
+        /// When true, an offset is applied to allow alignment with historical storyboards displayed in the same parent space.
+        /// This will shift the playfield downwards slightly.
+        /// </summary>
+        public bool AlignWithStoryboard
+        {
+            set => content.PlayfieldShift = value;
+        }
+
         public OsuPlayfieldAdjustmentContainer()
         {
             Anchor = Anchor.Centre;
@@ -39,6 +48,8 @@ namespace osu.Game.Rulesets.Osu.UI
         /// </summary>
         private class ScalingContainer : Container
         {
+            internal bool PlayfieldShift { get; set; }
+
             protected override void Update()
             {
                 base.Update();
@@ -55,6 +66,7 @@ namespace osu.Game.Rulesets.Osu.UI
                 // Scale = 819.2 / 512
                 // Scale = 1.6
                 Scale = new Vector2(Parent.ChildSize.X / OsuPlayfield.BASE_SIZE.X);
+                Position = new Vector2(0, (PlayfieldShift ? 8f : 0f) * Scale.X);
                 // Size = 0.625
                 Size = Vector2.Divide(Vector2.One, Scale);
             }

osu.Game.Rulesets.Taiko.Tests/Resources/SampleLookups/taiko-hitobject-beatmap-custom-sample-bank.osu

@@ -0,0 +1,10 @@
+osu file format v14
+
+[General]
+Mode: 1
+
+[TimingPoints]
+0,300,4,1,2,100,1,0
+
+[HitObjects]
+444,320,1000,5,0,0:0:0:0:

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

@@ -0,0 +1,52 @@
+// 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.Reflection;
+using NUnit.Framework;
+using osu.Framework.IO.Stores;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    public class TestSceneTaikoHitObjectSamples : HitObjectSampleTest
+    {
+        protected override Ruleset CreatePlayerRuleset() => new TaikoRuleset();
+
+        protected override IResourceStore<byte[]> Resources => new DllResourceStore(Assembly.GetAssembly(typeof(TestSceneTaikoHitObjectSamples)));
+
+        [TestCase("taiko-normal-hitnormal")]
+        [TestCase("normal-hitnormal")]
+        [TestCase("hitnormal")]
+        public void TestDefaultCustomSampleFromBeatmap(string expectedSample)
+        {
+            SetupSkins(expectedSample, expectedSample);
+
+            CreateTestWithBeatmap("taiko-hitobject-beatmap-custom-sample-bank.osu");
+
+            AssertBeatmapLookup(expectedSample);
+        }
+
+        [TestCase("taiko-normal-hitnormal")]
+        [TestCase("normal-hitnormal")]
+        [TestCase("hitnormal")]
+        public void TestDefaultCustomSampleFromUserSkinFallback(string expectedSample)
+        {
+            SetupSkins(string.Empty, expectedSample);
+
+            CreateTestWithBeatmap("taiko-hitobject-beatmap-custom-sample-bank.osu");
+
+            AssertUserLookup(expectedSample);
+        }
+
+        [TestCase("taiko-normal-hitnormal2")]
+        [TestCase("normal-hitnormal2")]
+        public void TestUserSkinLookupIgnoresSampleBank(string unwantedSample)
+        {
+            SetupSkins(string.Empty, unwantedSample);
+
+            CreateTestWithBeatmap("taiko-hitobject-beatmap-custom-sample-bank.osu");
+
+            AssertNoLookup(unwantedSample);
+        }
+    }
+}

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

osu.Game.Tests/Gameplay/TestSceneHitObjectSamples.cs

@@ -6,9 +6,9 @@ using osu.Framework.IO.Stores;
 using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
-using osu.Game.Skinning;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Resources;
+using static osu.Game.Skinning.LegacySkinConfiguration;
 
 namespace osu.Game.Tests.Gameplay
 {
@@ -67,9 +67,11 @@ namespace osu.Game.Tests.Gameplay
         /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the beatmap skin:
         /// normal-hitnormal2
         /// normal-hitnormal
+        /// hitnormal
         /// </summary>
         [TestCase("normal-hitnormal2")]
         [TestCase("normal-hitnormal")]
+        [TestCase("hitnormal")]
         public void TestDefaultCustomSampleFromBeatmap(string expectedSample)
         {
             SetupSkins(expectedSample, expectedSample);
@@ -80,12 +82,13 @@ namespace osu.Game.Tests.Gameplay
         }
 
         /// <summary>
-        /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the user skin when the beatmap does not contain the sample:
-        /// normal-hitnormal2
+        /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the user skin
+        /// (ignoring the custom sample set index) when the beatmap skin does not contain the sample:
         /// normal-hitnormal
+        /// hitnormal
         /// </summary>
-        [TestCase("normal-hitnormal2")]
         [TestCase("normal-hitnormal")]
+        [TestCase("hitnormal")]
         public void TestDefaultCustomSampleFromUserSkinFallback(string expectedSample)
         {
             SetupSkins(string.Empty, expectedSample);
@@ -95,6 +98,23 @@ namespace osu.Game.Tests.Gameplay
             AssertUserLookup(expectedSample);
         }
 
+        /// <summary>
+        /// Tests that a hitobject which provides a custom sample set of 2 does not retrieve a normal-hitnormal2 sample from the user skin
+        /// if the beatmap skin does not contain the sample.
+        /// User skins in stable ignore the custom sample set index when performing lookups.
+        /// </summary>
+        [Test]
+        public void TestUserSkinLookupIgnoresSampleBank()
+        {
+            const string unwanted_sample = "normal-hitnormal2";
+
+            SetupSkins(string.Empty, unwanted_sample);
+
+            CreateTestWithBeatmap("hitobject-beatmap-custom-sample.osu");
+
+            AssertNoLookup(unwanted_sample);
+        }
+
         /// <summary>
         /// Tests that a hitobject which provides a sample file retrieves the sample file from the beatmap skin.
         /// </summary>
@@ -145,6 +165,7 @@ namespace osu.Game.Tests.Gameplay
         /// </summary>
         [TestCase("normal-hitnormal2")]
         [TestCase("normal-hitnormal")]
+        [TestCase("hitnormal")]
         public void TestControlPointCustomSampleFromBeatmap(string sampleName)
         {
             SetupSkins(sampleName, sampleName);
@@ -178,7 +199,7 @@ namespace osu.Game.Tests.Gameplay
             string[] expectedSamples =
             {
                 "normal-hitnormal2",
-                "normal-hitwhistle2"
+                "normal-hitwhistle" // user skin lookups ignore custom sample set index
             };
 
             SetupSkins(expectedSamples[0], expectedSamples[1]);
@@ -190,7 +211,7 @@ namespace osu.Game.Tests.Gameplay
         }
 
         /// <summary>
-        /// Tests that when a custom sample bank is used, but <see cref="GlobalSkinConfiguration.LayeredHitSounds"/> is disabled,
+        /// Tests that when a custom sample bank is used, but <see cref="LegacySetting.LayeredHitSounds"/> is disabled,
         /// only the additional sound will be looked up.
         /// </summary>
         [Test]
@@ -209,7 +230,7 @@ namespace osu.Game.Tests.Gameplay
         }
 
         /// <summary>
-        /// Tests that when a normal sample bank is used and <see cref="GlobalSkinConfiguration.LayeredHitSounds"/> is disabled,
+        /// Tests that when a normal sample bank is used and <see cref="LegacySetting.LayeredHitSounds"/> is disabled,
         /// the normal sound will be looked up anyway.
         /// </summary>
         [Test]
@@ -226,6 +247,6 @@ namespace osu.Game.Tests.Gameplay
         }
 
         private void disableLayeredHitSounds()
-            => AddStep("set LayeredHitSounds to false", () => Skin.Configuration.ConfigDictionary[GlobalSkinConfiguration.LayeredHitSounds.ToString()] = "0");
+            => AddStep("set LayeredHitSounds to false", () => Skin.Configuration.ConfigDictionary[LegacySetting.LayeredHitSounds.ToString()] = "0");
     }
 }

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

@@ -3,14 +3,24 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Net;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Newtonsoft.Json.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Multi.Ranking;
+using osu.Game.Screens.Ranking;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Users;
 
@@ -18,43 +28,134 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
     public class TestSceneTimeshiftResultsScreen : ScreenTestScene
     {
-        private bool roomsReceived;
+        private const int scores_per_result = 10;
+
+        private TestResultsScreen resultsScreen;
+        private int currentScoreId;
+        private bool requestComplete;
 
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            roomsReceived = false;
+            currentScoreId = 0;
+            requestComplete = false;
             bindHandler();
         });
 
         [Test]
-        public void TestShowResultsWithScore()
+        public void TestShowWithUserScore()
         {
-            createResults(new TestScoreInfo(new OsuRuleset().RulesetInfo));
-            AddWaitStep("wait for display", 5);
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(userScore: userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddAssert("user score selected", () => this.ChildrenOfType<ScorePanel>().Single(p => p.Score.OnlineScoreID == userScore.OnlineScoreID).State == PanelState.Expanded);
         }
 
         [Test]
-        public void TestShowResultsNullScore()
+        public void TestShowNullUserScore()
         {
-            createResults(null);
-            AddWaitStep("wait for display", 5);
+            createResults();
+            waitForDisplay();
+
+            AddAssert("top score selected", () => this.ChildrenOfType<ScorePanel>().OrderByDescending(p => p.Score.TotalScore).First().State == PanelState.Expanded);
         }
 
         [Test]
-        public void TestShowResultsNullScoreWithDelay()
+        public void TestShowUserScoreWithDelay()
+        {
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(3000, userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddAssert("more than 1 panel displayed", () => this.ChildrenOfType<ScorePanel>().Count() > 1);
+            AddAssert("user score selected", () => this.ChildrenOfType<ScorePanel>().Single(p => p.Score.OnlineScoreID == userScore.OnlineScoreID).State == PanelState.Expanded);
+        }
+
+        [Test]
+        public void TestShowNullUserScoreWithDelay()
         {
             AddStep("bind delayed handler", () => bindHandler(3000));
-            createResults(null);
-            AddUntilStep("wait for rooms to be received", () => roomsReceived);
-            AddWaitStep("wait for display", 5);
+
+            createResults();
+            waitForDisplay();
+
+            AddAssert("top score selected", () => this.ChildrenOfType<ScorePanel>().OrderByDescending(p => p.Score.TotalScore).First().State == PanelState.Expanded);
         }
 
-        private void createResults(ScoreInfo score)
+        [Test]
+        public void TestFetchWhenScrolledToTheRight()
+        {
+            createResults();
+            waitForDisplay();
+
+            AddStep("bind delayed handler", () => bindHandler(3000));
+
+            for (int i = 0; i < 2; i++)
+            {
+                int beforePanelCount = 0;
+
+                AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
+                AddStep("scroll to right", () => resultsScreen.ScorePanelList.ChildrenOfType<OsuScrollContainer>().Single().ScrollToEnd(false));
+
+                AddAssert("right loading spinner shown", () => resultsScreen.RightSpinner.State.Value == Visibility.Visible);
+                waitForDisplay();
+
+                AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
+                AddAssert("right loading spinner hidden", () => resultsScreen.RightSpinner.State.Value == Visibility.Hidden);
+            }
+        }
+
+        [Test]
+        public void TestFetchWhenScrolledToTheLeft()
+        {
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(userScore: userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddStep("bind delayed handler", () => bindHandler(3000));
+
+            for (int i = 0; i < 2; i++)
+            {
+                int beforePanelCount = 0;
+
+                AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
+                AddStep("scroll to left", () => resultsScreen.ScorePanelList.ChildrenOfType<OsuScrollContainer>().Single().ScrollToStart(false));
+
+                AddAssert("left loading spinner shown", () => resultsScreen.LeftSpinner.State.Value == Visibility.Visible);
+                waitForDisplay();
+
+                AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
+                AddAssert("left loading spinner hidden", () => resultsScreen.LeftSpinner.State.Value == Visibility.Hidden);
+            }
+        }
+
+        private void createResults(Func<ScoreInfo> getScore = null)
         {
             AddStep("load results", () =>
             {
-                LoadScreen(new TimeshiftResultsScreen(score, 1, new PlaylistItem
+                LoadScreen(resultsScreen = new TestResultsScreen(getScore?.Invoke(), 1, new PlaylistItem
                 {
                     Beatmap = { Value = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo },
                     Ruleset = { Value = new OsuRuleset().RulesetInfo }
@@ -62,62 +163,214 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
         }
 
-        private void bindHandler(double delay = 0)
+        private void waitForDisplay()
         {
-            var roomScores = new List<MultiplayerScore>();
+            AddUntilStep("wait for request to complete", () => requestComplete);
+            AddWaitStep("wait for display", 5);
+        }
 
-            for (int i = 0; i < 10; i++)
+        private void bindHandler(double delay = 0, ScoreInfo userScore = null, bool failRequests = false) => ((DummyAPIAccess)API).HandleRequest = request =>
+        {
+            requestComplete = false;
+
+            if (failRequests)
             {
-                roomScores.Add(new MultiplayerScore
+                triggerFail(request, delay);
+                return;
+            }
+
+            switch (request)
+            {
+                case ShowPlaylistUserScoreRequest s:
+                    if (userScore == null)
+                        triggerFail(s, delay);
+                    else
+                        triggerSuccess(s, createUserResponse(userScore), delay);
+                    break;
+
+                case IndexPlaylistScoresRequest i:
+                    triggerSuccess(i, createIndexResponse(i), delay);
+                    break;
+            }
+        };
+
+        private void triggerSuccess<T>(APIRequest<T> req, T result, double delay)
+            where T : class
+        {
+            if (delay == 0)
+                success();
+            else
+            {
+                Task.Run(async () =>
                 {
-                    ID = i,
-                    Accuracy = 0.9 - 0.01 * i,
-                    EndedAt = DateTimeOffset.Now.Subtract(TimeSpan.FromHours(i)),
+                    await Task.Delay(TimeSpan.FromMilliseconds(delay));
+                    Schedule(success);
+                });
+            }
+
+            void success()
+            {
+                requestComplete = true;
+                req.TriggerSuccess(result);
+            }
+        }
+
+        private void triggerFail(APIRequest req, double delay)
+        {
+            if (delay == 0)
+                fail();
+            else
+            {
+                Task.Run(async () =>
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(delay));
+                    Schedule(fail);
+                });
+            }
+
+            void fail()
+            {
+                requestComplete = true;
+                req.TriggerFailure(new WebException("Failed."));
+            }
+        }
+
+        private MultiplayerScore createUserResponse([NotNull] ScoreInfo userScore)
+        {
+            var multiplayerUserScore = new MultiplayerScore
+            {
+                ID = (int)(userScore.OnlineScoreID ?? currentScoreId++),
+                Accuracy = userScore.Accuracy,
+                EndedAt = userScore.Date,
+                Passed = userScore.Passed,
+                Rank = userScore.Rank,
+                Position = 200,
+                MaxCombo = userScore.MaxCombo,
+                TotalScore = userScore.TotalScore,
+                User = userScore.User,
+                Statistics = userScore.Statistics,
+                ScoresAround = new MultiplayerScoresAround
+                {
+                    Higher = new MultiplayerScores(),
+                    Lower = new MultiplayerScores()
+                }
+            };
+
+            for (int i = 1; i <= scores_per_result; i++)
+            {
+                multiplayerUserScore.ScoresAround.Lower.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = userScore.Accuracy,
+                    EndedAt = userScore.Date,
                     Passed = true,
-                    Rank = ScoreRank.B,
-                    MaxCombo = 999,
-                    TotalScore = 999999 - i * 1000,
+                    Rank = userScore.Rank,
+                    MaxCombo = userScore.MaxCombo,
+                    TotalScore = userScore.TotalScore - i,
                     User = new User
                     {
                         Id = 2,
                         Username = $"peppy{i}",
                         CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
                     },
-                    Statistics =
+                    Statistics = userScore.Statistics
+                });
+
+                multiplayerUserScore.ScoresAround.Higher.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = userScore.Accuracy,
+                    EndedAt = userScore.Date,
+                    Passed = true,
+                    Rank = userScore.Rank,
+                    MaxCombo = userScore.MaxCombo,
+                    TotalScore = userScore.TotalScore + i,
+                    User = new User
+                    {
+                        Id = 2,
+                        Username = $"peppy{i}",
+                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    },
+                    Statistics = userScore.Statistics
+                });
+            }
+
+            addCursor(multiplayerUserScore.ScoresAround.Lower);
+            addCursor(multiplayerUserScore.ScoresAround.Higher);
+
+            return multiplayerUserScore;
+        }
+
+        private IndexedMultiplayerScores createIndexResponse(IndexPlaylistScoresRequest req)
+        {
+            var result = new IndexedMultiplayerScores();
+
+            long startTotalScore = req.Cursor?.Properties["total_score"].ToObject<long>() ?? 1000000;
+            string sort = req.IndexParams?.Properties["sort"].ToObject<string>() ?? "score_desc";
+
+            for (int i = 1; i <= scores_per_result; i++)
+            {
+                result.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = 1,
+                    EndedAt = DateTimeOffset.Now,
+                    Passed = true,
+                    Rank = ScoreRank.X,
+                    MaxCombo = 1000,
+                    TotalScore = startTotalScore + (sort == "score_asc" ? i : -i),
+                    User = new User
+                    {
+                        Id = 2,
+                        Username = $"peppy{i}",
+                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    },
+                    Statistics = new Dictionary<HitResult, int>
                     {
                         { HitResult.Miss, 1 },
                         { HitResult.Meh, 50 },
                         { HitResult.Good, 100 },
-                        { HitResult.Great, 300 },
+                        { HitResult.Great, 300 }
                     }
                 });
             }
 
-            ((DummyAPIAccess)API).HandleRequest = request =>
+            addCursor(result);
+
+            return result;
+        }
+
+        private void addCursor(MultiplayerScores scores)
+        {
+            scores.Cursor = new Cursor
             {
-                switch (request)
+                Properties = new Dictionary<string, JToken>
                 {
-                    case GetRoomPlaylistScoresRequest r:
-                        if (delay == 0)
-                            success();
-                        else
-                        {
-                            Task.Run(async () =>
-                            {
-                                await Task.Delay(TimeSpan.FromMilliseconds(delay));
-                                Schedule(success);
-                            });
-                        }
+                    { "total_score", JToken.FromObject(scores.Scores[^1].TotalScore) },
+                    { "score_id", JToken.FromObject(scores.Scores[^1].ID) },
+                }
+            };
 
-                        void success()
-                        {
-                            r.TriggerSuccess(new RoomPlaylistScores { Scores = roomScores });
-                            roomsReceived = true;
-                        }
-
-                        break;
+            scores.Params = new IndexScoresParams
+            {
+                Properties = new Dictionary<string, JToken>
+                {
+                    { "sort", JToken.FromObject(scores.Scores[^1].TotalScore > scores.Scores[^2].TotalScore ? "score_asc" : "score_desc") }
                 }
             };
         }
+
+        private class TestResultsScreen : TimeshiftResultsScreen
+        {
+            public new LoadingSpinner LeftSpinner => base.LeftSpinner;
+            public new LoadingSpinner CentreSpinner => base.CentreSpinner;
+            public new LoadingSpinner RightSpinner => base.RightSpinner;
+            public new ScorePanelList ScorePanelList => base.ScorePanelList;
+
+            public TestResultsScreen(ScoreInfo score, int roomId, PlaylistItem playlistItem, bool allowRetry = true)
+                : base(score, roomId, playlistItem, allowRetry)
+            {
+            }
+        }
     }
 }

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

@@ -31,15 +31,16 @@ namespace osu.Game.Tests.Visual.Online
                 {
                     new NewsCard(new APINewsPost
                     {
-                        Title = "This post has an image which starts with \"/\" and has many authors!",
+                        Title = "This post has an image which starts with \"/\" and has many authors! (clickable)",
                         Preview = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
                         Author = "someone, someone1, someone2, someone3, someone4",
                         FirstImage = "/help/wiki/shared/news/banners/monthly-beatmapping-contest.png",
-                        PublishedAt = DateTimeOffset.Now
+                        PublishedAt = DateTimeOffset.Now,
+                        Slug = "2020-07-16-summer-theme-park-2020-voting-open"
                     }),
                     new NewsCard(new APINewsPost
                     {
-                        Title = "This post has a full-url image! (HTML entity: &)",
+                        Title = "This post has a full-url image! (HTML entity: &) (non-clickable)",
                         Preview = "boom (HTML entity: &)",
                         Author = "user (HTML entity: &)",
                         FirstImage = "https://assets.ppy.sh/artists/88/header.jpg",

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

@@ -0,0 +1,53 @@
+// 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.Game.Overlays.News;
+using osu.Framework.Graphics;
+using osu.Game.Overlays;
+using osu.Framework.Allocation;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneNewsHeader : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        private TestHeader header;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Child = header = new TestHeader
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            };
+        });
+
+        [Test]
+        public void TestControl()
+        {
+            AddAssert("Front page selected", () => header.Current.Value == "frontpage");
+            AddAssert("1 tab total", () => header.TabCount == 1);
+
+            AddStep("Set article 1", () => header.SetArticle("1"));
+            AddAssert("Article 1 selected", () => header.Current.Value == "1");
+            AddAssert("2 tabs total", () => header.TabCount == 2);
+
+            AddStep("Set article 2", () => header.SetArticle("2"));
+            AddAssert("Article 2 selected", () => header.Current.Value == "2");
+            AddAssert("2 tabs total", () => header.TabCount == 2);
+
+            AddStep("Set front page", () => header.SetFrontPage());
+            AddAssert("Front page selected", () => header.Current.Value == "frontpage");
+            AddAssert("1 tab total", () => header.TabCount == 1);
+        }
+
+        private class TestHeader : NewsHeader
+        {
+            public int TabCount => TabControl.Items.Count;
+        }
+    }
+}

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

@@ -2,65 +2,64 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Graphics;
+using NUnit.Framework;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
-using osu.Game.Overlays.News;
 
 namespace osu.Game.Tests.Visual.Online
 {
     public class TestSceneNewsOverlay : OsuTestScene
     {
-        private TestNewsOverlay news;
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
 
-        protected override void LoadComplete()
+        private NewsOverlay news;
+
+        [SetUp]
+        public void SetUp() => Schedule(() => Child = news = new NewsOverlay());
+
+        [Test]
+        public void TestRequest()
         {
-            base.LoadComplete();
-            Add(news = new TestNewsOverlay());
-            AddStep(@"Show", news.Show);
-            AddStep(@"Hide", news.Hide);
-
-            AddStep(@"Show front page", () => news.ShowFrontPage());
-            AddStep(@"Custom article", () => news.Current.Value = "Test Article 101");
-
-            AddStep(@"Article covers", () => news.LoadAndShowContent(new NewsCoverTest()));
+            setUpNewsResponse(responseExample);
+            AddStep("Show", () => news.Show());
+            AddStep("Show article", () => news.ShowArticle("article"));
         }
 
-        private class TestNewsOverlay : NewsOverlay
-        {
-            public new void LoadAndShowContent(NewsContent content) => base.LoadAndShowContent(content);
-        }
-
-        private class NewsCoverTest : NewsContent
-        {
-            public NewsCoverTest()
+        private void setUpNewsResponse(GetNewsResponse r)
+            => AddStep("set up response", () =>
             {
-                Spacing = new osuTK.Vector2(0, 10);
-
-                var article = new NewsArticleCover.ArticleInfo
+                dummyAPI.HandleRequest = request =>
                 {
-                    Author = "Ephemeral",
-                    CoverUrl = "https://assets.ppy.sh/artists/58/header.jpg",
-                    Time = new DateTime(2019, 12, 4),
-                    Title = "New Featured Artist: Kurokotei"
-                };
+                    if (!(request is GetNewsRequest getNewsRequest))
+                        return;
 
-                Children = new Drawable[]
-                {
-                    new NewsArticleCover(article)
-                    {
-                        Height = 200
-                    },
-                    new NewsArticleCover(article)
-                    {
-                        Height = 120
-                    },
-                    new NewsArticleCover(article)
-                    {
-                        RelativeSizeAxes = Axes.None,
-                        Size = new osuTK.Vector2(400, 200),
-                    }
+                    getNewsRequest.TriggerSuccess(r);
                 };
+            });
+
+        private GetNewsResponse responseExample => new GetNewsResponse
+        {
+            NewsPosts = new[]
+            {
+                new APINewsPost
+                {
+                    Title = "This post has an image which starts with \"/\" and has many authors!",
+                    Preview = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+                    Author = "someone, someone1, someone2, someone3, someone4",
+                    FirstImage = "/help/wiki/shared/news/banners/monthly-beatmapping-contest.png",
+                    PublishedAt = DateTimeOffset.Now
+                },
+                new APINewsPost
+                {
+                    Title = "This post has a full-url image! (HTML entity: &)",
+                    Preview = "boom (HTML entity: &)",
+                    Author = "user (HTML entity: &)",
+                    FirstImage = "https://assets.ppy.sh/artists/88/header.jpg",
+                    PublishedAt = DateTimeOffset.Now
+                }
             }
-        }
+        };
     }
 }

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

@@ -4,19 +4,22 @@
 using osu.Framework.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Framework.Allocation;
-using osu.Game.Graphics;
+using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual.Online
 {
     public class TestSceneShowMoreButton : OsuTestScene
     {
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Green);
+
         public TestSceneShowMoreButton()
         {
-            TestButton button = null;
+            ShowMoreButton button = null;
 
             int fireCount = 0;
 
-            Add(button = new TestButton
+            Add(button = new ShowMoreButton
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -46,16 +49,5 @@ namespace osu.Game.Tests.Visual.Online
             AddAssert("action fired twice", () => fireCount == 2);
             AddAssert("is in loading state", () => button.IsLoading);
         }
-
-        private class TestButton : ShowMoreButton
-        {
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colors)
-            {
-                IdleColour = colors.YellowDark;
-                HoverColour = colors.Yellow;
-                ChevronIconColour = colors.Red;
-            }
-        }
     }
 }

osu.Game.Tests/Visual/Settings/TestSceneKeyBindingPanel.cs

@@ -64,5 +64,77 @@ namespace osu.Game.Tests.Visual.Settings
                 }, 0, true);
             });
         }
+
+        [Test]
+        public void TestClearButtonOnBindings()
+        {
+            KeyBindingRow backBindingRow = null;
+
+            AddStep("click back binding row", () =>
+            {
+                backBindingRow = panel.ChildrenOfType<KeyBindingRow>().ElementAt(10);
+                InputManager.MoveMouseTo(backBindingRow);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            clickClearButton();
+
+            AddAssert("first binding cleared", () => string.IsNullOrEmpty(backBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().First().Text.Text));
+
+            AddStep("click second binding", () =>
+            {
+                var target = backBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().ElementAt(1);
+
+                InputManager.MoveMouseTo(target);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            clickClearButton();
+
+            AddAssert("second binding cleared", () => string.IsNullOrEmpty(backBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().ElementAt(1).Text.Text));
+
+            void clickClearButton()
+            {
+                AddStep("click clear button", () =>
+                {
+                    var clearButton = backBindingRow.ChildrenOfType<KeyBindingRow.ClearButton>().Single();
+
+                    InputManager.MoveMouseTo(clearButton);
+                    InputManager.Click(MouseButton.Left);
+                });
+            }
+        }
+
+        [Test]
+        public void TestClickRowSelectsFirstBinding()
+        {
+            KeyBindingRow backBindingRow = null;
+
+            AddStep("click back binding row", () =>
+            {
+                backBindingRow = panel.ChildrenOfType<KeyBindingRow>().ElementAt(10);
+                InputManager.MoveMouseTo(backBindingRow);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("first binding selected", () => backBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().First().IsBinding);
+
+            AddStep("click second binding", () =>
+            {
+                var target = backBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().ElementAt(1);
+
+                InputManager.MoveMouseTo(target);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("click back binding row", () =>
+            {
+                backBindingRow = panel.ChildrenOfType<KeyBindingRow>().ElementAt(10);
+                InputManager.MoveMouseTo(backBindingRow);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("first binding selected", () => backBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().First().IsBinding);
+        }
     }
 }

osu.Game.Tests/Visual/TestSceneOsuGame.cs

@@ -44,6 +44,7 @@ namespace osu.Game.Tests.Visual
             typeof(NotificationOverlay),
             typeof(BeatmapListingOverlay),
             typeof(DashboardOverlay),
+            typeof(NewsOverlay),
             typeof(ChannelManager),
             typeof(ChatOverlay),
             typeof(SettingsOverlay),

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

@@ -0,0 +1,150 @@
+// 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.Containers;
+using osu.Framework.Graphics;
+using osu.Game.Overlays.Dashboard.Home;
+using osu.Game.Beatmaps;
+using osu.Game.Overlays;
+using osu.Framework.Allocation;
+using osu.Game.Users;
+using System;
+using osu.Framework.Graphics.Shapes;
+using System.Collections.Generic;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneDashboardBeatmapListing : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        private readonly Container content;
+
+        public TestSceneDashboardBeatmapListing()
+        {
+            Add(content = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Y,
+                Width = 300,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colourProvider.Background4
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Padding = new MarginPadding { Horizontal = 10 },
+                        Child = new DashboardBeatmapListing(new_beatmaps, popular_beatmaps)
+                    }
+                }
+            });
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddStep("Set width to 500", () => content.ResizeWidthTo(500, 500));
+            AddStep("Set width to 300", () => content.ResizeWidthTo(300, 500));
+        }
+
+        private static readonly List<BeatmapSetInfo> new_beatmaps = new List<BeatmapSetInfo>
+        {
+            new BeatmapSetInfo
+            {
+                Metadata = new BeatmapMetadata
+                {
+                    Title = "Very Long Title (TV size) [TATOE]",
+                    Artist = "This artist has a really long name how is this possible",
+                    Author = new User
+                    {
+                        Username = "author",
+                        Id = 100
+                    }
+                },
+                OnlineInfo = new BeatmapSetOnlineInfo
+                {
+                    Covers = new BeatmapSetOnlineCovers
+                    {
+                        Cover = "https://assets.ppy.sh/beatmaps/1189904/covers/cover.jpg?1595456608",
+                    },
+                    Ranked = DateTimeOffset.Now
+                }
+            },
+            new BeatmapSetInfo
+            {
+                Metadata = new BeatmapMetadata
+                {
+                    Title = "Very Long Title (TV size) [TATOE]",
+                    Artist = "This artist has a really long name how is this possible",
+                    Author = new User
+                    {
+                        Username = "author",
+                        Id = 100
+                    }
+                },
+                OnlineInfo = new BeatmapSetOnlineInfo
+                {
+                    Covers = new BeatmapSetOnlineCovers
+                    {
+                        Cover = "https://assets.ppy.sh/beatmaps/1189904/covers/cover.jpg?1595456608",
+                    },
+                    Ranked = DateTimeOffset.MinValue
+                }
+            }
+        };
+
+        private static readonly List<BeatmapSetInfo> popular_beatmaps = new List<BeatmapSetInfo>
+        {
+            new BeatmapSetInfo
+            {
+                Metadata = new BeatmapMetadata
+                {
+                    Title = "Title",
+                    Artist = "Artist",
+                    Author = new User
+                    {
+                        Username = "author",
+                        Id = 100
+                    }
+                },
+                OnlineInfo = new BeatmapSetOnlineInfo
+                {
+                    Covers = new BeatmapSetOnlineCovers
+                    {
+                        Cover = "https://assets.ppy.sh/beatmaps/1079428/covers/cover.jpg?1595295586",
+                    },
+                    FavouriteCount = 100
+                }
+            },
+            new BeatmapSetInfo
+            {
+                Metadata = new BeatmapMetadata
+                {
+                    Title = "Title 2",
+                    Artist = "Artist 2",
+                    Author = new User
+                    {
+                        Username = "someone",
+                        Id = 100
+                    }
+                },
+                OnlineInfo = new BeatmapSetOnlineInfo
+                {
+                    Covers = new BeatmapSetOnlineCovers
+                    {
+                        Cover = "https://assets.ppy.sh/beatmaps/1079428/covers/cover.jpg?1595295586",
+                    },
+                    FavouriteCount = 10
+                }
+            }
+        };
+    }
+}

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

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -263,7 +264,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private void moveLogoFacade()
         {
-            if (logoFacade?.Transforms.Count == 0 && transferContainer?.Transforms.Count == 0)
+            if (!(logoFacade?.Transforms).Any() && !(transferContainer?.Transforms).Any())
             {
                 Random random = new Random();
                 trackingContainer.Delay(500).MoveTo(new Vector2(random.Next(0, (int)logo.Parent.DrawWidth), random.Next(0, (int)logo.Parent.DrawHeight)), 300);

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

@@ -3,7 +3,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -5,7 +5,7 @@
   </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
   </ItemGroup>

osu.Game.Tournament/Screens/Ladder/Components/LadderEditorSettings.cs

@@ -81,7 +81,7 @@ namespace osu.Game.Tournament.Screens.Ladder.Components
         {
         }
 
-        private class SettingsRoundDropdown : LadderSettingsDropdown<TournamentRound>
+        private class SettingsRoundDropdown : SettingsDropdown<TournamentRound>
         {
             public SettingsRoundDropdown(BindableList<TournamentRound> rounds)
             {

osu.Game.Tournament/Screens/Ladder/Components/LadderSettingsDropdown.cs

@@ -1,26 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Overlays.Settings;
-
-namespace osu.Game.Tournament.Screens.Ladder.Components
-{
-    public class LadderSettingsDropdown<T> : SettingsDropdown<T>
-    {
-        protected override OsuDropdown<T> CreateDropdown() => new DropdownControl();
-
-        private new class DropdownControl : SettingsDropdown<T>.DropdownControl
-        {
-            protected override DropdownMenu CreateMenu() => new Menu();
-
-            private new class Menu : OsuDropdownMenu
-            {
-                public Menu()
-                {
-                    MaxHeight = 200;
-                }
-            }
-        }
-    }
-}

osu.Game.Tournament/Screens/Ladder/Components/SettingsTeamDropdown.cs

@@ -6,11 +6,12 @@ using System.Collections.Specialized;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Overlays.Settings;
 using osu.Game.Tournament.Models;
 
 namespace osu.Game.Tournament.Screens.Ladder.Components
 {
-    public class SettingsTeamDropdown : LadderSettingsDropdown<TournamentTeam>
+    public class SettingsTeamDropdown : SettingsDropdown<TournamentTeam>
     {
         public SettingsTeamDropdown(BindableList<TournamentTeam> teams)
         {

osu.Game/Beatmaps/BeatmapDifficultyManager.cs

@@ -109,25 +109,58 @@ namespace osu.Game.Beatmaps
         }
 
         private CancellationTokenSource trackedUpdateCancellationSource;
+        private readonly List<CancellationTokenSource> linkedCancellationSources = new List<CancellationTokenSource>();
 
         /// <summary>
         /// Updates all tracked <see cref="BindableStarDifficulty"/> using the current ruleset and mods.
         /// </summary>
         private void updateTrackedBindables()
         {
-            trackedUpdateCancellationSource?.Cancel();
+            cancelTrackedBindableUpdate();
             trackedUpdateCancellationSource = new CancellationTokenSource();
 
             foreach (var b in trackedBindables)
             {
-                if (trackedUpdateCancellationSource.IsCancellationRequested)
-                    break;
+                var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(trackedUpdateCancellationSource.Token, b.CancellationToken);
+                linkedCancellationSources.Add(linkedSource);
 
-                using (var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(trackedUpdateCancellationSource.Token, b.CancellationToken))
-                    updateBindable(b, currentRuleset.Value, currentMods.Value, linkedSource.Token);
+                updateBindable(b, currentRuleset.Value, currentMods.Value, linkedSource.Token);
             }
         }
 
+        /// <summary>
+        /// Cancels the existing update of all tracked <see cref="BindableStarDifficulty"/> via <see cref="updateTrackedBindables"/>.
+        /// </summary>
+        private void cancelTrackedBindableUpdate()
+        {
+            trackedUpdateCancellationSource?.Cancel();
+            trackedUpdateCancellationSource = null;
+
+            if (linkedCancellationSources != null)
+            {
+                foreach (var c in linkedCancellationSources)
+                    c.Dispose();
+
+                linkedCancellationSources.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="BindableStarDifficulty"/> and triggers an initial value update.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> that star difficulty should correspond to.</param>
+        /// <param name="initialRulesetInfo">The initial <see cref="RulesetInfo"/> to get the difficulty with.</param>
+        /// <param name="initialMods">The initial <see cref="Mod"/>s to get the difficulty with.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops updating the star difficulty for the given <see cref="BeatmapInfo"/>.</param>
+        /// <returns>The <see cref="BindableStarDifficulty"/>.</returns>
+        private BindableStarDifficulty createBindable([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo initialRulesetInfo, [CanBeNull] IEnumerable<Mod> initialMods,
+                                                      CancellationToken cancellationToken)
+        {
+            var bindable = new BindableStarDifficulty(beatmapInfo, cancellationToken);
+            updateBindable(bindable, initialRulesetInfo, initialMods, cancellationToken);
+            return bindable;
+        }
+
         /// <summary>
         /// Updates the value of a <see cref="BindableStarDifficulty"/> with a given ruleset + mods.
         /// </summary>
@@ -148,22 +181,6 @@ namespace osu.Game.Beatmaps
             }, cancellationToken);
         }
 
-        /// <summary>
-        /// Creates a new <see cref="BindableStarDifficulty"/> and triggers an initial value update.
-        /// </summary>
-        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> that star difficulty should correspond to.</param>
-        /// <param name="initialRulesetInfo">The initial <see cref="RulesetInfo"/> to get the difficulty with.</param>
-        /// <param name="initialMods">The initial <see cref="Mod"/>s to get the difficulty with.</param>
-        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops updating the star difficulty for the given <see cref="BeatmapInfo"/>.</param>
-        /// <returns>The <see cref="BindableStarDifficulty"/>.</returns>
-        private BindableStarDifficulty createBindable([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo initialRulesetInfo, [CanBeNull] IEnumerable<Mod> initialMods,
-                                                      CancellationToken cancellationToken)
-        {
-            var bindable = new BindableStarDifficulty(beatmapInfo, cancellationToken);
-            updateBindable(bindable, initialRulesetInfo, initialMods, cancellationToken);
-            return bindable;
-        }
-
         /// <summary>
         /// Computes the difficulty defined by a <see cref="DifficultyCacheLookup"/> key, and stores it to the timed cache.
         /// </summary>
@@ -220,6 +237,14 @@ namespace osu.Game.Beatmaps
             return difficultyCache.TryGetValue(key, out existingDifficulty);
         }
 
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            cancelTrackedBindableUpdate();
+            updateScheduler?.Dispose();
+        }
+
         private readonly struct DifficultyCacheLookup : IEquatable<DifficultyCacheLookup>
         {
             public readonly int BeatmapId;

osu.Game/Graphics/UserInterface/ShowMoreButton.cs

@@ -1,13 +1,15 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+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.Sprites;
+using osu.Game.Overlays;
 using osuTK;
-using osuTK.Graphics;
 using System.Collections.Generic;
 
 namespace osu.Game.Graphics.UserInterface
@@ -16,14 +18,6 @@ namespace osu.Game.Graphics.UserInterface
     {
         private const int duration = 200;
 
-        private Color4 chevronIconColour;
-
-        protected Color4 ChevronIconColour
-        {
-            get => chevronIconColour;
-            set => chevronIconColour = leftChevron.Colour = rightChevron.Colour = value;
-        }
-
         public string Text
         {
             get => text.Text;
@@ -32,22 +26,28 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override IEnumerable<Drawable> EffectTargets => new[] { background };
 
-        private ChevronIcon leftChevron;
-        private ChevronIcon rightChevron;
+        private ChevronIcon leftIcon;
+        private ChevronIcon rightIcon;
         private SpriteText text;
         private Box background;
         private FillFlowContainer textContainer;
 
         public ShowMoreButton()
         {
-            Height = 30;
-            Width = 140;
+            AutoSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
+            IdleColour = colourProvider.Background2;
+            HoverColour = colourProvider.Background1;
         }
 
         protected override Drawable CreateContent() => new CircularContainer
         {
             Masking = true,
-            RelativeSizeAxes = Axes.Both,
+            AutoSizeAxes = Axes.Both,
             Children = new Drawable[]
             {
                 background = new Box
@@ -56,22 +56,36 @@ namespace osu.Game.Graphics.UserInterface
                 },
                 textContainer = new FillFlowContainer
                 {
+                    AlwaysPresent = true,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     AutoSizeAxes = Axes.Both,
                     Direction = FillDirection.Horizontal,
-                    Spacing = new Vector2(7),
+                    Spacing = new Vector2(10),
+                    Margin = new MarginPadding
+                    {
+                        Horizontal = 20,
+                        Vertical = 5
+                    },
                     Children = new Drawable[]
                     {
-                        leftChevron = new ChevronIcon(),
+                        leftIcon = new ChevronIcon
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
                         text = new OsuSpriteText
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
-                            Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold),
+                            Font = OsuFont.GetFont(size: 12, weight: FontWeight.SemiBold),
                             Text = "show more".ToUpper(),
                         },
-                        rightChevron = new ChevronIcon(),
+                        rightIcon = new ChevronIcon
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        }
                     }
                 }
             }
@@ -81,17 +95,40 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override void OnLoadFinished() => textContainer.FadeIn(duration, Easing.OutQuint);
 
-        private class ChevronIcon : SpriteIcon
+        protected override bool OnHover(HoverEvent e)
         {
-            private const int icon_size = 8;
+            base.OnHover(e);
+            leftIcon.SetHoveredState(true);
+            rightIcon.SetHoveredState(true);
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            leftIcon.SetHoveredState(false);
+            rightIcon.SetHoveredState(false);
+        }
+
+        public class ChevronIcon : SpriteIcon
+        {
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; }
 
             public ChevronIcon()
             {
-                Anchor = Anchor.Centre;
-                Origin = Anchor.Centre;
-                Size = new Vector2(icon_size);
+                Size = new Vector2(7.5f);
                 Icon = FontAwesome.Solid.ChevronDown;
             }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Colour = colourProvider.Foreground1;
+            }
+
+            public void SetHoveredState(bool hovered) =>
+                this.FadeColour(hovered ? colourProvider.Light1 : colourProvider.Foreground1, 200, Easing.OutQuint);
         }
     }
 }

osu.Game/Online/API/APIRequest.cs

@@ -136,6 +136,11 @@ namespace osu.Game.Online.API
             Success?.Invoke();
         }
 
+        internal void TriggerFailure(Exception e)
+        {
+            Failure?.Invoke(e);
+        }
+
         public void Cancel() => Fail(new OperationCanceledException(@"Request cancelled"));
 
         public void Fail(Exception e)
@@ -166,7 +171,7 @@ namespace osu.Game.Online.API
             }
 
             Logger.Log($@"Failing request {this} ({e})", LoggingTarget.Network);
-            pendingFailure = () => Failure?.Invoke(e);
+            pendingFailure = () => TriggerFailure(e);
             checkAndScheduleFailure();
         }
 

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

@@ -15,6 +15,6 @@ namespace osu.Game.Online.API.Requests
     {
         [UsedImplicitly]
         [JsonExtensionData]
-        public IDictionary<string, JToken> Properties;
+        public IDictionary<string, JToken> Properties { get; set; } = new Dictionary<string, JToken>();
     }
 }

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

@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.IO.Network;
+using osu.Game.Extensions;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetNewsRequest : APIRequest<GetNewsResponse>
+    {
+        private readonly Cursor cursor;
+
+        public GetNewsRequest(Cursor cursor = null)
+        {
+            this.cursor = cursor;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+            req.AddCursor(cursor);
+            return req;
+        }
+
+        protected override string Target => "news";
+    }
+}

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

@@ -0,0 +1,15 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetNewsResponse : ResponseWithCursor
+    {
+        [JsonProperty("news_posts")]
+        public IEnumerable<APINewsPost> NewsPosts;
+    }
+}

osu.Game/Online/Multiplayer/CreateRoomScoreRequest.cs

@@ -11,17 +11,20 @@ namespace osu.Game.Online.Multiplayer
     {
         private readonly int roomId;
         private readonly int playlistItemId;
+        private readonly string versionHash;
 
-        public CreateRoomScoreRequest(int roomId, int playlistItemId)
+        public CreateRoomScoreRequest(int roomId, int playlistItemId, string versionHash)
         {
             this.roomId = roomId;
             this.playlistItemId = playlistItemId;
+            this.versionHash = versionHash;
         }
 
         protected override WebRequest CreateWebRequest()
         {
             var req = base.CreateWebRequest();
             req.Method = HttpMethod.Post;
+            req.AddParameter("version_hash", versionHash);
             return req;
         }
 

osu.Game/Online/Multiplayer/GetRoomPlaylistScoresRequest.cs

@@ -1,29 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using Newtonsoft.Json;
-using osu.Game.Online.API;
-
-namespace osu.Game.Online.Multiplayer
-{
-    public class GetRoomPlaylistScoresRequest : APIRequest<RoomPlaylistScores>
-    {
-        private readonly int roomId;
-        private readonly int playlistItemId;
-
-        public GetRoomPlaylistScoresRequest(int roomId, int playlistItemId)
-        {
-            this.roomId = roomId;
-            this.playlistItemId = playlistItemId;
-        }
-
-        protected override string Target => $@"rooms/{roomId}/playlist/{playlistItemId}/scores";
-    }
-
-    public class RoomPlaylistScores
-    {
-        [JsonProperty("scores")]
-        public List<MultiplayerScore> Scores { get; set; }
-    }
-}

osu.Game/Online/Multiplayer/IndexPlaylistScoresRequest.cs

@@ -0,0 +1,59 @@
+// 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.Diagnostics;
+using JetBrains.Annotations;
+using osu.Framework.IO.Network;
+using osu.Game.Extensions;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+
+namespace osu.Game.Online.Multiplayer
+{
+    /// <summary>
+    /// Returns a list of scores for the specified playlist item.
+    /// </summary>
+    public class IndexPlaylistScoresRequest : APIRequest<IndexedMultiplayerScores>
+    {
+        public readonly int RoomId;
+        public readonly int PlaylistItemId;
+
+        [CanBeNull]
+        public readonly Cursor Cursor;
+
+        [CanBeNull]
+        public readonly IndexScoresParams IndexParams;
+
+        public IndexPlaylistScoresRequest(int roomId, int playlistItemId)
+        {
+            RoomId = roomId;
+            PlaylistItemId = playlistItemId;
+        }
+
+        public IndexPlaylistScoresRequest(int roomId, int playlistItemId, [NotNull] Cursor cursor, [NotNull] IndexScoresParams indexParams)
+            : this(roomId, playlistItemId)
+        {
+            Cursor = cursor;
+            IndexParams = indexParams;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+
+            if (Cursor != null)
+            {
+                Debug.Assert(IndexParams != null);
+
+                req.AddCursor(Cursor);
+
+                foreach (var (key, value) in IndexParams.Properties)
+                    req.AddParameter(key, value.ToString());
+            }
+
+            return req;
+        }
+
+        protected override string Target => $@"rooms/{RoomId}/playlist/{PlaylistItemId}/scores";
+    }
+}

osu.Game/Online/Multiplayer/IndexScoresParams.cs

@@ -0,0 +1,20 @@
+// 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 JetBrains.Annotations;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace osu.Game.Online.Multiplayer
+{
+    /// <summary>
+    /// A collection of parameters which should be passed to the index endpoint to fetch the next page.
+    /// </summary>
+    public class IndexScoresParams
+    {
+        [UsedImplicitly]
+        [JsonExtensionData]
+        public IDictionary<string, JToken> Properties { get; set; } = new Dictionary<string, JToken>();
+    }
+}

osu.Game/Online/Multiplayer/IndexedMultiplayerScores.cs

@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+
+namespace osu.Game.Online.Multiplayer
+{
+    /// <summary>
+    /// A <see cref="MultiplayerScores"/> object returned via a <see cref="IndexPlaylistScoresRequest"/>.
+    /// </summary>
+    public class IndexedMultiplayerScores : MultiplayerScores
+    {
+        /// <summary>
+        /// The total scores in the playlist item.
+        /// </summary>
+        [JsonProperty("total")]
+        public int? TotalScores { get; set; }
+
+        /// <summary>
+        /// The user's score, if any.
+        /// </summary>
+        [JsonProperty("user_score")]
+        [CanBeNull]
+        public MultiplayerScore UserScore { get; set; }
+    }
+}

osu.Game/Online/Multiplayer/MultiplayerScore.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using osu.Game.Online.API;
@@ -47,6 +48,19 @@ namespace osu.Game.Online.Multiplayer
         [JsonProperty("ended_at")]
         public DateTimeOffset EndedAt { get; set; }
 
+        /// <summary>
+        /// The position of this score, starting at 1.
+        /// </summary>
+        [JsonProperty("position")]
+        public int? Position { get; set; }
+
+        /// <summary>
+        /// Any scores in the room around this score.
+        /// </summary>
+        [JsonProperty("scores_around")]
+        [CanBeNull]
+        public MultiplayerScoresAround ScoresAround { get; set; }
+
         public ScoreInfo CreateScoreInfo(PlaylistItem playlistItem)
         {
             var rulesetInstance = playlistItem.Ruleset.Value.CreateInstance();
@@ -66,7 +80,8 @@ namespace osu.Game.Online.Multiplayer
                 Date = EndedAt,
                 Hash = string.Empty, // todo: temporary?
                 Rank = Rank,
-                Mods = Mods?.Select(m => m.ToMod(rulesetInstance)).ToArray() ?? Array.Empty<Mod>()
+                Mods = Mods?.Select(m => m.ToMod(rulesetInstance)).ToArray() ?? Array.Empty<Mod>(),
+                Position = Position,
             };
 
             return scoreInfo;

osu.Game/Online/Multiplayer/MultiplayerScores.cs

@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using osu.Game.Online.API.Requests;
+
+namespace osu.Game.Online.Multiplayer
+{
+    /// <summary>
+    /// An object which contains scores and related data for fetching next pages.
+    /// </summary>
+    public class MultiplayerScores : ResponseWithCursor
+    {
+        /// <summary>
+        /// The scores.
+        /// </summary>
+        [JsonProperty("scores")]
+        public List<MultiplayerScore> Scores { get; set; } = new List<MultiplayerScore>();
+
+        /// <summary>
+        /// The parameters to be used to fetch the next page.
+        /// </summary>
+        [JsonProperty("params")]
+        public IndexScoresParams Params { get; set; } = new IndexScoresParams();
+    }
+}

osu.Game/Online/Multiplayer/MultiplayerScoresAround.cs

@@ -0,0 +1,28 @@
+// 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 JetBrains.Annotations;
+using Newtonsoft.Json;
+
+namespace osu.Game.Online.Multiplayer
+{
+    /// <summary>
+    /// An object which stores scores higher and lower than the user's score.
+    /// </summary>
+    public class MultiplayerScoresAround
+    {
+        /// <summary>
+        /// Scores sorted "higher" than the user's score, depending on the sorting order.
+        /// </summary>
+        [JsonProperty("higher")]
+        [CanBeNull]
+        public MultiplayerScores Higher { get; set; }
+
+        /// <summary>
+        /// Scores sorted "lower" than the user's score, depending on the sorting order.
+        /// </summary>
+        [JsonProperty("lower")]
+        [CanBeNull]
+        public MultiplayerScores Lower { get; set; }
+    }
+}

osu.Game/Online/Multiplayer/ShowPlaylistUserScoreRequest.cs

@@ -0,0 +1,23 @@
+// 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.Online.API;
+
+namespace osu.Game.Online.Multiplayer
+{
+    public class ShowPlaylistUserScoreRequest : APIRequest<MultiplayerScore>
+    {
+        private readonly int roomId;
+        private readonly int playlistItemId;
+        private readonly long userId;
+
+        public ShowPlaylistUserScoreRequest(int roomId, int playlistItemId, long userId)
+        {
+            this.roomId = roomId;
+            this.playlistItemId = playlistItemId;
+            this.userId = userId;
+        }
+
+        protected override string Target => $"rooms/{roomId}/playlist/{playlistItemId}/scores/users/{userId}";
+    }
+}

osu.Game/OsuGame.cs

@@ -67,12 +67,12 @@ namespace osu.Game
         [NotNull]
         private readonly NotificationOverlay notifications = new NotificationOverlay();
 
-        private NowPlayingOverlay nowPlaying;
-
         private BeatmapListingOverlay beatmapListing;
 
         private DashboardOverlay dashboard;
 
+        private NewsOverlay news;
+
         private UserProfileOverlay userProfile;
 
         private BeatmapSetOverlay beatmapSetOverlay;
@@ -632,6 +632,7 @@ namespace osu.Game
             // overlay elements
             loadComponentSingleFile(beatmapListing = new BeatmapListingOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(dashboard = new DashboardOverlay(), overlayContent.Add, true);
+            loadComponentSingleFile(news = new NewsOverlay(), overlayContent.Add, true);
             var rankingsOverlay = loadComponentSingleFile(new RankingsOverlay(), overlayContent.Add, true);
             loadComponentSingleFile(channelManager = new ChannelManager(), AddInternal, true);
             loadComponentSingleFile(chatOverlay = new ChatOverlay(), overlayContent.Add, true);
@@ -647,7 +648,7 @@ namespace osu.Game
                 Origin = Anchor.TopRight,
             }, rightFloatingOverlayContent.Add, true);
 
-            loadComponentSingleFile(nowPlaying = new NowPlayingOverlay
+            loadComponentSingleFile(new NowPlayingOverlay
             {
                 GetToolbarHeight = () => ToolbarOffset,
                 Anchor = Anchor.TopRight,
@@ -682,14 +683,13 @@ namespace osu.Game
             {
                 overlay.State.ValueChanged += state =>
                 {
-                    if (state.NewValue == Visibility.Hidden) return;
-
-                    informationalOverlays.Where(o => o != overlay).ForEach(o => o.Hide());
+                    if (state.NewValue != Visibility.Hidden)
+                        showOverlayAboveOthers(overlay, informationalOverlays);
                 };
             }
 
             // ensure only one of these overlays are open at once.
-            var singleDisplayOverlays = new OverlayContainer[] { chatOverlay, dashboard, beatmapListing, changelogOverlay, rankingsOverlay };
+            var singleDisplayOverlays = new OverlayContainer[] { chatOverlay, news, dashboard, beatmapListing, changelogOverlay, rankingsOverlay };
 
             foreach (var overlay in singleDisplayOverlays)
             {
@@ -698,9 +698,8 @@ namespace osu.Game
                     // informational overlays should be dismissed on a show or hide of a full overlay.
                     informationalOverlays.ForEach(o => o.Hide());
 
-                    if (state.NewValue == Visibility.Hidden) return;
-
-                    singleDisplayOverlays.Where(o => o != overlay).ForEach(o => o.Hide());
+                    if (state.NewValue != Visibility.Hidden)
+                        showOverlayAboveOthers(overlay, singleDisplayOverlays);
                 };
             }
 
@@ -725,6 +724,15 @@ namespace osu.Game
             notifications.State.ValueChanged += _ => updateScreenOffset();
         }
 
+        private void showOverlayAboveOthers(OverlayContainer overlay, OverlayContainer[] otherOverlays)
+        {
+            otherOverlays.Where(o => o != overlay).ForEach(o => o.Hide());
+
+            // show above others if not visible at all, else leave at current depth.
+            if (!overlay.IsPresent)
+                overlayContent.ChangeChildDepth(overlay, (float)-Clock.CurrentTime);
+        }
+
         public class GameIdleTracker : IdleTracker
         {
             private InputManager inputManager;
@@ -859,18 +867,6 @@ namespace osu.Game
 
             switch (action)
             {
-                case GlobalAction.ToggleNowPlaying:
-                    nowPlaying.ToggleVisibility();
-                    return true;
-
-                case GlobalAction.ToggleChat:
-                    chatOverlay.ToggleVisibility();
-                    return true;
-
-                case GlobalAction.ToggleSocial:
-                    dashboard.ToggleVisibility();
-                    return true;
-
                 case GlobalAction.ResetInputSettings:
                     var sensitivity = frameworkConfig.GetBindable<double>(FrameworkSetting.CursorSensitivity);
 
@@ -886,18 +882,6 @@ namespace osu.Game
                     Toolbar.ToggleVisibility();
                     return true;
 
-                case GlobalAction.ToggleSettings:
-                    Settings.ToggleVisibility();
-                    return true;
-
-                case GlobalAction.ToggleDirect:
-                    beatmapListing.ToggleVisibility();
-                    return true;
-
-                case GlobalAction.ToggleNotifications:
-                    notifications.ToggleVisibility();
-                    return true;
-
                 case GlobalAction.ToggleGameplayMouseButtons:
                     LocalConfig.Set(OsuSetting.MouseDisableButtons, !LocalConfig.Get<bool>(OsuSetting.MouseDisableButtons));
                     return true;

osu.Game/OsuGameBase.cs

@@ -11,6 +11,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Development;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.IO.Stores;
@@ -35,6 +36,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 using osu.Game.Skinning;
 using osuTK.Input;
+using RuntimeInfo = osu.Framework.RuntimeInfo;
 
 namespace osu.Game
 {
@@ -97,6 +99,11 @@ namespace osu.Game
 
         public virtual Version AssemblyVersion => Assembly.GetEntryAssembly()?.GetName().Version ?? new Version();
 
+        /// <summary>
+        /// MD5 representation of the game executable.
+        /// </summary>
+        public string VersionHash { get; private set; }
+
         public bool IsDeployedBuild => AssemblyVersion.Major > 0;
 
         public virtual string Version
@@ -128,6 +135,18 @@ namespace osu.Game
         [BackgroundDependencyLoader]
         private void load()
         {
+            try
+            {
+                using (var str = File.OpenRead(typeof(OsuGameBase).Assembly.Location))
+                    VersionHash = str.ComputeMD5Hash();
+            }
+            catch
+            {
+                // special case for android builds, which can't read DLLs from a packed apk.
+                // should eventually be handled in a better way.
+                VersionHash = $"{Version}-{RuntimeInfo.OS}".ComputeMD5Hash();
+            }
+
             Resources.AddStore(new DllResourceStore(OsuResources.ResourceAssembly));
 
             dependencies.Cache(contextFactory = new DatabaseContextFactory(Storage));

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

@@ -5,12 +5,12 @@ 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;
+using static osu.Game.Graphics.UserInterface.ShowMoreButton;
 
 namespace osu.Game.Overlays.Comments.Buttons
 {
@@ -25,7 +25,7 @@ namespace osu.Game.Overlays.Comments.Buttons
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; }
 
-        private readonly SpriteIcon icon;
+        private readonly ChevronIcon icon;
         private readonly Box background;
         private readonly OsuSpriteText text;
 
@@ -68,12 +68,10 @@ namespace osu.Game.Overlays.Comments.Buttons
                                         AlwaysPresent = true,
                                         Font = OsuFont.GetFont(size: 12, weight: FontWeight.SemiBold)
                                     },
-                                    icon = new SpriteIcon
+                                    icon = new ChevronIcon
                                     {
                                         Anchor = Anchor.CentreLeft,
-                                        Origin = Anchor.CentreLeft,
-                                        Size = new Vector2(7.5f),
-                                        Icon = FontAwesome.Solid.ChevronDown
+                                        Origin = Anchor.CentreLeft
                                     }
                                 }
                             }
@@ -88,7 +86,6 @@ namespace osu.Game.Overlays.Comments.Buttons
         private void load()
         {
             background.Colour = colourProvider.Background2;
-            icon.Colour = colourProvider.Foreground1;
         }
 
         protected void SetIconDirection(bool upwards) => icon.ScaleTo(new Vector2(1, upwards ? -1 : 1));
@@ -99,7 +96,7 @@ namespace osu.Game.Overlays.Comments.Buttons
         {
             base.OnHover(e);
             background.FadeColour(colourProvider.Background1, 200, Easing.OutQuint);
-            icon.FadeColour(colourProvider.Light1, 200, Easing.OutQuint);
+            icon.SetHoveredState(true);
             return true;
         }
 
@@ -107,7 +104,7 @@ namespace osu.Game.Overlays.Comments.Buttons
         {
             base.OnHoverLost(e);
             background.FadeColour(colourProvider.Background2, 200, Easing.OutQuint);
-            icon.FadeColour(colourProvider.Foreground1, 200, Easing.OutQuint);
+            icon.SetHoveredState(false);
         }
     }
 }

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

@@ -12,13 +12,13 @@ using osu.Framework.Allocation;
 
 namespace osu.Game.Overlays.Comments.Buttons
 {
-    public class ShowMoreButton : LoadingButton
+    public class ShowMoreRepliesButton : LoadingButton
     {
         protected override IEnumerable<Drawable> EffectTargets => new[] { text };
 
         private OsuSpriteText text;
 
-        public ShowMoreButton()
+        public ShowMoreRepliesButton()
         {
             AutoSizeAxes = Axes.Both;
             LoadingAnimationSize = new Vector2(8);

osu.Game/Overlays/Comments/CommentsShowMoreButton.cs

@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Game.Graphics.UserInterface;
 
@@ -11,16 +10,6 @@ namespace osu.Game.Overlays.Comments
     {
         public readonly BindableInt Current = new BindableInt();
 
-        [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colourProvider)
-        {
-            Height = 20;
-
-            IdleColour = colourProvider.Background2;
-            HoverColour = colourProvider.Background1;
-            ChevronIconColour = colourProvider.Foreground1;
-        }
-
         protected override void LoadComplete()
         {
             Current.BindValueChanged(onCurrentChanged, true);

osu.Game/Overlays/Comments/DrawableComment.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Overlays.Comments
         private FillFlowContainer childCommentsVisibilityContainer;
         private FillFlowContainer childCommentsContainer;
         private LoadRepliesButton loadRepliesButton;
-        private ShowMoreButton showMoreButton;
+        private ShowMoreRepliesButton showMoreButton;
         private ShowRepliesButton showRepliesButton;
         private ChevronButton chevronButton;
         private DeletedCommentsCounter deletedCommentsCounter;
@@ -213,7 +213,7 @@ namespace osu.Game.Overlays.Comments
                                             Top = 10
                                         }
                                     },
-                                    showMoreButton = new ShowMoreButton
+                                    showMoreButton = new ShowMoreRepliesButton
                                     {
                                         Action = () => RepliesRequested(this, ++currentPage)
                                     }

osu.Game/Overlays/Dashboard/Home/DashboardBeatmapListing.cs

@@ -0,0 +1,43 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osuTK;
+
+namespace osu.Game.Overlays.Dashboard.Home
+{
+    public class DashboardBeatmapListing : CompositeDrawable
+    {
+        private readonly List<BeatmapSetInfo> newBeatmaps;
+        private readonly List<BeatmapSetInfo> popularBeatmaps;
+
+        public DashboardBeatmapListing(List<BeatmapSetInfo> newBeatmaps, List<BeatmapSetInfo> popularBeatmaps)
+        {
+            this.newBeatmaps = newBeatmaps;
+            this.popularBeatmaps = popularBeatmaps;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+            InternalChild = new FillFlowContainer<DrawableBeatmapList>
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 10),
+                Children = new DrawableBeatmapList[]
+                {
+                    new DrawableNewBeatmapList(newBeatmaps),
+                    new DrawablePopularBeatmapList(popularBeatmaps)
+                }
+            };
+        }
+    }
+}

osu.Game/Overlays/Dashboard/Home/DashboardBeatmapPanel.cs

@@ -0,0 +1,168 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using 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.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Overlays.Dashboard.Home
+{
+    public abstract class DashboardBeatmapPanel : OsuClickableContainer
+    {
+        [Resolved]
+        protected OverlayColourProvider ColourProvider { get; private set; }
+
+        [Resolved(canBeNull: true)]
+        private BeatmapSetOverlay beatmapOverlay { get; set; }
+
+        protected readonly BeatmapSetInfo SetInfo;
+
+        private Box hoverBackground;
+        private SpriteIcon chevron;
+
+        protected DashboardBeatmapPanel(BeatmapSetInfo setInfo)
+        {
+            SetInfo = setInfo;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = 60;
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Horizontal = -10 },
+                    Child = hoverBackground = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = ColourProvider.Background3,
+                        Alpha = 0
+                    }
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = new GridContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        ColumnDimensions = new[]
+                        {
+                            new Dimension(GridSizeMode.Absolute, 70),
+                            new Dimension(),
+                            new Dimension(GridSizeMode.AutoSize)
+                        },
+                        RowDimensions = new[]
+                        {
+                            new Dimension()
+                        },
+                        Content = new[]
+                        {
+                            new Drawable[]
+                            {
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Masking = true,
+                                    CornerRadius = 6,
+                                    Child = new UpdateableBeatmapSetCover
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        BeatmapSet = SetInfo
+                                    }
+                                },
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding { Horizontal = 10 },
+                                    Child = new FillFlowContainer
+                                    {
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.CentreLeft,
+                                        AutoSizeAxes = Axes.Y,
+                                        RelativeSizeAxes = Axes.X,
+                                        Direction = FillDirection.Vertical,
+                                        Children = new Drawable[]
+                                        {
+                                            new OsuSpriteText
+                                            {
+                                                RelativeSizeAxes = Axes.X,
+                                                Truncate = true,
+                                                Font = OsuFont.GetFont(weight: FontWeight.Regular),
+                                                Text = SetInfo.Metadata.Title
+                                            },
+                                            new OsuSpriteText
+                                            {
+                                                RelativeSizeAxes = Axes.X,
+                                                Truncate = true,
+                                                Font = OsuFont.GetFont(size: 12, weight: FontWeight.Regular),
+                                                Text = SetInfo.Metadata.Artist
+                                            },
+                                            new LinkFlowContainer(f => f.Font = OsuFont.GetFont(size: 10, weight: FontWeight.Regular))
+                                            {
+                                                AutoSizeAxes = Axes.Y,
+                                                RelativeSizeAxes = Axes.X,
+                                                Spacing = new Vector2(3),
+                                                Margin = new MarginPadding { Top = 2 }
+                                            }.With(c =>
+                                            {
+                                                c.AddText("by");
+                                                c.AddUserLink(SetInfo.Metadata.Author);
+                                                c.AddArbitraryDrawable(CreateInfo());
+                                            })
+                                        }
+                                    }
+                                },
+                                chevron = new SpriteIcon
+                                {
+                                    Anchor = Anchor.CentreRight,
+                                    Origin = Anchor.CentreRight,
+                                    Size = new Vector2(16),
+                                    Icon = FontAwesome.Solid.ChevronRight,
+                                    Colour = ColourProvider.Foreground1
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            Action = () =>
+            {
+                if (SetInfo.OnlineBeatmapSetID.HasValue)
+                    beatmapOverlay?.FetchAndShowBeatmapSet(SetInfo.OnlineBeatmapSetID.Value);
+            };
+        }
+
+        protected abstract Drawable CreateInfo();
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            base.OnHover(e);
+            hoverBackground.FadeIn(200, Easing.OutQuint);
+            chevron.FadeColour(ColourProvider.Light1, 200, Easing.OutQuint);
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            hoverBackground.FadeOut(200, Easing.OutQuint);
+            chevron.FadeColour(ColourProvider.Foreground1, 200, Easing.OutQuint);
+        }
+    }
+}

osu.Game/Overlays/Dashboard/Home/DashboardNewBeatmapPanel.cs

@@ -0,0 +1,23 @@
+// 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;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+
+namespace osu.Game.Overlays.Dashboard.Home
+{
+    public class DashboardNewBeatmapPanel : DashboardBeatmapPanel
+    {
+        public DashboardNewBeatmapPanel(BeatmapSetInfo setInfo)
+            : base(setInfo)
+        {
+        }
+
+        protected override Drawable CreateInfo() => new DrawableDate(SetInfo.OnlineInfo.Ranked ?? DateTimeOffset.Now, 10, false)
+        {
+            Colour = ColourProvider.Foreground1
+        };
+    }
+}

osu.Game/Overlays/Dashboard/Home/DashboardPopularBeatmapPanel.cs

@@ -0,0 +1,42 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Overlays.Dashboard.Home
+{
+    public class DashboardPopularBeatmapPanel : DashboardBeatmapPanel
+    {
+        public DashboardPopularBeatmapPanel(BeatmapSetInfo setInfo)
+            : base(setInfo)
+        {
+        }
+
+        protected override Drawable CreateInfo() => new FillFlowContainer
+        {
+            AutoSizeAxes = Axes.Both,
+            Direction = FillDirection.Horizontal,
+            Spacing = new Vector2(3, 0),
+            Colour = ColourProvider.Foreground1,
+            Children = new Drawable[]
+            {
+                new SpriteIcon
+                {
+                    Size = new Vector2(10),
+                    Icon = FontAwesome.Solid.Heart
+                },
+                new OsuSpriteText
+                {
+                    Font = OsuFont.GetFont(size: 10, weight: FontWeight.Regular),
+                    Text = SetInfo.OnlineInfo.FavouriteCount.ToString()
+                }
+            }
+        };
+    }
+}

osu.Game/Overlays/Dashboard/Home/DrawableBeatmapList.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 osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Overlays.Dashboard.Home
+{
+    public abstract class DrawableBeatmapList : CompositeDrawable
+    {
+        private readonly List<BeatmapSetInfo> beatmaps;
+
+        protected DrawableBeatmapList(List<BeatmapSetInfo> beatmaps)
+        {
+            this.beatmaps = beatmaps;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
+            FillFlowContainer flow;
+
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+            InternalChild = flow = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 10),
+                Children = new Drawable[]
+                {
+                    new OsuSpriteText
+                    {
+                        Font = OsuFont.GetFont(size: 16, weight: FontWeight.Bold),
+                        Colour = colourProvider.Light1,
+                        Text = Title
+                    }
+                }
+            };
+
+            flow.AddRange(beatmaps.Select(CreateBeatmapPanel));
+        }
+
+        protected abstract string Title { get; }
+
+        protected abstract DashboardBeatmapPanel CreateBeatmapPanel(BeatmapSetInfo setInfo);
+    }
+}

osu.Game/Overlays/Dashboard/Home/DrawableNewBeatmapList.cs

@@ -0,0 +1,20 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Overlays.Dashboard.Home
+{
+    public class DrawableNewBeatmapList : DrawableBeatmapList
+    {
+        public DrawableNewBeatmapList(List<BeatmapSetInfo> beatmaps)
+            : base(beatmaps)
+        {
+        }
+
+        protected override DashboardBeatmapPanel CreateBeatmapPanel(BeatmapSetInfo setInfo) => new DashboardNewBeatmapPanel(setInfo);
+
+        protected override string Title => "New Ranked Beatmaps";
+    }
+}

osu.Game/Overlays/Dashboard/Home/DrawablePopularBeatmapList.cs

@@ -0,0 +1,20 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Overlays.Dashboard.Home
+{
+    public class DrawablePopularBeatmapList : DrawableBeatmapList
+    {
+        public DrawablePopularBeatmapList(List<BeatmapSetInfo> beatmaps)
+            : base(beatmaps)
+        {
+        }
+
+        protected override DashboardBeatmapPanel CreateBeatmapPanel(BeatmapSetInfo setInfo) => new DashboardPopularBeatmapPanel(setInfo);
+
+        protected override string Title => "Popular Beatmaps";
+    }
+}

osu.Game/Overlays/DashboardOverlay.cs

@@ -19,7 +19,6 @@ namespace osu.Game.Overlays
     {
         private CancellationTokenSource cancellationToken;
 
-        private Box background;
         private Container content;
         private DashboardOverlayHeader header;
         private LoadingLayer loading;
@@ -35,9 +34,10 @@ namespace osu.Game.Overlays
         {
             Children = new Drawable[]
             {
-                background = new Box
+                new Box
                 {
-                    RelativeSizeAxes = Axes.Both
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = ColourProvider.Background5
                 },
                 scrollFlow = new OverlayScrollContainer
                 {
@@ -66,8 +66,6 @@ namespace osu.Game.Overlays
                 },
                 loading = new LoadingLayer(content),
             };
-
-            background.Colour = ColourProvider.Background5;
         }
 
         protected override void LoadComplete()

osu.Game/Overlays/KeyBinding/KeyBindingRow.cs

@@ -48,8 +48,7 @@ namespace osu.Game.Overlays.KeyBinding
         public bool FilteringActive { get; set; }
 
         private OsuSpriteText text;
-        private Drawable pressAKey;
-
+        private FillFlowContainer cancelAndClearButtons;
         private FillFlowContainer<KeyButton> buttons;
 
         public IEnumerable<string> FilterTerms => bindings.Select(b => b.KeyCombination.ReadableString()).Prepend((string)text.Text);
@@ -80,7 +79,7 @@ namespace osu.Game.Overlays.KeyBinding
                 Hollow = true,
             };
 
-            Children = new[]
+            Children = new Drawable[]
             {
                 new Box
                 {
@@ -99,7 +98,7 @@ namespace osu.Game.Overlays.KeyBinding
                     Anchor = Anchor.TopRight,
                     Origin = Anchor.TopRight
                 },
-                pressAKey = new FillFlowContainer
+                cancelAndClearButtons = new FillFlowContainer
                 {
                     AutoSizeAxes = Axes.Both,
                     Padding = new MarginPadding(padding) { Top = height + padding * 2 },
@@ -187,7 +186,8 @@ namespace osu.Game.Overlays.KeyBinding
 
             if (bindTarget.IsHovered)
                 finalise();
-            else
+            // prevent updating bind target before clear button's action
+            else if (!cancelAndClearButtons.Any(b => b.IsHovered))
                 updateBindTarget();
         }
 
@@ -298,8 +298,8 @@ namespace osu.Game.Overlays.KeyBinding
             if (HasFocus)
                 GetContainingInputManager().ChangeFocus(null);
 
-            pressAKey.FadeOut(300, Easing.OutQuint);
-            pressAKey.BypassAutoSizeAxes |= Axes.Y;
+            cancelAndClearButtons.FadeOut(300, Easing.OutQuint);
+            cancelAndClearButtons.BypassAutoSizeAxes |= Axes.Y;
         }
 
         protected override void OnFocus(FocusEvent e)
@@ -307,8 +307,8 @@ namespace osu.Game.Overlays.KeyBinding
             AutoSizeDuration = 500;
             AutoSizeEasing = Easing.OutQuint;
 
-            pressAKey.FadeIn(300, Easing.OutQuint);
-            pressAKey.BypassAutoSizeAxes &= ~Axes.Y;
+            cancelAndClearButtons.FadeIn(300, Easing.OutQuint);
+            cancelAndClearButtons.BypassAutoSizeAxes &= ~Axes.Y;
 
             updateBindTarget();
             base.OnFocus(e);
@@ -320,6 +320,9 @@ namespace osu.Game.Overlays.KeyBinding
             base.OnFocusLost(e);
         }
 
+        /// <summary>
+        /// Updates the bind target to the currently hovered key button or the first if clicked anywhere else.
+        /// </summary>
         private void updateBindTarget()
         {
             if (bindTarget != null) bindTarget.IsBinding = false;
@@ -354,7 +357,7 @@ namespace osu.Game.Overlays.KeyBinding
             }
         }
 
-        private class KeyButton : Container
+        public class KeyButton : Container
         {
             public readonly Framework.Input.Bindings.KeyBinding KeyBinding;
 

osu.Game/Overlays/MusicController.cs

@@ -236,8 +236,8 @@ namespace osu.Game.Overlays
             {
                 if (beatmap is Bindable<WorkingBeatmap> working)
                     working.Value = beatmaps.GetWorkingBeatmap(playable.Beatmaps.First(), beatmap.Value);
-                beatmap.Value.Track.Restart();
 
+                restartTrack();
                 return PreviousTrackResult.Previous;
             }
 
@@ -262,13 +262,21 @@ namespace osu.Game.Overlays
             {
                 if (beatmap is Bindable<WorkingBeatmap> working)
                     working.Value = beatmaps.GetWorkingBeatmap(playable.Beatmaps.First(), beatmap.Value);
-                beatmap.Value.Track.Restart();
+
+                restartTrack();
                 return true;
             }
 
             return false;
         }
 
+        private void restartTrack()
+        {
+            // if not scheduled, the previously track will be stopped one frame later (see ScheduleAfterChildren logic in GameBase).
+            // we probably want to move this to a central method for switching to a new working beatmap in the future.
+            Schedule(() => beatmap.Value.Track.Restart());
+        }
+
         private WorkingBeatmap current;
 
         private TrackChangeDirection? queuedDirection;

osu.Game/Overlays/News/Displays/FrontPageDisplay.cs

@@ -0,0 +1,114 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using System.Threading;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osuTK;
+
+namespace osu.Game.Overlays.News.Displays
+{
+    public class FrontPageDisplay : CompositeDrawable
+    {
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        private FillFlowContainer content;
+        private ShowMoreButton showMore;
+
+        private GetNewsRequest request;
+        private Cursor lastCursor;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+            Padding = new MarginPadding
+            {
+                Vertical = 20,
+                Left = 30,
+                Right = 50
+            };
+
+            InternalChild = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 10),
+                Children = new Drawable[]
+                {
+                    content = new FillFlowContainer
+                    {
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(0, 10)
+                    },
+                    showMore = new ShowMoreButton
+                    {
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        Margin = new MarginPadding
+                        {
+                            Top = 15
+                        },
+                        Action = performFetch,
+                        Alpha = 0
+                    }
+                }
+            };
+
+            performFetch();
+        }
+
+        private void performFetch()
+        {
+            request?.Cancel();
+
+            request = new GetNewsRequest(lastCursor);
+            request.Success += response => Schedule(() => onSuccess(response));
+            api.PerformAsync(request);
+        }
+
+        private CancellationTokenSource cancellationToken;
+
+        private void onSuccess(GetNewsResponse response)
+        {
+            cancellationToken?.Cancel();
+
+            lastCursor = response.Cursor;
+
+            var flow = new FillFlowContainer<NewsCard>
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0, 10),
+                Children = response.NewsPosts.Select(p => new NewsCard(p)).ToList()
+            };
+
+            LoadComponentAsync(flow, loaded =>
+            {
+                content.Add(loaded);
+                showMore.IsLoading = false;
+                showMore.Show();
+            }, (cancellationToken = new CancellationTokenSource()).Token);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            request?.Cancel();
+            cancellationToken?.Cancel();
+            base.Dispose(isDisposing);
+        }
+    }
+}

osu.Game/Overlays/News/NewsArticleCover.cs

@@ -1,174 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Colour;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.Events;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
-using osuTK.Graphics;
-
-namespace osu.Game.Overlays.News
-{
-    public class NewsArticleCover : Container
-    {
-        private const int hover_duration = 300;
-
-        private readonly Box gradient;
-
-        public NewsArticleCover(ArticleInfo info)
-        {
-            RelativeSizeAxes = Axes.X;
-            Masking = true;
-            CornerRadius = 4;
-
-            NewsBackground bg;
-
-            Children = new Drawable[]
-            {
-                new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = ColourInfo.GradientVertical(OsuColour.Gray(0.2f), OsuColour.Gray(0.1f))
-                },
-                new DelayedLoadWrapper(bg = new NewsBackground(info.CoverUrl)
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    FillMode = FillMode.Fill,
-                    Alpha = 0
-                })
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                },
-                gradient = new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = ColourInfo.GradientVertical(Color4.Black.Opacity(0.1f), Color4.Black.Opacity(0.7f)),
-                    Alpha = 0
-                },
-                new DateContainer(info.Time)
-                {
-                    Margin = new MarginPadding
-                    {
-                        Right = 20,
-                        Top = 20,
-                    }
-                },
-                new OsuSpriteText
-                {
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.BottomLeft,
-                    Margin = new MarginPadding
-                    {
-                        Left = 25,
-                        Bottom = 50,
-                    },
-                    Font = OsuFont.GetFont(Typeface.Torus, 24, FontWeight.Bold),
-                    Text = info.Title,
-                },
-                new OsuSpriteText
-                {
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.BottomLeft,
-                    Margin = new MarginPadding
-                    {
-                        Left = 25,
-                        Bottom = 30,
-                    },
-                    Font = OsuFont.GetFont(Typeface.Torus, 16, FontWeight.Bold),
-                    Text = "by " + info.Author
-                }
-            };
-
-            bg.OnLoadComplete += d => d.FadeIn(250, Easing.In);
-        }
-
-        protected override bool OnHover(HoverEvent e)
-        {
-            gradient.FadeIn(hover_duration, Easing.OutQuint);
-            return base.OnHover(e);
-        }
-
-        protected override void OnHoverLost(HoverLostEvent e)
-        {
-            base.OnHoverLost(e);
-            gradient.FadeOut(hover_duration, Easing.OutQuint);
-        }
-
-        [LongRunningLoad]
-        private class NewsBackground : Sprite
-        {
-            private readonly string url;
-
-            public NewsBackground(string coverUrl)
-            {
-                url = coverUrl ?? "Headers/news";
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(LargeTextureStore store)
-            {
-                Texture = store.Get(url);
-            }
-        }
-
-        private class DateContainer : Container, IHasTooltip
-        {
-            private readonly DateTime date;
-
-            public DateContainer(DateTime date)
-            {
-                this.date = date;
-
-                Anchor = Anchor.TopRight;
-                Origin = Anchor.TopRight;
-                Masking = true;
-                CornerRadius = 4;
-                AutoSizeAxes = Axes.Both;
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.Black.Opacity(0.5f),
-                    },
-                    new OsuSpriteText
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Font = OsuFont.GetFont(Typeface.Torus, 12, FontWeight.Bold, false, false),
-                        Text = date.ToString("d MMM yyy").ToUpper(),
-                        Margin = new MarginPadding
-                        {
-                            Vertical = 4,
-                            Horizontal = 8,
-                        }
-                    }
-                };
-            }
-
-            public string TooltipText => date.ToString("dddd dd MMMM yyyy hh:mm:ss UTCz").ToUpper();
-        }
-
-        // fake API data struct to use for now as a skeleton for data, as there is no API struct for news article info for now
-        public class ArticleInfo
-        {
-            public string Title { get; set; }
-            public string CoverUrl { get; set; }
-            public DateTime Time { get; set; }
-            public string Author { get; set; }
-        }
-    }
-}

osu.Game/Overlays/News/NewsCard.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -11,17 +12,17 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input.Events;
+using osu.Framework.Platform;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Overlays.News
 {
-    public class NewsCard : CompositeDrawable
+    public class NewsCard : OsuHoverContainer
     {
-        [Resolved]
-        private OverlayColourProvider colourProvider { get; set; }
+        protected override IEnumerable<Drawable> EffectTargets => new[] { background };
 
         private readonly APINewsPost post;
 
@@ -31,24 +32,28 @@ namespace osu.Game.Overlays.News
         public NewsCard(APINewsPost post)
         {
             this.post = post;
-        }
 
-        [BackgroundDependencyLoader]
-        private void load()
-        {
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
             Masking = true;
             CornerRadius = 6;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider, GameHost host)
+        {
+            if (post.Slug != null)
+            {
+                TooltipText = "view in browser";
+                Action = () => host.OpenUrlExternally("https://osu.ppy.sh/home/news/" + post.Slug);
+            }
 
             NewsBackground bg;
-
-            InternalChildren = new Drawable[]
+            AddRange(new Drawable[]
             {
                 background = new Box
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = colourProvider.Background4
+                    RelativeSizeAxes = Axes.Both
                 },
                 new FillFlowContainer
                 {
@@ -104,9 +109,11 @@ namespace osu.Game.Overlays.News
                             }
                         }
                     }
-                },
-                new HoverClickSounds()
-            };
+                }
+            });
+
+            IdleColour = colourProvider.Background4;
+            HoverColour = colourProvider.Background3;
 
             bg.OnLoadComplete += d => d.FadeIn(250, Easing.In);
 
@@ -116,18 +123,6 @@ namespace osu.Game.Overlays.News
             main.AddText(post.Author, t => t.Font = OsuFont.GetFont(size: 12, weight: FontWeight.SemiBold));
         }
 
-        protected override bool OnHover(HoverEvent e)
-        {
-            background.FadeColour(colourProvider.Background3, 200, Easing.OutQuint);
-            return true;
-        }
-
-        protected override void OnHoverLost(HoverLostEvent e)
-        {
-            background.FadeColour(colourProvider.Background4, 200, Easing.OutQuint);
-            base.OnHoverLost(e);
-        }
-
         [LongRunningLoad]
         private class NewsBackground : Sprite
         {
@@ -193,6 +188,8 @@ namespace osu.Game.Overlays.News
                     }
                 };
             }
+
+            protected override bool OnClick(ClickEvent e) => true; // Protects the NewsCard from clicks while hovering DateContainer
         }
     }
 }

osu.Game/Overlays/News/NewsContent.cs

@@ -1,19 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-
-namespace osu.Game.Overlays.News
-{
-    public abstract class NewsContent : FillFlowContainer
-    {
-        protected NewsContent()
-        {
-            RelativeSizeAxes = Axes.X;
-            AutoSizeAxes = Axes.Y;
-            Direction = FillDirection.Vertical;
-            Padding = new MarginPadding { Bottom = 100, Top = 20, Horizontal = 50 };
-        }
-    }
-}