Merge branch 'master' into drawable-room-update

osu-framework

@@ -1 +1 @@
-Subproject commit 46a56e0e11d56c788ff8db089582718a606ed158
+Subproject commit 428cb7fcadfdc6656ec4b0398ecfe2820e2e1bdb

osu.Desktop.VisualTests/Tests/TestCaseBeatSyncedContainer.cs

@@ -198,7 +198,7 @@ namespace osu.Desktop.VisualTests.Tests
                 AutoSizeAxes = Axes.Both;
                 Direction = FillDirection.Horizontal;
                 Add(new OsuSpriteText { Text = header + @": ", TextSize = text_size });
-                Add(valueText = new OsuSpriteText() { TextSize = text_size });
+                Add(valueText = new OsuSpriteText { TextSize = text_size });
                 Margin = new MarginPadding(margin);
             }
         }

osu.Desktop.VisualTests/Tests/TestCaseMedalOverlay.cs

@@ -0,0 +1,27 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Testing;
+using osu.Game.Overlays;
+using osu.Game.Users;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseMedalOverlay : TestCase
+    {
+        public override string Description => @"medal get!";
+
+        public TestCaseMedalOverlay()
+        {
+            AddStep(@"display", () =>
+            {
+                LoadComponentAsync(new MedalOverlay(new Medal
+                {
+                    Name = @"Animations",
+                    InternalName = @"all-intro-doubletime",
+                    Description = @"More complex than you think.",
+                }), Add);
+            });
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/TestCaseResults.cs

@@ -46,7 +46,7 @@ namespace osu.Desktop.VisualTests.Tests
                 MaxCombo = 123,
                 Rank = ScoreRank.A,
                 Date = DateTimeOffset.Now,
-                Statistics = new Dictionary<string, dynamic>()
+                Statistics = new Dictionary<string, dynamic>
                 {
                     { "300", 50 },
                     { "100", 20 },

osu.Desktop.VisualTests/osu.Desktop.VisualTests.csproj

@@ -231,6 +231,7 @@
     <Compile Include="Tests\TestCaseDirect.cs" />
     <Compile Include="Tests\TestCaseSocial.cs" />
     <Compile Include="Tests\TestCaseBreadcrumbs.cs" />
+    <Compile Include="Tests\TestCaseMedalOverlay.cs" />
     <Compile Include="Tests\TestCaseRoomInspector.cs" />
   </ItemGroup>
   <ItemGroup />

osu.Desktop/OsuGameDesktop.cs

@@ -50,7 +50,7 @@ namespace osu.Desktop
             {
                 desktopWindow.CursorState |= CursorState.Hidden;
 
-                desktopWindow.Icon = Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location);
+                desktopWindow.Icon = new Icon(Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico"));
                 desktopWindow.Title = Name;
 
                 desktopWindow.DragEnter += dragEnter;

osu.Desktop/Overlays/VersionManager.cs

@@ -186,7 +186,7 @@ namespace osu.Desktop.Overlays
         {
             private OsuGame game;
 
-            protected override Notification CreateCompletionNotification() => new ProgressCompletionNotification()
+            protected override Notification CreateCompletionNotification() => new ProgressCompletionNotification
             {
                 Text = @"Update ready to install. Click to restart!",
                 Activated = () =>

osu.Desktop/osu.Desktop.csproj

@@ -232,7 +232,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Content Include="lazer.ico" />
+    <EmbeddedResource Include="lazer.ico" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -15,6 +15,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Rulesets.Osu
 {
@@ -119,6 +120,8 @@ namespace osu.Game.Rulesets.Osu
 
         public override ScoreProcessor CreateScoreProcessor() => new OsuScoreProcessor();
 
+        public override SettingsSubsection CreateSettings() => new OsuSettings();
+
         public override int LegacyID => 0;
     }
 }

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

@@ -0,0 +1,33 @@
+// Copyright (c) 2007-2017 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.Graphics;
+using osu.Game.Configuration;
+using osu.Game.Overlays.Settings;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public class OsuSettings : SettingsSubsection
+    {
+        protected override string Header => "osu!";
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            Children = new Drawable[]
+            {
+                new SettingsCheckbox
+                {
+                    LabelText = "Snaking in sliders",
+                    Bindable = config.GetBindable<bool>(OsuSetting.SnakingInSliders)
+                },
+                new SettingsCheckbox
+                {
+                    LabelText = "Snaking out sliders",
+                    Bindable = config.GetBindable<bool>(OsuSetting.SnakingOutSliders)
+                },
+            };
+        }
+    }
+}

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

@@ -78,6 +78,7 @@
     <Compile Include="OsuDifficulty\Skills\Speed.cs" />
     <Compile Include="OsuDifficulty\Utils\History.cs" />
     <Compile Include="OsuKeyConversionInputManager.cs" />
+    <Compile Include="UI\OsuSettings.cs" />
     <Compile Include="Scoring\OsuScoreProcessor.cs" />
     <Compile Include="UI\OsuHitRenderer.cs" />
     <Compile Include="UI\OsuPlayfield.cs" />

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -91,7 +91,7 @@ namespace osu.Game.Beatmaps.ControlPoints
             if (time < list[0].Time)
                 return prePoint ?? new T();
 
-            int index = list.BinarySearch(new T() { Time = time });
+            int index = list.BinarySearch(new T { Time = time });
 
             // Check if we've found an exact match (t == time)
             if (index >= 0)

osu.Game/Graphics/Containers/SectionsContainer.cs

@@ -114,7 +114,7 @@ namespace osu.Game.Graphics.Containers
 
         public SectionsContainer()
         {
-            Add(ScrollContainer = new ScrollContainer()
+            Add(ScrollContainer = new ScrollContainer
             {
                 RelativeSizeAxes = Axes.Both,
                 Masking = false,

osu.Game/Overlays/Direct/FilterControl.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Overlays.Direct
         {
             DisplayStyleControl.Dropdown.AccentColour = colours.BlueDark;
 
-            Ruleset.BindTo(game?.Ruleset ?? new Bindable<RulesetInfo>() { Value = rulesets.GetRuleset(0) });
+            Ruleset.BindTo(game?.Ruleset ?? new Bindable<RulesetInfo> { Value = rulesets.GetRuleset(0) });
             foreach (var r in rulesets.AllRulesets)
             {
                 modeButtons.Add(new RulesetToggleButton(Ruleset, r));

osu.Game/Overlays/MedalOverlay.cs

@@ -0,0 +1,304 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Users;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Overlays.MedalSplash;
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Audio;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Input;
+using OpenTK.Input;
+using System.Linq;
+using osu.Framework.Graphics.Shapes;
+using System;
+using osu.Framework.MathUtils;
+
+namespace osu.Game.Overlays
+{
+    public class MedalOverlay : FocusedOverlayContainer
+    {
+        public const float DISC_SIZE = 400;
+
+        private const float border_width = 5;
+
+        private readonly Medal medal;
+        private readonly Box background;
+        private readonly Container backgroundStrip, particleContainer;
+        private readonly BackgroundStrip leftStrip, rightStrip;
+        private readonly CircularContainer disc;
+        private readonly Sprite innerSpin, outerSpin;
+        private DrawableMedal drawableMedal;
+
+        private SampleChannel getSample;
+
+        public MedalOverlay(Medal medal)
+        {
+            this.medal = medal;
+            RelativeSizeAxes = Axes.Both;
+
+            Children = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Black.Opacity(60),
+                },
+                outerSpin = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(DISC_SIZE + 500),
+                    Alpha = 0f,
+                },
+                backgroundStrip = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = border_width,
+                    Alpha = 0f,
+                    Children = new[]
+                    {
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.CentreRight,
+                            Width = 0.5f,
+                            Padding = new MarginPadding { Right = DISC_SIZE / 2 },
+                            Children = new[]
+                            {
+                                leftStrip = new BackgroundStrip(0f, 1f)
+                                {
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                },
+                            },
+                        },
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.CentreLeft,
+                            Width = 0.5f,
+                            Padding = new MarginPadding { Left = DISC_SIZE / 2 },
+                            Children = new[]
+                            {
+                                rightStrip = new BackgroundStrip(1f, 0f),
+                            },
+                        },
+                    },
+                },
+                particleContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0f,
+                },
+                disc = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Alpha = 0f,
+                    Masking = true,
+                    AlwaysPresent = true,
+                    BorderColour = Color4.White,
+                    BorderThickness = border_width,
+                    Size = new Vector2(DISC_SIZE),
+                    Scale = new Vector2(0.8f),
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = OsuColour.FromHex(@"05262f"),
+                        },
+                        new Triangles
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            TriangleScale = 2,
+                            ColourDark = OsuColour.FromHex(@"04222b"),
+                            ColourLight = OsuColour.FromHex(@"052933"),
+                        },
+                        innerSpin = new Sprite
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Size = new Vector2(1.05f),
+                            Alpha = 0.25f,
+                        },
+                    },
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, TextureStore textures, AudioManager audio)
+        {
+            getSample = audio.Sample.Get(@"MedalSplash/medal-get");
+            innerSpin.Texture = outerSpin.Texture = textures.Get(@"MedalSplash/disc-spin");
+
+            disc.EdgeEffect = leftStrip.EdgeEffect = rightStrip.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = colours.Blue.Opacity(0.5f),
+                Radius = 50,
+            };
+
+            disc.Add(drawableMedal = new DrawableMedal(medal)
+            {
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+                RelativeSizeAxes = Axes.X,
+            });
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Show();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            particleContainer.Add(new MedalParticle(RNG.Next(0, 359)));
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            dismiss();
+            return true;
+        }
+
+        protected override void OnFocusLost(InputState state)
+        {
+            if (state.Keyboard.Keys.Contains(Key.Escape)) dismiss();
+        }
+
+        private const double initial_duration = 400;
+        private const double step_duration = 900;
+
+        protected override void PopIn()
+        {
+            base.PopIn();
+
+            FadeIn(200);
+            background.FlashColour(Color4.White.Opacity(0.25f), 400);
+
+            getSample.Play();
+
+            using (innerSpin.BeginLoopedSequence())
+                innerSpin.RotateTo(360, 20000);
+
+            using (outerSpin.BeginLoopedSequence())
+                outerSpin.RotateTo(360, 40000);
+
+            using (BeginDelayedSequence(200, true))
+            {
+                disc.FadeIn(initial_duration);
+                particleContainer.FadeIn(initial_duration);
+                outerSpin.FadeTo(0.1f, initial_duration * 2);
+                disc.ScaleTo(1f, initial_duration * 2, EasingTypes.OutElastic);
+
+                using (BeginDelayedSequence(initial_duration + 200, true))
+                {
+                    backgroundStrip.FadeIn(step_duration);
+                    leftStrip.ResizeWidthTo(1f, step_duration, EasingTypes.OutQuint);
+                    rightStrip.ResizeWidthTo(1f, step_duration, EasingTypes.OutQuint);
+                    Schedule(() => { if (drawableMedal.State != DisplayState.Full) drawableMedal.State = DisplayState.Icon; });
+
+                    using (BeginDelayedSequence(step_duration, true))
+                    {
+                        Schedule(() => { if (drawableMedal.State != DisplayState.Full) drawableMedal.State = DisplayState.MedalUnlocked; });
+
+                        using (BeginDelayedSequence(step_duration, true))
+                            Schedule(() => { if (drawableMedal.State != DisplayState.Full) drawableMedal.State = DisplayState.Full; });
+                    }
+                }
+            }
+        }
+
+        protected override void PopOut()
+        {
+            base.PopOut();
+            FadeOut(200);
+        }
+
+        private void dismiss()
+        {
+            if (drawableMedal.State != DisplayState.Full)
+            {
+                // if we haven't yet, play out the animation fully
+                drawableMedal.State = DisplayState.Full;
+                Flush(true);
+                return;
+            }
+
+            Hide();
+            Expire();
+        }
+
+        private class BackgroundStrip : Container
+        {
+            public BackgroundStrip(float start, float end)
+            {
+                RelativeSizeAxes = Axes.Both;
+                Width = 0f;
+                ColourInfo = ColourInfo.GradientHorizontal(Color4.White.Opacity(start), Color4.White.Opacity(end));
+                Masking = true;
+
+                Children = new[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.White,
+                    }
+                };
+            }
+        }
+
+        private class MedalParticle : CircularContainer
+        {
+            private readonly float direction;
+
+            private Vector2 positionForOffset(float offset) => new Vector2((float)(offset * Math.Sin(direction)), (float)(offset * Math.Cos(direction)));
+
+            public MedalParticle(float direction)
+            {
+                this.direction = direction;
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+                Position = positionForOffset(DISC_SIZE / 2);
+                Masking = true;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                EdgeEffect = new EdgeEffectParameters
+                {
+                    Type = EdgeEffectType.Glow,
+                    Colour = colours.Blue.Opacity(0.5f),
+                    Radius = 5,
+                };
+
+                MoveTo(positionForOffset(DISC_SIZE / 2 + 200), 500);
+                FadeOut(500);
+                Expire();
+            }
+        }
+    }
+}

osu.Game/Overlays/MedalSplash/DrawableMedal.cs

@@ -0,0 +1,183 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework;
+using OpenTK;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Users;
+
+namespace osu.Game.Overlays.MedalSplash
+{
+    public class DrawableMedal : Container, IStateful<DisplayState>
+    {
+        private const float scale_when_unlocked = 0.76f;
+        private const float scale_when_full = 0.6f;
+
+        private readonly Medal medal;
+        private readonly Container medalContainer;
+        private readonly Sprite medalSprite, medalGlow;
+        private readonly OsuSpriteText unlocked, name;
+        private readonly TextFlowContainer description;
+        private readonly FillFlowContainer infoFlow;
+        private DisplayState state;
+        public DrawableMedal(Medal medal)
+        {
+            this.medal = medal;
+            Position = new Vector2(0f, MedalOverlay.DISC_SIZE / 2);
+
+            Children = new Drawable[]
+            {
+                medalContainer = new Container
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.Centre,
+                    AutoSizeAxes = Axes.Both,
+                    Alpha = 0f,
+                    Children = new Drawable[]
+                    {
+                        medalSprite = new Sprite
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Scale = new Vector2(0.81f),
+                        },
+                        medalGlow = new Sprite
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                    },
+                },
+                unlocked = new OsuSpriteText
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    Text = "Medal Unlocked".ToUpper(),
+                    TextSize = 24,
+                    Font = @"Exo2.0-Light",
+                    Alpha = 0f,
+                    Scale = new Vector2(1f / scale_when_unlocked),
+                },
+                infoFlow = new FillFlowContainer
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Width = 0.6f,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(0f, 5f),
+                    Children = new Drawable[]
+                    {
+                        name = new OsuSpriteText
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            Text = medal.Name,
+                            TextSize = 20,
+                            Font = @"Exo2.0-Bold",
+                            Alpha = 0f,
+                            Scale = new Vector2(1f / scale_when_full),
+                        },
+                        description = new TextFlowContainer
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Alpha = 0f,
+                            Scale = new Vector2(1f / scale_when_full),
+                        },
+                    },
+                },
+            };
+
+            description.AddText(medal.Description, s =>
+            {
+                s.Anchor = Anchor.TopCentre;
+                s.Origin = Anchor.TopCentre;
+                s.TextSize = 16;
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, TextureStore textures)
+        {
+            medalSprite.Texture = textures.Get(medal.ImageUrl);
+            medalGlow.Texture = textures.Get(@"MedalSplash/medal-glow");
+            description.Colour = colours.BlueLight;
+
+            unlocked.Position = new Vector2(0f, medalContainer.Size.Y / 2 + 10);
+            infoFlow.Position = new Vector2(0f, unlocked.Position.Y + 90);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateState();
+        }
+
+        public DisplayState State
+        {
+            get { return state; }
+            set
+            {
+                if (state == value) return;
+
+                state = value;
+                updateState();
+            }
+        }
+
+        private void updateState()
+        {
+            if (!IsLoaded) return;
+
+            const double duration = 900;
+
+            switch (state)
+            {
+                case DisplayState.None:
+                    medalContainer.ScaleTo(0);
+                    break;
+                case DisplayState.Icon:
+                    medalContainer.ScaleTo(1, duration, EasingTypes.OutElastic);
+                    medalContainer.FadeIn(duration);
+                    break;
+                case DisplayState.MedalUnlocked:
+                    medalContainer.ScaleTo(1);
+                    medalContainer.Show();
+
+                    ScaleTo(scale_when_unlocked, duration, EasingTypes.OutExpo);
+                    MoveToY(MedalOverlay.DISC_SIZE / 2 - 30, duration, EasingTypes.OutExpo);
+                    unlocked.FadeInFromZero(duration);
+                    break;
+                case DisplayState.Full:
+                    medalContainer.ScaleTo(1);
+                    medalContainer.Show();
+
+                    ScaleTo(scale_when_full, duration, EasingTypes.OutExpo);
+                    MoveToY(MedalOverlay.DISC_SIZE / 2 - 60, duration, EasingTypes.OutExpo);
+                    name.FadeInFromZero(duration + 100);
+                    description.FadeInFromZero(duration * 2);
+                    break;
+            }
+
+
+        }
+    }
+
+    public enum DisplayState
+    {
+        None,
+        Icon,
+        MedalUnlocked,
+        Full,
+    }
+}

osu.Game/Overlays/Notifications/ProgressNotification.cs

@@ -90,7 +90,7 @@ namespace osu.Game.Overlays.Notifications
 
         private ProgressNotificationState state;
 
-        protected virtual Notification CreateCompletionNotification() => new ProgressCompletionNotification()
+        protected virtual Notification CreateCompletionNotification() => new ProgressCompletionNotification
         {
             Activated = CompletionClickAction,
             Text = $"Task \"{Text}\" has completed!"

osu.Game/Overlays/Settings/Sections/GameplaySection.cs

@@ -1,9 +1,13 @@
 // Copyright (c) 2007-2017 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.Graphics;
+using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Overlays.Settings.Sections.Gameplay;
+using osu.Game.Rulesets;
+using System.Linq;
 
 namespace osu.Game.Overlays.Settings.Sections
 {
@@ -20,5 +24,16 @@ namespace osu.Game.Overlays.Settings.Sections
                 new SongSelectSettings(),
             };
         }
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetDatabase rulesets)
+        {
+            foreach(Ruleset ruleset in rulesets.AllRulesets.Select(info => info.CreateInstance()))
+            {
+                SettingsSubsection section = ruleset.CreateSettings();
+                if (section != null)
+                    Add(section);
+            }
+        }
     }
 }

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

@@ -1,32 +1,10 @@
 // Copyright (c) 2007-2017 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.Graphics;
-using osu.Game.Configuration;
-
 namespace osu.Game.Overlays.Settings.Sections.Graphics
 {
     public class DetailSettings : SettingsSubsection
     {
         protected override string Header => "Detail Settings";
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            Children = new Drawable[]
-            {
-                new SettingsCheckbox
-                {
-                    LabelText = "Snaking in sliders",
-                    Bindable = config.GetBindable<bool>(OsuSetting.SnakingInSliders)
-                },
-                new SettingsCheckbox
-                {
-                    LabelText = "Snaking out sliders",
-                    Bindable = config.GetBindable<bool>(OsuSetting.SnakingOutSliders)
-                },
-            };
-        }
     }
 }

osu.Game/Overlays/Settings/SettingsItem.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Overlays.Settings
                 if (text == null)
                 {
                     // construct lazily for cases where the label is not needed (may be provided by the Control).
-                    Add(text = new OsuSpriteText() { Depth = 1 });
+                    Add(text = new OsuSpriteText { Depth = 1 });
                 }
 
                 text.Text = value;

osu.Game/Overlays/Settings/SettingsSlider.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Overlays.Settings
         where T : struct, IEquatable<T>
         where U : SliderBar<T>, new()
     {
-        protected override Drawable CreateControl() => new U()
+        protected override Drawable CreateControl() => new U
         {
             Margin = new MarginPadding { Top = 5, Bottom = 5 },
             RelativeSizeAxes = Axes.X

osu.Game/Rulesets/Ruleset.cs

@@ -8,6 +8,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Play;
 using System.Collections.Generic;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Rulesets
 {
@@ -36,6 +37,8 @@ namespace osu.Game.Rulesets
 
         public abstract IEnumerable<KeyCounter> CreateGameplayKeys();
 
+        public virtual SettingsSubsection CreateSettings() => null;
+
         /// <summary>
         /// Do not override this unless you are a legacy mode.
         /// </summary>

osu.Game/Screens/Play/ReplaySettings/PlaybackSettings.cs

@@ -16,7 +16,7 @@ namespace osu.Game.Screens.Play.ReplaySettings
         {
             Children = new Drawable[]
             {
-                new ReplaySliderBar<double>()
+                new ReplaySliderBar<double>
                 {
                     LabelText = "Playback speed",
                     Bindable = config.GetBindable<double>(OsuSetting.PlaybackSpeed)

osu.Game/Screens/Play/ReplaySettings/ReplaySliderBar.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Screens.Play.ReplaySettings
     public class ReplaySliderBar<T> : SettingsSlider<T>
         where T : struct, IEquatable<T>
     {
-        protected override Drawable CreateControl() => new Sliderbar()
+        protected override Drawable CreateControl() => new Sliderbar
         {
             Margin = new MarginPadding { Top = 5, Bottom = 5 },
             RelativeSizeAxes = Axes.X

osu.Game/Screens/Play/SkipButton.cs

@@ -277,9 +277,19 @@ namespace osu.Game.Screens.Play
 
             protected override bool OnClick(InputState state)
             {
+                if (!Enabled)
+                    return false;
+
                 box.FlashColour(Color4.White, 500, EasingTypes.OutQuint);
                 aspect.ScaleTo(1.2f, 2000, EasingTypes.OutQuint);
-                return base.OnClick(state);
+
+                bool result = base.OnClick(state);
+
+                // for now, let's disable the skip button after the first press.
+                // this will likely need to be contextual in the future (bound from external components).
+                Enabled.Value = false;
+
+                return result;
             }
         }
     }

osu.Game/Screens/Select/BeatmapDetails.cs

@@ -160,7 +160,7 @@ namespace osu.Game.Screens.Select
                     Colour = Color4.Black,
                     Alpha = 0.5f,
                 },
-                new FillFlowContainer<MetadataSegment>()
+                new FillFlowContainer<MetadataSegment>
                 {
                     Anchor = Anchor.TopRight,
                     Origin = Anchor.TopRight,

osu.Game/Screens/Select/FilterControl.cs

@@ -128,7 +128,7 @@ namespace osu.Game.Screens.Select
                                 //        Bottom = 5
                                 //    },
                                 //},
-                                sortTabs = new OsuTabControl<SortMode>()
+                                sortTabs = new OsuTabControl<SortMode>
                                 {
                                     RelativeSizeAxes = Axes.X,
                                     Width = 0.5f,

osu.Game/Users/Medal.cs

@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Users
+{
+    public class Medal
+    {
+        public string Name { get; set; }
+        public string InternalName { get; set; }
+        public string ImageUrl => $@"https://s.ppy.sh/images/medals-client/{InternalName}@2x.png";
+        public string Description { get; set; }
+    }
+}

osu.Game/osu.Game.csproj

@@ -489,6 +489,9 @@
     <Compile Include="Overlays\SearchableList\SlimEnumDropdown.cs" />
     <Compile Include="Overlays\SearchableList\DisplayStyleControl.cs" />
     <Compile Include="Graphics\UserInterface\BreadcrumbControl.cs" />
+    <Compile Include="Overlays\MedalOverlay.cs" />
+    <Compile Include="Users\Medal.cs" />
+    <Compile Include="Overlays\MedalSplash\DrawableMedal.cs" />
     <Compile Include="Screens\Multiplayer\RoomInspector.cs" />
     <Compile Include="Online\Multiplayer\GameType.cs" />
     <Compile Include="Screens\Multiplayer\DrawableGameType.cs" />

osu.sln.DotSettings

@@ -66,8 +66,8 @@
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantCommaInAttributeList/@EntryIndexedValue">DO_NOT_SHOW</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantCommaInEnumDeclaration/@EntryIndexedValue">DO_NOT_SHOW</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantCommaInInitializer/@EntryIndexedValue">DO_NOT_SHOW</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantEmptyObjectCreationArgumentList/@EntryIndexedValue"></s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantEmptyObjectCreationArgumentList/@EntryIndexedValue">WARNING</s:String>
-	<s:Boolean x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantEmptyObjectCreationArgumentList/@EntryIndexRemoved">True</s:Boolean>
+	
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantExplicitParamsArrayCreation/@EntryIndexedValue">WARNING</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantImmediateDelegateInvocation/@EntryIndexedValue">WARNING</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantLambdaSignatureParentheses/@EntryIndexedValue">WARNING</s:String>