Merge branch 'master' into fix-leaderboard-nullref

osu-framework

@@ -1 +1 @@
-Subproject commit eb6362eaf1317b0fa27b2c9e559bd9a0f1ce357c
+Subproject commit 7e8788e601b62577e51197a29e24f56eeeac0286

osu.Game.Tests/Visual/TestCaseBadgeContainer.cs

@@ -0,0 +1,62 @@
+// 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 NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Overlays.Profile.Header;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual
+{
+    [TestFixture]
+    public class TestCaseBadgeContainer : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(BadgeContainer) };
+
+        public TestCaseBadgeContainer()
+        {
+            BadgeContainer badgeContainer;
+
+            Child = badgeContainer = new BadgeContainer
+            {
+                RelativeSizeAxes = Axes.Both
+            };
+
+            AddStep("Show 1 badge", () => badgeContainer.ShowBadges(new[]
+            {
+                new Badge
+                {
+                    AwardedAt = DateTimeOffset.Now,
+                    Description = "Appreciates compasses",
+                    ImageUrl = "https://assets.ppy.sh/profile-badges/mg2018-1star.png",
+                }
+            }));
+
+            AddStep("Show 2 badges", () => badgeContainer.ShowBadges(new[]
+            {
+                new Badge
+                {
+                    AwardedAt = DateTimeOffset.Now,
+                    Description = "Contributed to osu!lazer testing",
+                    ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.png",
+                },
+                new Badge
+                {
+                    AwardedAt = DateTimeOffset.Now,
+                    Description = "Appreciates compasses",
+                    ImageUrl = "https://assets.ppy.sh/profile-badges/mg2018-1star.png",
+                }
+            }));
+
+            AddStep("Show many badges", () => badgeContainer.ShowBadges(Enumerable.Range(1, 20).Select(i => new Badge
+            {
+                AwardedAt = DateTimeOffset.Now,
+                Description = $"Contributed to osu!lazer testing {i} times",
+                ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg",
+            }).ToArray()));
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseRankGraph.cs

@@ -1,7 +1,6 @@
 // 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.Game.Overlays.Profile;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using OpenTK;
@@ -11,6 +10,7 @@ using System.Collections.Generic;
 using System;
 using NUnit.Framework;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays.Profile.Header;
 using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual

osu.Game.Tests/Visual/TestCaseUserProfile.cs

@@ -8,6 +8,7 @@ using NUnit.Framework;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Profile;
+using osu.Game.Overlays.Profile.Header;
 using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual
@@ -23,6 +24,7 @@ namespace osu.Game.Tests.Visual
             typeof(UserProfileOverlay),
             typeof(RankGraph),
             typeof(LineGraph),
+            typeof(BadgeContainer)
         };
 
         public TestCaseUserProfile()
@@ -53,6 +55,15 @@ namespace osu.Game.Tests.Visual
                 {
                     Mode = @"osu",
                     Data = Enumerable.Range(2345, 45).Concat(Enumerable.Range(2109, 40)).ToArray()
+                },
+                Badges = new[]
+                {
+                    new Badge
+                    {
+                        AwardedAt = DateTimeOffset.FromUnixTimeSeconds(1505741569),
+                        Description = "Outstanding help by being a voluntary test subject.",
+                        ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg"
+                    }
                 }
             }, false));
 

osu.Game.Tests/Visual/TestCaseWaveContainer.cs

@@ -0,0 +1,54 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Tests.Visual
+{
+    [TestFixture]
+    public class TestCaseWaveContainer : OsuTestCase
+    {
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            WaveContainer container;
+            Add(container = new WaveContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(400),
+                FirstWaveColour = colours.Red,
+                SecondWaveColour = colours.Green,
+                ThirdWaveColour = colours.Blue,
+                FourthWaveColour = colours.Pink,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.Black.Opacity(0.5f),
+                    },
+                    new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        TextSize = 20,
+                        Text = @"Wave Container",
+                    },
+                },
+            });
+
+            AddStep(@"show", container.Show);
+            AddStep(@"hide", container.Hide);
+        }
+    }
+}

osu.Game/Configuration/OsuConfigManager.cs

@@ -84,6 +84,7 @@ namespace osu.Game.Configuration
             Set(OsuSetting.Version, string.Empty);
 
             Set(OsuSetting.ScreenshotFormat, ScreenshotFormat.Jpg);
+            Set(OsuSetting.ScreenshotCaptureMenuCursor, false);
         }
 
         public OsuConfigManager(Storage storage) : base(storage)
@@ -128,6 +129,7 @@ namespace osu.Game.Configuration
         ShowConvertedBeatmaps,
         SpeedChangeVisualisation,
         Skin,
-        ScreenshotFormat
+        ScreenshotFormat,
+        ScreenshotCaptureMenuCursor
     }
 }

osu.Game/Graphics/Containers/WaveContainer.cs

@@ -0,0 +1,167 @@
+// 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.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using OpenTK.Graphics;
+
+namespace osu.Game.Graphics.Containers
+{
+    public class WaveContainer : VisibilityContainer
+    {
+        public const float APPEAR_DURATION = 800;
+        public const float DISAPPEAR_DURATION = 500;
+
+        private const Easing easing_show = Easing.OutSine;
+        private const Easing easing_hide = Easing.InSine;
+
+        private readonly Wave firstWave;
+        private readonly Wave secondWave;
+        private readonly Wave thirdWave;
+        private readonly Wave fourthWave;
+
+        private readonly Container<Wave> wavesContainer;
+        private readonly Container contentContainer;
+
+        protected override Container<Drawable> Content => contentContainer;
+
+        public Color4 FirstWaveColour
+        {
+            get => firstWave.Colour;
+            set => firstWave.Colour = value;
+        }
+
+        public Color4 SecondWaveColour
+        {
+            get => secondWave.Colour;
+            set => secondWave.Colour = value;
+        }
+
+        public Color4 ThirdWaveColour
+        {
+            get => thirdWave.Colour;
+            set => thirdWave.Colour = value;
+        }
+
+        public Color4 FourthWaveColour
+        {
+            get => fourthWave.Colour;
+            set => fourthWave.Colour = value;
+        }
+
+        public WaveContainer()
+        {
+            Masking = true;
+
+            AddInternal(wavesContainer = new Container<Wave>
+            {
+                RelativeSizeAxes = Axes.X,
+                Origin = Anchor.TopCentre,
+                Anchor = Anchor.TopCentre,
+                Masking = true,
+                Children = new[]
+                {
+                    firstWave = new Wave
+                    {
+                        Rotation = 13,
+                        FinalPosition = -930,
+                    },
+                    secondWave = new Wave
+                    {
+                        Origin = Anchor.TopRight,
+                        Anchor = Anchor.TopRight,
+                        Rotation = -7,
+                        FinalPosition = -560,
+                    },
+                    thirdWave = new Wave
+                    {
+                        Rotation = 4,
+                        FinalPosition = -390,
+                    },
+                    fourthWave = new Wave
+                    {
+                        Origin = Anchor.TopRight,
+                        Anchor = Anchor.TopRight,
+                        Rotation = -2,
+                        FinalPosition = -220,
+                    },
+                },
+            });
+
+            AddInternal(contentContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+            });
+        }
+
+        protected override void PopIn()
+        {
+            foreach (var w in wavesContainer.Children)
+                w.State = Visibility.Visible;
+
+            this.FadeIn(100, Easing.OutQuint);
+            contentContainer.MoveToY(0, APPEAR_DURATION, Easing.OutQuint);
+
+            this.FadeIn(100, Easing.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            this.FadeOut(DISAPPEAR_DURATION, Easing.InQuint);
+            contentContainer.MoveToY(DrawHeight * 2f, DISAPPEAR_DURATION, Easing.In);
+
+            foreach (var w in wavesContainer.Children)
+                w.State = Visibility.Hidden;
+
+            this.FadeOut(DISAPPEAR_DURATION, Easing.InQuint);
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            // This is done as an optimization, such that invisible parts of the waves
+            // are masked away, and thus do not consume fill rate.
+            wavesContainer.Height = Math.Max(0, DrawHeight - (contentContainer.DrawHeight - contentContainer.Y));
+        }
+
+        private class Wave : VisibilityContainer
+        {
+            public float FinalPosition;
+
+            protected override bool StartHidden => true;
+
+            public Wave()
+            {
+                RelativeSizeAxes = Axes.X;
+                Width = 1.5f;
+                Masking = true;
+                EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Shadow,
+                    Colour = Color4.Black.Opacity(50),
+                    Radius = 20f,
+                };
+
+                Child = new Box { RelativeSizeAxes = Axes.Both };
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                // We can not use RelativeSizeAxes for Height, because the height
+                // of our parent diminishes as the content moves up.
+                Height = Parent.Parent.DrawSize.Y * 1.5f;
+            }
+
+            protected override void PopIn() => this.MoveToY(FinalPosition, APPEAR_DURATION, easing_show);
+            protected override void PopOut() => this.MoveToY(Parent.Parent.DrawSize.Y, DISAPPEAR_DURATION, easing_hide);
+        }
+    }
+}

osu.Game/Graphics/Cursor/CursorOverrideContainer.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Graphics.Cursor
         /// <summary>
         /// Whether any cursors can be displayed.
         /// </summary>
-        public bool CanShowCursor = true;
+        internal bool CanShowCursor = true;
 
         public CursorContainer Cursor { get; }
         public bool ProvidingUserCursor => true;

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -12,12 +12,16 @@ using osu.Framework.Input;
 using osu.Game.Configuration;
 using System;
 using System.Diagnostics;
+using JetBrains.Annotations;
 using osu.Framework.Graphics.Textures;
 
 namespace osu.Game.Graphics.Cursor
 {
     public class MenuCursor : CursorContainer
     {
+        private readonly IBindable<bool> screenshotCursorVisibility = new Bindable<bool>(true);
+        public override bool IsPresent => screenshotCursorVisibility.Value && base.IsPresent;
+
         protected override Drawable CreateCursor() => new Cursor();
 
         private Bindable<bool> cursorRotate;
@@ -25,6 +29,15 @@ namespace osu.Game.Graphics.Cursor
 
         private bool startRotation;
 
+        [BackgroundDependencyLoader(true)]
+        private void load([NotNull] OsuConfigManager config, [CanBeNull] ScreenshotManager screenshotManager)
+        {
+            cursorRotate = config.GetBindable<bool>(OsuSetting.CursorRotation);
+
+            if (screenshotManager != null)
+                screenshotCursorVisibility.BindTo(screenshotManager.CursorVisibility);
+        }
+
         protected override bool OnMouseMove(InputState state)
         {
             if (cursorRotate && dragging)
@@ -104,12 +117,6 @@ namespace osu.Game.Graphics.Cursor
             ActiveCursor.ScaleTo(0.6f, 250, Easing.In);
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            cursorRotate = config.GetBindable<bool>(OsuSetting.CursorRotation);
-        }
-
         public class Cursor : Container
         {
             private Container cursorContainer;

osu.Game/Graphics/ScreenshotManager.cs

@@ -4,6 +4,8 @@
 using System;
 using System.Drawing.Imaging;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -12,6 +14,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Platform;
+using osu.Framework.Threading;
 using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
@@ -21,7 +24,17 @@ namespace osu.Game.Graphics
 {
     public class ScreenshotManager : Container, IKeyBindingHandler<GlobalAction>, IHandleGlobalInput
     {
+        private readonly BindableBool cursorVisibility = new BindableBool(true);
+
+        /// <summary>
+        /// Changed when screenshots are being or have finished being taken, to control whether cursors should be visible.
+        /// If cursors should not be visible, cursors have 3 frames to hide themselves.
+        /// </summary>
+        public IBindable<bool> CursorVisibility => cursorVisibility;
+
         private Bindable<ScreenshotFormat> screenshotFormat;
+        private Bindable<bool> captureMenuCursor;
+
         private GameHost host;
         private Storage storage;
         private NotificationOverlay notificationOverlay;
@@ -36,6 +49,7 @@ namespace osu.Game.Graphics
             this.notificationOverlay = notificationOverlay;
 
             screenshotFormat = config.GetBindable<ScreenshotFormat>(OsuSetting.ScreenshotFormat);
+            captureMenuCursor = config.GetBindable<bool>(OsuSetting.ScreenshotCaptureMenuCursor);
 
             shutter = audio.Sample.Get("UI/shutter");
         }
@@ -55,10 +69,31 @@ namespace osu.Game.Graphics
 
         public bool OnReleased(GlobalAction action) => false;
 
-        public async void TakeScreenshotAsync()
+        private volatile int screenShotTasks;
+
+        public async Task TakeScreenshotAsync() => await Task.Run(async () =>
         {
+            Interlocked.Increment(ref screenShotTasks);
+
+            if (!captureMenuCursor.Value)
+            {
+                cursorVisibility.Value = false;
+
+                // We need to wait for at most 3 draw nodes to be drawn, following which we can be assured at least one DrawNode has been generated/drawn with the set value
+                const int frames_to_wait = 3;
+
+                int framesWaited = 0;
+                ScheduledDelegate waitDelegate = host.DrawThread.Scheduler.AddDelayed(() => framesWaited++, 0, true);
+                while (framesWaited < frames_to_wait)
+                    Thread.Sleep(10);
+
+                waitDelegate.Cancel();
+            }
+
             using (var bitmap = await host.TakeScreenshotAsync())
             {
+                Interlocked.Decrement(ref screenShotTasks);
+
                 var fileName = getFileName();
                 if (fileName == null) return;
 
@@ -86,6 +121,14 @@ namespace osu.Game.Graphics
                     }
                 });
             }
+        });
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (cursorVisibility == false && Interlocked.CompareExchange(ref screenShotTasks, 0, 0) == 0)
+                cursorVisibility.Value = true;
         }
 
         private string getFileName()

osu.Game/OsuGame.cs

@@ -60,6 +60,8 @@ namespace osu.Game
 
         private BeatmapSetOverlay beatmapSetOverlay;
 
+        private ScreenshotManager screenshotManager;
+
         public virtual Storage GetStorageForStableInstall() => null;
 
         private Intro intro
@@ -200,6 +202,9 @@ namespace osu.Game
 
         protected override void LoadComplete()
         {
+            // this needs to be cached before base.LoadComplete as it is used by CursorOverrideContainer.
+            dependencies.Cache(screenshotManager = new ScreenshotManager());
+
             base.LoadComplete();
 
             // The next time this is updated is in UpdateAfterChildren, which occurs too late and results
@@ -243,7 +248,8 @@ namespace osu.Game
 
             loadComponentSingleFile(volume = new VolumeOverlay(), overlayContent.Add);
             loadComponentSingleFile(onscreenDisplay = new OnScreenDisplay(), Add);
-            loadComponentSingleFile(new ScreenshotManager(), Add);
+
+            loadComponentSingleFile(screenshotManager, Add);
 
             //overlay elements
             loadComponentSingleFile(direct = new DirectOverlay { Depth = -1 }, mainContent.Add);

osu.Game/Overlays/BeatmapSetOverlay.cs

@@ -40,10 +40,10 @@ namespace osu.Game.Overlays
 
         public BeatmapSetOverlay()
         {
-            FirstWaveColour = OsuColour.Gray(0.4f);
+            Waves.FirstWaveColour = OsuColour.Gray(0.4f);
-            SecondWaveColour = OsuColour.Gray(0.3f);
+            Waves.SecondWaveColour = OsuColour.Gray(0.3f);
-            ThirdWaveColour = OsuColour.Gray(0.2f);
+            Waves.ThirdWaveColour = OsuColour.Gray(0.2f);
-            FourthWaveColour = OsuColour.Gray(0.1f);
+            Waves.FourthWaveColour = OsuColour.Gray(0.1f);
 
             Anchor = Anchor.TopCentre;
             Origin = Anchor.TopCentre;
@@ -123,14 +123,14 @@ namespace osu.Game.Overlays
         protected override void PopIn()
         {
             base.PopIn();
-            FadeEdgeEffectTo(0.25f, APPEAR_DURATION, Easing.In);
+            FadeEdgeEffectTo(0.25f, WaveContainer.APPEAR_DURATION, Easing.In);
         }
 
         protected override void PopOut()
         {
             base.PopOut();
             header.Details.StopPreview();
-            FadeEdgeEffectTo(0, DISAPPEAR_DURATION, Easing.Out);
+            FadeEdgeEffectTo(0, WaveContainer.DISAPPEAR_DURATION, Easing.Out);
         }
 
         protected override bool OnClick(InputState state)

osu.Game/Overlays/Direct/PlayButton.cs

@@ -173,8 +173,9 @@ namespace osu.Game.Overlays.Direct
                     if (trackLoader != d) return;
 
                     Preview = d?.Preview;
-                    Playing.TriggerChange();
+                    updatePreviewTrack(Playing);
                     loading = false;
+
                     Add(trackLoader);
                 });
         }

osu.Game/Overlays/DirectOverlay.cs

@@ -89,10 +89,10 @@ namespace osu.Game.Overlays
 
             // osu!direct colours are not part of the standard palette
 
-            FirstWaveColour = OsuColour.FromHex(@"19b0e2");
+            Waves.FirstWaveColour = OsuColour.FromHex(@"19b0e2");
-            SecondWaveColour = OsuColour.FromHex(@"2280a2");
+            Waves.SecondWaveColour = OsuColour.FromHex(@"2280a2");
-            ThirdWaveColour = OsuColour.FromHex(@"005774");
+            Waves.ThirdWaveColour = OsuColour.FromHex(@"005774");
-            FourthWaveColour = OsuColour.FromHex(@"003a4e");
+            Waves.FourthWaveColour = OsuColour.FromHex(@"003a4e");
 
             ScrollFlow.Children = new Drawable[]
             {

osu.Game/Overlays/Mods/ModSelectOverlay.cs

@@ -18,6 +18,7 @@ using System.Linq;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics.Containers;
 using osu.Game.Rulesets;
 using osu.Game.Graphics.UserInterface;
 
@@ -113,14 +114,14 @@ namespace osu.Game.Overlays.Mods
         {
             base.PopOut();
 
-            footerContainer.MoveToX(footerContainer.DrawSize.X, DISAPPEAR_DURATION, Easing.InSine);
+            footerContainer.MoveToX(footerContainer.DrawSize.X, WaveContainer.DISAPPEAR_DURATION, Easing.InSine);
-            footerContainer.FadeOut(DISAPPEAR_DURATION, Easing.InSine);
+            footerContainer.FadeOut(WaveContainer.DISAPPEAR_DURATION, Easing.InSine);
 
             foreach (ModSection section in ModSectionsContainer.Children)
             {
-                section.ButtonsContainer.TransformSpacingTo(new Vector2(100f, 0f), DISAPPEAR_DURATION, Easing.InSine);
+                section.ButtonsContainer.TransformSpacingTo(new Vector2(100f, 0f), WaveContainer.DISAPPEAR_DURATION, Easing.InSine);
-                section.ButtonsContainer.MoveToX(100f, DISAPPEAR_DURATION, Easing.InSine);
+                section.ButtonsContainer.MoveToX(100f, WaveContainer.DISAPPEAR_DURATION, Easing.InSine);
-                section.ButtonsContainer.FadeOut(DISAPPEAR_DURATION, Easing.InSine);
+                section.ButtonsContainer.FadeOut(WaveContainer.DISAPPEAR_DURATION, Easing.InSine);
             }
         }
 
@@ -128,14 +129,14 @@ namespace osu.Game.Overlays.Mods
         {
             base.PopIn();
 
-            footerContainer.MoveToX(0, APPEAR_DURATION, Easing.OutQuint);
+            footerContainer.MoveToX(0, WaveContainer.APPEAR_DURATION, Easing.OutQuint);
-            footerContainer.FadeIn(APPEAR_DURATION, Easing.OutQuint);
+            footerContainer.FadeIn(WaveContainer.APPEAR_DURATION, Easing.OutQuint);
 
             foreach (ModSection section in ModSectionsContainer.Children)
             {
-                section.ButtonsContainer.TransformSpacingTo(new Vector2(50f, 0f), APPEAR_DURATION, Easing.OutQuint);
+                section.ButtonsContainer.TransformSpacingTo(new Vector2(50f, 0f), WaveContainer.APPEAR_DURATION, Easing.OutQuint);
-                section.ButtonsContainer.MoveToX(0, APPEAR_DURATION, Easing.OutQuint);
+                section.ButtonsContainer.MoveToX(0, WaveContainer.APPEAR_DURATION, Easing.OutQuint);
-                section.ButtonsContainer.FadeIn(APPEAR_DURATION, Easing.OutQuint);
+                section.ButtonsContainer.FadeIn(WaveContainer.APPEAR_DURATION, Easing.OutQuint);
             }
         }
 
@@ -181,14 +182,12 @@ namespace osu.Game.Overlays.Mods
 
         public ModSelectOverlay()
         {
-            FirstWaveColour = OsuColour.FromHex(@"19b0e2");
+            Waves.FirstWaveColour = OsuColour.FromHex(@"19b0e2");
-            SecondWaveColour = OsuColour.FromHex(@"2280a2");
+            Waves.SecondWaveColour = OsuColour.FromHex(@"2280a2");
-            ThirdWaveColour = OsuColour.FromHex(@"005774");
+            Waves.ThirdWaveColour = OsuColour.FromHex(@"005774");
-            FourthWaveColour = OsuColour.FromHex(@"003a4e");
+            Waves.FourthWaveColour = OsuColour.FromHex(@"003a4e");
 
             Height = 510;
-            Content.RelativeSizeAxes = Axes.X;
-            Content.AutoSizeAxes = Axes.Y;
             Children = new Drawable[]
             {
                 new Container

osu.Game/Overlays/Profile/Header/BadgeContainer.cs

@@ -0,0 +1,195 @@
+// 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.Allocation;
+using osu.Framework.Graphics;
+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;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Users;
+using OpenTK;
+
+namespace osu.Game.Overlays.Profile.Header
+{
+    public class BadgeContainer : Container
+    {
+        private static readonly Vector2 badge_size = new Vector2(86, 40);
+        private static readonly MarginPadding outer_padding = new MarginPadding(3);
+
+        private OsuSpriteText badgeCountText;
+        private FillFlowContainer badgeFlowContainer;
+        private FillFlowContainer outerBadgeContainer;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Child = new Container
+            {
+                Masking = true,
+                CornerRadius = 4,
+                AutoSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colours.Gray3
+                    },
+                    outerBadgeContainer = new OuterBadgeContainer(onOuterHover, onOuterHoverLost)
+                    {
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                        Direction = FillDirection.Vertical,
+                        Padding = outer_padding,
+                        Width = DrawableBadge.DRAWABLE_BADGE_SIZE.X + outer_padding.TotalHorizontal,
+                        AutoSizeAxes = Axes.Y,
+                        Children = new Drawable[]
+                        {
+                            badgeCountText = new OsuSpriteText
+                            {
+                                Alpha = 0,
+                                TextSize = 12,
+                                Anchor = Anchor.BottomCentre,
+                                Origin = Anchor.BottomCentre,
+                                Font = "Exo2.0-Regular"
+                            },
+                            new Container
+                            {
+                                Anchor = Anchor.BottomLeft,
+                                Origin = Anchor.BottomLeft,
+                                AutoSizeAxes = Axes.Both,
+                                Child = badgeFlowContainer = new FillFlowContainer
+                                {
+                                    Direction = FillDirection.Horizontal,
+                                    AutoSizeAxes = Axes.Both,
+                                }
+                            }
+                        }
+                    },
+                }
+            };
+
+            Scheduler.AddDelayed(rotateBadges, 3000, true);
+        }
+
+        private void rotateBadges()
+        {
+            if (outerBadgeContainer.IsHovered) return;
+
+            visibleBadge = (visibleBadge + 1) % badgeCount;
+
+            badgeFlowContainer.MoveToX(-DrawableBadge.DRAWABLE_BADGE_SIZE.X * visibleBadge, 500, Easing.InOutQuad);
+        }
+
+        private int visibleBadge;
+        private int badgeCount;
+
+        public void ShowBadges(Badge[] badges)
+        {
+            switch (badges.Length)
+            {
+                case 0:
+                    Hide();
+                    return;
+                case 1:
+                    badgeCountText.Hide();
+                    break;
+                default:
+                    badgeCountText.Show();
+                    badgeCountText.Text = $"{badges.Length} badges";
+                    break;
+            }
+
+            Show();
+            badgeCount = badges.Length;
+            visibleBadge = 0;
+
+            badgeFlowContainer.Clear();
+            foreach (var badge in badges)
+            {
+                LoadComponentAsync(new DrawableBadge(badge)
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                }, badgeFlowContainer.Add);
+            }
+        }
+
+        private void onOuterHover()
+        {
+            badgeFlowContainer.ClearTransforms();
+            badgeFlowContainer.X = 0;
+            badgeFlowContainer.Direction = FillDirection.Full;
+            outerBadgeContainer.AutoSizeAxes = Axes.Both;
+
+            badgeFlowContainer.MaximumSize = new Vector2(ChildSize.X, float.MaxValue);
+        }
+
+        private void onOuterHoverLost()
+        {
+            badgeFlowContainer.X = -DrawableBadge.DRAWABLE_BADGE_SIZE.X * visibleBadge;
+            badgeFlowContainer.Direction = FillDirection.Horizontal;
+            outerBadgeContainer.AutoSizeAxes = Axes.Y;
+            outerBadgeContainer.Width = DrawableBadge.DRAWABLE_BADGE_SIZE.X + outer_padding.TotalHorizontal;
+        }
+
+        private class OuterBadgeContainer : FillFlowContainer
+        {
+            private readonly Action hoverAction;
+            private readonly Action hoverLostAction;
+
+            public OuterBadgeContainer(Action hoverAction, Action hoverLostAction)
+            {
+                this.hoverAction = hoverAction;
+                this.hoverLostAction = hoverLostAction;
+            }
+
+            protected override bool OnHover(InputState state)
+            {
+                hoverAction();
+                return true;
+            }
+
+            protected override void OnHoverLost(InputState state) => hoverLostAction();
+        }
+
+        private class DrawableBadge : Container, IHasTooltip
+        {
+            public static readonly Vector2 DRAWABLE_BADGE_SIZE = badge_size + outer_padding.Total;
+
+            private readonly Badge badge;
+
+            public DrawableBadge(Badge badge)
+            {
+                this.badge = badge;
+                Padding = outer_padding;
+                Size = DRAWABLE_BADGE_SIZE;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                Child = new Sprite
+                {
+                    FillMode = FillMode.Fit,
+                    RelativeSizeAxes = Axes.Both,
+                    Texture = textures.Get(badge.ImageUrl),
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                Child.FadeInFromZero(200);
+            }
+
+            public string TooltipText => badge.Description;
+        }
+    }
+}

osu.Game/Overlays/Profile/Header/RankGraph.cs

@@ -2,9 +2,10 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
-using OpenTK;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -14,10 +15,9 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Users;
-using System.Collections.Generic;
+using OpenTK;
-using osu.Framework.Configuration;
 
-namespace osu.Game.Overlays.Profile
+namespace osu.Game.Overlays.Profile.Header
 {
     public class RankGraph : Container
     {

osu.Game/Overlays/Profile/Header/SupporterIcon.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -9,8 +8,9 @@ using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
+using OpenTK;
 
-namespace osu.Game.Overlays.Profile
+namespace osu.Game.Overlays.Profile.Header
 {
     public class SupporterIcon : CircularContainer, IHasTooltip
     {

osu.Game/Overlays/Profile/ProfileHeader.cs

@@ -17,6 +17,7 @@ using osu.Framework.Graphics.Textures;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays.Profile.Header;
 using osu.Game.Users;
 
 namespace osu.Game.Overlays.Profile
@@ -35,6 +36,7 @@ namespace osu.Game.Overlays.Profile
         private readonly GradeBadge gradeSSPlus, gradeSS, gradeSPlus, gradeS, gradeA;
         private readonly Box colourBar;
         private readonly DrawableFlag countryFlag;
+        private readonly BadgeContainer badgeContainer;
 
         private const float cover_height = 350;
         private const float info_height = 150;
@@ -42,6 +44,7 @@ namespace osu.Game.Overlays.Profile
         private const float avatar_size = 110;
         private const float level_position = 30;
         private const float level_height = 60;
+        private const float stats_width = 280;
 
         public ProfileHeader(User user)
         {
@@ -66,9 +69,9 @@ namespace osu.Game.Overlays.Profile
                         {
                             Anchor = Anchor.BottomLeft,
                             Origin = Anchor.BottomLeft,
-                            X = UserProfileOverlay.CONTENT_X_MARGIN,
+                            Padding = new MarginPadding { Left = UserProfileOverlay.CONTENT_X_MARGIN, Bottom = 20, Right = stats_width + UserProfileOverlay.CONTENT_X_MARGIN },
-                            Y = -20,
+                            AutoSizeAxes = Axes.Y,
-                            AutoSizeAxes = Axes.Both,
+                            RelativeSizeAxes = Axes.X,
                             Children = new Drawable[]
                             {
                                 new UpdateableAvatar
@@ -116,7 +119,15 @@ namespace osu.Game.Overlays.Profile
                                             Height = 20
                                         }
                                     }
-                                }
+                                },
+                                badgeContainer = new BadgeContainer
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Origin = Anchor.BottomLeft,
+                                    Margin = new MarginPadding { Bottom = 5 },
+                                    Alpha = 0,
+                                },
                             }
                         },
                         colourBar = new Box
@@ -156,7 +167,7 @@ namespace osu.Game.Overlays.Profile
                 {
                     X = -UserProfileOverlay.CONTENT_X_MARGIN,
                     RelativeSizeAxes = Axes.Y,
-                    Width = 280,
+                    Width = stats_width,
                     Anchor = Anchor.TopRight,
                     Origin = Anchor.TopRight,
                     Children = new Drawable[]
@@ -417,6 +428,8 @@ namespace osu.Game.Overlays.Profile
 
                 rankGraph.User.Value = user;
             }
+
+            badgeContainer.ShowBadges(user.Badges);
         }
 
         private void tryAddInfoRightLine(FontAwesome icon, string str, string url = null)

osu.Game/Overlays/Profile/Sections/Beatmaps/PaginatedBeatmapContainer.cs

@@ -1,6 +1,7 @@
 // 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 OpenTK;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
@@ -19,6 +20,8 @@ namespace osu.Game.Overlays.Profile.Sections.Beatmaps
 
         private DirectPanel currentlyPlaying;
 
+        public event Action<PaginatedBeatmapContainer> BeganPlayingPreview;
+
         public PaginatedBeatmapContainer(BeatmapSetType type, Bindable<User> user, string header, string missing = "None... yet.")
             : base(user, header, missing)
         {
@@ -56,17 +59,25 @@ namespace osu.Game.Overlays.Profile.Sections.Beatmaps
 
                     panel.PreviewPlaying.ValueChanged += isPlaying =>
                     {
-                        if (!isPlaying) return;
+                        StopPlayingPreview();
 
-                        if (currentlyPlaying != null && currentlyPlaying != panel)
+                        if (isPlaying)
-                            currentlyPlaying.PreviewPlaying.Value = false;
+                        {
-
+                            BeganPlayingPreview?.Invoke(this);
-                        currentlyPlaying = panel;
+                            currentlyPlaying = panel;
+                        }
                     };
                 }
             };
 
             Api.Queue(req);
         }
+
+        public void StopPlayingPreview()
+        {
+            if (currentlyPlaying == null) return;
+            currentlyPlaying.PreviewPlaying.Value = false;
+            currentlyPlaying = null;
+        }
     }
 }

osu.Game/Overlays/Profile/Sections/BeatmapsSection.cs

@@ -1,6 +1,7 @@
 // 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.Linq;
 using osu.Game.Online.API.Requests;
 using osu.Game.Overlays.Profile.Sections.Beatmaps;
 
@@ -21,6 +22,15 @@ namespace osu.Game.Overlays.Profile.Sections
                 new PaginatedBeatmapContainer(BeatmapSetType.Unranked, User, "Pending Beatmaps"),
                 new PaginatedBeatmapContainer(BeatmapSetType.Graveyard, User, "Graveyarded Beatmaps"),
             };
+
+            foreach (var paginatedBeatmapContainer in Children.OfType<PaginatedBeatmapContainer>())
+            {
+                paginatedBeatmapContainer.BeganPlayingPreview += _ =>
+                {
+                    foreach (var bc in Children.OfType<PaginatedBeatmapContainer>())
+                        bc.StopPlayingPreview();
+                };
+            }
         }
     }
 }

osu.Game/Overlays/Settings/Sections/Graphics/DetailSettings.cs

@@ -30,6 +30,11 @@ namespace osu.Game.Overlays.Settings.Sections.Graphics
                 {
                     LabelText = "Screenshot format",
                     Bindable = config.GetBindable<ScreenshotFormat>(OsuSetting.ScreenshotFormat)
+                },
+                new SettingsCheckbox
+                {
+                    LabelText = "Show menu cursor in screenshots",
+                    Bindable = config.GetBindable<bool>(OsuSetting.ScreenshotCaptureMenuCursor)
                 }
             };
         }

osu.Game/Overlays/SocialOverlay.cs

@@ -48,10 +48,10 @@ namespace osu.Game.Overlays
 
         public SocialOverlay()
         {
-            FirstWaveColour = OsuColour.FromHex(@"cb5fa0");
+            Waves.FirstWaveColour = OsuColour.FromHex(@"cb5fa0");
-            SecondWaveColour = OsuColour.FromHex(@"b04384");
+            Waves.SecondWaveColour = OsuColour.FromHex(@"b04384");
-            ThirdWaveColour = OsuColour.FromHex(@"9b2b6e");
+            Waves.ThirdWaveColour = OsuColour.FromHex(@"9b2b6e");
-            FourthWaveColour = OsuColour.FromHex(@"6d214d");
+            Waves.FourthWaveColour = OsuColour.FromHex(@"6d214d");
 
             Add(loading = new LoadingAnimation());
 

osu.Game/Overlays/UserProfileOverlay.cs

@@ -35,10 +35,10 @@ namespace osu.Game.Overlays
 
         public UserProfileOverlay()
         {
-            FirstWaveColour = OsuColour.Gray(0.4f);
+            Waves.FirstWaveColour = OsuColour.Gray(0.4f);
-            SecondWaveColour = OsuColour.Gray(0.3f);
+            Waves.SecondWaveColour = OsuColour.Gray(0.3f);
-            ThirdWaveColour = OsuColour.Gray(0.2f);
+            Waves.ThirdWaveColour = OsuColour.Gray(0.2f);
-            FourthWaveColour = OsuColour.Gray(0.1f);
+            Waves.FourthWaveColour = OsuColour.Gray(0.1f);
 
             RelativeSizeAxes = Axes.Both;
             RelativePositionAxes = Axes.Both;
@@ -64,13 +64,13 @@ namespace osu.Game.Overlays
         protected override void PopIn()
         {
             base.PopIn();
-            FadeEdgeEffectTo(0.5f, APPEAR_DURATION, Easing.In);
+            FadeEdgeEffectTo(0.5f, WaveContainer.APPEAR_DURATION, Easing.In);
         }
 
         protected override void PopOut()
         {
             base.PopOut();
-            FadeEdgeEffectTo(0, DISAPPEAR_DURATION, Easing.Out);
+            FadeEdgeEffectTo(0, WaveContainer.DISAPPEAR_DURATION, Easing.Out);
         }
 
         public void ShowUser(long userId)

osu.Game/Overlays/WaveOverlayContainer.cs

@@ -1,203 +1,37 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Graphics;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics;
-using System;
-using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Overlays
 {
     public abstract class WaveOverlayContainer : OsuFocusedOverlayContainer
     {
-        protected const float APPEAR_DURATION = 800;
+        protected readonly WaveContainer Waves;
-        protected const float DISAPPEAR_DURATION = 500;
-
-        private const Easing easing_show = Easing.OutSine;
-        private const Easing easing_hide = Easing.InSine;
-
-        private readonly Wave firstWave;
-        private readonly Wave secondWave;
-        private readonly Wave thirdWave;
-        private readonly Wave fourthWave;
-
-        private readonly Container<Wave> wavesContainer;
-
-        private readonly Container contentContainer;
 
         protected override bool BlockPassThroughKeyboard => true;
-
+        protected override Container<Drawable> Content => Waves;
-        protected override Container<Drawable> Content => contentContainer;
-
-        protected Color4 FirstWaveColour
-        {
-            get
-            {
-                return firstWave.Colour;
-            }
-            set
-            {
-                if (firstWave.Colour == value) return;
-                firstWave.Colour = value;
-            }
-        }
-
-        protected Color4 SecondWaveColour
-        {
-            get
-            {
-                return secondWave.Colour;
-            }
-            set
-            {
-                if (secondWave.Colour == value) return;
-                secondWave.Colour = value;
-            }
-        }
-
-        protected Color4 ThirdWaveColour
-        {
-            get
-            {
-                return thirdWave.Colour;
-            }
-            set
-            {
-                if (thirdWave.Colour == value) return;
-                thirdWave.Colour = value;
-            }
-        }
-
-        protected Color4 FourthWaveColour
-        {
-            get
-            {
-                return fourthWave.Colour;
-            }
-            set
-            {
-                if (fourthWave.Colour == value) return;
-                fourthWave.Colour = value;
-            }
-        }
 
         protected WaveOverlayContainer()
         {
-            Masking = true;
+            AddInternal(Waves = new WaveContainer
-
-            AddInternal(wavesContainer = new Container<Wave>
-            {
-                RelativeSizeAxes = Axes.X,
-                Origin = Anchor.TopCentre,
-                Anchor = Anchor.TopCentre,
-                Masking = true,
-                Children = new[]
-                {
-                    firstWave = new Wave
-                    {
-                        Rotation = 13,
-                        FinalPosition = -930,
-                    },
-                    secondWave = new Wave
-                    {
-                        Origin = Anchor.TopRight,
-                        Anchor = Anchor.TopRight,
-                        Rotation = -7,
-                        FinalPosition = -560,
-                    },
-                    thirdWave = new Wave
-                    {
-                        Rotation = 4,
-                        FinalPosition = -390,
-                    },
-                    fourthWave = new Wave
-                    {
-                        Origin = Anchor.TopRight,
-                        Anchor = Anchor.TopRight,
-                        Rotation = -2,
-                        FinalPosition = -220,
-                    },
-                },
-            });
-
-            AddInternal(contentContainer = new Container
             {
                 RelativeSizeAxes = Axes.Both,
-                Anchor = Anchor.BottomCentre,
-                Origin = Anchor.BottomCentre,
             });
         }
 
         protected override void PopIn()
         {
             base.PopIn();
-
+            Waves.Show();
-            foreach (var w in wavesContainer.Children)
-                w.State = Visibility.Visible;
-
-            this.FadeIn(100, Easing.OutQuint);
-            contentContainer.MoveToY(0, APPEAR_DURATION, Easing.OutQuint);
-
-            this.FadeIn(100, Easing.OutQuint);
         }
 
         protected override void PopOut()
         {
             base.PopOut();
-
+            Waves.Hide();
-            this.FadeOut(DISAPPEAR_DURATION, Easing.InQuint);
-            contentContainer.MoveToY(DrawHeight * 2f, DISAPPEAR_DURATION, Easing.In);
-
-            foreach (var w in wavesContainer.Children)
-                w.State = Visibility.Hidden;
-
-            this.FadeOut(DISAPPEAR_DURATION, Easing.InQuint);
-        }
-
-        protected override void UpdateAfterChildren()
-        {
-            base.UpdateAfterChildren();
-
-            // This is done as an optimization, such that invisible parts of the waves
-            // are masked away, and thus do not consume fill rate.
-            wavesContainer.Height = Math.Max(0, DrawHeight - (contentContainer.DrawHeight - contentContainer.Y));
-        }
-
-        private class Wave : VisibilityContainer
-        {
-            public float FinalPosition;
-
-            protected override bool StartHidden => true;
-
-            public Wave()
-            {
-                RelativeSizeAxes = Axes.X;
-                Width = 1.5f;
-                Masking = true;
-                EdgeEffect = new EdgeEffectParameters
-                {
-                    Type = EdgeEffectType.Shadow,
-                    Colour = Color4.Black.Opacity(50),
-                    Radius = 20f,
-                };
-
-                Child = new Box { RelativeSizeAxes = Axes.Both };
-            }
-
-            protected override void Update()
-            {
-                base.Update();
-
-                // We can not use RelativeSizeAxes for Height, because the height
-                // of our parent diminishes as the content moves up.
-                Height = Parent.Parent.DrawSize.Y * 1.5f;
-            }
-
-            protected override void PopIn() => this.MoveToY(FinalPosition, APPEAR_DURATION, easing_show);
-            protected override void PopOut() => this.MoveToY(Parent.Parent.DrawSize.Y, DISAPPEAR_DURATION, easing_hide);
         }
     }
 }

osu.Game/Screens/Menu/Button.cs

@@ -222,7 +222,7 @@ namespace osu.Game.Screens.Menu
             boxHoverLayer.FadeOut(800, Easing.OutExpo);
         }
 
-        public override bool HandleKeyboardInput => state != ButtonState.Exploded;
+        public override bool HandleKeyboardInput => state == ButtonState.Expanded;
         public override bool HandleMouseInput => state != ButtonState.Exploded && box.Scale.X >= 0.8f;
 
         protected override void Update()

osu.Game/Users/Badge.cs

@@ -0,0 +1,20 @@
+// 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 Newtonsoft.Json;
+
+namespace osu.Game.Users
+{
+    public class Badge
+    {
+        [JsonProperty("awarded_at")]
+        public DateTimeOffset AwardedAt;
+
+        [JsonProperty("description")]
+        public string Description;
+
+        [JsonProperty("image_url")]
+        public string ImageUrl;
+    }
+}

osu.Game/Users/User.cs

@@ -137,6 +137,9 @@ namespace osu.Game.Users
         [JsonProperty(@"rankHistory")]
         public RankHistoryData RankHistory;
 
+        [JsonProperty("badges")]
+        public Badge[] Badges;
+
         public override string ToString() => Username;
     }
 }

osu.Game/Users/UserPanel.cs

@@ -17,7 +17,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
 using osu.Framework.Graphics.Cursor;
 using osu.Game.Graphics.Containers;
-using osu.Game.Overlays.Profile;
+using osu.Game.Overlays.Profile.Header;
 
 namespace osu.Game.Users
 {