Separate out Leaderboard into BeatmapLeaderboard

osu.Game/Online/Leaderboards/DrawableRank.cs

@@ -0,0 +1,57 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Scoring;
+
+namespace osu.Game.Online.Leaderboards
+{
+    public class DrawableRank : Container
+    {
+        private readonly Sprite rankSprite;
+        private TextureStore textures;
+
+        public ScoreRank Rank { get; private set; }
+
+        public DrawableRank(ScoreRank rank)
+        {
+            Rank = rank;
+
+            Children = new Drawable[]
+            {
+                rankSprite = new Sprite
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    FillMode = FillMode.Fit
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
+        {
+            this.textures = textures;
+            updateTexture();
+        }
+
+        private void updateTexture()
+        {
+            rankSprite.Texture = textures.Get($@"Grades/{Rank.GetDescription()}");
+        }
+
+        public void UpdateRank(ScoreRank newRank)
+        {
+            Rank = newRank;
+
+            if (LoadState >= LoadState.Ready)
+                updateTexture();
+        }
+    }
+}

osu.Game/Online/Leaderboards/Leaderboard.cs

@@ -0,0 +1,301 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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.Threading;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Screens.Select.Leaderboards;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Online.Leaderboards
+{
+    public abstract class Leaderboard<TScope, TScoreModel> : Container
+    {
+        private const double fade_duration = 300;
+
+        private readonly ScrollContainer scrollContainer;
+        private readonly Container placeholderContainer;
+
+        private FillFlowContainer<LeaderboardScore<TScoreModel>> scrollFlow;
+
+        private readonly LoadingAnimation loading;
+
+        private ScheduledDelegate showScoresDelegate;
+
+        private bool scoresLoadedOnce;
+
+        private IEnumerable<TScoreModel> scores;
+
+        public IEnumerable<TScoreModel> Scores
+        {
+            get { return scores; }
+            set
+            {
+                scores = value;
+
+                scoresLoadedOnce = true;
+
+                scrollFlow?.FadeOut(fade_duration, Easing.OutQuint).Expire();
+                scrollFlow = null;
+
+                loading.Hide();
+
+                if (scores == null || !scores.Any())
+                    return;
+
+                // ensure placeholder is hidden when displaying scores
+                PlaceholderState = PlaceholderState.Successful;
+
+                var flow = scrollFlow = new FillFlowContainer<LeaderboardScore<TScoreModel>>
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Spacing = new Vector2(0f, 5f),
+                    Padding = new MarginPadding { Top = 10, Bottom = 5 },
+                    ChildrenEnumerable = scores.Select((s, index) => CreateScoreVisualiser(s, index + 1))
+                };
+
+                // schedule because we may not be loaded yet (LoadComponentAsync complains).
+                showScoresDelegate?.Cancel();
+                if (!IsLoaded)
+                    showScoresDelegate = Schedule(showScores);
+                else
+                    showScores();
+
+                void showScores() => LoadComponentAsync(flow, _ =>
+                {
+                    scrollContainer.Add(flow);
+
+                    int i = 0;
+                    foreach (var s in flow.Children)
+                    {
+                        using (s.BeginDelayedSequence(i++ * 50, true))
+                            s.Show();
+                    }
+
+                    scrollContainer.ScrollTo(0f, false);
+                });
+            }
+        }
+
+        private TScope scope;
+
+        public TScope Scope
+        {
+            get { return scope; }
+            set
+            {
+                if (value.Equals(scope))
+                    return;
+
+                scope = value;
+                UpdateScores();
+            }
+        }
+
+        private PlaceholderState placeholderState;
+
+        /// <summary>
+        /// Update the placeholder visibility.
+        /// Setting this to anything other than PlaceholderState.Successful will cancel all existing retrieval requests and hide scores.
+        /// </summary>
+        protected PlaceholderState PlaceholderState
+        {
+            get { return placeholderState; }
+            set
+            {
+                if (value != PlaceholderState.Successful)
+                {
+                    getScoresRequest?.Cancel();
+                    getScoresRequest = null;
+                    Scores = null;
+                }
+
+                if (value == placeholderState)
+                    return;
+
+                switch (placeholderState = value)
+                {
+                    case PlaceholderState.NetworkFailure:
+                        replacePlaceholder(new RetrievalFailurePlaceholder
+                        {
+                            OnRetry = UpdateScores,
+                        });
+                        break;
+                    case PlaceholderState.Unavailable:
+                        replacePlaceholder(new MessagePlaceholder(@"Leaderboards are not available for this beatmap!"));
+                        break;
+                    case PlaceholderState.NoScores:
+                        replacePlaceholder(new MessagePlaceholder(@"No records yet!"));
+                        break;
+                    case PlaceholderState.NotLoggedIn:
+                        replacePlaceholder(new MessagePlaceholder(@"Please sign in to view online leaderboards!"));
+                        break;
+                    case PlaceholderState.NotSupporter:
+                        replacePlaceholder(new MessagePlaceholder(@"Please invest in an osu!supporter tag to view this leaderboard!"));
+                        break;
+                    default:
+                        replacePlaceholder(null);
+                        break;
+                }
+            }
+        }
+
+        protected Leaderboard()
+        {
+            Children = new Drawable[]
+            {
+                scrollContainer = new OsuScrollContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    ScrollbarVisible = false,
+                },
+                loading = new LoadingAnimation(),
+                placeholderContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
+            };
+        }
+
+        private APIAccess api;
+
+        private ScheduledDelegate pendingUpdateScores;
+
+        [BackgroundDependencyLoader(true)]
+        private void load(APIAccess api)
+        {
+            this.api = api;
+
+            if (api != null)
+                api.OnStateChange += handleApiStateChange;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (api != null)
+                api.OnStateChange -= handleApiStateChange;
+        }
+
+        public void RefreshScores() => UpdateScores();
+
+        private APIRequest getScoresRequest;
+
+        private void handleApiStateChange(APIState oldState, APIState newState)
+        {
+            if (newState == APIState.Online)
+                UpdateScores();
+        }
+
+        protected void UpdateScores()
+        {
+            // don't display any scores or placeholder until the first Scores_Set has been called.
+            // this avoids scope changes flickering a "no scores" placeholder before initialisation of song select is finished.
+            if (!scoresLoadedOnce) return;
+
+            getScoresRequest?.Cancel();
+            getScoresRequest = null;
+
+            pendingUpdateScores?.Cancel();
+            pendingUpdateScores = Schedule(() =>
+            {
+                if (api?.IsLoggedIn != true)
+                {
+                    PlaceholderState = PlaceholderState.NotLoggedIn;
+                    return;
+                }
+
+                PlaceholderState = PlaceholderState.Retrieving;
+                loading.Show();
+
+                getScoresRequest = FetchScores(scores => Schedule(() =>
+                {
+                    Scores = scores;
+                    PlaceholderState = Scores.Any() ? PlaceholderState.Successful : PlaceholderState.NoScores;
+                }));
+
+                if (getScoresRequest == null)
+                    return;
+
+                getScoresRequest.Failure += e => Schedule(() =>
+                {
+                    if (e is OperationCanceledException)
+                        return;
+
+                    PlaceholderState = PlaceholderState.NetworkFailure;
+                });
+
+                api.Queue(getScoresRequest);
+            });
+        }
+
+        protected abstract APIRequest FetchScores(Action<IEnumerable<TScoreModel>> scoresCallback);
+
+        private Placeholder currentPlaceholder;
+
+        private void replacePlaceholder(Placeholder placeholder)
+        {
+            if (placeholder != null && placeholder.Equals(currentPlaceholder))
+                return;
+
+            currentPlaceholder?.FadeOut(150, Easing.OutQuint).Expire();
+
+            if (placeholder == null)
+            {
+                currentPlaceholder = null;
+                return;
+            }
+
+            placeholderContainer.Child = placeholder;
+
+            placeholder.ScaleTo(0.8f).Then().ScaleTo(1, fade_duration * 3, Easing.OutQuint);
+            placeholder.FadeInFromZero(fade_duration, Easing.OutQuint);
+
+            currentPlaceholder = placeholder;
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            var fadeStart = scrollContainer.Current + scrollContainer.DrawHeight;
+
+            if (!scrollContainer.IsScrolledToEnd())
+                fadeStart -= LeaderboardScore.HEIGHT;
+
+            if (scrollFlow == null)
+                return;
+
+            foreach (var c in scrollFlow.Children)
+            {
+                var topY = c.ToSpaceOfOtherDrawable(Vector2.Zero, scrollFlow).Y;
+                var bottomY = topY + LeaderboardScore.HEIGHT;
+
+                if (bottomY < fadeStart)
+                    c.Colour = Color4.White;
+                else if (topY > fadeStart + LeaderboardScore.HEIGHT)
+                    c.Colour = Color4.Transparent;
+                else
+                {
+                    c.Colour = ColourInfo.GradientVertical(
+                        Color4.White.Opacity(Math.Min(1 - (topY - fadeStart) / LeaderboardScore.HEIGHT, 1)),
+                        Color4.White.Opacity(Math.Min(1 - (bottomY - fadeStart) / LeaderboardScore.HEIGHT, 1)));
+                }
+            }
+        }
+
+        protected abstract LeaderboardScore<TScoreModel> CreateScoreVisualiser(TScoreModel model, int index);
+    }
+}

osu.Game/Online/Leaderboards/LeaderboardScore.cs

@@ -0,0 +1,390 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
+using osu.Game.Users;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Online.Leaderboards
+{
+    public static class LeaderboardScore
+    {
+        public const float HEIGHT = 60;
+    }
+
+    public abstract class LeaderboardScore<TScoreModel> : OsuClickableContainer
+    {
+        public readonly int RankPosition;
+
+        private const float corner_radius = 5;
+        private const float edge_margin = 5;
+        private const float background_alpha = 0.25f;
+        private const float rank_width = 30;
+
+        protected Container RankContainer { get; private set; }
+
+        private readonly TScoreModel score;
+
+        private Box background;
+        private Container content;
+        private Drawable avatar;
+        private Drawable scoreRank;
+        private OsuSpriteText nameLabel;
+        private GlowingSpriteText scoreLabel;
+        private Container flagBadgeContainer;
+        private FillFlowContainer<ModIcon> modsContainer;
+
+        private List<ScoreComponentLabel> statisticsLabels;
+
+        protected LeaderboardScore(TScoreModel score, int rank)
+        {
+            this.score = score;
+            RankPosition = rank;
+
+            RelativeSizeAxes = Axes.X;
+            Height = LeaderboardScore.HEIGHT;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var user = GetUser(score);
+
+            statisticsLabels = GetStatistics(score).Select(s => new ScoreComponentLabel(s.icon, s.value, s.name)).ToList();
+
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Width = rank_width,
+                    Children = new[]
+                    {
+                        new OsuSpriteText
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Font = @"Exo2.0-MediumItalic",
+                            TextSize = 22,
+                            // ReSharper disable once ImpureMethodCallOnReadonlyValueField
+                            Text = RankPosition.ToString(),
+                        },
+                    },
+                },
+                content = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Left = rank_width, },
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            CornerRadius = corner_radius,
+                            Masking = true,
+                            Children = new[]
+                            {
+                                background = new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.Black,
+                                    Alpha = background_alpha,
+                                },
+                            },
+                        },
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding(edge_margin),
+                            Children = new[]
+                            {
+                                avatar = new DelayedLoadWrapper(
+                                    new Avatar(user)
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        CornerRadius = corner_radius,
+                                        Masking = true,
+                                        OnLoadComplete = d => d.FadeInFromZero(200),
+                                        EdgeEffect = new EdgeEffectParameters
+                                        {
+                                            Type = EdgeEffectType.Shadow,
+                                            Radius = 1,
+                                            Colour = Color4.Black.Opacity(0.2f),
+                                        },
+                                    })
+                                {
+                                    RelativeSizeAxes = Axes.None,
+                                    Size = new Vector2(LeaderboardScore.HEIGHT - edge_margin * 2, LeaderboardScore.HEIGHT - edge_margin * 2),
+                                },
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Y,
+                                    AutoSizeAxes = Axes.X,
+                                    Position = new Vector2(LeaderboardScore.HEIGHT - edge_margin, 0f),
+                                    Children = new Drawable[]
+                                    {
+                                        nameLabel = new OsuSpriteText
+                                        {
+                                            Text = user.Username,
+                                            Font = @"Exo2.0-BoldItalic",
+                                            TextSize = 23,
+                                        },
+                                        new FillFlowContainer
+                                        {
+                                            Origin = Anchor.BottomLeft,
+                                            Anchor = Anchor.BottomLeft,
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Spacing = new Vector2(10f, 0f),
+                                            Children = new Drawable[]
+                                            {
+                                                flagBadgeContainer = new Container
+                                                {
+                                                    Origin = Anchor.BottomLeft,
+                                                    Anchor = Anchor.BottomLeft,
+                                                    Size = new Vector2(87f, 20f),
+                                                    Masking = true,
+                                                    Children = new Drawable[]
+                                                    {
+                                                        new DrawableFlag(user.Country)
+                                                        {
+                                                            Width = 30,
+                                                            RelativeSizeAxes = Axes.Y,
+                                                        },
+                                                    },
+                                                },
+                                                new FillFlowContainer
+                                                {
+                                                    Origin = Anchor.BottomLeft,
+                                                    Anchor = Anchor.BottomLeft,
+                                                    AutoSizeAxes = Axes.Both,
+                                                    Direction = FillDirection.Horizontal,
+                                                    Spacing = new Vector2(10f, 0f),
+                                                    Margin = new MarginPadding { Left = edge_margin },
+                                                    Children = statisticsLabels
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                                new FillFlowContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                    Direction = FillDirection.Horizontal,
+                                    Spacing = new Vector2(5f, 0f),
+                                    Children = new Drawable[]
+                                    {
+                                        scoreLabel = new GlowingSpriteText(GetTotalScore(score).ToString(@"N0"), @"Venera", 23, Color4.White, OsuColour.FromHex(@"83ccfa")),
+                                        RankContainer = new Container
+                                        {
+                                            Size = new Vector2(40f, 20f),
+                                            Children = new[]
+                                            {
+                                                scoreRank = new DrawableRank(GetRank(score))
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    Size = new Vector2(40f)
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                                modsContainer = new FillFlowContainer<ModIcon>
+                                {
+                                    Anchor = Anchor.BottomRight,
+                                    Origin = Anchor.BottomRight,
+                                    AutoSizeAxes = Axes.Both,
+                                    Direction = FillDirection.Horizontal,
+                                    ChildrenEnumerable = GetMods(score).Select(mod => new ModIcon(mod) { Scale = new Vector2(0.375f) })
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+        }
+
+        public override void Show()
+        {
+            foreach (var d in new[] { avatar, nameLabel, scoreLabel, scoreRank, flagBadgeContainer, modsContainer }.Concat(statisticsLabels))
+                d.FadeOut();
+
+            Alpha = 0;
+
+            content.MoveToY(75);
+            avatar.MoveToX(75);
+            nameLabel.MoveToX(150);
+
+            this.FadeIn(200);
+            content.MoveToY(0, 800, Easing.OutQuint);
+
+            using (BeginDelayedSequence(100, true))
+            {
+                avatar.FadeIn(300, Easing.OutQuint);
+                nameLabel.FadeIn(350, Easing.OutQuint);
+
+                avatar.MoveToX(0, 300, Easing.OutQuint);
+                nameLabel.MoveToX(0, 350, Easing.OutQuint);
+
+                using (BeginDelayedSequence(250, true))
+                {
+                    scoreLabel.FadeIn(200);
+                    scoreRank.FadeIn(200);
+
+                    using (BeginDelayedSequence(50, true))
+                    {
+                        var drawables = new Drawable[] { flagBadgeContainer, modsContainer }.Concat(statisticsLabels).ToArray();
+                        for (int i = 0; i < drawables.Length; i++)
+                            drawables[i].FadeIn(100 + i * 50);
+                    }
+                }
+            }
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            background.FadeTo(0.5f, 300, Easing.OutQuint);
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            background.FadeTo(background_alpha, 200, Easing.OutQuint);
+            base.OnHoverLost(e);
+        }
+
+        protected abstract User GetUser(TScoreModel model);
+
+        protected abstract IEnumerable<Mod> GetMods(TScoreModel model);
+
+        protected abstract IEnumerable<(FontAwesome icon, string value, string name)> GetStatistics(TScoreModel model);
+
+        protected abstract int GetTotalScore(TScoreModel model);
+
+        protected abstract ScoreRank GetRank(TScoreModel model);
+
+        private class GlowingSpriteText : Container
+        {
+            public GlowingSpriteText(string text, string font, int textSize, Color4 textColour, Color4 glowColour)
+            {
+                AutoSizeAxes = Axes.Both;
+
+                Children = new Drawable[]
+                {
+                    new BufferedContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        BlurSigma = new Vector2(4),
+                        CacheDrawnFrameBuffer = true,
+                        RelativeSizeAxes = Axes.Both,
+                        Blending = BlendingMode.Additive,
+                        Size = new Vector2(3f),
+                        Children = new[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Font = font,
+                                FixedWidth = true,
+                                TextSize = textSize,
+                                Text = text,
+                                Colour = glowColour,
+                                Shadow = false,
+                            },
+                        },
+                    },
+                    new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Font = font,
+                        FixedWidth = true,
+                        TextSize = textSize,
+                        Text = text,
+                        Colour = textColour,
+                        Shadow = false,
+                    },
+                };
+            }
+        }
+
+        private class ScoreComponentLabel : Container, IHasTooltip
+        {
+            private const float icon_size = 20;
+
+            private readonly string name;
+            private readonly FillFlowContainer content;
+
+            public override bool Contains(Vector2 screenSpacePos) => content.Contains(screenSpacePos);
+
+            public string TooltipText => name;
+
+            public ScoreComponentLabel(FontAwesome icon, string value, string name)
+            {
+                this.name = name;
+                AutoSizeAxes = Axes.Both;
+
+                Child = content = new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            AutoSizeAxes = Axes.Both,
+                            Children = new[]
+                            {
+                                new SpriteIcon
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Size = new Vector2(icon_size),
+                                    Rotation = 45,
+                                    Colour = OsuColour.FromHex(@"3087ac"),
+                                    Icon = FontAwesome.fa_square,
+                                    Shadow = true,
+                                },
+                                new SpriteIcon
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Size = new Vector2(icon_size - 6),
+                                    Colour = OsuColour.FromHex(@"a4edff"),
+                                    Icon = icon,
+                                },
+                            },
+                        },
+                        new GlowingSpriteText(value, @"Exo2.0-Bold", 17, Color4.White, OsuColour.FromHex(@"83ccfa"))
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                        },
+                    },
+                };
+            }
+        }
+    }
+}

osu.Game/Online/Leaderboards/MessagePlaceholder.cs

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Graphics;
+
+namespace osu.Game.Online.Leaderboards
+{
+    public class MessagePlaceholder : Placeholder
+    {
+        private readonly string message;
+
+        public MessagePlaceholder(string message)
+        {
+            AddIcon(FontAwesome.fa_exclamation_circle, cp =>
+            {
+                cp.TextSize = TEXT_SIZE;
+                cp.Padding = new MarginPadding { Right = 10 };
+            });
+
+            AddText(this.message = message);
+        }
+
+        public override bool Equals(Placeholder other) => (other as MessagePlaceholder)?.message == message;
+    }
+}

osu.Game/Online/Leaderboards/Placeholder.cs

@@ -0,0 +1,29 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Framework.Graphics;
+using osu.Game.Graphics.Containers;
+
+namespace osu.Game.Online.Leaderboards
+{
+    public abstract class Placeholder : OsuTextFlowContainer, IEquatable<Placeholder>
+    {
+        protected const float TEXT_SIZE = 22;
+
+        protected Placeholder()
+            : base(cp => cp.TextSize = TEXT_SIZE)
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            TextAnchor = Anchor.TopCentre;
+
+            Padding = new MarginPadding(20);
+
+            AutoSizeAxes = Axes.Y;
+            RelativeSizeAxes = Axes.X;
+        }
+
+        public virtual bool Equals(Placeholder other) => GetType() == other?.GetType();
+    }
+}

osu.Game/Online/Leaderboards/PlaceholderState.cs

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Online.Leaderboards
+{
+    public enum PlaceholderState
+    {
+        Successful,
+        Retrieving,
+        NetworkFailure,
+        Unavailable,
+        NoScores,
+        NotLoggedIn,
+        NotSupporter,
+    }
+}

osu.Game/Online/Leaderboards/RetrievalFailurePlaceholder.cs

@@ -0,0 +1,64 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osuTK;
+
+namespace osu.Game.Online.Leaderboards
+{
+    public class RetrievalFailurePlaceholder : Placeholder
+    {
+        public Action OnRetry;
+
+        public RetrievalFailurePlaceholder()
+        {
+            AddArbitraryDrawable(new RetryButton
+            {
+                Action = () => OnRetry?.Invoke(),
+                Padding = new MarginPadding { Right = 10 }
+            });
+
+            AddText(@"Couldn't retrieve scores!");
+        }
+
+        public class RetryButton : OsuHoverContainer
+        {
+            private readonly SpriteIcon icon;
+
+            public new Action Action;
+
+            public RetryButton()
+            {
+                AutoSizeAxes = Axes.Both;
+
+                Child = new OsuClickableContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Action = () => Action?.Invoke(),
+                    Child = icon = new SpriteIcon
+                    {
+                        Icon = FontAwesome.fa_refresh,
+                        Size = new Vector2(TEXT_SIZE),
+                        Shadow = true,
+                    },
+                };
+            }
+
+            protected override bool OnMouseDown(MouseDownEvent e)
+            {
+                icon.ScaleTo(0.8f, 4000, Easing.OutQuint);
+                return base.OnMouseDown(e);
+            }
+
+            protected override bool OnMouseUp(MouseUpEvent e)
+            {
+                icon.ScaleTo(1, 1000, Easing.OutElastic);
+                return base.OnMouseUp(e);
+            }
+        }
+    }
+}