Merge branch 'master' into master

.vscode/launch.json

@@ -2,46 +2,60 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "Launch VisualTests",
+            "name": "VisualTests (debug)",
             "windows": {
                 "type": "clr"
             },
             "type": "mono",
             "request": "launch",
             "program": "${workspaceRoot}/osu.Desktop.VisualTests/bin/Debug/osu!.exe",
-            "args": [],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "build",
+            "preLaunchTask": "Build (Debug)",
             "runtimeExecutable": null,
             "env": {},
             "console": "internalConsole"
         },
         {
-            "name": "Launch Desktop",
+            "name": "VisualTests (release)",
+            "windows": {
+                "type": "clr"
+            },
+            "type": "mono",
+            "request": "launch",
+            "program": "${workspaceRoot}/osu.Desktop.VisualTests/bin/Release/osu!.exe",
+            "cwd": "${workspaceRoot}",
+            "preLaunchTask": "Build (Release)",
+            "runtimeExecutable": null,
+            "env": {},
+            "console": "internalConsole"
+        },
+        {
+            "name": "osu! (debug)",
             "windows": {
                 "type": "clr"
             },
             "type": "mono",
             "request": "launch",
             "program": "${workspaceRoot}/osu.Desktop/bin/Debug/osu!.exe",
-            "args": [],
             "cwd": "${workspaceRoot}",
-            "preLaunchTask": "build",
+            "preLaunchTask": "Build (Debug)",
             "runtimeExecutable": null,
             "env": {},
             "console": "internalConsole"
         },
         {
-            "name": "Attach",
+            "name": "osu! (release)",
             "windows": {
-                "type": "clr",
+                "type": "clr"
-                "request": "attach",
-                "processName": "osu!"
             },
             "type": "mono",
-            "request": "attach",
+            "request": "launch",
-            "address": "localhost",
+            "program": "${workspaceRoot}/osu.Desktop/bin/Release/osu!.exe",
-            "port": 55555
+            "cwd": "${workspaceRoot}",
+            "preLaunchTask": "Build (Release)",
+            "runtimeExecutable": null,
+            "env": {},
+            "console": "internalConsole"
         }
     ]
 }

.vscode/tasks.json

@@ -1,51 +1,50 @@
 {
     // See https://go.microsoft.com/fwlink/?LinkId=733558
     // for the documentation about the tasks.json format
-    "version": "0.1.0",
+    "version": "2.0.0",
-    "taskSelector": "/t:",
+    "problemMatcher": "$msCompile",
+    "isShellCommand": true,
+    "command": "msbuild",
+    "suppressTaskName": true,
+    "showOutput": "silent",
+    "args": [
+        "/property:GenerateFullPaths=true",
+        "/property:DebugType=portable"
+    ],
+    "windows": {
+        "args": [
+            "/property:GenerateFullPaths=true",
+            "/property:DebugType=portable",
+            "/m" //parallel compiling support. doesn't work well with mono atm
+        ]
+    },
     "tasks": [
         {
-            "taskName": "build",
+            "taskName": "Build (Debug)",
-            "isShellCommand": true,
-            "showOutput": "silent",
-            "command": "msbuild",
-            "args": [
-                "/property:GenerateFullPaths=true",
-                "/property:DebugType=portable"
-            ],
-            "windows": {
-                "args": [
-                    "/property:GenerateFullPaths=true",
-                    "/property:DebugType=portable",
-                    "/m" //parallel compiling support. doesn't work well with mono atm
-                ]
-            },
-            // Use the standard MS compiler pattern to detect errors, warnings and infos
-            "problemMatcher": "$msCompile",
             "isBuildCommand": true
         },
         {
-            "taskName": "rebuild",
+            "taskName": "Build (Release)",
-            "isShellCommand": true,
-            "showOutput": "silent",
-            "command": "msbuild",
             "args": [
-                // Ask msbuild to generate full paths for file names.
+                "/property:Configuration=Release"
-                "/property:GenerateFullPaths=true",
+            ]
-                "/property:DebugType=portable",
+        },
-                "/target:Clean,Build"
+        {
-            ],
+            "taskName": "Clean All",
-            "windows": {
+            "dependsOn": ["Clean (Debug)", "Clean (Release)"]
-                "args": [
+        },
-                    "/property:GenerateFullPaths=true",
+        {
-                    "/property:DebugType=portable",
+            "taskName": "Clean (Debug)",
-                    "/target:Clean,Build",
+            "args": [
-                    "/m" //parallel compiling support. doesn't work well with mono atm
+                "/target:Clean"
-                ]
+            ]
-            },
+        },
-            // Use the standard MS compiler pattern to detect errors, warnings and infos
+        {
-            "problemMatcher": "$msCompile",
+            "taskName": "Clean (Release)",
-            "isBuildCommand": true
+            "args": [
+                "/target:Clean",
+                "/property:Configuration=Release"
+            ]
         }
     ]
 }

osu.Desktop.VisualTests/Tests/TestCaseManiaPlayfield.cs

@@ -0,0 +1,70 @@
+// 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.Extensions.IEnumerableExtensions;
+using osu.Framework.Input;
+using osu.Framework.Testing;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.UI;
+using System.Linq;
+using System;
+
+namespace osu.Desktop.VisualTests.Tests
+{
+    internal class TestCaseManiaPlayfield : TestCase
+    {
+        public override string Description => @"Mania playfield";
+
+        protected override double TimePerAction => 200;
+
+        public override void Reset()
+        {
+            base.Reset();
+
+            const int max_columns = 10;
+
+            Action<int, SpecialColumnPosition> createPlayfield = (cols, pos) =>
+            {
+                Clear();
+                Add(new ManiaPlayfield(cols)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    SpecialColumnPosition = pos
+                });
+            };
+
+            for (int i = 1; i <= max_columns; i++)
+            {
+                int tempI = i;
+
+                AddStep($"{i} column" + (i > 1 ? "s" : ""), () => createPlayfield(tempI, SpecialColumnPosition.Normal));
+
+                AddStep("Trigger keys down", () => ((ManiaPlayfield)Children.First()).Columns.Children.ForEach(triggerKeyDown));
+                AddStep("Trigger keys up", () => ((ManiaPlayfield)Children.First()).Columns.Children.ForEach(triggerKeyUp));
+
+                AddStep("Left special style", () => createPlayfield(tempI, SpecialColumnPosition.Left));
+                AddStep("Right special style", () => createPlayfield(tempI, SpecialColumnPosition.Right));
+            }
+
+            AddStep("Normal special style", () => createPlayfield(max_columns, SpecialColumnPosition.Normal));
+        }
+
+        private void triggerKeyDown(Column column)
+        {
+            column.TriggerKeyDown(new InputState(), new KeyDownEventArgs
+            {
+                Key = column.Key,
+                Repeat = false
+            });
+        }
+
+        private void triggerKeyUp(Column column)
+        {
+            column.TriggerKeyUp(new InputState(), new KeyUpEventArgs
+            {
+                Key = column.Key
+            });
+        }
+    }
+}

osu.Desktop.VisualTests/Tests/TestCaseMods.cs

@@ -6,16 +6,21 @@ using osu.Framework.Graphics;
 using osu.Game.Overlays.Mods;
 using osu.Framework.Testing;
 using osu.Game.Database;
+using osu.Game.Screens.Play.HUD;
+using OpenTK;
 
 namespace osu.Desktop.VisualTests.Tests
 {
-    internal class TestCaseModSelectOverlay : TestCase
+    internal class TestCaseMods : TestCase
     {
-        public override string Description => @"Tests the mod select overlay";
+        public override string Description => @"Mod select overlay and in-game display";
 
         private ModSelectOverlay modSelect;
+        private ModDisplay modDisplay;
+
         private RulesetDatabase rulesets;
 
+
         [BackgroundDependencyLoader]
         private void load(RulesetDatabase rulesets)
         {
@@ -33,6 +38,16 @@ namespace osu.Desktop.VisualTests.Tests
                 Anchor = Anchor.BottomCentre,
             });
 
+            Add(modDisplay = new ModDisplay
+            {
+                Anchor = Anchor.TopRight,
+                Origin = Anchor.TopRight,
+                AutoSizeAxes = Axes.Both,
+                Position = new Vector2(0, 25),
+            });
+
+            modDisplay.Current.BindTo(modSelect.SelectedMods);
+
             AddStep("Toggle", modSelect.ToggleVisibility);
 
             foreach (var ruleset in rulesets.AllRulesets)

osu.Desktop.VisualTests/Tests/TestCaseScoreCounter.cs

@@ -8,7 +8,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play.HUD;
 
 namespace osu.Desktop.VisualTests.Tests
 {

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

@@ -190,6 +190,7 @@
     <Compile Include="Tests\TestCaseDrawings.cs" />
     <Compile Include="Tests\TestCaseGamefield.cs" />
     <Compile Include="Tests\TestCaseGraph.cs" />
+    <Compile Include="Tests\TestCaseManiaPlayfield.cs" />
     <Compile Include="Tests\TestCaseMenuOverlays.cs" />
     <Compile Include="Tests\TestCaseMusicController.cs" />
     <Compile Include="Tests\TestCaseNotificationManager.cs" />
@@ -211,7 +212,7 @@
     <Compile Include="Platform\TestStorage.cs" />
     <Compile Include="Tests\TestCaseOptions.cs" />
     <Compile Include="Tests\TestCaseSongProgress.cs" />
-    <Compile Include="Tests\TestCaseModSelectOverlay.cs" />
+    <Compile Include="Tests\TestCaseMods.cs" />
     <Compile Include="Tests\TestCaseDialogOverlay.cs" />
     <Compile Include="Tests\TestCaseBeatmapOptionsOverlay.cs" />
     <Compile Include="Tests\TestCaseLeaderboard.cs" />

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

@@ -64,6 +64,7 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Name => "FadeIn";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_hidden;
+        public override ModType Type => ModType.DifficultyIncrease;
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight) };

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

@@ -0,0 +1,202 @@
+// 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 OpenTK.Input;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class Column : Container, IHasAccentColour
+    {
+        private const float key_size = 50;
+
+        private const float key_icon_size = 10;
+        private const float key_icon_corner_radius = 3;
+        private const float key_icon_border_radius = 2;
+
+        private const float hit_target_height = 10;
+        private const float hit_target_bar_height = 2;
+
+        private const float column_width = 45;
+        private const float special_column_width = 70;
+
+        public Key Key;
+
+        private readonly Box background;
+        private readonly Container hitTargetBar;
+        private readonly Container keyIcon;
+
+        public Column()
+        {
+            RelativeSizeAxes = Axes.Y;
+            Width = column_width;
+
+            Children = new Drawable[]
+            {
+                background = new Box
+                {
+                    Name = "Foreground",
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.2f
+                },
+                new FillFlowContainer
+                {
+                    Name = "Key + hit target",
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                    Children = new[]
+                    {
+                        new Container
+                        {
+                            Name = "Key",
+                            Anchor = Anchor.BottomCentre,
+                            Origin = Anchor.BottomCentre,
+                            RelativeSizeAxes = Axes.X,
+                            Height = key_size,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    Name = "Key gradient",
+                                    RelativeSizeAxes = Axes.Both,
+                                    ColourInfo = ColourInfo.GradientVertical(Color4.Black, Color4.Black.Opacity(0)),
+                                    Alpha = 0.5f
+                                },
+                                keyIcon = new Container
+                                {
+                                    Name = "Key icon",
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Size = new Vector2(key_icon_size),
+                                    Masking = true,
+                                    CornerRadius = key_icon_corner_radius,
+                                    BorderThickness = 2,
+                                    BorderColour = Color4.White, // Not true
+                                    Children = new[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Alpha = 0,
+                                            AlwaysPresent = true
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        new Container
+                        {
+                            Name = "Hit target",
+                            Anchor = Anchor.BottomCentre,
+                            Origin = Anchor.BottomCentre,
+                            RelativeSizeAxes = Axes.X,
+                            Height = hit_target_height,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    Name = "Background",
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.Black
+                                },
+                                hitTargetBar = new Container
+                                {
+                                    Name = "Bar",
+                                    Anchor = Anchor.BottomCentre,
+                                    Origin = Anchor.BottomCentre,
+                                    RelativeSizeAxes = Axes.X,
+                                    Height = hit_target_bar_height,
+                                    Masking = true,
+                                    Children = new[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        private bool isSpecial;
+        public bool IsSpecial
+        {
+            get { return isSpecial; }
+            set
+            {
+                if (isSpecial == value)
+                    return;
+                isSpecial = value;
+
+                Width = isSpecial ? special_column_width : column_width;
+            }
+        }
+
+        private Color4 accentColour;
+        public Color4 AccentColour
+        {
+            get { return accentColour; }
+            set
+            {
+                if (accentColour == value)
+                    return;
+                accentColour = value;
+
+                background.Colour = accentColour;
+
+                hitTargetBar.EdgeEffect = new EdgeEffect
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 5,
+                    Colour = accentColour.Opacity(0.5f),
+                };
+
+                keyIcon.EdgeEffect = new EdgeEffect
+                {
+                    Type = EdgeEffectType.Glow,
+                    Radius = 5,
+                    Colour = accentColour.Opacity(0.5f),
+                };
+            }
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (args.Key == Key && !args.Repeat)
+            {
+                background.FadeTo(background.Alpha + 0.2f, 50, EasingTypes.OutQuint);
+                keyIcon.ScaleTo(1.4f, 50, EasingTypes.OutQuint);
+            }
+
+            return false;
+        }
+
+        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+        {
+            if (args.Key == Key)
+            {
+                background.FadeTo(0.2f, 800, EasingTypes.OutQuart);
+                keyIcon.ScaleTo(1f, 400, EasingTypes.OutQuart);
+            }
+
+            return false;
+        }
+    }
+
+}

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

@@ -8,29 +8,153 @@ using osu.Game.Rulesets.UI;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Game.Rulesets.Mania.Judgements;
+using osu.Framework.Graphics.Containers;
+using System;
+using osu.Framework.Graphics.Primitives;
+using osu.Game.Graphics;
+using osu.Framework.Allocation;
+using OpenTK.Input;
+using System.Linq;
+using System.Collections.Generic;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
     public class ManiaPlayfield : Playfield<ManiaBaseHit, ManiaJudgement>
     {
-        public ManiaPlayfield(int columns)
+        /// <summary>
+        /// Default column keys, expanding outwards from the middle as more column are added.
+        /// E.g. 2 columns use FJ, 4 columns use DFJK, 6 use SDFJKL, etc...
+        /// </summary>
+        private static readonly Key[] default_keys = { Key.A, Key.S, Key.D, Key.F, Key.J, Key.K, Key.L, Key.Semicolon };
+
+        private SpecialColumnPosition specialColumnPosition;
+        /// <summary>
+        /// The style to use for the special column.
+        /// </summary>
+        public SpecialColumnPosition SpecialColumnPosition
         {
-            Size = new Vector2(0.8f, 1f);
+            get { return specialColumnPosition; }
-            Anchor = Anchor.BottomCentre;
+            set
-            Origin = Anchor.BottomCentre;
+            {
+                if (IsLoaded)
+                    throw new InvalidOperationException($"Setting {nameof(SpecialColumnPosition)} after the playfield is loaded requires re-creating the playfield.");
+                specialColumnPosition = value;
+            }
+        }
 
-            Add(new Box { RelativeSizeAxes = Axes.Both, Alpha = 0.5f });
+        public readonly FlowContainer<Column> Columns;
 
-            for (int i = 0; i < columns; i++)
+        private List<Color4> normalColumnColours = new List<Color4>();
-                Add(new Box
+        private Color4 specialColumnColour;
+
+        private readonly int columnCount;
+
+        public ManiaPlayfield(int columnCount)
+        {
+            this.columnCount = columnCount;
+
+            if (columnCount <= 0)
+                throw new ArgumentException("Can't have zero or fewer columns.");
+
+            Children = new Drawable[]
+            {
+                new Container
                 {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Y,
-                    Size = new Vector2(2, 1),
+                    AutoSizeAxes = Axes.X,
-                    RelativePositionAxes = Axes.Both,
+                    Children = new Drawable[]
-                    Position = new Vector2((float)i / columns, 0),
+                    {
-                    Alpha = 0.5f,
+                        new Box
-                    Colour = Color4.Black
+                        {
-                });
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Black
+                        },
+                        Columns = new FillFlowContainer<Column>
+                        {
+                            RelativeSizeAxes = Axes.Y,
+                            AutoSizeAxes = Axes.X,
+                            Direction = FillDirection.Horizontal,
+                            Padding = new MarginPadding { Left = 1, Right = 1 },
+                            Spacing = new Vector2(1, 0)
+                        }
+                    }
+                }
+            };
+
+            for (int i = 0; i < columnCount; i++)
+                Columns.Add(new Column());
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            normalColumnColours = new List<Color4>
+            {
+                colours.RedDark,
+                colours.GreenDark
+            };
+
+            specialColumnColour = colours.BlueDark;
+
+            // Set the special column + colour + key
+            for (int i = 0; i < columnCount; i++)
+            {
+                Column column = Columns.Children.ElementAt(i);
+                column.IsSpecial = isSpecialColumn(i);
+
+                if (!column.IsSpecial)
+                    continue;
+
+                column.Key = Key.Space;
+                column.AccentColour = specialColumnColour;
+            }
+
+            var nonSpecialColumns = Columns.Children.Where(c => !c.IsSpecial).ToList();
+
+            // We'll set the colours of the non-special columns in a separate loop, because the non-special
+            // column colours are mirrored across their centre and special styles mess with this
+            for (int i = 0; i < Math.Ceiling(nonSpecialColumns.Count / 2f); i++)
+            {
+                Color4 colour = normalColumnColours[i % normalColumnColours.Count];
+                nonSpecialColumns[i].AccentColour = colour;
+                nonSpecialColumns[nonSpecialColumns.Count - 1 - i].AccentColour = colour;
+            }
+
+            // We'll set the keys for non-special columns in another separate loop because it's not mirrored like the above colours
+            // Todo: This needs to go when we get to bindings and use Button1, ..., ButtonN instead
+            for (int i = 0; i < nonSpecialColumns.Count; i++)
+            {
+                Column column = nonSpecialColumns[i];
+
+                int keyOffset = default_keys.Length / 2 - nonSpecialColumns.Count / 2 + i;
+                if (keyOffset >= 0 && keyOffset < default_keys.Length)
+                    column.Key = default_keys[keyOffset];
+                else
+                    // There is no default key defined for this column. Let's set this to Unknown for now
+                    // however note that this will be gone after bindings are in place
+                    column.Key = Key.Unknown;
+            }
+        }
+
+        /// <summary>
+        /// Whether the column index is a special column for this playfield.
+        /// </summary>
+        /// <param name="column">The 0-based column index.</param>
+        /// <returns>Whether the column is a special column.</returns>
+        private bool isSpecialColumn(int column)
+        {
+            switch (SpecialColumnPosition)
+            {
+                default:
+                case SpecialColumnPosition.Normal:
+                    return columnCount % 2 == 1 && column == columnCount / 2;
+                case SpecialColumnPosition.Left:
+                    return column == 0;
+                case SpecialColumnPosition.Right:
+                    return column == columnCount - 1;
+            }
         }
     }
-}
+}

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

@@ -0,0 +1,21 @@
+// 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.Rulesets.Mania.UI
+{
+    public enum SpecialColumnPosition
+    {
+        /// <summary>
+        /// The special column will lie in the center of the columns.
+        /// </summary>
+        Normal,
+        /// <summary>
+        /// The special column will lie to the left of the columns.
+        /// </summary>
+        Left,
+        /// <summary>
+        /// The special column will lie to the right of the columns.
+        /// </summary>
+        Right
+    }
+}

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

@@ -56,10 +56,12 @@
     <Compile Include="Objects\ManiaBaseHit.cs" />
     <Compile Include="Objects\Note.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UI\Column.cs" />
     <Compile Include="UI\ManiaHitRenderer.cs" />
     <Compile Include="UI\ManiaPlayfield.cs" />
     <Compile Include="ManiaRuleset.cs" />
     <Compile Include="Mods\ManiaMod.cs" />
+    <Compile Include="UI\SpecialColumnPosition.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu-framework\osu.Framework\osu.Framework.csproj">

osu.Game/Overlays/Mods/AssistedSection.cs

@@ -16,7 +16,6 @@ namespace osu.Game.Overlays.Mods
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            ButtonColour = colours.Blue;
             SelectedColour = colours.BlueLight;
         }
 

osu.Game/Overlays/Mods/DifficultyIncreaseSection.cs

@@ -16,7 +16,6 @@ namespace osu.Game.Overlays.Mods
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            ButtonColour = colours.Yellow;
             SelectedColour = colours.YellowLight;
         }
 

osu.Game/Overlays/Mods/DifficultyReductionSection.cs

@@ -16,7 +16,6 @@ namespace osu.Game.Overlays.Mods
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            ButtonColour = colours.Green;
             SelectedColour = colours.GreenLight;
         }
 

osu.Game/Overlays/Mods/ModButton.cs

@@ -19,7 +19,11 @@ using System.Linq;
 
 namespace osu.Game.Overlays.Mods
 {
-    public class ModButton : FillFlowContainer
+
+    /// <summary>
+    /// Represents a clickable button which can cycle through one of more mods.
+    /// </summary>
+    public class ModButton : ModButtonEmpty
     {
         private ModIcon foregroundIcon { get; set; }
         private readonly SpriteText text;
@@ -51,7 +55,7 @@ namespace osu.Game.Overlays.Mods
 
                 iconsContainer.RotateTo(Selected ? 5f : 0f, 300, EasingTypes.OutElastic);
                 iconsContainer.ScaleTo(Selected ? 1.1f : 1f, 300, EasingTypes.OutElastic);
-                foregroundIcon.Colour = Selected ? SelectedColour : ButtonColour;
+                foregroundIcon.Highlighted = Selected;
 
                 if (mod != null)
                     displayMod(SelectedMod ?? Mods[0]);
@@ -60,23 +64,6 @@ namespace osu.Game.Overlays.Mods
 
         public bool Selected => selectedIndex != -1;
 
-        private Color4 buttonColour;
-        public Color4 ButtonColour
-        {
-            get
-            {
-                return buttonColour;
-            }
-            set
-            {
-                if (value == buttonColour) return;
-                buttonColour = value;
-                foreach (ModIcon icon in iconsContainer.Children)
-                {
-                    icon.Colour = value;
-                }
-            }
-        }
 
         private Color4 selectedColour;
         public Color4 SelectedColour
@@ -127,7 +114,7 @@ namespace osu.Game.Overlays.Mods
 
         // the mods from Mod, only multiple if Mod is a MultiMod
 
-        public Mod SelectedMod => Mods.ElementAtOrDefault(selectedIndex);
+        public override Mod SelectedMod => Mods.ElementAtOrDefault(selectedIndex);
 
         [BackgroundDependencyLoader]
         private void load(AudioManager audio)
@@ -180,50 +167,35 @@ namespace osu.Game.Overlays.Mods
             {
                 iconsContainer.Add(new[]
                 {
-                    new ModIcon
+                    new ModIcon(Mods[0])
                     {
                         Origin = Anchor.Centre,
                         Anchor = Anchor.Centre,
                         AutoSizeAxes = Axes.Both,
                         Position = new Vector2(1.5f),
-                        Colour = ButtonColour
                     },
-                    foregroundIcon = new ModIcon
+                    foregroundIcon = new ModIcon(Mods[0])
                     {
                         Origin = Anchor.Centre,
                         Anchor = Anchor.Centre,
                         AutoSizeAxes = Axes.Both,
                         Position = new Vector2(-1.5f),
-                        Colour = ButtonColour
                     },
                 });
             }
             else
             {
-                iconsContainer.Add(foregroundIcon = new ModIcon
+                iconsContainer.Add(foregroundIcon = new ModIcon(Mod)
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
                     AutoSizeAxes = Axes.Both,
-                    Colour = ButtonColour
                 });
             }
         }
 
-        protected override void LoadComplete()
+        public ModButton(Mod mod)
         {
-            base.LoadComplete();
-            foreach (ModIcon icon in iconsContainer.Children)
-                icon.Colour = ButtonColour;
-        }
-
-        public ModButton(Mod m)
-        {
-            Direction = FillDirection.Vertical;
-            Spacing = new Vector2(0f, -5f);
-            Size = new Vector2(100f);
-            AlwaysPresent = true;
-
             Children = new Drawable[]
             {
                 new Container
@@ -243,13 +215,14 @@ namespace osu.Game.Overlays.Mods
                 },
                 text = new OsuSpriteText
                 {
+                    Y = 75,
                     Origin = Anchor.TopCentre,
                     Anchor = Anchor.TopCentre,
                     TextSize = 18,
                 },
             };
 
-            Mod = m;
+            Mod = mod;
         }
     }
 }

osu.Game/Overlays/Mods/ModButtonEmpty.cs

@@ -0,0 +1,23 @@
+// 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 osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Overlays.Mods
+{
+    /// <summary>
+    /// A mod button used exclusively for providing an empty space the size of a mod button.
+    /// </summary>
+    public class ModButtonEmpty : Container
+    {
+        public virtual Mod SelectedMod => null;
+
+        public ModButtonEmpty()
+        {
+            Size = new Vector2(100f);
+            AlwaysPresent = true;
+        }
+    }
+}

osu.Game/Overlays/Mods/ModSection.cs

@@ -11,6 +11,8 @@ using osu.Framework.Input;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using System;
+using System.Linq;
+using System.Collections.Generic;
 
 namespace osu.Game.Overlays.Mods
 {
@@ -18,7 +20,7 @@ namespace osu.Game.Overlays.Mods
     {
         private readonly OsuSpriteText headerLabel;
 
-        public FillFlowContainer<ModButton> ButtonsContainer { get; }
+        public FillFlowContainer<ModButtonEmpty> ButtonsContainer { get; }
 
         public Action<Mod> Action;
         protected abstract Key[] ToggleKeys { get; }
@@ -36,47 +38,30 @@ namespace osu.Game.Overlays.Mods
             }
         }
 
+        public IEnumerable<Mod> SelectedMods => buttons.Select(b => b.SelectedMod).Where(m => m != null);
+
+        public IEnumerable<Mod> Mods
+        {
+            set
+            {
+                var modContainers = value.Select(m =>
+                {
+                    if (m == null)
+                        return new ModButtonEmpty();
+                    else
+                        return new ModButton(m)
+                        {
+                            SelectedColour = selectedColour,
+                            Action = Action,
+                        };
+                }).ToArray();
+
+                ButtonsContainer.Children = modContainers;
+                buttons = modContainers.OfType<ModButton>().ToArray();
+            }
+        }
+
         private ModButton[] buttons = { };
-        public ModButton[] Buttons
-        {
-            get
-            {
-                return buttons;
-            }
-            set
-            {
-                if (value == buttons) return;
-                buttons = value;
-
-                foreach (ModButton button in value)
-                {
-                    button.ButtonColour = ButtonColour;
-                    button.SelectedColour = selectedColour;
-                    button.Action = Action;
-                }
-
-                ButtonsContainer.Children = value;
-            }
-        }
-
-        private Color4 buttonsBolour = Color4.White;
-        public Color4 ButtonColour
-        {
-            get
-            {
-                return buttonsBolour;
-            }
-            set
-            {
-                if (value == buttonsBolour) return;
-                buttonsBolour = value;
-
-                foreach (ModButton button in buttons)
-                {
-                    button.ButtonColour = value;
-                }
-            }
-        }
 
         private Color4 selectedColour = Color4.White;
         public Color4 SelectedColour
@@ -91,17 +76,15 @@ namespace osu.Game.Overlays.Mods
                 selectedColour = value;
 
                 foreach (ModButton button in buttons)
-                {
                     button.SelectedColour = value;
-                }
             }
         }
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
             var index = Array.IndexOf(ToggleKeys, args.Key);
-            if (index > -1 && index < Buttons.Length)
+            if (index > -1 && index < buttons.Length)
-                Buttons[index].SelectNext();
+                buttons[index].SelectNext();
 
             return base.OnKeyDown(state, args);
         }
@@ -109,8 +92,18 @@ namespace osu.Game.Overlays.Mods
         public void DeselectAll()
         {
             foreach (ModButton button in buttons)
-            {
                 button.Deselect();
+        }
+
+        public void DeselectTypes(Type[] modTypes)
+        {
+            foreach (var button in buttons)
+            {
+                Mod selected = button.SelectedMod;
+                if (selected == null) continue;
+                foreach (Type type in modTypes)
+                    if (type.IsInstanceOfType(selected))
+                        button.Deselect();
             }
         }
 
@@ -127,7 +120,7 @@ namespace osu.Game.Overlays.Mods
                     Position = new Vector2(0f, 0f),
                     Font = @"Exo2.0-Bold"
                 },
-                ButtonsContainer = new FillFlowContainer<ModButton>
+                ButtonsContainer = new FillFlowContainer<ModButtonEmpty>
                 {
                     AutoSizeAxes = Axes.Both,
                     Origin = Anchor.BottomLeft,

osu.Game/Overlays/Mods/ModSelectOverlay.cs

@@ -44,7 +44,7 @@ namespace osu.Game.Overlays.Mods
             var instance = newRuleset.CreateInstance();
 
             foreach (ModSection section in modSectionsContainer.Children)
-                section.Buttons = instance.GetModsFor(section.ModType).Select(m => new ModButton(m)).ToArray();
+                section.Mods = instance.GetModsFor(section.ModType);
             refreshSelectedMods();
         }
 
@@ -103,14 +103,7 @@ namespace osu.Game.Overlays.Mods
         {
             if (modTypes.Length == 0) return;
             foreach (ModSection section in modSectionsContainer.Children)
-                foreach (ModButton button in section.Buttons)
+                section.DeselectTypes(modTypes);
-                {
-                    Mod selected = button.SelectedMod;
-                    if (selected == null) continue;
-                    foreach (Type type in modTypes)
-                        if (type.IsInstanceOfType(selected))
-                            button.Deselect();
-                }
         }
 
         private void modButtonPressed(Mod selectedMod)
@@ -122,7 +115,7 @@ namespace osu.Game.Overlays.Mods
 
         private void refreshSelectedMods()
         {
-            SelectedMods.Value = modSectionsContainer.Children.SelectMany(s => s.Buttons.Select(x => x.SelectedMod).Where(x => x != null)).ToArray();
+            SelectedMods.Value = modSectionsContainer.Children.SelectMany(s => s.SelectedMods).ToArray();
 
             double multiplier = 1.0;
             bool ranked = true;

osu.Game/Overlays/Options/OptionCheckbox.cs

@@ -0,0 +1,21 @@
+// 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.Graphics;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Overlays.Options
+{
+    public class OptionCheckbox : OptionItem<bool>
+    {
+        private OsuCheckbox checkbox;
+
+        protected override Drawable CreateControl() => checkbox = new OsuCheckbox();
+
+        public override string LabelText
+        {
+            get { return checkbox.LabelText; }
+            set { checkbox.LabelText = value; }
+        }
+    }
+}

osu.Game/Overlays/Options/OptionDropdown.cs

@@ -2,45 +2,18 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options
 {
-    public class OptionDropdown<T> : FillFlowContainer
+    public class OptionDropdown<T> : OptionItem<T>
     {
-        private readonly Dropdown<T> dropdown;
+        private Dropdown<T> dropdown;
-        private readonly SpriteText text;
 
-        public string LabelText
+        private IEnumerable<KeyValuePair<string, T>> items = new KeyValuePair<string, T>[] { };
-        {
-            get { return text.Text; }
-            set
-            {
-                text.Text = value;
-                text.Alpha = !string.IsNullOrEmpty(value) ? 1 : 0;
-            }
-        }
-
-        public Bindable<T> Bindable
-        {
-            get { return bindable; }
-            set
-            {
-                bindable = value;
-                dropdown.Current.BindTo(bindable);
-            }
-        }
-
-        private Bindable<T> bindable;
-
-        private IEnumerable<KeyValuePair<string, T>> items;
         public IEnumerable<KeyValuePair<string, T>> Items
         {
             get
@@ -55,30 +28,11 @@ namespace osu.Game.Overlays.Options
             }
         }
 
-        public OptionDropdown()
+        protected override Drawable CreateControl() => dropdown = new OsuDropdown<T>
         {
-            Items = new KeyValuePair<string, T>[0];
+            Margin = new MarginPadding { Top = 5 },
-
+            RelativeSizeAxes = Axes.X,
-            Direction = FillDirection.Vertical;
+            Items = Items,
-            RelativeSizeAxes = Axes.X;
+        };
-            AutoSizeAxes = Axes.Y;
-            Children = new Drawable[]
-            {
-                text = new OsuSpriteText {
-                    Alpha = 0,
-                },
-                dropdown = new OsuDropdown<T>
-                {
-                    Margin = new MarginPadding { Top = 5 },
-                    RelativeSizeAxes = Axes.X,
-                    Items = Items,
-                }
-            };
-
-            dropdown.Current.DisabledChanged += disabled =>
-            {
-                Alpha = disabled ? 0.3f : 1;
-            };
-        }
     }
 }

osu.Game/Overlays/Options/OptionItem.cs

@@ -0,0 +1,82 @@
+// 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.Graphics;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Overlays.Options
+{
+    public abstract class OptionItem<T> : FillFlowContainer, IFilterable
+    {
+        protected abstract Drawable CreateControl();
+
+        protected Drawable Control { get; }
+
+        private IHasCurrentValue<T> controlWithCurrent => Control as IHasCurrentValue<T>;
+
+        private SpriteText text;
+
+        public virtual string LabelText
+        {
+            get { return text?.Text ?? string.Empty; }
+            set
+            {
+                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 });
+                }
+
+                text.Text = value;
+            }
+        }
+
+        // hold a reference to the provided bindable so we don't have to in every options section.
+        private Bindable<T> bindable;
+
+        public Bindable<T> Bindable
+        {
+            get
+            {
+                return bindable;
+            }
+
+            set
+            {
+                bindable = value;
+                controlWithCurrent?.Current.BindTo(bindable);
+            }
+        }
+
+        public string[] FilterTerms => new[] { LabelText };
+
+        public bool MatchingCurrentFilter
+        {
+            set
+            {
+                // probably needs a better transition.
+                FadeTo(value ? 1 : 0);
+            }
+        }
+
+        protected OptionItem()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+            Padding = new MarginPadding { Right = 5 };
+
+            if ((Control = CreateControl()) != null)
+            {
+                if (controlWithCurrent != null)
+                    controlWithCurrent.Current.DisabledChanged += disabled => { Colour = disabled ? Color4.Gray : Color4.White; };
+                Add(Control);
+            }
+        }
+    }
+}

osu.Game/Overlays/Options/OptionLabel.cs

@@ -2,13 +2,15 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
 
 namespace osu.Game.Overlays.Options
 {
-    internal class OptionLabel : OsuSpriteText
+    internal class OptionLabel : OptionItem<string>
     {
+        protected override Drawable CreateControl() => null;
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colour)
         {

osu.Game/Overlays/Options/OptionSlider.cs

@@ -1,13 +1,9 @@
 // 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.Configuration;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options
@@ -17,52 +13,14 @@ namespace osu.Game.Overlays.Options
     {
     }
 
-    public class OptionSlider<T, U> : FillFlowContainer
+    public class OptionSlider<T, U> : OptionItem<T>
         where T : struct
         where U : SliderBar<T>, new()
     {
-        private readonly SliderBar<T> slider;
+        protected override Drawable CreateControl() => new U()
-        private readonly SpriteText text;
-
-        public string LabelText
         {
-            get { return text.Text; }
+            Margin = new MarginPadding { Top = 5, Bottom = 5 },
-            set
+            RelativeSizeAxes = Axes.X
-            {
+        };
-                text.Text = value;
-                text.Alpha = string.IsNullOrEmpty(value) ? 0 : 1;
-            }
-        }
-
-        private Bindable<T> bindable;
-
-        public Bindable<T> Bindable
-        {
-            set
-            {
-                bindable = value;
-                slider.Current.BindTo(bindable);
-            }
-        }
-
-        public OptionSlider()
-        {
-            RelativeSizeAxes = Axes.X;
-            AutoSizeAxes = Axes.Y;
-            Padding = new MarginPadding { Right = 5 };
-
-            Children = new Drawable[]
-            {
-                text = new OsuSpriteText
-                {
-                    Alpha = 0,
-                },
-                slider = new U()
-                {
-                    Margin = new MarginPadding { Top = 5, Bottom = 5 },
-                    RelativeSizeAxes = Axes.X
-                }
-            };
-        }
     }
 }

osu.Game/Overlays/Options/OptionTextBox.cs

@@ -1,22 +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.Configuration;
+using osu.Framework.Graphics;
 using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options
 {
-    public class OptionTextBox : OsuTextBox
+    public class OptionTextBox : OptionItem<string>
     {
-        private Bindable<string> bindable;
+        protected override Drawable CreateControl() => new OsuTextBox();
-
-        public Bindable<string> Bindable
-        {
-            set
-            {
-                bindable = value;
-                Current.BindTo(bindable);
-            }
-        }
     }
 }

osu.Game/Overlays/Options/Sections/Audio/MainMenuOptions.cs

@@ -3,7 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.Audio
 {
@@ -16,12 +15,12 @@ namespace osu.Game.Overlays.Options.Sections.Audio
         {
             Children = new[]
             {
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Interface voices",
                     Bindable = config.GetBindable<bool>(OsuConfig.MenuVoice)
                 },
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "osu! music theme",
                     Bindable = config.GetBindable<bool>(OsuConfig.MenuMusic)
@@ -29,4 +28,4 @@ namespace osu.Game.Overlays.Options.Sections.Audio
             };
         }
     }
-}
+}

osu.Game/Overlays/Options/Sections/Debug/GeneralOptions.cs

@@ -4,7 +4,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.Debug
 {
@@ -17,7 +16,7 @@ namespace osu.Game.Overlays.Options.Sections.Debug
         {
             Children = new Drawable[]
             {
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Bypass caching",
                     Bindable = config.GetBindable<bool>(FrameworkDebugConfig.BypassCaching)

osu.Game/Overlays/Options/Sections/Gameplay/GeneralOptions.cs

@@ -4,7 +4,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.Gameplay
 {
@@ -22,12 +21,12 @@ namespace osu.Game.Overlays.Options.Sections.Gameplay
                     LabelText = "Background dim",
                     Bindable = config.GetBindable<double>(OsuConfig.DimLevel)
                 },
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Show score overlay",
                     Bindable = config.GetBindable<bool>(OsuConfig.ShowInterface)
                 },
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Always show key overlay",
                     Bindable = config.GetBindable<bool>(OsuConfig.KeyOverlay)

osu.Game/Overlays/Options/Sections/General/LanguageOptions.cs

@@ -4,7 +4,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.General
 {
@@ -17,7 +16,7 @@ namespace osu.Game.Overlays.Options.Sections.General
         {
             Children = new Drawable[]
             {
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Prefer metadata in original language",
                     Bindable = frameworkConfig.GetBindable<bool>(FrameworkConfig.ShowUnicode)

osu.Game/Overlays/Options/Sections/General/LoginOptions.cs

@@ -132,12 +132,12 @@ namespace osu.Game.Overlays.Options.Sections.General
                         TabbableContentContainer = this,
                         OnCommit = (sender, newText) => performLogin()
                     },
-                    new OsuCheckbox
+                    new OptionCheckbox
                     {
                         LabelText = "Remember username",
                         Bindable = config.GetBindable<bool>(OsuConfig.SaveUsername),
                     },
-                    new OsuCheckbox
+                    new OptionCheckbox
                     {
                         LabelText = "Stay logged in",
                         Bindable = config.GetBindable<bool>(OsuConfig.SavePassword),

osu.Game/Overlays/Options/Sections/Graphics/DetailOptions.cs

@@ -4,7 +4,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.Graphics
 {
@@ -17,12 +16,12 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
         {
             Children = new Drawable[]
             {
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Snaking in sliders",
                     Bindable = config.GetBindable<bool>(OsuConfig.SnakingInSliders)
                 },
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Snaking out sliders",
                     Bindable = config.GetBindable<bool>(OsuConfig.SnakingOutSliders)
@@ -30,4 +29,4 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
             };
         }
     }
-}
+}

osu.Game/Overlays/Options/Sections/Graphics/LayoutOptions.cs

@@ -4,7 +4,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.Graphics
 {
@@ -29,7 +28,7 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
                     LabelText = "Screen mode",
                     Bindable = config.GetBindable<WindowMode>(FrameworkConfig.WindowMode),
                 },
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Letterboxing",
                     Bindable = letterboxing,
@@ -64,4 +63,4 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
             }
         }
     }
-}
+}

osu.Game/Overlays/Options/Sections/Graphics/MainMenuOptions.cs

@@ -3,7 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.Graphics
 {
@@ -16,7 +15,7 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
         {
             Children = new[]
             {
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Parallax",
                     Bindable = config.GetBindable<bool>(OsuConfig.MenuParallax)
@@ -24,4 +23,4 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
             };
         }
     }
-}
+}

osu.Game/Overlays/Options/Sections/Graphics/RendererOptions.cs

@@ -5,7 +5,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Options.Sections.Graphics
 {
@@ -25,7 +24,7 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
                     LabelText = "Frame limiter",
                     Bindable = config.GetBindable<FrameSync>(FrameworkConfig.FrameSync)
                 },
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Show FPS",
                     Bindable = osuConfig.GetBindable<bool>(OsuConfig.ShowFpsDisplay)
@@ -33,4 +32,4 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
             };
         }
     }
-}
+}

osu.Game/Overlays/Options/Sections/Input/MouseOptions.cs

@@ -24,12 +24,12 @@ namespace osu.Game.Overlays.Options.Sections.Input
                     LabelText = "Confine mouse cursor",
                     Bindable = config.GetBindable<ConfineMouseMode>(FrameworkConfig.ConfineMouseMode),
                 },
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Disable mouse wheel during gameplay",
                     Bindable = osuConfig.GetBindable<bool>(OsuConfig.MouseDisableWheel)
                 },
-                new OsuCheckbox
+                new OptionCheckbox
                 {
                     LabelText = "Disable mouse buttons during gameplay",
                     Bindable = osuConfig.GetBindable<bool>(OsuConfig.MouseDisableButtons)

osu.Game/Rulesets/Mods/Mod.cs

@@ -21,6 +21,11 @@ namespace osu.Game.Rulesets.Mods
         /// </summary>
         public virtual FontAwesome Icon => FontAwesome.fa_question;
 
+        /// <summary>
+        /// The type of this mod.
+        /// </summary>
+        public virtual ModType Type => ModType.Special;
+
         /// <summary>
         /// The user readable description of this mod.
         /// </summary>

osu.Game/Rulesets/Mods/ModDoubleTime.cs

@@ -11,6 +11,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Double Time";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_doubletime;
+        public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => "Zoooooooooom";
         public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModHalfTime) };

osu.Game/Rulesets/Mods/ModEasy.cs

@@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Easy";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_easy;
+        public override ModType Type => ModType.DifficultyReduction;
         public override string Description => "Reduces overall difficulty - larger circles, more forgiving HP drain, less accuracy required.";
         public override double ScoreMultiplier => 0.5;
         public override bool Ranked => true;

osu.Game/Rulesets/Mods/ModFlashlight.cs

@@ -9,6 +9,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Flashlight";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_flashlight;
+        public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => "Restricted view area.";
         public override bool Ranked => true;
     }

osu.Game/Rulesets/Mods/ModHalfTime.cs

@@ -11,6 +11,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Half Time";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_halftime;
+        public override ModType Type => ModType.DifficultyReduction;
         public override string Description => "Less zoom";
         public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModDoubleTime) };

osu.Game/Rulesets/Mods/ModHardRock.cs

@@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Hard Rock";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_hardrock;
+        public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => "Everything just got a bit harder...";
         public override Type[] IncompatibleMods => new[] { typeof(ModEasy) };
     }

osu.Game/Rulesets/Mods/ModHidden.cs

@@ -9,6 +9,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Hidden";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_hidden;
+        public override ModType Type => ModType.DifficultyIncrease;
         public override bool Ranked => true;
     }
 }

osu.Game/Rulesets/Mods/ModNoFail.cs

@@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "NoFail";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_nofail;
+        public override ModType Type => ModType.DifficultyReduction;
         public override string Description => "You can't fail, no matter what.";
         public override double ScoreMultiplier => 0.5;
         public override bool Ranked => true;

osu.Game/Rulesets/Mods/ModSuddenDeath.cs

@@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mods
     {
         public override string Name => "Sudden Death";
         public override FontAwesome Icon => FontAwesome.fa_osu_mod_suddendeath;
+        public override ModType Type => ModType.DifficultyIncrease;
         public override string Description => "Miss a note and fail.";
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;

osu.Game/Rulesets/UI/HitRenderer.cs

@@ -202,8 +202,6 @@ namespace osu.Game.Rulesets.UI
         protected HitRenderer(WorkingBeatmap beatmap)
             : base(beatmap)
         {
-            KeyConversionInputManager.Add(Playfield = CreatePlayfield());
-
             InputManager.Add(content = new Container
             {
                 RelativeSizeAxes = Axes.Both,
@@ -216,6 +214,8 @@ namespace osu.Game.Rulesets.UI
         [BackgroundDependencyLoader]
         private void load()
         {
+            KeyConversionInputManager.Add(Playfield = CreatePlayfield());
+
             loadObjects();
 
             if (InputManager?.ReplayInputHandler != null)

osu.Game/Rulesets/UI/ModIcon.cs

@@ -1,10 +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 System;
 using OpenTK.Graphics;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.UI
 {
@@ -13,72 +16,88 @@ namespace osu.Game.Rulesets.UI
         private readonly TextAwesome modIcon;
         private readonly TextAwesome background;
 
-        private float iconSize = 80;
+        private const float icon_size = 80;
-        public float IconSize
-        {
-            get
-            {
-                return iconSize;
-            }
-            set
-            {
-                iconSize = value;
-                reapplySize();
-            }
-        }
-
-        public new Color4 Colour
-        {
-            get
-            {
-                return background.Colour;
-            }
-            set
-            {
-                background.Colour = value;
-            }
-        }
 
         public FontAwesome Icon
         {
-            get
+            get { return modIcon.Icon; }
-            {
+            set { modIcon.Icon = value; }
-                return modIcon.Icon;
-            }
-            set
-            {
-                modIcon.Icon = value;
-            }
         }
 
-        private void reapplySize()
+        private readonly ModType type;
-        {
-            background.TextSize = iconSize;
-            modIcon.TextSize = iconSize - 35;
-        }
 
-        public ModIcon()
+        public ModIcon(Mod mod)
         {
+            if (mod == null) throw new ArgumentNullException(nameof(mod));
+
+            type = mod.Type;
+
             Children = new Drawable[]
             {
                 background = new TextAwesome
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
+                    TextSize = icon_size,
                     Icon = FontAwesome.fa_osu_mod_bg,
                     Shadow = true,
-                    TextSize = 20
                 },
                 modIcon = new TextAwesome
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
                     Colour = OsuColour.Gray(84),
-                    TextSize = 20
+                    TextSize = icon_size - 35,
+                    Icon = mod.Icon
                 },
             };
+        }
 
-            reapplySize();
+        private Color4 backgroundColour;
+        private Color4 highlightedColour;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            switch (type)
+            {
+                default:
+                case ModType.DifficultyIncrease:
+                    backgroundColour = colours.Yellow;
+                    highlightedColour = colours.YellowLight;
+                    break;
+                case ModType.DifficultyReduction:
+                    backgroundColour = colours.Green;
+                    highlightedColour = colours.GreenLight;
+                    break;
+                case ModType.Special:
+                    backgroundColour = colours.Blue;
+                    highlightedColour = colours.BlueLight;
+                    break;
+            }
+
+            applyStyle();
+        }
+
+        private bool highlighted;
+
+        public bool Highlighted
+        {
+            get
+            {
+                return highlighted;
+            }
+
+            set
+            {
+                highlighted = value;
+                applyStyle();
+            }
+        }
+
+        private void applyStyle()
+        {
+            background.Colour = highlighted ? highlightedColour : backgroundColour;
         }
     }
-}
+}

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

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Transforms;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics.Sprites;
 
-namespace osu.Game.Rulesets.UI
+namespace osu.Game.Screens.Play.HUD
 {
     public abstract class ComboCounter : Container
     {

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

@@ -1,13 +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 System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Transforms;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics.UserInterface;
-using System;
 
-namespace osu.Game.Rulesets.UI
+namespace osu.Game.Screens.Play.HUD
 {
     /// <summary>
     /// Used to display combo with a roll-up animation in results screen.

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

@@ -4,7 +4,7 @@
 using osu.Framework.Configuration;
 using osu.Framework.Graphics.Containers;
 
-namespace osu.Game.Rulesets.UI
+namespace osu.Game.Screens.Play.HUD
 {
     public abstract class HealthDisplay : Container
     {

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

@@ -0,0 +1,105 @@
+// Copyright (c) 2007-2017 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.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+using OpenTK;
+using osu.Framework.Input;
+
+namespace osu.Game.Screens.Play.HUD
+{
+    public class ModDisplay : Container, IHasCurrentValue<IEnumerable<Mod>>
+    {
+        private readonly Bindable<IEnumerable<Mod>> mods = new Bindable<IEnumerable<Mod>>();
+
+        public Bindable<IEnumerable<Mod>> Current => mods;
+
+        private readonly FillFlowContainer<ModIcon> iconsContainer;
+
+        public ModDisplay()
+        {
+            Children = new Drawable[]
+            {
+                iconsContainer = new IconFlow
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                    Margin = new MarginPadding { Left = 10, Right = 10 },
+                },
+                new OsuSpriteText
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.TopCentre,
+                    Text = @"/ UNRANKED /",
+                    Font = @"Venera",
+                    TextSize = 12,
+                }
+            };
+
+            mods.ValueChanged += mods =>
+            {
+                iconsContainer.Clear();
+                foreach (Mod mod in mods)
+                {
+                    iconsContainer.Add(new ModIcon(mod)
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Scale = new Vector2(0.6f),
+
+                    });
+                }
+
+                if (IsLoaded)
+                    appearTransform();
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            appearTransform();
+        }
+
+        private void appearTransform()
+        {
+            iconsContainer.Flush();
+            iconsContainer.FadeInFromZero(1000, EasingTypes.OutQuint);
+            expand();
+            using (iconsContainer.BeginDelayedSequence(1200))
+                contract();
+        }
+
+        private void expand() => iconsContainer.TransformSpacingTo(new Vector2(5, 0), 500, EasingTypes.OutQuint);
+
+        private void contract() => iconsContainer.TransformSpacingTo(new Vector2(-25, 0), 500, EasingTypes.OutQuint);
+
+        protected override bool OnHover(InputState state)
+        {
+            expand();
+            return base.OnHover(state);
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            contract();
+            base.OnHoverLost(state);
+        }
+
+        private class IconFlow : FillFlowContainer<ModIcon>
+        {
+            // just reverses the depth of flow contents.
+            protected override IComparer<Drawable> DepthComparer => new ReverseCreationOrderDepthComparer();
+            protected override IEnumerable<ModIcon> FlowingChildren => base.FlowingChildren.Reverse();
+        }
+    }
+}

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

@@ -3,7 +3,7 @@
 
 using OpenTK;
 
-namespace osu.Game.Rulesets.UI
+namespace osu.Game.Screens.Play.HUD
 {
     /// <summary>
     /// Uses the 'x' symbol and has a pop-out effect while rolling over.

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

@@ -1,8 +1,7 @@
 // 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 System;
-using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -10,9 +9,10 @@ using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
-using System;
+using OpenTK;
+using OpenTK.Graphics;
 
-namespace osu.Game.Rulesets.UI
+namespace osu.Game.Screens.Play.HUD
 {
     public class StandardHealthDisplay : HealthDisplay, IHasAccentColour
     {

osu.Game/Screens/Play/HUDOverlay.cs

@@ -5,18 +5,19 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
 using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Screens.Play;
-using osu.Game.Rulesets.Scoring;
-using osu.Framework.Input;
-using OpenTK.Input;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play.HUD;
+using OpenTK.Input;
 
-namespace osu.Game.Rulesets.UI
+namespace osu.Game.Screens.Play
 {
-    public abstract class HudOverlay : Container
+    public abstract class HUDOverlay : Container
     {
         private const int duration = 100;
 
@@ -27,6 +28,7 @@ namespace osu.Game.Rulesets.UI
         public readonly RollingCounter<double> AccuracyCounter;
         public readonly HealthDisplay HealthDisplay;
         public readonly SongProgress Progress;
+        public readonly ModDisplay ModDisplay;
 
         private Bindable<bool> showKeyCounter;
         private Bindable<bool> showHud;
@@ -39,8 +41,9 @@ namespace osu.Game.Rulesets.UI
         protected abstract ScoreCounter CreateScoreCounter();
         protected abstract HealthDisplay CreateHealthDisplay();
         protected abstract SongProgress CreateProgress();
+        protected abstract ModDisplay CreateModsContainer();
 
-        protected HudOverlay()
+        protected HUDOverlay()
         {
             RelativeSizeAxes = Axes.Both;
 
@@ -56,6 +59,7 @@ namespace osu.Game.Rulesets.UI
                     AccuracyCounter = CreateAccuracyCounter(),
                     HealthDisplay = CreateHealthDisplay(),
                     Progress = CreateProgress(),
+                    ModDisplay = CreateModsContainer(),
                 }
             });
         }
@@ -105,6 +109,11 @@ namespace osu.Game.Rulesets.UI
         public virtual void BindHitRenderer(HitRenderer hitRenderer)
         {
             hitRenderer.InputManager.Add(KeyCounter.GetReceptor());
+
+            // in the case a replay isn't loaded, we want some elements to only appear briefly.
+            if (!hitRenderer.HasReplayLoaded)
+                using (ModDisplay.BeginDelayedSequence(2000))
+                    ModDisplay.FadeOut(200);
         }
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)

osu.Game/Screens/Play/Player.cs

@@ -72,7 +72,7 @@ namespace osu.Game.Screens.Play
 
         private Container hitRendererContainer;
 
-        private HudOverlay hudOverlay;
+        private HUDOverlay hudOverlay;
         private PauseOverlay pauseOverlay;
         private FailOverlay failOverlay;
 
@@ -154,7 +154,7 @@ namespace osu.Game.Screens.Play
 
             scoreProcessor = HitRenderer.CreateScoreProcessor();
 
-            hudOverlay = new StandardHudOverlay()
+            hudOverlay = new StandardHUDOverlay()
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre
@@ -169,6 +169,8 @@ namespace osu.Game.Screens.Play
             hudOverlay.Progress.AllowSeeking = HitRenderer.HasReplayLoaded;
             hudOverlay.Progress.OnSeek = pos => decoupledClock.Seek(pos);
 
+            hudOverlay.ModDisplay.Current.BindTo(Beatmap.Mods);
+
             //bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
             HitRenderer.OnAllJudged += onCompletion;
 

osu.Game/Screens/Play/StandardHUDOverlay.cs

@@ -1,18 +1,18 @@
 // 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 osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD;
+using OpenTK;
 
-namespace osu.Game.Rulesets.UI
+namespace osu.Game.Screens.Play
 {
-    public class StandardHudOverlay : HudOverlay
+    public class StandardHUDOverlay : HUDOverlay
     {
         protected override RollingCounter<double> CreateAccuracyCounter() => new PercentageCounter
         {
@@ -64,6 +64,14 @@ namespace osu.Game.Rulesets.UI
             RelativeSizeAxes = Axes.X,
         };
 
+        protected override ModDisplay CreateModsContainer() => new ModDisplay
+        {
+            Anchor = Anchor.TopRight,
+            Origin = Anchor.TopRight,
+            AutoSizeAxes = Axes.Both,
+            Margin = new MarginPadding { Top = 20, Right = 10 },
+        };
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -69,6 +69,13 @@ namespace osu.Game.Screens.Select
             base.OnResuming(last);
         }
 
+        protected override void OnSuspending(Screen next)
+        {
+            modSelect.Hide();
+
+            base.OnSuspending(next);
+        }
+
         protected override bool OnExiting(Screen next)
         {
             if (modSelect.State == Visibility.Visible)

osu.Game/osu.Game.csproj

@@ -178,10 +178,9 @@
     <Compile Include="Database\RulesetDatabase.cs" />
     <Compile Include="Rulesets\Scoring\Score.cs" />
     <Compile Include="Rulesets\Scoring\ScoreProcessor.cs" />
-    <Compile Include="Rulesets\UI\HealthDisplay.cs" />
+    <Compile Include="Screens\Play\HUD\HealthDisplay.cs" />
-    <Compile Include="Rulesets\UI\HudOverlay.cs" />
+    <Compile Include="Screens\Play\HUDOverlay.cs" />
-    <Compile Include="Rulesets\UI\StandardHealthDisplay.cs" />
+    <Compile Include="Screens\Play\HUD\StandardHealthDisplay.cs" />
-    <Compile Include="Rulesets\UI\StandardHudOverlay.cs" />
     <Compile Include="Online\API\IOnlineComponent.cs" />
     <Compile Include="Online\API\Requests\GetScoresRequest.cs" />
     <Compile Include="Online\API\Requests\GetBeatmapDetailsRequest.cs" />
@@ -228,7 +227,9 @@
     <Compile Include="Screens\Charts\ChartInfo.cs" />
     <Compile Include="Screens\Edit\Editor.cs" />
     <Compile Include="Screens\Play\HotkeyRetryOverlay.cs" />
+    <Compile Include="Screens\Play\HUD\ModDisplay.cs" />
     <Compile Include="Screens\Play\SquareGraph.cs" />
+    <Compile Include="Screens\Play\StandardHUDOverlay.cs" />
     <Compile Include="Screens\Ranking\ResultsPage.cs" />
     <Compile Include="Screens\Ranking\ResultsPageRanking.cs" />
     <Compile Include="Screens\Ranking\ResultsPageScore.cs" />
@@ -254,7 +255,7 @@
     <Compile Include="Screens\Play\PlayerLoader.cs" />
     <Compile Include="Screens\Play\ReplayPlayer.cs" />
     <Compile Include="Screens\Play\SkipButton.cs" />
-    <Compile Include="Rulesets\UI\StandardComboCounter.cs" />
+    <Compile Include="Screens\Play\HUD\StandardComboCounter.cs" />
     <Compile Include="Screens\Ranking\AspectContainer.cs" />
     <Compile Include="Screens\Ranking\ResultMode.cs" />
     <Compile Include="Screens\Ranking\ResultModeButton.cs" />
@@ -279,8 +280,8 @@
     <Compile Include="Rulesets\UI\HitRenderer.cs" />
     <Compile Include="Rulesets\UI\Playfield.cs" />
     <Compile Include="Screens\Select\EditSongSelect.cs" />
-    <Compile Include="Rulesets\UI\ComboCounter.cs" />
+    <Compile Include="Screens\Play\HUD\ComboCounter.cs" />
-    <Compile Include="Rulesets\UI\ComboResultCounter.cs" />
+    <Compile Include="Screens\Play\HUD\ComboResultCounter.cs" />
     <Compile Include="Graphics\UserInterface\RollingCounter.cs" />
     <Compile Include="Graphics\UserInterface\Volume\VolumeControlReceptor.cs" />
     <Compile Include="Input\GlobalHotkeys.cs" />
@@ -371,8 +372,10 @@
     <Compile Include="Overlays\Options\Sections\SkinSection.cs" />
     <Compile Include="Graphics\UserInterface\OsuCheckbox.cs" />
     <Compile Include="Overlays\Options\SidebarButton.cs" />
+    <Compile Include="Overlays\Options\OptionCheckbox.cs" />
     <Compile Include="Overlays\Options\OptionTextBox.cs" />
     <Compile Include="Overlays\Options\OptionSlider.cs" />
+    <Compile Include="Overlays\Options\OptionItem.cs" />
     <Compile Include="Overlays\Options\OptionEnumDropdown.cs" />
     <Compile Include="Configuration\RankingType.cs" />
     <Compile Include="Configuration\ScoreMeterType.cs" />
@@ -390,6 +393,7 @@
     <Compile Include="Screens\Play\Pause\PauseProgressGraph.cs" />
     <Compile Include="Overlays\Mods\ModSelectOverlay.cs" />
     <Compile Include="Rulesets\Mods\Mod.cs" />
+    <Compile Include="Overlays\Mods\ModButtonEmpty.cs" />
     <Compile Include="Overlays\Mods\ModButton.cs" />
     <Compile Include="Rulesets\UI\ModIcon.cs" />
     <Compile Include="Overlays\Mods\ModSection.cs" />

osu.sln.DotSettings

@@ -182,6 +182,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=GL/@EntryIndexedValue">GL</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=GLSL/@EntryIndexedValue">GLSL</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=HID/@EntryIndexedValue">HID</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=HUD/@EntryIndexedValue">HUD</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=ID/@EntryIndexedValue">ID</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IP/@EntryIndexedValue">IP</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IPC/@EntryIndexedValue">IPC</s:String>