Merge remote-tracking branch 'upstream/master' into quit-chat-channels

osu-framework

@@ -1 +1 @@
-Subproject commit 2a56eb0619adf654ed4927af1a4b227596c87494
+Subproject commit 1ba1e8ef1e5ec0466632be02492023a081cb85ab

osu.Desktop.Deploy/Program.cs

@@ -17,8 +17,8 @@ namespace osu.Desktop.Deploy
 {
     internal static class Program
     {
-        private const string nuget_path = @"packages\NuGet.CommandLine.3.5.0\tools\NuGet.exe";
-        private const string squirrel_path = @"packages\squirrel.windows.1.5.2\tools\Squirrel.exe";
+        private const string nuget_path = @"packages\NuGet.CommandLine.4.1.0\tools\NuGet.exe";
+        private const string squirrel_path = @"packages\squirrel.windows.1.7.5\tools\Squirrel.exe";
         private const string msbuild_path = @"C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe";
 
         public static string StagingFolder = ConfigurationManager.AppSettings["StagingFolder"];

osu.Desktop.Tests/Visual/OsuTestCase.cs

@@ -14,7 +14,7 @@ namespace osu.Desktop.Tests.Visual
         [Test]
         public override void RunTest()
         {
-            using (var host = new HeadlessGameHost())
+            using (var host = new HeadlessGameHost(realtime: false))
                 host.Run(new OsuTestCaseTestRunner(this));
         }
 

osu.Desktop.Tests/Visual/TestCaseHitObjects.cs

@@ -2,60 +2,38 @@
 // 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.Sprites;
-using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Timing;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using OpenTK;
-using OpenTK.Graphics;
+using osu.Game.Rulesets.Osu;
+using osu.Framework.Allocation;
+using osu.Game.Rulesets;
 
 namespace osu.Desktop.Tests.Visual
 {
     internal class TestCaseHitObjects : OsuTestCase
     {
-        private readonly FramedClock framedClock;
+        private FramedClock framedClock;
 
         private bool auto;
 
-        public TestCaseHitObjects()
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
         {
             var rateAdjustClock = new StopwatchClock(true);
             framedClock = new FramedClock(rateAdjustClock);
-            playbackSpeed.ValueChanged += delegate { rateAdjustClock.Rate = playbackSpeed.Value; };
-
-            playbackSpeed.TriggerChange();
 
             AddStep(@"circles", () => loadHitobjects(HitObjectType.Circle));
             AddStep(@"slider", () => loadHitobjects(HitObjectType.Slider));
             AddStep(@"spinner", () => loadHitobjects(HitObjectType.Spinner));
 
-            AddToggleStep(@"auto", state => { auto = state; loadHitobjects(mode); });
-
-            BasicSliderBar<double> sliderBar;
-            Add(new Container
-            {
-                Anchor = Anchor.TopRight,
-                Origin = Anchor.TopRight,
-                AutoSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new SpriteText { Text = "Playback Speed" },
-                    sliderBar = new BasicSliderBar<double>
-                    {
-                        Width = 150,
-                        Height = 10,
-                        SelectionColor = Color4.Orange,
-                    }
-                }
-            });
-
-            sliderBar.Current.BindTo(playbackSpeed);
+            AddToggleStep("Auto", state => { auto = state; loadHitobjects(mode); });
+            AddSliderStep("Playback speed", 0.0, 2.0, 0.5, v => rateAdjustClock.Rate = v);
 
             framedClock.ProcessFrame();
 
@@ -65,7 +43,7 @@ namespace osu.Desktop.Tests.Visual
                 Clock = framedClock,
                 Children = new[]
                 {
-                    playfieldContainer = new Container { RelativeSizeAxes = Axes.Both },
+                    playfieldContainer = new OsuInputManager(rulesets.GetRuleset(0)) { RelativeSizeAxes = Axes.Both },
                     approachContainer = new Container { RelativeSizeAxes = Axes.Both }
                 }
             };
@@ -75,9 +53,8 @@ namespace osu.Desktop.Tests.Visual
 
         private HitObjectType mode = HitObjectType.Slider;
 
-        private readonly BindableNumber<double> playbackSpeed = new BindableDouble(0.5) { MinValue = 0, MaxValue = 1 };
-        private readonly Container playfieldContainer;
-        private readonly Container approachContainer;
+        private Container playfieldContainer;
+        private Container approachContainer;
 
         private void loadHitobjects(HitObjectType mode)
         {

osu.Desktop.Tests/Visual/TestCaseKeyConfiguration.cs

@@ -0,0 +1,25 @@
+// 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.Game.Overlays;
+
+namespace osu.Desktop.Tests.Visual
+{
+    public class TestCaseKeyConfiguration : OsuTestCase
+    {
+        private readonly KeyBindingOverlay overlay;
+
+        public override string Description => @"Key configuration";
+
+        public TestCaseKeyConfiguration()
+        {
+            Child = overlay = new KeyBindingOverlay();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            overlay.Show();
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseKeyCounter.cs

@@ -1,16 +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.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
 using osu.Framework.MathUtils;
 using osu.Game.Screens.Play;
-using OpenTK;
-using OpenTK.Graphics;
 using OpenTK.Input;
 
 namespace osu.Desktop.Tests.Visual
@@ -34,69 +27,15 @@ namespace osu.Desktop.Tests.Visual
                     new KeyCounterMouse(MouseButton.Right),
                 },
             };
-            BindableInt bindable = new BindableInt { MinValue = 0, MaxValue = 200, Default = 50 };
-            bindable.ValueChanged += delegate { kc.FadeTime = bindable.Value; };
-            AddStep("Add Random", () =>
+
+            AddStep("Add random", () =>
             {
                 Key key = (Key)((int)Key.A + RNG.Next(26));
                 kc.Add(new KeyCounterKeyboard(key));
             });
-
-            TestSliderBar<int> sliderBar;
-
-            Add(new Container
-            {
-                Anchor = Anchor.TopRight,
-                Origin = Anchor.TopRight,
-                AutoSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    new SpriteText { Text = "FadeTime" },
-                    sliderBar = new TestSliderBar<int>
-                    {
-                        Width = 150,
-                        Height = 10,
-                        SelectionColor = Color4.Orange,
-                    }
-                }
-            });
-
-            sliderBar.Current.BindTo(bindable);
+            AddSliderStep("Fade time", 0, 200, 50, v => kc.FadeTime = v);
 
             Add(kc);
         }
-        private class TestSliderBar<T> : SliderBar<T> where T : struct
-        {
-            public Color4 Color
-            {
-                get { return Box.Colour; }
-                set { Box.Colour = value; }
-            }
-
-            public Color4 SelectionColor
-            {
-                get { return SelectionBox.Colour; }
-                set { SelectionBox.Colour = value; }
-            }
-
-            protected readonly Box SelectionBox;
-            protected readonly Box Box;
-
-            public TestSliderBar()
-            {
-                Children = new Drawable[]
-                {
-                    Box = new Box { RelativeSizeAxes = Axes.Both },
-                    SelectionBox = new Box { RelativeSizeAxes = Axes.Both }
-                };
-            }
-
-            protected override void UpdateValue(float value)
-            {
-                SelectionBox.ScaleTo(
-                    new Vector2(value, 1),
-                    300, Easing.OutQuint);
-            }
-        }
     }
 }

osu.Desktop.Tests/Visual/TestCaseManiaHitObjects.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using OpenTK;
@@ -40,8 +41,8 @@ namespace osu.Desktop.Tests.Visual
                                 RelativeChildSize = new Vector2(1, 10000),
                                 Children = new[]
                                 {
-                                    new DrawableNote(new Note { StartTime = 5000 }) { AccentColour = Color4.Red },
-                                    new DrawableNote(new Note { StartTime = 6000 }) { AccentColour = Color4.Red }
+                                    new DrawableNote(new Note { StartTime = 5000 }, ManiaAction.Key1) { AccentColour = Color4.Red },
+                                    new DrawableNote(new Note { StartTime = 6000 }, ManiaAction.Key1) { AccentColour = Color4.Red }
                                 }
                             }
                         }
@@ -66,7 +67,7 @@ namespace osu.Desktop.Tests.Visual
                                     {
                                         StartTime = 5000,
                                         Duration = 1000
-                                    }) { AccentColour = Color4.Red }
+                                    }, ManiaAction.Key1) { AccentColour = Color4.Red }
                                 }
                             }
                         }

osu.Desktop.Tests/Visual/TestCaseManiaPlayfield.cs

@@ -1,111 +1,34 @@
 // 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 System.Linq;
-using osu.Framework.Configuration;
+using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Input;
 using osu.Framework.Timing;
+using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Timing;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Timing;
-using OpenTK;
-using OpenTK.Input;
+using osu.Game.Rulesets;
 
 namespace osu.Desktop.Tests.Visual
 {
     internal class TestCaseManiaPlayfield : OsuTestCase
     {
+        private const double start_time = 500;
+        private const double duration = 500;
+
         public override string Description => @"Mania playfield";
 
         protected override double TimePerAction => 200;
 
+        private RulesetInfo maniaRuleset;
+
         public TestCaseManiaPlayfield()
         {
-            Action<int, SpecialColumnPosition> createPlayfield = (cols, pos) =>
-            {
-                Clear();
-                Add(new ManiaPlayfield(cols)
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    SpecialColumnPosition = pos,
-                    Scale = new Vector2(1, -1)
-                });
-            };
-
-            const double start_time = 500;
-            const double duration = 500;
-
-            Func<double, bool, SpeedAdjustmentContainer> createTimingChange = (time, gravity) => new ManiaSpeedAdjustmentContainer(new MultiplierControlPoint(time)
-            {
-                TimingPoint = { BeatLength = 1000 }
-            }, gravity ? ScrollingAlgorithm.Gravity : ScrollingAlgorithm.Basic);
-
-            Action<bool> createPlayfieldWithNotes = gravity =>
-            {
-                Clear();
-
-                var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
-
-                ManiaPlayfield playField;
-                Add(playField = new ManiaPlayfield(4)
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Scale = new Vector2(1, -1),
-                    Clock = new FramedClock(rateAdjustClock)
-                });
-
-                if (!gravity)
-                    playField.Columns.ForEach(c => c.Add(createTimingChange(0, false)));
-
-                for (double t = start_time; t <= start_time + duration; t += 100)
-                {
-                    if (gravity)
-                        playField.Columns.ElementAt(0).Add(createTimingChange(t, true));
-
-                    playField.Add(new DrawableNote(new Note
-                    {
-                        StartTime = t,
-                        Column = 0
-                    }, new Bindable<Key>(Key.D)));
-
-                    if (gravity)
-                        playField.Columns.ElementAt(3).Add(createTimingChange(t, true));
-
-                    playField.Add(new DrawableNote(new Note
-                    {
-                        StartTime = t,
-                        Column = 3
-                    }, new Bindable<Key>(Key.K)));
-                }
-
-                if (gravity)
-                    playField.Columns.ElementAt(1).Add(createTimingChange(start_time, true));
-
-                playField.Add(new DrawableHoldNote(new HoldNote
-                {
-                    StartTime = start_time,
-                    Duration = duration,
-                    Column = 1
-                }, new Bindable<Key>(Key.F)));
-
-                if (gravity)
-                    playField.Columns.ElementAt(2).Add(createTimingChange(start_time, true));
-
-                playField.Add(new DrawableHoldNote(new HoldNote
-                {
-                    StartTime = start_time,
-                    Duration = duration,
-                    Column = 2
-                }, new Bindable<Key>(Key.J)));
-            };
-
             AddStep("1 column", () => createPlayfield(1, SpecialColumnPosition.Normal));
             AddStep("4 columns", () => createPlayfield(4, SpecialColumnPosition.Normal));
             AddStep("Left special style", () => createPlayfield(4, SpecialColumnPosition.Left));
@@ -114,29 +37,105 @@ namespace osu.Desktop.Tests.Visual
             AddStep("8 columns", () => createPlayfield(8, SpecialColumnPosition.Normal));
             AddStep("Left special style", () => createPlayfield(8, SpecialColumnPosition.Left));
             AddStep("Right special style", () => createPlayfield(8, SpecialColumnPosition.Right));
+            AddStep("Reversed", () => createPlayfield(4, SpecialColumnPosition.Normal, true));
 
             AddStep("Notes with input", () => createPlayfieldWithNotes(false));
-            AddWaitStep((int)Math.Ceiling((start_time + duration) / TimePerAction));
-
+            AddStep("Notes with input (reversed)", () => createPlayfieldWithNotes(false, true));
             AddStep("Notes with gravity", () => createPlayfieldWithNotes(true));
-            AddWaitStep((int)Math.Ceiling((start_time + duration) / TimePerAction));
+            AddStep("Notes with gravity (reversed)", () => createPlayfieldWithNotes(true, true));
         }
 
-        private void triggerKeyDown(Column column)
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
         {
-            column.TriggerOnKeyDown(new InputState(), new KeyDownEventArgs
-            {
-                Key = column.Key,
-                Repeat = false
-            });
+            maniaRuleset = rulesets.GetRuleset(3);
         }
 
-        private void triggerKeyUp(Column column)
+        private SpeedAdjustmentContainer createTimingChange(double time, bool gravity) => new ManiaSpeedAdjustmentContainer(new MultiplierControlPoint(time)
         {
-            column.TriggerOnKeyUp(new InputState(), new KeyUpEventArgs
+            TimingPoint = { BeatLength = 1000 }
+        }, gravity ? ScrollingAlgorithm.Gravity : ScrollingAlgorithm.Basic);
+
+        private void createPlayfield(int cols, SpecialColumnPosition specialPos, bool inverted = false)
+        {
+            Clear();
+
+            var inputManager = new ManiaInputManager(maniaRuleset, cols) { RelativeSizeAxes = Axes.Both };
+            Add(inputManager);
+
+            ManiaPlayfield playfield;
+            inputManager.Add(playfield = new ManiaPlayfield(cols)
             {
-                Key = column.Key
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                SpecialColumnPosition = specialPos
             });
+
+            playfield.Inverted.Value = inverted;
+        }
+
+        private void createPlayfieldWithNotes(bool gravity, bool inverted = false)
+        {
+            Clear();
+
+            var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
+
+            var inputManager = new ManiaInputManager(maniaRuleset, 4) { RelativeSizeAxes = Axes.Both };
+            Add(inputManager);
+
+            ManiaPlayfield playfield;
+            inputManager.Add(playfield = new ManiaPlayfield(4)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Clock = new FramedClock(rateAdjustClock)
+            });
+
+            playfield.Inverted.Value = inverted;
+
+            if (!gravity)
+                playfield.Columns.ForEach(c => c.Add(createTimingChange(0, false)));
+
+            for (double t = start_time; t <= start_time + duration; t += 100)
+            {
+                if (gravity)
+                    playfield.Columns.ElementAt(0).Add(createTimingChange(t, true));
+
+                playfield.Add(new DrawableNote(new Note
+                {
+                    StartTime = t,
+                    Column = 0
+                }, ManiaAction.Key1));
+
+                if (gravity)
+                    playfield.Columns.ElementAt(3).Add(createTimingChange(t, true));
+
+                playfield.Add(new DrawableNote(new Note
+                {
+                    StartTime = t,
+                    Column = 3
+                }, ManiaAction.Key4));
+            }
+
+            if (gravity)
+                playfield.Columns.ElementAt(1).Add(createTimingChange(start_time, true));
+
+            playfield.Add(new DrawableHoldNote(new HoldNote
+            {
+                StartTime = start_time,
+                Duration = duration,
+                Column = 1
+            }, ManiaAction.Key2));
+
+            if (gravity)
+                playfield.Columns.ElementAt(2).Add(createTimingChange(start_time, true));
+
+            playfield.Add(new DrawableHoldNote(new HoldNote
+            {
+                StartTime = start_time,
+                Duration = duration,
+                Column = 2
+            }, ManiaAction.Key3));
         }
     }
 }

osu.Desktop.Tests/Visual/TestCaseNotificationOverlay.cs

@@ -68,7 +68,7 @@ namespace osu.Desktop.Tests.Visual
 
             while (progressingNotifications.Count(n => n.State == ProgressNotificationState.Active) < 3)
             {
-                var p = progressingNotifications.FirstOrDefault(n => n.IsLoaded && n.State == ProgressNotificationState.Queued);
+                var p = progressingNotifications.FirstOrDefault(n => n.IsAlive && n.State == ProgressNotificationState.Queued);
                 if (p == null)
                     break;
 

osu.Desktop.Tests/Visual/TestCaseScrollingPlayfield.cs

@@ -3,18 +3,23 @@
 
 using System;
 using System.Collections.Generic;
+using NUnit.Framework;
 using OpenTK;
 using osu.Desktop.Tests.Beatmaps;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Timing;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Desktop.Tests.Visual
@@ -22,6 +27,7 @@ namespace osu.Desktop.Tests.Visual
     /// <summary>
     /// The most minimal implementation of a playfield with scrolling hit objects.
     /// </summary>
+    [TestFixture]
     public class TestCaseScrollingPlayfield : OsuTestCase
     {
         public TestCaseScrollingPlayfield()
@@ -58,11 +64,71 @@ namespace osu.Desktop.Tests.Visual
 
             AddStep("Reverse direction", () =>
             {
-                horizontalRulesetContainer.Playfield.Reversed.Toggle();
-                verticalRulesetContainer.Playfield.Reversed.Toggle();
+                horizontalRulesetContainer.Playfield.Reverse();
+                verticalRulesetContainer.Playfield.Reverse();
             });
         }
 
+        [Test]
+        public void TestSpeedAdjustmentOrdering()
+        {
+            var hitObjectContainer = new ScrollingPlayfield<TestHitObject, TestJudgement>.ScrollingHitObjectContainer(Axes.X);
+
+            var speedAdjustments = new[]
+            {
+                new SpeedAdjustmentContainer(new MultiplierControlPoint()),
+                new SpeedAdjustmentContainer(new MultiplierControlPoint(1000)
+                {
+                    TimingPoint = new TimingControlPoint { BeatLength = 500 }
+                }),
+                new SpeedAdjustmentContainer(new MultiplierControlPoint(2000)
+                {
+                    TimingPoint = new TimingControlPoint { BeatLength = 1000 },
+                    DifficultyPoint = new DifficultyControlPoint { SpeedMultiplier = 2}
+                }),
+                new SpeedAdjustmentContainer(new MultiplierControlPoint(3000)
+                {
+                    TimingPoint = new TimingControlPoint { BeatLength = 1000 },
+                    DifficultyPoint = new DifficultyControlPoint { SpeedMultiplier = 1}
+                }),
+            };
+
+            var hitObjects = new[]
+            {
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = -1000 }),
+                new DrawableTestHitObject(Axes.X, new TestHitObject()),
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = 1000 }),
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = 2000 }),
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = 3000 }),
+                new DrawableTestHitObject(Axes.X, new TestHitObject { StartTime = 4000 }),
+            };
+
+            hitObjects.ForEach(h => hitObjectContainer.Add(h));
+            speedAdjustments.ForEach(hitObjectContainer.AddSpeedAdjustment);
+
+            // The 0th index in hitObjectContainer.SpeedAdjustments is the "default" control point
+            // Check multiplier of the default speed adjustment
+            Assert.AreEqual(1, hitObjectContainer.SpeedAdjustments[0].ControlPoint.Multiplier);
+            Assert.AreEqual(1, speedAdjustments[0].ControlPoint.Multiplier);
+            Assert.AreEqual(2, speedAdjustments[1].ControlPoint.Multiplier);
+            Assert.AreEqual(2, speedAdjustments[2].ControlPoint.Multiplier);
+            Assert.AreEqual(1, speedAdjustments[3].ControlPoint.Multiplier);
+
+            // Check insertion of hit objects
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[4].Contains(hitObjects[0]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[3].Contains(hitObjects[1]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[2].Contains(hitObjects[2]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[1].Contains(hitObjects[3]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[0].Contains(hitObjects[4]));
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[0].Contains(hitObjects[5]));
+
+            hitObjectContainer.RemoveSpeedAdjustment(hitObjectContainer.SpeedAdjustments[3]);
+
+            // The hit object contained in this speed adjustment should be resorted into the one occuring before it
+
+            Assert.IsTrue(hitObjectContainer.SpeedAdjustments[3].Contains(hitObjects[1]));
+        }
+
         private class TestRulesetContainer : ScrollingRulesetContainer<TestPlayfield, TestHitObject, TestJudgement>
         {
             private readonly Axes scrollingAxes;
@@ -77,6 +143,8 @@ namespace osu.Desktop.Tests.Visual
 
             public override ScoreProcessor CreateScoreProcessor() => new TestScoreProcessor();
 
+            public override PassThroughInputManager CreateInputManager() => new PassThroughInputManager();
+
             protected override BeatmapConverter<TestHitObject> CreateBeatmapConverter() => new TestBeatmapConverter();
 
             protected override Playfield<TestHitObject, TestJudgement> CreatePlayfield() => new TestPlayfield(scrollingAxes);
@@ -142,6 +210,8 @@ namespace osu.Desktop.Tests.Visual
                     content = new Container { RelativeSizeAxes = Axes.Both }
                 };
             }
+
+            public void Reverse() => Reversed.Toggle();
         }
 
 
@@ -155,4 +225,4 @@ namespace osu.Desktop.Tests.Visual
             public override string MaxResultString { get { throw new NotImplementedException(); } }
         }
     }
-}
+}

osu.Desktop.Tests/Visual/TestCaseSettings.cs

@@ -13,7 +13,7 @@ namespace osu.Desktop.Tests.Visual
 
         public TestCaseSettings()
         {
-            Children = new[] { settings = new SettingsOverlay() };
+            Children = new[] { settings = new MainSettings() };
         }
 
         protected override void LoadComplete()

osu.Desktop.Tests/Visual/TestCaseTaikoPlayfield.cs

@@ -14,6 +14,11 @@ using osu.Game.Rulesets.Taiko.UI;
 using OpenTK;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps;
+using osu.Desktop.Tests.Beatmaps;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Desktop.Tests.Visual
 {
@@ -27,10 +32,11 @@ namespace osu.Desktop.Tests.Visual
         protected override double TimePerAction => default_duration * 2;
 
         private readonly Random rng = new Random(1337);
-        private readonly TaikoPlayfield playfield;
-        private readonly Container playfieldContainer;
+        private TaikoRulesetContainer rulesetContainer;
+        private Container playfieldContainer;
 
-        public TestCaseTaikoPlayfield()
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
         {
             AddStep("Hit!", () => addHitJudgement(false));
             AddStep("Kiai hit", () => addHitJudgement(true));
@@ -51,6 +57,25 @@ namespace osu.Desktop.Tests.Visual
             AddStep("Height test 5", () => changePlayfieldSize(5));
             AddStep("Reset height", () => changePlayfieldSize(6));
 
+            var controlPointInfo = new ControlPointInfo();
+            controlPointInfo.TimingPoints.Add(new TimingControlPoint());
+
+            WorkingBeatmap beatmap = new TestWorkingBeatmap(new Beatmap
+            {
+                HitObjects = new List<HitObject> { new CentreHit() },
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Difficulty = new BeatmapDifficulty(),
+                    Metadata = new BeatmapMetadata
+                    {
+                        Artist = @"Unknown",
+                        Title = @"Sample Beatmap",
+                        Author = @"peppy",
+                    },
+                },
+                ControlPointInfo = controlPointInfo
+            });
+
             var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
 
             Add(playfieldContainer = new Container
@@ -58,12 +83,9 @@ namespace osu.Desktop.Tests.Visual
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 RelativeSizeAxes = Axes.X,
-                Height = TaikoPlayfield.DEFAULT_HEIGHT,
+                Height = 768,
                 Clock = new FramedClock(rateAdjustClock),
-                Children = new[]
-                {
-                    playfield = new TaikoPlayfield()
-                }
+                Children = new[] { rulesetContainer = new TaikoRulesetContainer(rulesets.GetRuleset(1).CreateInstance(), beatmap, true) }
             });
         }
 
@@ -128,18 +150,18 @@ namespace osu.Desktop.Tests.Visual
                 }
             };
 
-            playfield.OnJudgement(h);
+            rulesetContainer.Playfield.OnJudgement(h);
 
             if (RNG.Next(10) == 0)
             {
                 h.Judgement.SecondHit = true;
-                playfield.OnJudgement(h);
+                rulesetContainer.Playfield.OnJudgement(h);
             }
         }
 
         private void addMissJudgement()
         {
-            playfield.OnJudgement(new DrawableTestHit(new Hit())
+            rulesetContainer.Playfield.OnJudgement(new DrawableTestHit(new Hit())
             {
                 Judgement = new TaikoJudgement
                 {
@@ -151,22 +173,17 @@ namespace osu.Desktop.Tests.Visual
 
         private void addBarLine(bool major, double delay = scroll_time)
         {
-            BarLine bl = new BarLine
-            {
-                StartTime = playfield.Time.Current + delay,
-                ScrollTime = scroll_time
-            };
+            BarLine bl = new BarLine { StartTime = rulesetContainer.Playfield.Time.Current + delay };
 
-            playfield.AddBarLine(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
+            rulesetContainer.Playfield.Add(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
         }
 
         private void addSwell(double duration = default_duration)
         {
-            playfield.Add(new DrawableSwell(new Swell
+            rulesetContainer.Playfield.Add(new DrawableSwell(new Swell
             {
-                StartTime = playfield.Time.Current + scroll_time,
+                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
                 Duration = duration,
-                ScrollTime = scroll_time
             }));
         }
 
@@ -177,43 +194,40 @@ namespace osu.Desktop.Tests.Visual
 
             var d = new DrumRoll
             {
-                StartTime = playfield.Time.Current + scroll_time,
+                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
                 IsStrong = strong,
                 Duration = duration,
-                ScrollTime = scroll_time,
             };
 
-            playfield.Add(new DrawableDrumRoll(d));
+            rulesetContainer.Playfield.Add(new DrawableDrumRoll(d));
         }
 
         private void addCentreHit(bool strong)
         {
             Hit h = new Hit
             {
-                StartTime = playfield.Time.Current + scroll_time,
-                ScrollTime = scroll_time,
+                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
                 IsStrong = strong
             };
 
             if (strong)
-                playfield.Add(new DrawableCentreHitStrong(h));
+                rulesetContainer.Playfield.Add(new DrawableCentreHitStrong(h));
             else
-                playfield.Add(new DrawableCentreHit(h));
+                rulesetContainer.Playfield.Add(new DrawableCentreHit(h));
         }
 
         private void addRimHit(bool strong)
         {
             Hit h = new Hit
             {
-                StartTime = playfield.Time.Current + scroll_time,
-                ScrollTime = scroll_time,
+                StartTime = rulesetContainer.Playfield.Time.Current + scroll_time,
                 IsStrong = strong
             };
 
             if (strong)
-                playfield.Add(new DrawableRimHitStrong(h));
+                rulesetContainer.Playfield.Add(new DrawableRimHitStrong(h));
             else
-                playfield.Add(new DrawableRimHit(h));
+                rulesetContainer.Playfield.Add(new DrawableRimHit(h));
         }
 
         private class DrawableTestHit : DrawableHitObject<TaikoHitObject, TaikoJudgement>

osu.Desktop.Tests/osu.Desktop.Tests.csproj

@@ -81,6 +81,7 @@
     <Compile Include="Visual\TestCaseGamefield.cs" />
     <Compile Include="Visual\TestCaseGraph.cs" />
     <Compile Include="Visual\TestCaseHitObjects.cs" />
+    <Compile Include="Visual\TestCaseKeyConfiguration.cs" />
     <Compile Include="Visual\TestCaseKeyCounter.cs" />
     <Compile Include="Visual\TestCaseLeaderboard.cs" />
     <Compile Include="Visual\TestCaseManiaHitObjects.cs" />

osu.Desktop/OsuGameDesktop.cs

@@ -20,16 +20,11 @@ namespace osu.Desktop
 {
     internal class OsuGameDesktop : OsuGame
     {
-        private readonly VersionManager versionManager;
+        private VersionManager versionManager;
 
         public OsuGameDesktop(string[] args = null)
             : base(args)
         {
-            versionManager = new VersionManager
-            {
-                Depth = int.MinValue,
-                State = Visibility.Hidden
-            };
         }
 
         public override Storage GetStorageForStableInstall()
@@ -88,11 +83,15 @@ namespace osu.Desktop
         {
             base.LoadComplete();
 
-            LoadComponentAsync(versionManager, Add);
+            LoadComponentAsync(versionManager = new VersionManager { Depth = int.MinValue });
+
             ScreenChanged += s =>
             {
-                if (!versionManager.IsPresent && s is Intro)
+                if (s is Intro && s.ChildScreen == null)
+                {
+                    Add(versionManager);
                     versionManager.State = Visibility.Visible;
+                }
             };
         }
 

osu.Desktop/Overlays/VersionManager.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -19,6 +20,7 @@ using OpenTK.Graphics;
 using System.Net.Http;
 using osu.Framework.Logging;
 using osu.Game;
+using osu.Game.Configuration;
 
 namespace osu.Desktop.Overlays
 {
@@ -26,19 +28,22 @@ namespace osu.Desktop.Overlays
     {
         private UpdateManager updateManager;
         private NotificationOverlay notificationOverlay;
-
-        protected override bool HideOnEscape => false;
+        private OsuConfigManager config;
+        private OsuGameBase game;
 
         public override bool HandleInput => false;
 
         [BackgroundDependencyLoader]
-        private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game)
+        private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game, OsuConfigManager config)
         {
             notificationOverlay = notification;
+            this.config = config;
+            this.game = game;
 
             AutoSizeAxes = Axes.Both;
             Anchor = Anchor.BottomCentre;
             Origin = Anchor.BottomCentre;
+
             Alpha = 0;
 
             Children = new Drawable[]
@@ -93,6 +98,42 @@ namespace osu.Desktop.Overlays
                 checkForUpdateAsync();
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            var version = game.Version;
+            var lastVersion = config.Get<string>(OsuSetting.Version);
+            if (game.IsDeployedBuild && version != lastVersion)
+            {
+                config.Set(OsuSetting.Version, version);
+
+                // only show a notification if we've previously saved a version to the config file (ie. not the first run).
+                if (!string.IsNullOrEmpty(lastVersion))
+                    Scheduler.AddDelayed(() => notificationOverlay.Post(new UpdateCompleteNotification(version)), 5000);
+            }
+        }
+
+        private class UpdateCompleteNotification : SimpleNotification
+        {
+            public UpdateCompleteNotification(string version)
+            {
+                Text = $"You are now running osu!lazer {version}.\nClick to see what's new!";
+                Icon = FontAwesome.fa_check_square;
+                Activated = delegate
+                {
+                    Process.Start($"https://github.com/ppy/osu/releases/tag/v{version}");
+                    return true;
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                IconBackgound.Colour = colours.BlueDark;
+            }
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);

osu.Game.Rulesets.Catch/CatchInputManager.cs

@@ -1,30 +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 System.Collections.Generic;
 using System.ComponentModel;
 using osu.Framework.Input.Bindings;
-using osu.Game.Input.Bindings;
-using OpenTK.Input;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch
 {
-    public class CatchInputManager : DatabasedKeyBindingInputManager<CatchAction>
+    public class CatchInputManager : RulesetInputManager<CatchAction>
     {
         public CatchInputManager(RulesetInfo ruleset)
-            : base(ruleset, simultaneousMode: SimultaneousBindingMode.Unique)
+            : base(ruleset, 0, SimultaneousBindingMode.Unique)
         {
         }
-
-        protected override IEnumerable<KeyBinding> CreateDefaultMappings() => new[]
-        {
-            new KeyBinding(Key.Z, CatchAction.MoveLeft),
-            new KeyBinding(Key.Left, CatchAction.MoveLeft),
-            new KeyBinding(Key.X, CatchAction.MoveRight),
-            new KeyBinding(Key.Right, CatchAction.MoveRight),
-            new KeyBinding(Key.LShift, CatchAction.Dash),
-            new KeyBinding(Key.RShift, CatchAction.Dash),
-        };
     }
 
     public enum CatchAction

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -1,18 +1,17 @@
 // 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.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Mods;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Scoring;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Rulesets.Catch
 {
@@ -20,6 +19,16 @@ namespace osu.Game.Rulesets.Catch
     {
         public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchRulesetContainer(this, beatmap, isForCurrentRuleset);
 
+        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
+        {
+            new KeyBinding(InputKey.Z, CatchAction.MoveLeft),
+            new KeyBinding(InputKey.Left, CatchAction.MoveLeft),
+            new KeyBinding(InputKey.X, CatchAction.MoveRight),
+            new KeyBinding(InputKey.Right, CatchAction.MoveRight),
+            new KeyBinding(InputKey.Shift, CatchAction.Dash),
+            new KeyBinding(InputKey.Shift, CatchAction.Dash),
+        };
+
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
             switch (type)
@@ -90,13 +99,6 @@ namespace osu.Game.Rulesets.Catch
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_fruits_o };
 
-        public override IEnumerable<KeyCounter> CreateGameplayKeys() => new KeyCounter[]
-        {
-            new KeyCounterKeyboard(Key.ShiftLeft),
-            new KeyCounterMouse(MouseButton.Left),
-            new KeyCounterMouse(MouseButton.Right)
-        };
-
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new CatchDifficultyCalculator(beatmap);
 
         public override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor();

osu.Game.Rulesets.Catch/UI/CatchRulesetContainer.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override Playfield<CatchBaseHit, CatchJudgement> CreatePlayfield() => new CatchPlayfield();
 
-        protected override PassThroughInputManager CreateActionMappingInputManager() => new CatchInputManager(Ruleset?.RulesetInfo);
+        public override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
 
         protected override DrawableHitObject<CatchBaseHit, CatchJudgement> GetVisualRepresentation(CatchBaseHit h)
         {

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -28,12 +28,20 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         private Pattern lastPattern = new Pattern();
         private FastRandom random;
         private Beatmap beatmap;
-        private bool isForCurrentRuleset;
 
-        protected override Beatmap<ManiaHitObject> ConvertBeatmap(Beatmap original, bool isForCurrentRuleset)
+        private readonly int availableColumns;
+        private readonly bool isForCurrentRuleset;
+
+        public ManiaBeatmapConverter(bool isForCurrentRuleset, int availableColumns)
         {
-            this.isForCurrentRuleset = isForCurrentRuleset;
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
 
+            this.isForCurrentRuleset = isForCurrentRuleset;
+            this.availableColumns = availableColumns;
+        }
+
+        protected override Beatmap<ManiaHitObject> ConvertBeatmap(Beatmap original)
+        {
             beatmap = original;
 
             BeatmapDifficulty difficulty = original.BeatmapInfo.Difficulty;
@@ -41,7 +49,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             int seed = (int)Math.Round(difficulty.DrainRate + difficulty.CircleSize) * 20 + (int)(difficulty.OverallDifficulty * 41.2) + (int)Math.Round(difficulty.ApproachRate);
             random = new FastRandom(seed);
 
-            return base.ConvertBeatmap(original, isForCurrentRuleset);
+            return base.ConvertBeatmap(original);
         }
 
         protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
@@ -89,7 +97,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// <returns>The hit objects generated.</returns>
         private IEnumerable<ManiaHitObject> generateSpecific(HitObject original)
         {
-            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, lastPattern);
+            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, availableColumns, lastPattern);
 
             Pattern newPattern = generator.Generate();
             lastPattern = newPattern;
@@ -113,14 +121,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             Patterns.PatternGenerator conversion = null;
 
             if (distanceData != null)
-                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, lastPattern);
+                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, availableColumns, lastPattern);
             else if (endTimeData != null)
-                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap);
+                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap, availableColumns);
             else if (positionData != null)
             {
                 computeDensity(original.StartTime);
 
-                conversion = new HitObjectPatternGenerator(random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair);
+                conversion = new HitObjectPatternGenerator(random, original, beatmap, availableColumns, lastPattern, lastTime, lastPosition, density, lastStair);
 
                 recordNote(original.StartTime, positionData.Position);
             }
@@ -142,8 +150,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// </summary>
         private class SpecificBeatmapPatternGenerator : Patterns.Legacy.PatternGenerator
         {
-            public SpecificBeatmapPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-                : base(random, hitObject, beatmap, previousPattern)
+            public SpecificBeatmapPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+                : base(random, hitObject, beatmap, availableColumns, previousPattern)
             {
             }
 

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs

@@ -29,8 +29,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         private PatternType convertType;
 
-        public DistanceObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-            : base(random, hitObject, beatmap, previousPattern)
+        public DistanceObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+            : base(random, hitObject, beatmap, availableColumns, previousPattern)
         {
             convertType = PatternType.None;
             if (Beatmap.ControlPointInfo.EffectPointAt(hitObject.StartTime).KiaiMode)
@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             // The true distance, accounting for any repeats
             double distance = (distanceData?.Distance ?? 0) * repeatCount;
             // The velocity of the osu! hit object - calculated as the velocity of a slider
-            double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.Difficulty.SliderMultiplier / (timingPoint.BeatLength * difficultyPoint.SpeedMultiplier);
+            double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.Difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier / timingPoint.BeatLength;
             // The duration of the osu! hit object
             double osuDuration = distance / osuVelocity;
 

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs

@@ -15,8 +15,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
     {
         private readonly double endTime;
 
-        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap)
-            : base(random, hitObject, beatmap, new Pattern())
+        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns)
+            : base(random, hitObject, beatmap, availableColumns, new Pattern())
         {
             var endtimeData = HitObject as IHasEndTime;
 

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs

@@ -20,9 +20,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         private readonly PatternType convertType;
 
-        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density, PatternType lastStair)
-            : base(random, hitObject, beatmap, previousPattern)
+        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density, PatternType lastStair)
+            : base(random, hitObject, beatmap, availableColumns, previousPattern)
         {
+            if (previousTime > hitObject.StartTime) throw new ArgumentOutOfRangeException(nameof(previousTime));
+            if (density < 0) throw new ArgumentOutOfRangeException(nameof(density));
+
             StairType = lastStair;
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternGenerator.cs

@@ -25,11 +25,15 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         protected readonly FastRandom Random;
 
-        protected PatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-            : base(hitObject, beatmap, previousPattern)
+        protected PatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+            : base(hitObject, beatmap, availableColumns, previousPattern)
         {
-            Random = random;
+            if (random == null) throw new ArgumentNullException(nameof(random));
+            if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
+            if (previousPattern == null) throw new ArgumentNullException(nameof(previousPattern));
 
+            Random = random;
             RandomStart = AvailableColumns == 8 ? 1 : 0;
         }
 
@@ -62,6 +66,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <returns>The amount of notes to be generated.</returns>
         protected int GetRandomNoteCount(double p2, double p3, double p4 = 0, double p5 = 0, double p6 = 0)
         {
+            if (p2 < 0 || p2 > 1) throw new ArgumentOutOfRangeException(nameof(p2));
+            if (p3 < 0 || p3 > 1) throw new ArgumentOutOfRangeException(nameof(p3));
+            if (p4 < 0 || p4 > 1) throw new ArgumentOutOfRangeException(nameof(p4));
+            if (p5 < 0 || p5 > 1) throw new ArgumentOutOfRangeException(nameof(p5));
+            if (p6 < 0 || p6 > 1) throw new ArgumentOutOfRangeException(nameof(p6));
+
             double val = Random.NextDouble();
             if (val >= 1 - p6)
                 return 6;

osu.Game.Rulesets.Mania/Beatmaps/Patterns/PatternGenerator.cs

@@ -32,13 +32,17 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
         /// </summary>
         protected readonly Beatmap Beatmap;
 
-        protected PatternGenerator(HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
+        protected PatternGenerator(HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
         {
-            PreviousPattern = previousPattern;
+            if (hitObject == null) throw new ArgumentNullException(nameof(hitObject));
+            if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
+            if (previousPattern == null) throw new ArgumentNullException(nameof(previousPattern));
+
             HitObject = hitObject;
             Beatmap = beatmap;
-
-            AvailableColumns = (int)Math.Round(beatmap.BeatmapInfo.Difficulty.CircleSize);
+            AvailableColumns = availableColumns;
+            PreviousPattern = previousPattern;
         }
 
         /// <summary>

osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs

@@ -6,6 +6,7 @@ using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using System.Collections.Generic;
+using System;
 
 namespace osu.Game.Rulesets.Mania
 {
@@ -21,6 +22,6 @@ namespace osu.Game.Rulesets.Mania
             return 0;
         }
 
-        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter();
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter(true, (int)Math.Max(1, Math.Round(Beatmap.BeatmapInfo.Difficulty.CircleSize)));
     }
-}
+}

osu.Game.Rulesets.Mania/ManiaInputManager.cs

@@ -0,0 +1,41 @@
+// 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.ComponentModel;
+using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class ManiaInputManager : RulesetInputManager<ManiaAction>
+    {
+        public ManiaInputManager(RulesetInfo ruleset, int variant)
+            : base(ruleset, variant, SimultaneousBindingMode.Unique)
+        {
+        }
+    }
+
+    public enum ManiaAction
+    {
+        [Description("Special")]
+        Special,
+        [Description("Key 1")]
+        Key1 = 10,
+        [Description("Key 2")]
+        Key2,
+        [Description("Key 3")]
+        Key3,
+        [Description("Key 4")]
+        Key4,
+        [Description("Key 5")]
+        Key5,
+        [Description("Key 6")]
+        Key6,
+        [Description("Key 7")]
+        Key7,
+        [Description("Key 8")]
+        Key8,
+        [Description("Key 9")]
+        Key9
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -6,9 +6,9 @@ using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Scoring;
@@ -111,8 +111,6 @@ namespace osu.Game.Rulesets.Mania
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_mania_o };
 
-        public override IEnumerable<KeyCounter> CreateGameplayKeys() => new KeyCounter[] { /* Todo: Should be keymod specific */ };
-
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new ManiaDifficultyCalculator(beatmap);
 
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor();
@@ -123,5 +121,43 @@ namespace osu.Game.Rulesets.Mania
             : base(rulesetInfo)
         {
         }
+
+        public override IEnumerable<int> AvailableVariants => new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0)
+        {
+            var leftKeys = new[]
+            {
+                InputKey.A,
+                InputKey.S,
+                InputKey.D,
+                InputKey.F
+            };
+
+            var rightKeys = new[]
+            {
+                InputKey.J,
+                InputKey.K,
+                InputKey.L,
+                InputKey.Semicolon
+            };
+
+            ManiaAction currentKey = ManiaAction.Key1;
+
+            var bindings = new List<KeyBinding>();
+
+            for (int i = leftKeys.Length - variant / 2; i < leftKeys.Length; i++)
+                bindings.Add(new KeyBinding(leftKeys[i], currentKey++));
+
+            for (int i = 0; i < variant / 2; i++)
+                bindings.Add(new KeyBinding(rightKeys[i], currentKey++));
+
+            if (variant % 2 == 1)
+                bindings.Add(new KeyBinding(InputKey.Space, ManiaAction.Special));
+
+            return bindings;
+        }
+
+        public override string GetVariantName(int variant) => $"{variant}K";
     }
 }

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs

@@ -5,20 +5,18 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using OpenTK.Graphics;
-using osu.Framework.Configuration;
-using OpenTK.Input;
-using osu.Framework.Input;
 using OpenTK;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
     /// <summary>
     /// Visualises a <see cref="HoldNote"/> hit object.
     /// </summary>
-    public class DrawableHoldNote : DrawableManiaHitObject<HoldNote>
+    public class DrawableHoldNote : DrawableManiaHitObject<HoldNote>, IKeyBindingHandler<ManiaAction>
     {
         private readonly DrawableNote head;
         private readonly DrawableNote tail;
@@ -36,8 +34,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// </summary>
         private bool hasBroken;
 
-        public DrawableHoldNote(HoldNote hitObject, Bindable<Key> key = null)
-            : base(hitObject, key)
+        public DrawableHoldNote(HoldNote hitObject, ManiaAction action)
+            : base(hitObject, action)
         {
             RelativeSizeAxes = Axes.Both;
             Height = (float)HitObject.Duration;
@@ -58,12 +56,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     RelativeChildOffset = new Vector2(0, (float)HitObject.StartTime),
                     RelativeChildSize = new Vector2(1, (float)HitObject.Duration)
                 },
-                head = new DrawableHeadNote(this, key)
+                head = new DrawableHeadNote(this, action)
                 {
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre
                 },
-                tail = new DrawableTailNote(this, key)
+                tail = new DrawableTailNote(this, action)
                 {
                     Anchor = Anchor.BottomCentre,
                     Origin = Anchor.TopCentre
@@ -106,16 +104,13 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        public bool OnPressed(ManiaAction action)
         {
-            // Make sure the keypress happened within the body of the hold note
+            // Make sure the action happened within the body of the hold note
             if (Time.Current < HitObject.StartTime || Time.Current > HitObject.EndTime)
                 return false;
 
-            if (args.Key != Key)
-                return false;
-
-            if (args.Repeat)
+            if (action != Action)
                 return false;
 
             // The user has pressed during the body of the hold note, after the head note and its hit windows have passed
@@ -126,13 +121,13 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             return true;
         }
 
-        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+        public bool OnReleased(ManiaAction action)
         {
             // Make sure that the user started holding the key during the hold note
             if (!holdStartTime.HasValue)
                 return false;
 
-            if (args.Key != Key)
+            if (action != Action)
                 return false;
 
             holdStartTime = null;
@@ -151,8 +146,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             private readonly DrawableHoldNote holdNote;
 
-            public DrawableHeadNote(DrawableHoldNote holdNote, Bindable<Key> key = null)
-                : base(holdNote.HitObject.Head, key)
+            public DrawableHeadNote(DrawableHoldNote holdNote, ManiaAction action)
+                : base(holdNote.HitObject.Head, action)
             {
                 this.holdNote = holdNote;
 
@@ -160,9 +155,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 Y = 0;
             }
 
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+            public override bool OnPressed(ManiaAction action)
             {
-                if (!base.OnKeyDown(state, args))
+                if (!base.OnPressed(action))
                     return false;
 
                 // We only want to trigger a holding state from the head if the head has received a judgement
@@ -188,8 +183,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             private readonly DrawableHoldNote holdNote;
 
-            public DrawableTailNote(DrawableHoldNote holdNote, Bindable<Key> key = null)
-                : base(holdNote.HitObject.Tail, key)
+            public DrawableTailNote(DrawableHoldNote holdNote, ManiaAction action)
+                : base(holdNote.HitObject.Tail, action)
             {
                 this.holdNote = holdNote;
 
@@ -210,7 +205,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 tailJudgement.HasBroken = holdNote.hasBroken;
             }
 
-            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+            public override bool OnPressed(ManiaAction action) => false; // Tail doesn't handle key down
+
+            public override bool OnReleased(ManiaAction action)
             {
                 // Make sure that the user started holding the key during the hold note
                 if (!holdNote.holdStartTime.HasValue)
@@ -219,7 +216,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 if (Judgement.Result != HitResult.None)
                     return false;
 
-                if (args.Key != Key)
+                if (action != Action)
                     return false;
 
                 UpdateJudgement(true);
@@ -227,12 +224,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 // Handled by the hold note, which will set holding = false
                 return false;
             }
-
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-            {
-                // Tail doesn't handle key down
-                return false;
-            }
         }
     }
 }

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableManiaHitObject.cs

@@ -2,8 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using OpenTK.Graphics;
-using OpenTK.Input;
-using osu.Framework.Configuration;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 
@@ -15,17 +13,17 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// <summary>
         /// The key that will trigger input for this hit object.
         /// </summary>
-        protected Bindable<Key> Key { get; private set; } = new Bindable<Key>();
+        protected ManiaAction Action { get; }
 
         public new TObject HitObject;
 
-        protected DrawableManiaHitObject(TObject hitObject, Bindable<Key> key = null)
+        protected DrawableManiaHitObject(TObject hitObject, ManiaAction? action = null)
             : base(hitObject)
         {
             HitObject = hitObject;
 
-            if (key != null)
-                Key.BindTo(key);
+            if (action != null)
+                Action = action.Value;
         }
 
         public override Color4 AccentColour

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableNote.cs

@@ -3,10 +3,8 @@
 
 using System;
 using OpenTK.Graphics;
-using OpenTK.Input;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -16,12 +14,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// <summary>
     /// Visualises a <see cref="Note"/> hit object.
     /// </summary>
-    public class DrawableNote : DrawableManiaHitObject<Note>
+    public class DrawableNote : DrawableManiaHitObject<Note>, IKeyBindingHandler<ManiaAction>
     {
         private readonly NotePiece headPiece;
 
-        public DrawableNote(Note hitObject, Bindable<Key> key = null)
-            : base(hitObject, key)
+        public DrawableNote(Note hitObject, ManiaAction action)
+            : base(hitObject, action)
         {
             RelativeSizeAxes = Axes.X;
             Height = 100;
@@ -81,18 +79,14 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             }
         }
 
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        public virtual bool OnPressed(ManiaAction action)
         {
-            if (Judgement.Result != HitResult.None)
-                return false;
-
-            if (args.Key != Key)
-                return false;
-
-            if (args.Repeat)
+            if (action != Action)
                 return false;
 
             return UpdateJudgement(true);
         }
+
+        public virtual bool OnReleased(ManiaAction action) => false;
     }
 }

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

@@ -3,17 +3,15 @@
 
 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.Shapes;
 using osu.Framework.Graphics.Colour;
-using osu.Framework.Input;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using System;
-using osu.Framework.Configuration;
+using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Judgements;
@@ -32,10 +30,7 @@ namespace osu.Game.Rulesets.Mania.UI
         private const float column_width = 45;
         private const float special_column_width = 70;
 
-        /// <summary>
-        /// The key that will trigger input actions for this column and hit objects contained inside it.
-        /// </summary>
-        public Bindable<Key> Key = new Bindable<Key>();
+        public ManiaAction Action;
 
         private readonly Box background;
         private readonly Container hitTargetBar;
@@ -101,8 +96,8 @@ namespace osu.Game.Rulesets.Mania.UI
                         // For column lighting, we need to capture input events before the notes
                         new InputTarget
                         {
-                            KeyDown = onKeyDown,
-                            KeyUp = onKeyUp
+                            Pressed = onPressed,
+                            Released = onReleased
                         }
                     }
                 },
@@ -199,12 +194,9 @@ namespace osu.Game.Rulesets.Mania.UI
             HitObjects.Add(hitObject);
         }
 
-        private bool onKeyDown(InputState state, KeyDownEventArgs args)
+        private bool onPressed(ManiaAction action)
         {
-            if (args.Repeat)
-                return false;
-
-            if (args.Key == Key)
+            if (action == Action)
             {
                 background.FadeTo(background.Alpha + 0.2f, 50, Easing.OutQuint);
                 keyIcon.ScaleTo(1.4f, 50, Easing.OutQuint);
@@ -213,9 +205,9 @@ namespace osu.Game.Rulesets.Mania.UI
             return false;
         }
 
-        private bool onKeyUp(InputState state, KeyUpEventArgs args)
+        private bool onReleased(ManiaAction action)
         {
-            if (args.Key == Key)
+            if (action == Action)
             {
                 background.FadeTo(0.2f, 800, Easing.OutQuart);
                 keyIcon.ScaleTo(1f, 400, Easing.OutQuart);
@@ -227,10 +219,10 @@ namespace osu.Game.Rulesets.Mania.UI
         /// <summary>
         /// This is a simple container which delegates various input events that have to be captured before the notes.
         /// </summary>
-        private class InputTarget : Container
+        private class InputTarget : Container, IKeyBindingHandler<ManiaAction>
         {
-            public Func<InputState, KeyDownEventArgs, bool> KeyDown;
-            public Func<InputState, KeyUpEventArgs, bool> KeyUp;
+            public Func<ManiaAction, bool> Pressed;
+            public Func<ManiaAction, bool> Released;
 
             public InputTarget()
             {
@@ -239,8 +231,8 @@ namespace osu.Game.Rulesets.Mania.UI
                 Alpha = 0;
             }
 
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args) => KeyDown?.Invoke(state, args) ?? false;
-            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args) => KeyUp?.Invoke(state, args) ?? false;
+            public bool OnPressed(ManiaAction action) => Pressed?.Invoke(action) ?? false;
+            public bool OnReleased(ManiaAction action) => Released?.Invoke(action) ?? false;
         }
     }
 }

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

@@ -14,6 +14,7 @@ using osu.Framework.Allocation;
 using OpenTK.Input;
 using System.Linq;
 using System.Collections.Generic;
+using osu.Framework.Configuration;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Framework.Graphics.Shapes;
@@ -45,6 +46,11 @@ namespace osu.Game.Rulesets.Mania.UI
             }
         }
 
+        /// <summary>
+        /// Whether this playfield should be inverted. This flips everything inside the playfield.
+        /// </summary>
+        public readonly Bindable<bool> Inverted = new Bindable<bool>(true);
+
         private readonly FlowContainer<Column> columns;
         public IEnumerable<Column> Columns => columns.Children;
 
@@ -64,6 +70,8 @@ namespace osu.Game.Rulesets.Mania.UI
             if (columnCount <= 0)
                 throw new ArgumentException("Can't have zero or fewer columns.");
 
+            Inverted.Value = true;
+
             InternalChildren = new Drawable[]
             {
                 new Container
@@ -122,14 +130,26 @@ namespace osu.Game.Rulesets.Mania.UI
                 }
             };
 
+            var currentAction = ManiaAction.Key1;
             for (int i = 0; i < columnCount; i++)
             {
                 var c = new Column();
                 c.VisibleTimeRange.BindTo(VisibleTimeRange);
 
+                c.IsSpecial = isSpecialColumn(i);
+                c.Action = c.IsSpecial ? ManiaAction.Special : currentAction++;
+
                 columns.Add(c);
                 AddNested(c);
             }
+
+            Inverted.ValueChanged += invertedChanged;
+            Inverted.TriggerChange();
+        }
+
+        private void invertedChanged(bool newValue)
+        {
+            Scale = new Vector2(1, newValue ? -1 : 1);
         }
 
         [BackgroundDependencyLoader]
@@ -144,15 +164,11 @@ namespace osu.Game.Rulesets.Mania.UI
             specialColumnColour = colours.BlueDark;
 
             // Set the special column + colour + key
-            for (int i = 0; i < columnCount; i++)
+            foreach (var column in Columns)
             {
-                Column column = Columns.ElementAt(i);
-                column.IsSpecial = isSpecialColumn(i);
-
                 if (!column.IsSpecial)
                     continue;
 
-                column.Key.Value = Key.Space;
                 column.AccentColour = specialColumnColour;
             }
 
@@ -166,21 +182,6 @@ namespace osu.Game.Rulesets.Mania.UI
                 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.Value = 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.Value = Key.Unknown;
-            }
         }
 
         /// <summary>

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

@@ -5,11 +5,10 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using OpenTK;
-using OpenTK.Input;
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Input;
 using osu.Framework.Lists;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
@@ -32,9 +31,10 @@ namespace osu.Game.Rulesets.Mania.UI
     public class ManiaRulesetContainer : ScrollingRulesetContainer<ManiaPlayfield, ManiaHitObject, ManiaJudgement>
     {
         /// <summary>
-        /// Preferred column count. This will only have an effect during the initialization of the play field.
+        /// The number of columns which the <see cref="ManiaPlayfield"/> should display, and which
+        /// the beatmap converter will attempt to convert beatmaps to use.
         /// </summary>
-        public int PreferredColumns;
+        private int availableColumns;
 
         public IEnumerable<DrawableBarLine> BarLines;
 
@@ -75,36 +75,47 @@ namespace osu.Game.Rulesets.Mania.UI
             BarLines.ForEach(Playfield.Add);
         }
 
-        protected override void ApplyBeatmap()
-        {
-            base.ApplyBeatmap();
-
-            PreferredColumns = (int)Math.Max(1, Math.Round(Beatmap.BeatmapInfo.Difficulty.CircleSize));
-        }
-
-        protected sealed override Playfield<ManiaHitObject, ManiaJudgement> CreatePlayfield() => new ManiaPlayfield(PreferredColumns)
+        protected sealed override Playfield<ManiaHitObject, ManiaJudgement> CreatePlayfield() => new ManiaPlayfield(availableColumns)
         {
             Anchor = Anchor.Centre,
             Origin = Anchor.Centre,
-            // Invert by default for now (should be moved to config/skin later)
-            Scale = new Vector2(1, -1)
         };
 
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor(this);
 
-        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter();
+        public override PassThroughInputManager CreateInputManager() => new ManiaInputManager(Ruleset.RulesetInfo, availableColumns);
+
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter()
+        {
+            if (IsForCurrentRuleset)
+                availableColumns = (int)Math.Max(1, Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.CircleSize));
+            else
+            {
+                float percentSliderOrSpinner = (float)WorkingBeatmap.Beatmap.HitObjects.Count(h => h is IHasEndTime) / WorkingBeatmap.Beatmap.HitObjects.Count;
+                if (percentSliderOrSpinner < 0.2)
+                    availableColumns = 7;
+                else if (percentSliderOrSpinner < 0.3 || Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.CircleSize) >= 5)
+                    availableColumns = Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) > 5 ? 7 : 6;
+                else if (percentSliderOrSpinner > 0.6)
+                    availableColumns = Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) > 4 ? 5 : 4;
+                else
+                    availableColumns = Math.Max(4, Math.Min((int)Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) + 1, 7));
+            }
+
+            return new ManiaBeatmapConverter(IsForCurrentRuleset, availableColumns);
+        }
 
         protected override DrawableHitObject<ManiaHitObject, ManiaJudgement> GetVisualRepresentation(ManiaHitObject h)
         {
-            Bindable<Key> key = Playfield.Columns.ElementAt(h.Column).Key;
+            ManiaAction action = Playfield.Columns.ElementAt(h.Column).Action;
 
             var holdNote = h as HoldNote;
             if (holdNote != null)
-                return new DrawableHoldNote(holdNote, key);
+                return new DrawableHoldNote(holdNote, action);
 
             var note = h as Note;
             if (note != null)
-                return new DrawableNote(note, key);
+                return new DrawableNote(note, action);
 
             return null;
         }

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

@@ -79,6 +79,7 @@
     <Compile Include="Objects\ManiaHitObject.cs" />
     <Compile Include="Objects\Note.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ManiaInputManager.cs" />
     <Compile Include="Timing\GravityScrollingContainer.cs" />
     <Compile Include="Timing\ScrollingAlgorithm.cs" />
     <Compile Include="UI\Column.cs" />

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

@@ -7,8 +7,13 @@ using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -28,10 +33,23 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override double ScoreMultiplier => 1.06;
     }
 
-    public class OsuModHardRock : ModHardRock
+    public class OsuModHardRock : ModHardRock, IApplicableMod<OsuHitObject>
     {
         public override double ScoreMultiplier => 1.06;
         public override bool Ranked => true;
+
+        public void ApplyToRulesetContainer(RulesetContainer<OsuHitObject> rulesetContainer)
+        {
+            rulesetContainer.Objects.OfType<OsuHitObject>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Y));
+            rulesetContainer.Objects.OfType<Slider>().ForEach(s =>
+            {
+                var newControlPoints = new List<Vector2>();
+                s.ControlPoints.ForEach(c => newControlPoints.Add(new Vector2(c.X, OsuPlayfield.BASE_SIZE.Y - c.Y)));
+
+                s.ControlPoints = newControlPoints;
+                s.Curve?.Calculate(); // Recalculate the slider curve
+            });
+        }
     }
 
     public class OsuModSuddenDeath : ModSuddenDeath

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

@@ -51,6 +51,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected virtual void UpdateCurrentState(ArmedState state)
         {
         }
+
+        private OsuInputManager osuActionInputManager;
+        internal OsuInputManager OsuActionInputManager => osuActionInputManager ?? (osuActionInputManager = GetContainingInputManager() as OsuInputManager);
     }
 
     public enum ComboResult

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

@@ -1,6 +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 System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -165,6 +166,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             glow.Colour = colours.BlueDark;
         }
 
+        protected override void Update()
+        {
+            disc.Tracking = OsuActionInputManager.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton);
+
+            base.Update();
+        }
+
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();

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

@@ -1,10 +1,12 @@
 // 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.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
+using OpenTK;
 using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
@@ -96,11 +98,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             return base.OnMouseMove(state);
         }
 
+        // If the current time is between the start and end of the slider, we should track mouse input regardless of the cursor position.
+        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => canCurrentlyTrack || base.ReceiveMouseInputAt(screenSpacePos);
+
         private bool tracking;
         public bool Tracking
         {
             get { return tracking; }
-            set
+            private set
             {
                 if (value == tracking) return;
 
@@ -117,8 +122,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         {
             base.Update();
 
+            // Make sure to use the base version of ReceiveMouseInputAt so that we correctly check the position.
             if (Time.Current < slider.EndTime)
-                Tracking = canCurrentlyTrack && lastState != null && ReceiveMouseInputAt(lastState.Mouse.NativeState.Position) && lastState.Mouse.HasMainButtonPressed;
+                Tracking = canCurrentlyTrack && lastState != null && base.ReceiveMouseInputAt(lastState.Mouse.NativeState.Position) && ((Parent as DrawableSlider)?.OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
         }
 
         public void UpdateProgress(double progress, int repeat)

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

@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     return;
                 accentColour = value;
 
-                if (LoadState == LoadState.Loaded)
+                if (LoadState == LoadState.Ready)
                     Schedule(reloadTexture);
             }
         }

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

@@ -66,21 +66,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             }
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
-        {
-            Tracking |= state.Mouse.HasMainButtonPressed;
-            return base.OnMouseDown(state, args);
-        }
-
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
-        {
-            Tracking &= state.Mouse.HasMainButtonPressed;
-            return base.OnMouseUp(state, args);
-        }
-
         protected override bool OnMouseMove(InputState state)
         {
-            Tracking |= state.Mouse.HasMainButtonPressed;
             mousePosition = Parent.ToLocalSpace(state.Mouse.NativeState.Position);
             return base.OnMouseMove(state);
         }

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

@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.Osu.Objects
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
             DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
 
-            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier / difficultyPoint.SpeedMultiplier;
+            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
             TickDistance = scoringDistance / difficulty.SliderTickRate;

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -1,51 +1,24 @@
 // 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.Input;
+using System.ComponentModel;
 using osu.Framework.Input.Bindings;
-using osu.Game.Input.Bindings;
-using OpenTK.Input;
-using KeyboardState = osu.Framework.Input.KeyboardState;
-using MouseState = osu.Framework.Input.MouseState;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu
 {
-    public class OsuInputManager : DatabasedKeyBindingInputManager<OsuAction>
+    public class OsuInputManager : RulesetInputManager<OsuAction>
     {
-        public OsuInputManager(RulesetInfo ruleset) : base(ruleset, simultaneousMode: SimultaneousBindingMode.Unique)
+        public OsuInputManager(RulesetInfo ruleset) : base(ruleset, 0, SimultaneousBindingMode.Unique)
         {
-
         }
-        protected override void TransformState(InputState state)
-        {
-            base.TransformState(state);
-
-            var mouse = state.Mouse as MouseState;
-            var keyboard = state.Keyboard as KeyboardState;
-
-            if (mouse != null && keyboard != null)
-            {
-                if (mouse.IsPressed(MouseButton.Left))
-                    keyboard.Keys = keyboard.Keys.Concat(new[] { Key.LastKey + 1 });
-                if (mouse.IsPressed(MouseButton.Right))
-                    keyboard.Keys = keyboard.Keys.Concat(new[] { Key.LastKey + 2 });
-            }
-        }
-
-        protected override IEnumerable<KeyBinding> CreateDefaultMappings() => new[]
-        {
-            new KeyBinding(Key.Z, OsuAction.LeftButton),
-            new KeyBinding(Key.X, OsuAction.RightButton),
-            new KeyBinding(Key.LastKey + 1, OsuAction.LeftButton),
-            new KeyBinding(Key.LastKey + 2, OsuAction.RightButton),
-        };
     }
 
     public enum OsuAction
     {
+        [Description("Left Button")]
         LeftButton,
+        [Description("Right Button")]
         RightButton
     }
 }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -1,7 +1,6 @@
 // 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.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
@@ -10,13 +9,13 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.OsuDifficulty;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Overlays.Settings;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Rulesets.Osu
 {
@@ -24,8 +23,16 @@ namespace osu.Game.Rulesets.Osu
     {
         public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new OsuRulesetContainer(this, beatmap, isForCurrentRuleset);
 
-        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
+        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
         {
+            new KeyBinding(InputKey.Z, OsuAction.LeftButton),
+            new KeyBinding(InputKey.X, OsuAction.RightButton),
+            new KeyBinding(InputKey.MouseLeft, OsuAction.LeftButton),
+            new KeyBinding(InputKey.MouseRight, OsuAction.RightButton),
+        };
+
+        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
+            {
             new BeatmapStatistic
             {
                 Name = @"Circle count",
@@ -113,14 +120,6 @@ namespace osu.Game.Rulesets.Osu
 
         public override string Description => "osu!";
 
-        public override IEnumerable<KeyCounter> CreateGameplayKeys() => new KeyCounter[]
-        {
-            new KeyCounterKeyboard(Key.Z),
-            new KeyCounterKeyboard(Key.X),
-            new KeyCounterMouse(MouseButton.Left),
-            new KeyCounterMouse(MouseButton.Right)
-        };
-
         public override ScoreProcessor CreateScoreProcessor() => new OsuScoreProcessor();
 
         public override SettingsSubsection CreateSettings() => new OsuSettings();

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

@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override Playfield<OsuHitObject, OsuJudgement> CreatePlayfield() => new OsuPlayfield();
 
-        protected override PassThroughInputManager CreateActionMappingInputManager() => new OsuInputManager(Ruleset?.RulesetInfo);
+        public override PassThroughInputManager CreateInputManager() => new OsuInputManager(Ruleset.RulesetInfo);
 
         protected override DrawableHitObject<OsuHitObject, OsuJudgement> GetVisualRepresentation(OsuHitObject h)
         {

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -39,15 +39,22 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
         /// </summary>
         private const float taiko_base_distance = 100;
 
+        private readonly bool isForCurrentRuleset;
+
         protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(HitObject) };
 
-        protected override Beatmap<TaikoHitObject> ConvertBeatmap(Beatmap original, bool isForCurrentRuleset)
+        public TaikoBeatmapConverter(bool isForCurrentRuleset)
+        {
+            this.isForCurrentRuleset = isForCurrentRuleset;
+        }
+
+        protected override Beatmap<TaikoHitObject> ConvertBeatmap(Beatmap original)
         {
             // Rewrite the beatmap info to add the slider velocity multiplier
             BeatmapInfo info = original.BeatmapInfo.DeepClone();
             info.Difficulty.SliderMultiplier *= legacy_velocity_multiplier;
 
-            Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original, isForCurrentRuleset);
+            Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original);
 
             // Post processing step to transform hit objects with the same start time into strong hits
             converted.HitObjects = converted.HitObjects.GroupBy(t => t.StartTime).Select(x =>
@@ -81,7 +88,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(obj.StartTime);
 
                 double speedAdjustment = difficultyPoint.SpeedMultiplier;
-                double speedAdjustedBeatLength = timingPoint.BeatLength * speedAdjustment;
+                double speedAdjustedBeatLength = timingPoint.BeatLength / speedAdjustment;
 
                 // The true distance, accounting for any repeats. This ends up being the drum roll distance later
                 double distance = distanceData.Distance * repeats * legacy_velocity_multiplier;
@@ -94,7 +101,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 // For some reason, old osu! always uses speedAdjustment to determine the taiko velocity, but
                 // only uses it to determine osu! velocity if beatmap version < 8. Let's account for that here.
                 if (beatmap.BeatmapInfo.BeatmapVersion >= 8)
-                    speedAdjustedBeatLength /= speedAdjustment;
+                    speedAdjustedBeatLength *= speedAdjustment;
 
                 // The velocity of the osu! hit object - calculated as the velocity of a slider
                 double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.Difficulty.SliderMultiplier * legacy_velocity_multiplier / speedAdjustedBeatLength;
@@ -104,7 +111,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 // If the drum roll is to be split into hit circles, assume the ticks are 1/8 spaced within the duration of one beat
                 double tickSpacing = Math.Min(speedAdjustedBeatLength / beatmap.BeatmapInfo.Difficulty.SliderTickRate, taikoDuration / repeats);
 
-                if (tickSpacing > 0 && osuDuration < 2 * speedAdjustedBeatLength)
+                if (!isForCurrentRuleset && tickSpacing > 0 && osuDuration < 2 * speedAdjustedBeatLength)
                 {
                     List<SampleInfoList> allSamples = curveData != null ? curveData.RepeatSamples : new List<SampleInfoList>(new[] { samples });
 

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableBarLine.cs

@@ -2,16 +2,17 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using OpenTK;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.Judgements;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
     /// <summary>
     /// A line that scrolls alongside hit objects in the playfield and visualises control points.
     /// </summary>
-    public class DrawableBarLine : Container
+    public class DrawableBarLine : DrawableScrollingHitObject<TaikoHitObject, TaikoJudgement>
     {
         /// <summary>
         /// The width of the line tracker.
@@ -34,15 +35,14 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         protected readonly BarLine BarLine;
 
         public DrawableBarLine(BarLine barLine)
+            : base(barLine)
         {
             BarLine = barLine;
 
             Anchor = Anchor.CentreLeft;
             Origin = Anchor.Centre;
 
-            RelativePositionAxes = Axes.X;
             RelativeSizeAxes = Axes.Y;
-
             Width = tracker_width;
 
             Children = new[]
@@ -56,24 +56,12 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                     Alpha = 0.75f
                 }
             };
-
-            LifetimeStart = BarLine.StartTime - BarLine.ScrollTime * 2;
-            LifetimeEnd = BarLine.StartTime + BarLine.ScrollTime;
         }
 
-        protected override void LoadComplete()
+        protected override TaikoJudgement CreateJudgement() => null;
+
+        protected override void UpdateState(ArmedState state)
         {
-            base.LoadComplete();
-            this.Delay(BarLine.StartTime - Time.Current).FadeOut(base_fadeout_time * BarLine.ScrollTime / 1000);
-        }
-
-        private void updateScrollPosition(double time) => this.MoveToX((float)((BarLine.StartTime - time) / BarLine.ScrollTime));
-
-        protected override void Update()
-        {
-            base.Update();
-
-            updateScrollPosition(Time.Current);
         }
     }
-}
+}

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableBarLineMajor.cs

@@ -20,10 +20,12 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         /// </summary>
         private const float triangle_size = 20f;
 
+        private readonly Container triangleContainer;
+
         public DrawableBarLineMajor(BarLine barLine)
             : base(barLine)
         {
-            Add(new Container
+            Add(triangleContainer = new Container
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -53,5 +55,13 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
             Tracker.Alpha = 1f;
         }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            using (triangleContainer.BeginAbsoluteSequence(HitObject.StartTime))
+                triangleContainer.FadeOut(150);
+        }
     }
-}
+}

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableCentreHit.cs

@@ -4,13 +4,12 @@
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
     public class DrawableCentreHit : DrawableHit
     {
-        protected override Key[] HitKeys { get; } = { Key.F, Key.J };
+        protected override TaikoAction[] HitActions { get; } = { TaikoAction.LeftCentre, TaikoAction.RightCentre };
 
         public DrawableCentreHit(Hit hit)
             : base(hit)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableCentreHitStrong.cs

@@ -4,13 +4,12 @@
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
     public class DrawableCentreHitStrong : DrawableHitStrong
     {
-        protected override Key[] HitKeys { get; } = { Key.F, Key.J };
+        protected override TaikoAction[] HitActions { get; } = { TaikoAction.LeftCentre, TaikoAction.RightCentre };
 
         public DrawableCentreHitStrong(Hit hit)
             : base(hit)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRoll.cs

@@ -11,6 +11,7 @@ using OpenTK;
 using OpenTK.Graphics;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
@@ -31,30 +32,31 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         public DrawableDrumRoll(DrumRoll drumRoll)
             : base(drumRoll)
         {
-            RelativeSizeAxes = Axes.Y;
-            AutoSizeAxes = Axes.X;
+            Width = (float)HitObject.Duration;
+
+            Container<DrawableDrumRollTick> tickContainer;
+            MainPiece.Add(tickContainer = new Container<DrawableDrumRollTick>
+            {
+                RelativeSizeAxes = Axes.Both,
+                RelativeChildOffset = new Vector2((float)HitObject.StartTime, 0),
+                RelativeChildSize = new Vector2((float)HitObject.Duration, 1)
+            });
 
             foreach (var tick in drumRoll.Ticks)
             {
-                var newTick = new DrawableDrumRollTick(tick)
-                {
-                    X = (float)((tick.StartTime - HitObject.StartTime) / HitObject.Duration)
-                };
-
+                var newTick = new DrawableDrumRollTick(tick);
                 newTick.OnJudgement += onTickJudgement;
 
                 AddNested(newTick);
-                MainPiece.Add(newTick);
+                tickContainer.Add(newTick);
             }
         }
 
         protected override TaikoJudgement CreateJudgement() => new TaikoJudgement { SecondHit = HitObject.IsStrong };
 
-        protected override TaikoPiece CreateMainPiece() => new ElongatedCirclePiece
-        {
-            Length = (float)(HitObject.Duration / HitObject.ScrollTime),
-            PlayfieldLengthReference = () => Parent.DrawSize.X
-        };
+        protected override TaikoPiece CreateMainPiece() => new ElongatedCirclePiece();
+
+        public override bool OnPressed(TaikoAction action) => false;
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
@@ -63,17 +65,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             accentDarkColour = colours.YellowDarker;
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            // This is naive, however it's based on the reasoning that the hit target
-            // is further than mid point of the play field, so the time taken to scroll in should always
-            // be greater than the time taken to scroll out to the left of the screen.
-            // Thus, using PreEmpt here is enough for the drum roll to completely scroll out.
-            LifetimeEnd = HitObject.EndTime + HitObject.ScrollTime;
-        }
-
         private void onTickJudgement(DrawableHitObject<TaikoHitObject, TaikoJudgement> obj)
         {
             if (obj.Judgement.Result == HitResult.Hit)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRollTick.cs

@@ -5,7 +5,6 @@ using System;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
-using OpenTK.Input;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
@@ -15,9 +14,21 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         public DrawableDrumRollTick(DrumRollTick tick)
             : base(tick)
         {
+            // Because ticks aren't added by the ScrollingPlayfield, we need to set the following properties ourselves
+            RelativePositionAxes = Axes.X;
+            X = (float)tick.StartTime;
+
             FillMode = FillMode.Fit;
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // We need to set this here because RelativeSizeAxes won't/can't set our size by default with a different RelativeChildSize
+            Width *= Parent.RelativeChildSize.X;
+        }
+
         protected override TaikoPiece CreateMainPiece() => new TickPiece
         {
             Filled = HitObject.FirstTick
@@ -47,12 +58,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             }
         }
 
-        protected override void UpdateScrollPosition(double time)
-        {
-            // Ticks don't move
-        }
-
-        protected override bool HandleKeyPress(Key key)
+        public override bool OnPressed(TaikoAction action)
         {
             return Judgement.Result == HitResult.None && UpdateJudgement(true);
         }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs

@@ -7,7 +7,6 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
@@ -16,7 +15,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         /// <summary>
         /// A list of keys which can result in hits for this HitObject.
         /// </summary>
-        protected abstract Key[] HitKeys { get; }
+        protected abstract TaikoAction[] HitActions { get; }
 
         /// <summary>
         /// Whether the last key pressed is a valid hit key.
@@ -54,16 +53,23 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 Judgement.Result = HitResult.Miss;
         }
 
-        protected override bool HandleKeyPress(Key key)
+        public override bool OnPressed(TaikoAction action)
         {
             if (Judgement.Result != HitResult.None)
                 return false;
 
-            validKeyPressed = HitKeys.Contains(key);
+            validKeyPressed = HitActions.Contains(action);
 
             return UpdateJudgement(true);
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            Size = BaseSize * Parent.RelativeChildSize;
+        }
+
         protected override void UpdateState(ArmedState state)
         {
             var circlePiece = MainPiece as CirclePiece;

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHitStrong.cs

@@ -3,10 +3,8 @@
 
 using System;
 using System.Linq;
-using osu.Framework.Input;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
@@ -20,7 +18,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         private double firstHitTime;
         private bool firstKeyHeld;
-        private Key firstHitKey;
+        private TaikoAction firstHitAction;
 
         protected DrawableHitStrong(Hit hit)
             : base(hit)
@@ -46,18 +44,26 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 Judgement.SecondHit = true;
         }
 
-        protected override bool HandleKeyPress(Key key)
+        public override bool OnReleased(TaikoAction action)
+        {
+            if (action == firstHitAction)
+                firstKeyHeld = false;
+            return base.OnReleased(action);
+        }
+
+        public override bool OnPressed(TaikoAction action)
         {
             // Check if we've handled the first key
             if (Judgement.Result == HitResult.None)
             {
                 // First key hasn't been handled yet, attempt to handle it
-                bool handled = base.HandleKeyPress(key);
+                bool handled = base.OnPressed(action);
 
                 if (handled)
                 {
                     firstHitTime = Time.Current;
-                    firstHitKey = key;
+                    firstHitAction = action;
+                    firstKeyHeld = true;
                 }
 
                 return handled;
@@ -68,22 +74,15 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 return false;
 
             // Don't handle represses of the first key
-            if (firstHitKey == key)
+            if (firstHitAction == action)
                 return false;
 
-            // Don't handle invalid hit key presses
-            if (!HitKeys.Contains(key))
+            // Don't handle invalid hit action presses
+            if (!HitActions.Contains(action))
                 return false;
 
             // Assume the intention was to hit the strong hit with both keys only if the first key is still being held down
             return firstKeyHeld && UpdateJudgement(true);
         }
-
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-        {
-            firstKeyHeld = state.Keyboard.Keys.Contains(firstHitKey);
-
-            return base.OnKeyDown(state, args);
-        }
     }
 }

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableRimHit.cs

@@ -4,13 +4,12 @@
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
     public class DrawableRimHit : DrawableHit
     {
-        protected override Key[] HitKeys { get; } = { Key.D, Key.K };
+        protected override TaikoAction[] HitActions { get; } = { TaikoAction.LeftRim, TaikoAction.RightRim };
 
         public DrawableRimHit(Hit hit)
             : base(hit)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableRimHitStrong.cs

@@ -4,13 +4,12 @@
 using osu.Framework.Allocation;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
     public class DrawableRimHitStrong : DrawableHitStrong
     {
-        protected override Key[] HitKeys { get; } = { Key.D, Key.K };
+        protected override TaikoAction[] HitActions { get; } = { TaikoAction.LeftRim, TaikoAction.RightRim };
 
         public DrawableRimHitStrong(Hit hit)
             : base(hit)

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs

@@ -13,7 +13,6 @@ using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
 using OpenTK;
 using OpenTK.Graphics;
-using OpenTK.Input;
 using osu.Framework.Graphics.Shapes;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
@@ -35,9 +34,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         private readonly CircularContainer targetRing;
         private readonly CircularContainer expandingRing;
 
-        private readonly Key[] rimKeys = { Key.D, Key.K };
-        private readonly Key[] centreKeys = { Key.F, Key.J };
-        private Key[] lastKeySet;
+        private readonly TaikoAction[] rimActions = { TaikoAction.LeftRim, TaikoAction.RightRim };
+        private readonly TaikoAction[] centreActions = { TaikoAction.LeftCentre, TaikoAction.RightCentre };
+        private TaikoAction[] lastAction;
 
         /// <summary>
         /// The amount of times the user has hit this swell.
@@ -118,7 +117,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             });
 
             MainPiece.Add(symbol = new SwellSymbolPiece());
-
         }
 
         [BackgroundDependencyLoader]
@@ -129,6 +127,14 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             targetRing.BorderColour = colours.YellowDark.Opacity(0.25f);
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // We need to set this here because RelativeSizeAxes won't/can't set our size by default with a different RelativeChildSize
+            Width *= Parent.RelativeChildSize.X;
+        }
+
         protected override void CheckJudgement(bool userTriggered)
         {
             if (userTriggered)
@@ -189,21 +195,24 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             Expire();
         }
 
-        protected override void UpdateScrollPosition(double time)
+        protected override void Update()
         {
-            // Make the swell stop at the hit target
-            double t = Math.Min(HitObject.StartTime, time);
+            base.Update();
 
+            Size = BaseSize * Parent.RelativeChildSize;
+
+            // Make the swell stop at the hit target
+            X = (float)Math.Max(Time.Current, HitObject.StartTime);
+
+            double t = Math.Min(HitObject.StartTime, Time.Current);
             if (t == HitObject.StartTime && !hasStarted)
             {
                 OnStart?.Invoke();
                 hasStarted = true;
             }
-
-            base.UpdateScrollPosition(t);
         }
 
-        protected override bool HandleKeyPress(Key key)
+        public override bool OnPressed(TaikoAction action)
         {
             if (Judgement.Result != HitResult.None)
                 return false;
@@ -213,12 +222,12 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 return false;
 
             // Find the keyset which this key corresponds to
-            var keySet = rimKeys.Contains(key) ? rimKeys : centreKeys;
+            var keySet = rimActions.Contains(action) ? rimActions : centreActions;
 
             // Ensure alternating keysets
-            if (keySet == lastKeySet)
+            if (keySet == lastAction)
                 return false;
-            lastKeySet = keySet;
+            lastAction = keySet;
 
             UpdateJudgement(true);
 

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs

@@ -1,28 +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 System.Collections.Generic;
 using osu.Framework.Graphics;
-using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
 using OpenTK;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
-    public abstract class DrawableTaikoHitObject<TaikoHitType> : DrawableHitObject<TaikoHitObject, TaikoJudgement>
-        where TaikoHitType : TaikoHitObject
+    public abstract class DrawableTaikoHitObject<TaikoHitType>
+                        : DrawableScrollingHitObject<TaikoHitObject, TaikoJudgement>, IKeyBindingHandler<TaikoAction>
+                        where TaikoHitType : TaikoHitObject
     {
-        /// <summary>
-        /// A list of keys which this hit object will accept. These are the standard Taiko keys for now.
-        /// These should be moved to bindings later.
-        /// </summary>
-        private readonly List<Key> validKeys = new List<Key>(new[] { Key.D, Key.F, Key.J, Key.K });
-
         public override Vector2 OriginPosition => new Vector2(DrawHeight / 2);
 
+        protected readonly Vector2 BaseSize;
+
         protected readonly TaikoPiece MainPiece;
 
         public new TaikoHitType HitObject;
@@ -36,46 +31,18 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             Origin = Anchor.Custom;
 
             RelativeSizeAxes = Axes.Both;
-            Size = new Vector2(HitObject.IsStrong ? TaikoHitObject.DEFAULT_STRONG_SIZE : TaikoHitObject.DEFAULT_SIZE);
-
-            RelativePositionAxes = Axes.X;
+            Size = BaseSize = new Vector2(HitObject.IsStrong ? TaikoHitObject.DEFAULT_STRONG_SIZE : TaikoHitObject.DEFAULT_SIZE);
 
             Add(MainPiece = CreateMainPiece());
             MainPiece.KiaiMode = HitObject.Kiai;
-
-            LifetimeStart = HitObject.StartTime - HitObject.ScrollTime * 2;
         }
 
         protected override TaikoJudgement CreateJudgement() => new TaikoJudgement();
 
         protected virtual TaikoPiece CreateMainPiece() => new CirclePiece();
 
-        /// <summary>
-        /// Sets the scroll position of the DrawableHitObject relative to the offset between
-        /// a time value and the HitObject's StartTime.
-        /// </summary>
-        /// <param name="time"></param>
-        protected virtual void UpdateScrollPosition(double time) => X = (float)((HitObject.StartTime - time) / HitObject.ScrollTime);
+        public abstract bool OnPressed(TaikoAction action);
 
-        protected override void Update()
-        {
-            UpdateScrollPosition(Time.Current);
-        }
-
-        protected virtual bool HandleKeyPress(Key key) => false;
-
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-        {
-            // Make sure we don't handle held-down keys
-            if (args.Repeat)
-                return false;
-
-            // Check if we've pressed a valid taiko key
-            if (!validKeys.Contains(args.Key))
-                return false;
-
-            // Handle it!
-            return HandleKeyPress(args.Key);
-        }
+        public virtual bool OnReleased(TaikoAction action) => false;
     }
 }

osu.Game.Rulesets.Taiko/Objects/Drawables/Pieces/ElongatedCirclePiece.cs

@@ -1,23 +1,12 @@
 // 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;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
 {
     public class ElongatedCirclePiece : CirclePiece
     {
-        /// <summary>
-        /// As we are being used to define the absolute size of hits, we need to be given a relative reference of our containing playfield container.
-        /// </summary>
-        public Func<float> PlayfieldLengthReference;
-
-        /// <summary>
-        /// The length of this piece as a multiple of the value returned by <see cref="PlayfieldLengthReference"/>
-        /// </summary>
-        public float Length;
-
         public ElongatedCirclePiece()
         {
             RelativeSizeAxes = Axes.Y;
@@ -35,7 +24,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
                 Right = padding,
             };
 
-            Width = (PlayfieldLengthReference?.Invoke() ?? 0) * Length + DrawHeight;
+            Width = Parent.DrawSize.X + DrawHeight;
         }
     }
 }

osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs

@@ -80,7 +80,6 @@ namespace osu.Game.Rulesets.Taiko.Objects
                 ret.Add(new DrumRollTick
                 {
                     FirstTick = first,
-                    ScrollTime = ScrollTime,
                     TickSpacing = tickSpacing,
                     StartTime = t,
                     IsStrong = IsStrong,

osu.Game.Rulesets.Taiko/Objects/TaikoHitObject.cs

@@ -24,16 +24,6 @@ namespace osu.Game.Rulesets.Taiko.Objects
         /// </summary>
         public const float DEFAULT_STRONG_SIZE = DEFAULT_SIZE * STRONG_SCALE;
 
-        /// <summary>
-        /// The time taken from the initial (off-screen) spawn position to the centre of the hit target for a <see cref="TimingControlPoint.BeatLength"/> of 1000ms.
-        /// </summary>
-        private const double scroll_time = 6000;
-
-        /// <summary>
-        /// Our adjusted <see cref="scroll_time"/> taking into consideration local <see cref="TimingControlPoint.BeatLength"/> and other speed multipliers.
-        /// </summary>
-        public double ScrollTime;
-
         /// <summary>
         /// Whether this HitObject is a "strong" type.
         /// Strong hit objects give more points for hitting the hit object with both keys.
@@ -49,12 +39,8 @@ namespace osu.Game.Rulesets.Taiko.Objects
         {
             base.ApplyDefaults(controlPointInfo, difficulty);
 
-            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
-            DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
             EffectControlPoint effectPoint = controlPointInfo.EffectPointAt(StartTime);
 
-            ScrollTime = scroll_time * (timingPoint.BeatLength * difficultyPoint.SpeedMultiplier / 1000) / difficulty.SliderMultiplier;
-
             Kiai |= effectPoint.KiaiMode;
         }
     }

osu.Game.Rulesets.Taiko/TaikoDifficultyCalculator.cs

@@ -135,6 +135,6 @@ namespace osu.Game.Rulesets.Taiko
             return difficulty;
         }
 
-        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter();
+        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter(true);
     }
-}
+}

osu.Game.Rulesets.Taiko/TaikoInputManager.cs

@@ -0,0 +1,29 @@
+// 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.ComponentModel;
+using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Taiko
+{
+    public class TaikoInputManager : RulesetInputManager<TaikoAction>
+    {
+        public TaikoInputManager(RulesetInfo ruleset)
+            : base(ruleset, 0, SimultaneousBindingMode.Unique)
+        {
+        }
+    }
+
+    public enum TaikoAction
+    {
+        [Description("Left (Rim)")]
+        LeftRim,
+        [Description("Left (Centre)")]
+        LeftCentre,
+        [Description("Right (Centre)")]
+        RightCentre,
+        [Description("Right (Rim)")]
+        RightRim
+    }
+}

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -1,18 +1,17 @@
 // 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.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.UI;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Scoring;
+using osu.Framework.Input.Bindings;
 
 namespace osu.Game.Rulesets.Taiko
 {
@@ -20,6 +19,18 @@ namespace osu.Game.Rulesets.Taiko
     {
         public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new TaikoRulesetContainer(this, beatmap, isForCurrentRuleset);
 
+        public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
+        {
+            new KeyBinding(InputKey.D, TaikoAction.LeftRim),
+            new KeyBinding(InputKey.F, TaikoAction.LeftCentre),
+            new KeyBinding(InputKey.J, TaikoAction.RightCentre),
+            new KeyBinding(InputKey.K, TaikoAction.RightRim),
+            new KeyBinding(InputKey.MouseLeft, TaikoAction.LeftCentre),
+            new KeyBinding(InputKey.MouseLeft, TaikoAction.RightCentre),
+            new KeyBinding(InputKey.MouseRight, TaikoAction.LeftRim),
+            new KeyBinding(InputKey.MouseRight, TaikoAction.RightRim),
+        };
+
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
             switch (type)
@@ -90,14 +101,6 @@ namespace osu.Game.Rulesets.Taiko
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_taiko_o };
 
-        public override IEnumerable<KeyCounter> CreateGameplayKeys() => new KeyCounter[]
-        {
-            new KeyCounterKeyboard(Key.D),
-            new KeyCounterKeyboard(Key.F),
-            new KeyCounterKeyboard(Key.J),
-            new KeyCounterKeyboard(Key.K)
-        };
-
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new TaikoDifficultyCalculator(beatmap);
 
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor();

osu.Game.Rulesets.Taiko/UI/InputDrum.cs

@@ -3,13 +3,12 @@
 
 using System;
 using OpenTK;
-using OpenTK.Input;
 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.Framework.Input;
+using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Taiko.UI
@@ -36,8 +35,8 @@ namespace osu.Game.Rulesets.Taiko.UI
                     RelativeSizeAxes = Axes.Both,
                     RelativePositionAxes = Axes.X,
                     X = -middle_split / 2,
-                    RimKey = Key.D,
-                    CentreKey = Key.F
+                    RimAction = TaikoAction.LeftRim,
+                    CentreAction = TaikoAction.LeftCentre
                 },
                 new TaikoHalfDrum(true)
                 {
@@ -47,8 +46,8 @@ namespace osu.Game.Rulesets.Taiko.UI
                     RelativeSizeAxes = Axes.Both,
                     RelativePositionAxes = Axes.X,
                     X = middle_split / 2,
-                    RimKey = Key.K,
-                    CentreKey = Key.J
+                    RimAction = TaikoAction.RightRim,
+                    CentreAction = TaikoAction.RightCentre
                 }
             };
         }
@@ -56,17 +55,17 @@ namespace osu.Game.Rulesets.Taiko.UI
         /// <summary>
         /// A half-drum. Contains one centre and one rim hit.
         /// </summary>
-        private class TaikoHalfDrum : Container
+        private class TaikoHalfDrum : Container, IKeyBindingHandler<TaikoAction>
         {
             /// <summary>
             /// The key to be used for the rim of the half-drum.
             /// </summary>
-            public Key RimKey;
+            public TaikoAction RimAction;
 
             /// <summary>
             /// The key to be used for the centre of the half-drum.
             /// </summary>
-            public Key CentreKey;
+            public TaikoAction CentreAction;
 
             private readonly Sprite rim;
             private readonly Sprite rimHit;
@@ -124,20 +123,17 @@ namespace osu.Game.Rulesets.Taiko.UI
                 centreHit.Colour = colours.Pink;
             }
 
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+            public bool OnPressed(TaikoAction action)
             {
-                if (args.Repeat)
-                    return false;
-
                 Drawable target = null;
                 Drawable back = null;
 
-                if (args.Key == CentreKey)
+                if (action == CentreAction)
                 {
                     target = centreHit;
                     back = centre;
                 }
-                else if (args.Key == RimKey)
+                else if (action == RimAction)
                 {
                     target = rimHit;
                     back = rim;
@@ -166,6 +162,8 @@ namespace osu.Game.Rulesets.Taiko.UI
 
                 return false;
             }
+
+            public bool OnReleased(TaikoAction action) => false;
         }
     }
 }

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -18,7 +18,7 @@ using osu.Game.Rulesets.Taiko.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
-    public class TaikoPlayfield : Playfield<TaikoHitObject, TaikoJudgement>
+    public class TaikoPlayfield : ScrollingPlayfield<TaikoHitObject, TaikoJudgement>
     {
         /// <summary>
         /// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="TaikoRulesetContainer"/>.
@@ -35,16 +35,18 @@ namespace osu.Game.Rulesets.Taiko.UI
         /// </summary>
         private const float left_area_size = 240;
 
-        protected override Container<Drawable> Content => hitObjectContainer;
 
         private readonly Container<HitExplosion> hitExplosionContainer;
         private readonly Container<KiaiHitExplosion> kiaiExplosionContainer;
-        private readonly Container<DrawableBarLine> barLineContainer;
         private readonly Container<DrawableTaikoJudgement> judgementContainer;
 
-        private readonly Container hitObjectContainer;
+        protected override Container<Drawable> Content => content;
+        private readonly Container content;
+
         private readonly Container topLevelHitContainer;
 
+        private readonly Container barlineContainer;
+
         private readonly Container overlayBackgroundContainer;
         private readonly Container backgroundContainer;
 
@@ -52,6 +54,7 @@ namespace osu.Game.Rulesets.Taiko.UI
         private readonly Box background;
 
         public TaikoPlayfield()
+            : base(Axes.X)
         {
             AddRangeInternal(new Drawable[]
             {
@@ -84,7 +87,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                     {
                         new Container
                         {
-                            Name = "Masked elements",
+                            Name = "Masked elements before hit objects",
                             RelativeSizeAxes = Axes.Both,
                             Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
                             Masking = true,
@@ -96,23 +99,27 @@ namespace osu.Game.Rulesets.Taiko.UI
                                     FillMode = FillMode.Fit,
                                     BlendingMode = BlendingMode.Additive,
                                 },
-                                barLineContainer = new Container<DrawableBarLine>
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                },
                                 new HitTarget
                                 {
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.Centre,
                                     RelativeSizeAxes = Axes.Both,
                                     FillMode = FillMode.Fit
-                                },
-                                hitObjectContainer = new Container
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                },
+                                }
                             }
                         },
+                        barlineContainer = new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET }
+                        },
+                        content = new Container
+                        {
+                            Name = "Hit objects",
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                            Masking = true
+                        },
                         kiaiExplosionContainer = new Container<KiaiHitExplosion>
                         {
                             Name = "Kiai hit explosions",
@@ -181,6 +188,8 @@ namespace osu.Game.Rulesets.Taiko.UI
                     RelativeSizeAxes = Axes.Both,
                 }
             });
+
+            VisibleTimeRange.Value = 6000;
         }
 
         [BackgroundDependencyLoader]
@@ -199,17 +208,16 @@ namespace osu.Game.Rulesets.Taiko.UI
 
             base.Add(h);
 
+            var barline = h as DrawableBarLine;
+            if (barline != null)
+                barlineContainer.Add(barline.CreateProxy());
+
             // Swells should be moved at the very top of the playfield when they reach the hit target
             var swell = h as DrawableSwell;
             if (swell != null)
                 swell.OnStart += () => topLevelHitContainer.Add(swell.CreateProxy());
         }
 
-        public void AddBarLine(DrawableBarLine barLine)
-        {
-            barLineContainer.Add(barLine);
-        }
-
         public override void OnJudgement(DrawableHitObject<TaikoHitObject, TaikoJudgement> judgedObject)
         {
             bool wasHit = judgedObject.Judgement.Result == HitResult.Hit;
@@ -230,7 +238,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
             if (!secondHit)
             {
-                if (judgedObject.X >= -0.05f && !(judgedObject is DrawableSwell))
+                if (judgedObject.X >= -0.05f && judgedObject is DrawableHit)
                 {
                     // If we're far enough away from the left stage, we should bring outselves in front of it
                     topLevelHitContainer.Add(judgedObject.CreateProxy());
@@ -245,4 +253,4 @@ namespace osu.Game.Rulesets.Taiko.UI
                 hitExplosionContainer.Children.FirstOrDefault(e => e.Judgement == judgedObject.Judgement)?.VisualiseSecondHit();
         }
     }
-}
+}

osu.Game.Rulesets.Taiko/UI/TaikoRulesetContainer.cs

@@ -18,10 +18,11 @@ using osu.Game.Rulesets.Taiko.Replays;
 using OpenTK;
 using osu.Game.Rulesets.Beatmaps;
 using System.Linq;
+using osu.Framework.Input;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
-    public class TaikoRulesetContainer : RulesetContainer<TaikoHitObject, TaikoJudgement>
+    public class TaikoRulesetContainer : ScrollingRulesetContainer<TaikoPlayfield, TaikoHitObject, TaikoJudgement>
     {
         public TaikoRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
             : base(ruleset, beatmap, isForCurrentRuleset)
@@ -36,11 +37,6 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         private void loadBarLines()
         {
-            var taikoPlayfield = Playfield as TaikoPlayfield;
-
-            if (taikoPlayfield == null)
-                return;
-
             TaikoHitObject lastObject = Beatmap.HitObjects[Beatmap.HitObjects.Count - 1];
             double lastHitTime = 1 + (lastObject as IHasEndTime)?.EndTime ?? lastObject.StartTime;
 
@@ -72,7 +68,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                 barLine.ApplyDefaults(Beatmap.ControlPointInfo, Beatmap.BeatmapInfo.Difficulty);
 
                 bool isMajor = currentBeat % (int)currentPoint.TimeSignature == 0;
-                taikoPlayfield.AddBarLine(isMajor ? new DrawableBarLineMajor(barLine) : new DrawableBarLine(barLine));
+                Playfield.Add(isMajor ? new DrawableBarLineMajor(barLine) : new DrawableBarLine(barLine));
 
                 double bl = currentPoint.BeatLength;
                 if (bl < 800)
@@ -95,7 +91,9 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor(this);
 
-        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter();
+        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter(IsForCurrentRuleset);
+
+        public override PassThroughInputManager CreateInputManager() => new TaikoInputManager(Ruleset.RulesetInfo);
 
         protected override Playfield<TaikoHitObject, TaikoJudgement> CreatePlayfield() => new TaikoPlayfield
         {

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

@@ -86,6 +86,7 @@
     <Compile Include="TaikoDifficultyCalculator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Scoring\TaikoScoreProcessor.cs" />
+    <Compile Include="TaikoInputManager.cs" />
     <Compile Include="UI\HitTarget.cs" />
     <Compile Include="UI\InputDrum.cs" />
     <Compile Include="UI\KiaiHitExplosion.cs" />

osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs

@@ -13,7 +13,6 @@ using osu.Framework.Platform;
 using osu.Game.IPC;
 using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets;
 
 namespace osu.Game.Tests.Beatmaps.IO
 {
@@ -98,16 +97,14 @@ namespace osu.Game.Tests.Beatmaps.IO
 
         private OsuGameBase loadOsu(GameHost host)
         {
+            host.Storage.DeleteDatabase(@"client");
+
             var osu = new OsuGameBase();
             Task.Run(() => host.Run(osu));
 
             while (!osu.IsLoaded)
                 Thread.Sleep(1);
 
-            //reset beatmap database (sqlite and storage backing)
-            osu.Dependencies.Get<RulesetStore>().Reset();
-            osu.Dependencies.Get<BeatmapManager>().Reset();
-
             return osu;
         }
 

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -49,9 +49,16 @@ namespace osu.Game.Beatmaps
 
         public string Path { get; set; }
 
-        [JsonProperty("file_md5")]
+        [JsonProperty("file_sha2")]
         public string Hash { get; set; }
 
+        /// <summary>
+        /// MD5 is kept for legacy support (matching against replays, osu-web-10 etc.).
+        /// </summary>
+        [Indexed]
+        [JsonProperty("file_md5")]
+        public string MD5Hash { get; set; }
+
         // General
         public int AudioLeadIn { get; set; }
         public bool Countdown { get; set; }

osu.Game/Beatmaps/BeatmapManager.cs

@@ -372,6 +372,7 @@ namespace osu.Game.Beatmaps
 
                     beatmap.BeatmapInfo.Path = name;
                     beatmap.BeatmapInfo.Hash = ms.ComputeSHA2Hash();
+                    beatmap.BeatmapInfo.MD5Hash = ms.ComputeMD5Hash();
 
                     // TODO: Diff beatmap metadata with set metadata and leave it here if necessary
                     beatmap.BeatmapInfo.Metadata = null;

osu.Game/Beatmaps/BeatmapStore.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Beatmaps
         /// The current version of this store. Used for migrations (see <see cref="PerformMigration(int, int)"/>).
         /// The initial version is 1.
         /// </summary>
-        protected override int StoreVersion => 2;
+        protected override int StoreVersion => 3;
 
         public BeatmapStore(SQLiteConnection connection)
             : base(connection)
@@ -77,6 +77,10 @@ namespace osu.Game.Beatmaps
                         // cannot migrate; breaking underlying changes.
                         Reset();
                         break;
+                    case 3:
+                        // Added MD5Hash column to BeatmapInfo
+                        Connection.MigrateTable<BeatmapInfo>();
+                        break;
                 }
             }
         }

osu.Game/Beatmaps/ControlPoints/DifficultyControlPoint.cs

@@ -10,4 +10,4 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         public double SpeedMultiplier = 1;
     }
-}
+}

osu.Game/Beatmaps/DifficultyCalculator.cs

@@ -30,11 +30,15 @@ namespace osu.Game.Beatmaps
 
     public abstract class DifficultyCalculator<T> : DifficultyCalculator where T : HitObject
     {
+        protected readonly Beatmap Beatmap;
+
         protected List<T> Objects;
 
         protected DifficultyCalculator(Beatmap beatmap)
         {
-            Objects = CreateBeatmapConverter().Convert(beatmap, true).HitObjects;
+            Beatmap = beatmap;
+
+            Objects = CreateBeatmapConverter().Convert(beatmap).HitObjects;
 
             foreach (var h in Objects)
                 h.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.Difficulty);

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -10,7 +10,6 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 
 namespace osu.Game.Beatmaps
 {
@@ -76,8 +75,6 @@ namespace osu.Game.Beatmaps
 
                 public override string Description => "dummy";
 
-                public override IEnumerable<KeyCounter> CreateGameplayKeys() => new List<KeyCounter>();
-
                 public DummyRuleset(RulesetInfo rulesetInfo)
                     : base(rulesetInfo)
                 {

osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs

@@ -280,7 +280,7 @@ namespace osu.Game.Beatmaps.Formats
 
             double time = double.Parse(split[0].Trim(), NumberFormatInfo.InvariantInfo);
             double beatLength = double.Parse(split[1].Trim(), NumberFormatInfo.InvariantInfo);
-            double speedMultiplier = beatLength < 0 ? -beatLength / 100.0 : 1;
+            double speedMultiplier = beatLength < 0 ? 100.0 / -beatLength : 1;
 
             TimeSignatures timeSignature = TimeSignatures.SimpleQuadruple;
             if (split.Length >= 3)
@@ -331,6 +331,7 @@ namespace osu.Game.Beatmaps.Formats
 
             if (speedMultiplier != difficultyPoint.SpeedMultiplier)
             {
+                beatmap.ControlPointInfo.DifficultyPoints.RemoveAll(x => x.Time == time);
                 beatmap.ControlPointInfo.DifficultyPoints.Add(new DifficultyControlPoint
                 {
                     Time = time,

osu.Game/Configuration/OsuConfigManager.cs

@@ -70,6 +70,8 @@ namespace osu.Game.Configuration
 
             // Update
             Set(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
+
+            Set(OsuSetting.Version, string.Empty);
         }
 
         public OsuConfigManager(Storage storage) : base(storage)
@@ -106,6 +108,7 @@ namespace osu.Game.Configuration
         SnakingInSliders,
         SnakingOutSliders,
         ShowFpsDisplay,
-        ChatDisplayHeight
+        ChatDisplayHeight,
+        Version
     }
 }

osu.Game/Graphics/Containers/ParallaxContainer.cs

@@ -34,9 +34,8 @@ namespace osu.Game.Graphics.Containers
         protected override Container<Drawable> Content => content;
 
         [BackgroundDependencyLoader]
-        private void load(UserInputManager input, OsuConfigManager config)
+        private void load(OsuConfigManager config)
         {
-            this.input = input;
             parallaxEnabled = config.GetBindable<bool>(OsuSetting.MenuParallax);
             parallaxEnabled.ValueChanged += delegate
             {
@@ -48,6 +47,12 @@ namespace osu.Game.Graphics.Containers
             };
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            input = GetContainingInputManager();
+        }
+
         private bool firstUpdate = true;
 
         protected override void Update()

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
 using osu.Game.Configuration;
 using System;
+using System.Diagnostics;
 using osu.Framework.Graphics.Textures;
 
 namespace osu.Game.Graphics.Cursor
@@ -21,20 +22,31 @@ namespace osu.Game.Graphics.Cursor
 
         private bool dragging;
 
+        private bool startRotation;
+
         protected override bool OnMouseMove(InputState state)
         {
             if (dragging)
             {
-                Vector2 offset = state.Mouse.Position - state.Mouse.PositionMouseDown ?? state.Mouse.Delta;
-                float degrees = (float)MathHelper.RadiansToDegrees(Math.Atan2(-offset.X, offset.Y)) + 24.3f;
+                Debug.Assert(state.Mouse.PositionMouseDown != null);
 
-                // Always rotate in the direction of least distance
-                float diff = (degrees - ActiveCursor.Rotation) % 360;
-                if (diff < -180) diff += 360;
-                if (diff > 180) diff -= 360;
-                degrees = ActiveCursor.Rotation + diff;
+                // don't start rotating until we're moved a minimum distance away from the mouse down location,
+                // else it can have an annoying effect.
+                startRotation |= Vector2.Distance(state.Mouse.Position, state.Mouse.PositionMouseDown.Value) > 30;
 
-                ActiveCursor.RotateTo(degrees, 600, Easing.OutQuint);
+                if (startRotation)
+                {
+                    Vector2 offset = state.Mouse.Position - state.Mouse.PositionMouseDown.Value;
+                    float degrees = (float)MathHelper.RadiansToDegrees(Math.Atan2(-offset.X, offset.Y)) + 24.3f;
+
+                    // Always rotate in the direction of least distance
+                    float diff = (degrees - ActiveCursor.Rotation) % 360;
+                    if (diff < -180) diff += 360;
+                    if (diff > 180) diff -= 360;
+                    degrees = ActiveCursor.Rotation + diff;
+
+                    ActiveCursor.RotateTo(degrees, 600, Easing.OutQuint);
+                }
             }
 
             return base.OnMouseMove(state);
@@ -61,6 +73,7 @@ namespace osu.Game.Graphics.Cursor
             if (!state.Mouse.HasMainButtonPressed)
             {
                 dragging = false;
+                startRotation = false;
 
                 ((Cursor)ActiveCursor).AdditiveLayer.FadeOut(500, Easing.OutQuint);
                 ActiveCursor.RotateTo(0, 600 * (1 + Math.Abs(ActiveCursor.Rotation / 720)), Easing.OutElasticHalf);

osu.Game/Graphics/UserInterface/BarGraph.cs

@@ -44,19 +44,31 @@ namespace osu.Game.Graphics.UserInterface
             {
                 List<Bar> bars = Children.ToList();
                 foreach (var bar in value.Select((length, index) => new { Value = length, Bar = bars.Count > index ? bars[index] : null }))
+                {
+                    float length = MaxValue ?? value.Max();
+                    if (length != 0)
+                        length = bar.Value / length;
+
+                    float size = value.Count();
+                    if (size != 0)
+                        size = 1.0f / size;
+
                     if (bar.Bar != null)
                     {
-                        bar.Bar.Length = bar.Value / (MaxValue ?? value.Max());
-                        bar.Bar.Size = (direction & BarDirection.Horizontal) > 0 ? new Vector2(1, 1.0f / value.Count()) : new Vector2(1.0f / value.Count(), 1);
+                        bar.Bar.Length = length;
+                        bar.Bar.Size = (direction & BarDirection.Horizontal) > 0 ? new Vector2(1, size) : new Vector2(size, 1);
                     }
                     else
+                    {
                         Add(new Bar
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Size = (direction & BarDirection.Horizontal) > 0 ? new Vector2(1, 1.0f / value.Count()) : new Vector2(1.0f / value.Count(), 1),
-                            Length = bar.Value / (MaxValue ?? value.Max()),
+                            Size = (direction & BarDirection.Horizontal) > 0 ? new Vector2(1, size) : new Vector2(size, 1),
+                            Length = length,
                             Direction = Direction,
                         });
+                    }
+                }
                 //I'm using ToList() here because Where() returns an Enumerable which can change it's elements afterwards
                 RemoveRange(Children.Where((bar, index) => index >= value.Count()).ToList());
             }

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -3,10 +3,8 @@
 
 using OpenTK.Graphics;
 using OpenTK.Input;
-using osu.Framework.Allocation;
 using osu.Framework.Input;
 using System;
-using System.Linq;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -28,34 +26,28 @@ namespace osu.Game.Graphics.UserInterface
             {
                 focus = value;
                 if (!focus && HasFocus)
-                    inputManager.ChangeFocus(null);
+                    GetContainingInputManager().ChangeFocus(null);
             }
         }
 
-        private InputManager inputManager;
-
-        [BackgroundDependencyLoader]
-        private void load(UserInputManager inputManager)
-        {
-            this.inputManager = inputManager;
-        }
-
         protected override void OnFocus(InputState state)
         {
             base.OnFocus(state);
             BorderThickness = 0;
         }
 
-        protected override void OnFocusLost(InputState state)
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
-            if (state.Keyboard.Keys.Any(key => key == Key.Escape))
+            if (args.Key == Key.Escape)
             {
                 if (Text.Length > 0)
                     Text = string.Empty;
                 else
                     Exit?.Invoke();
+                return true;
             }
-            base.OnFocusLost(state);
+
+            return base.OnKeyDown(state, args);
         }
 
         public override bool RequestsFocus => HoldFocus;

osu.Game/Graphics/UserInterface/OsuButton.cs

@@ -7,6 +7,7 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
@@ -16,13 +17,15 @@ using osu.Game.Graphics.Sprites;
 
 namespace osu.Game.Graphics.UserInterface
 {
-    public class OsuButton : Button
+    public class OsuButton : Button, IFilterable
     {
         private Box hover;
 
         private SampleChannel sampleClick;
         private SampleChannel sampleHover;
 
+        protected Triangles Triangles;
+
         public OsuButton()
         {
             Height = 40;
@@ -51,7 +54,7 @@ namespace osu.Game.Graphics.UserInterface
 
             AddRange(new Drawable[]
             {
-                new Triangles
+                Triangles = new Triangles
                 {
                     RelativeSizeAxes = Axes.Both,
                     ColourDark = colours.BlueDarker,
@@ -108,5 +111,15 @@ namespace osu.Game.Graphics.UserInterface
             Content.ScaleTo(1, 1000, Easing.OutElastic);
             return base.OnMouseUp(state, args);
         }
+
+        public string[] FilterTerms => new[] { Text };
+
+        public bool MatchingFilter
+        {
+            set
+            {
+                this.FadeTo(value ? 1 : 0);
+            }
+        }
     }
-}
+}

osu.Game/Graphics/UserInterface/Volume/VolumeControl.cs

@@ -3,11 +3,11 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input;
 using osu.Framework.Threading;
 using OpenTK;
 using osu.Framework.Audio;
 using osu.Framework.Allocation;
+using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface.Volume
 {
@@ -15,8 +15,6 @@ namespace osu.Game.Graphics.UserInterface.Volume
     {
         private readonly VolumeMeter volumeMeterMaster;
 
-        protected override bool HideOnEscape => false;
-
         private void volumeChanged(double newVolume)
         {
             Show();
@@ -66,15 +64,25 @@ namespace osu.Game.Graphics.UserInterface.Volume
             volumeMeterMusic.Bindable.ValueChanged -= volumeChanged;
         }
 
-        public void Adjust(InputState state)
+        public bool Adjust(GlobalAction action)
         {
-            if (State == Visibility.Hidden)
+            switch (action)
             {
-                Show();
-                return;
+                case GlobalAction.DecreaseVolume:
+                    if (State == Visibility.Hidden)
+                        Show();
+                    else
+                        volumeMeterMaster.Decrease();
+                    return true;
+                case GlobalAction.IncreaseVolume:
+                    if (State == Visibility.Hidden)
+                        Show();
+                    else
+                        volumeMeterMaster.Increase();
+                    return true;
             }
 
-            volumeMeterMaster.TriggerOnWheel(state);
+            return false;
         }
 
         [BackgroundDependencyLoader]

osu.Game/Graphics/UserInterface/Volume/VolumeControlReceptor.cs

@@ -3,32 +3,16 @@
 
 using System;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input;
-using OpenTK.Input;
+using osu.Framework.Input.Bindings;
+using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface.Volume
 {
-    internal class VolumeControlReceptor : Container
+    internal class VolumeControlReceptor : Container, IKeyBindingHandler<GlobalAction>
     {
-        public Action<InputState> ActionRequested;
+        public Func<GlobalAction, bool> ActionRequested;
 
-        protected override bool OnWheel(InputState state)
-        {
-            ActionRequested?.Invoke(state);
-            return true;
-        }
-
-        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
-        {
-            switch (args.Key)
-            {
-                case Key.Up:
-                case Key.Down:
-                    ActionRequested?.Invoke(state);
-                    return true;
-            }
-
-            return base.OnKeyDown(state, args);
-        }
+        public bool OnPressed(GlobalAction action) => ActionRequested?.Invoke(action) ?? false;
+        public bool OnReleased(GlobalAction action) => false;
     }
 }

osu.Game/Graphics/UserInterface/Volume/VolumeMeter.cs

@@ -4,15 +4,16 @@
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input;
 using osu.Game.Graphics.Sprites;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Bindings;
+using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface.Volume
 {
-    internal class VolumeMeter : Container
+    internal class VolumeMeter : Container, IKeyBindingHandler<GlobalAction>
     {
         private readonly Box meterFill;
         public BindableDouble Bindable { get; } = new BindableDouble();
@@ -76,12 +77,35 @@ namespace osu.Game.Graphics.UserInterface.Volume
             }
         }
 
-        protected override bool OnWheel(InputState state)
+        public void Increase()
         {
-            Volume += 0.05f * state.Mouse.WheelDelta;
-            return true;
+            Volume += 0.05f;
+        }
+
+        public void Decrease()
+        {
+            Volume -= 0.05f;
         }
 
         private void updateFill() => meterFill.ScaleTo(new Vector2(1, (float)Volume), 300, Easing.OutQuint);
+
+        public bool OnPressed(GlobalAction action)
+        {
+            if (!IsHovered) return false;
+
+            switch (action)
+            {
+                case GlobalAction.DecreaseVolume:
+                    Decrease();
+                    return true;
+                case GlobalAction.IncreaseVolume:
+                    Increase();
+                    return true;
+            }
+
+            return false;
+        }
+
+        public bool OnReleased(GlobalAction action) => false;
     }
 }

osu.Game/Input/BindingStore.cs

@@ -1,48 +0,0 @@
-// 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.Platform;
-using osu.Game.Database;
-using osu.Game.Input.Bindings;
-using SQLite.Net;
-
-namespace osu.Game.Input
-{
-    public class BindingStore : DatabaseBackedStore
-    {
-        public BindingStore(SQLiteConnection connection, Storage storage = null)
-            : base(connection, storage)
-        {
-        }
-
-        protected override int StoreVersion => 2;
-
-        protected override void PerformMigration(int currentVersion, int targetVersion)
-        {
-            base.PerformMigration(currentVersion, targetVersion);
-
-            while (currentVersion++ < targetVersion)
-            {
-                switch (currentVersion)
-                {
-                    case 1:
-                        // cannot migrate; breaking underlying changes.
-                        Reset();
-                        break;
-                }
-            }
-        }
-
-        protected override void Prepare(bool reset = false)
-        {
-            Connection.CreateTable<DatabasedKeyBinding>();
-        }
-
-        protected override Type[] ValidTypes => new[]
-        {
-            typeof(DatabasedKeyBinding)
-        };
-
-    }
-}

osu.Game/Input/Bindings/DatabasedKeyBinding.cs

@@ -11,6 +11,9 @@ namespace osu.Game.Input.Bindings
     [Table("KeyBinding")]
     public class DatabasedKeyBinding : KeyBinding
     {
+        [PrimaryKey, AutoIncrement]
+        public int ID { get; set; }
+
         [ForeignKey(typeof(RulesetInfo))]
         public int? RulesetID { get; set; }
 
@@ -24,11 +27,12 @@ namespace osu.Game.Input.Bindings
             private set { KeyCombination = value; }
         }
 
+        [Indexed]
         [Column("Action")]
-        public new int Action
+        public int IntAction
         {
-            get { return base.Action; }
-            private set { base.Action = value; }
+            get { return (int)Action; }
+            set { Action = value; }
         }
     }
 }

osu.Game/Input/Bindings/DatabasedKeyBindingInputManager.cs

@@ -1,6 +1,8 @@
 // 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 System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets;
@@ -18,7 +20,9 @@ namespace osu.Game.Input.Bindings
 
         private readonly int? variant;
 
-        private BindingStore store;
+        private KeyBindingStore store;
+
+        public override IEnumerable<KeyBinding> DefaultKeyBindings => ruleset.CreateInstance().GetDefaultKeyBindings();
 
         /// <summary>
         /// Create a new instance.
@@ -31,27 +35,20 @@ namespace osu.Game.Input.Bindings
         {
             this.ruleset = ruleset;
             this.variant = variant;
+
+            if (ruleset != null && variant == null)
+                throw new InvalidOperationException($"{nameof(variant)} can not be null when a non-null {nameof(ruleset)} is provided.");
         }
 
         [BackgroundDependencyLoader]
-        private void load(BindingStore bindings)
+        private void load(KeyBindingStore keyBindings)
         {
-            store = bindings;
+            store = keyBindings;
         }
 
         protected override void ReloadMappings()
         {
-            // load defaults
-            base.ReloadMappings();
-
-            var rulesetId = ruleset?.ID;
-
-            // load from database if present.
-            if (store != null)
-            {
-                foreach (var b in store.Query<DatabasedKeyBinding>(b => b.RulesetID == rulesetId && b.Variant == variant))
-                    KeyBindings.Add(b);
-            }
+            KeyBindings = store.Query(ruleset?.ID, variant);
         }
     }
 }

osu.Game/Input/Bindings/GlobalBindingInputManager.cs

@@ -1,68 +0,0 @@
-// 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.Input;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Linq;
-using osu.Framework.Graphics;
-using osu.Framework.Input;
-using osu.Framework.Input.Bindings;
-
-namespace osu.Game.Input.Bindings
-{
-    public class GlobalBindingInputManager : DatabasedKeyBindingInputManager<GlobalAction>
-    {
-        private readonly Drawable handler;
-
-        public GlobalBindingInputManager(OsuGameBase game)
-        {
-            if (game is IKeyBindingHandler<GlobalAction>)
-                handler = game;
-        }
-
-        protected override IEnumerable<KeyBinding> CreateDefaultMappings() => new[]
-        {
-            new KeyBinding(Key.F8, GlobalAction.ToggleChat),
-            new KeyBinding(Key.F9, GlobalAction.ToggleSocial),
-            new KeyBinding(new[] { Key.LControl, Key.LAlt, Key.R }, GlobalAction.ResetInputSettings),
-            new KeyBinding(new[] { Key.LControl, Key.T }, GlobalAction.ToggleToolbar),
-            new KeyBinding(new[] { Key.LControl, Key.O }, GlobalAction.ToggleSettings),
-            new KeyBinding(new[] { Key.LControl, Key.D }, GlobalAction.ToggleDirect),
-        };
-
-        protected override bool PropagateKeyDown(IEnumerable<Drawable> drawables, InputState state, KeyDownEventArgs args)
-        {
-            if (handler != null)
-                drawables = new[] { handler }.Concat(drawables);
-
-            // always handle ourselves before all children.
-            return base.PropagateKeyDown(drawables, state, args);
-        }
-
-        protected override bool PropagateKeyUp(IEnumerable<Drawable> drawables, InputState state, KeyUpEventArgs args)
-        {
-            if (handler != null)
-                drawables = new[] { handler }.Concat(drawables);
-
-            // always handle ourselves before all children.
-            return base.PropagateKeyUp(drawables, state, args);
-        }
-    }
-
-    public enum GlobalAction
-    {
-        [Description("Toggle chat overlay")]
-        ToggleChat,
-        [Description("Toggle social overlay")]
-        ToggleSocial,
-        [Description("Reset input settings")]
-        ResetInputSettings,
-        [Description("Toggle toolbar")]
-        ToggleToolbar,
-        [Description("Toggle settings")]
-        ToggleSettings,
-        [Description("Toggle osu!direct")]
-        ToggleDirect,
-    }
-}

osu.Game/Input/Bindings/GlobalKeyBindingInputManager.cs

@@ -0,0 +1,58 @@
+// 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.ComponentModel;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Bindings;
+
+namespace osu.Game.Input.Bindings
+{
+    public class GlobalKeyBindingInputManager : DatabasedKeyBindingInputManager<GlobalAction>
+    {
+        private readonly Drawable handler;
+
+        public GlobalKeyBindingInputManager(OsuGameBase game)
+        {
+            if (game is IKeyBindingHandler<GlobalAction>)
+                handler = game;
+        }
+
+        public override IEnumerable<KeyBinding> DefaultKeyBindings => new[]
+        {
+            new KeyBinding(InputKey.F8, GlobalAction.ToggleChat),
+            new KeyBinding(InputKey.F9, GlobalAction.ToggleSocial),
+            new KeyBinding(new[] { InputKey.Control, InputKey.Alt, InputKey.R }, GlobalAction.ResetInputSettings),
+            new KeyBinding(new[] { InputKey.Control, InputKey.T }, GlobalAction.ToggleToolbar),
+            new KeyBinding(new[] { InputKey.Control, InputKey.O }, GlobalAction.ToggleSettings),
+            new KeyBinding(new[] { InputKey.Up }, GlobalAction.IncreaseVolume),
+            new KeyBinding(new[] { InputKey.MouseWheelUp }, GlobalAction.IncreaseVolume),
+            new KeyBinding(new[] { InputKey.Down }, GlobalAction.DecreaseVolume),
+            new KeyBinding(new[] { InputKey.MouseWheelDown }, GlobalAction.DecreaseVolume),
+        };
+
+        protected override IEnumerable<Drawable> KeyBindingInputQueue =>
+            handler == null ? base.KeyBindingInputQueue : new[] { handler }.Concat(base.KeyBindingInputQueue);
+    }
+
+    public enum GlobalAction
+    {
+        [Description("Toggle chat overlay")]
+        ToggleChat,
+        [Description("Toggle social overlay")]
+        ToggleSocial,
+        [Description("Reset input settings")]
+        ResetInputSettings,
+        [Description("Toggle toolbar")]
+        ToggleToolbar,
+        [Description("Toggle settings")]
+        ToggleSettings,
+        [Description("Toggle osu!direct")]
+        ToggleDirect,
+        [Description("Increase Volume")]
+        IncreaseVolume,
+        [Description("Decrease Volume")]
+        DecreaseVolume,
+    }
+}

osu.Game/Input/KeyBindingStore.cs

@@ -0,0 +1,93 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Platform;
+using osu.Game.Database;
+using osu.Game.Input.Bindings;
+using osu.Game.Rulesets;
+using SQLite.Net;
+
+namespace osu.Game.Input
+{
+    public class KeyBindingStore : DatabaseBackedStore
+    {
+        public KeyBindingStore(SQLiteConnection connection, RulesetStore rulesets, Storage storage = null)
+            : base(connection, storage)
+        {
+            foreach (var info in rulesets.AllRulesets)
+            {
+                var ruleset = info.CreateInstance();
+                foreach (var variant in ruleset.AvailableVariants)
+                    insertDefaults(ruleset.GetDefaultKeyBindings(variant), info.ID, variant);
+            }
+        }
+
+        public void Register(KeyBindingInputManager manager) => insertDefaults(manager.DefaultKeyBindings);
+
+        protected override int StoreVersion => 3;
+
+        protected override void PerformMigration(int currentVersion, int targetVersion)
+        {
+            base.PerformMigration(currentVersion, targetVersion);
+
+            while (currentVersion++ < targetVersion)
+            {
+                switch (currentVersion)
+                {
+                    case 1:
+                    case 2:
+                    case 3:
+                        // cannot migrate; breaking underlying changes.
+                        Reset();
+                        break;
+                }
+            }
+        }
+
+        protected override void Prepare(bool reset = false)
+        {
+            if (reset)
+                Connection.DropTable<DatabasedKeyBinding>();
+
+            Connection.CreateTable<DatabasedKeyBinding>();
+        }
+
+        private void insertDefaults(IEnumerable<KeyBinding> defaults, int? rulesetId = null, int? variant = null)
+        {
+            var query = Query(rulesetId, variant);
+
+            // compare counts in database vs defaults
+            foreach (var group in defaults.GroupBy(k => k.Action))
+            {
+                int count;
+                while (group.Count() > (count = query.Count(k => (int)k.Action == (int)group.Key)))
+                {
+                    var insertable = group.Skip(count).First();
+
+                    // insert any defaults which are missing.
+                    Connection.Insert(new DatabasedKeyBinding
+                    {
+                        KeyCombination = insertable.KeyCombination,
+                        Action = insertable.Action,
+                        RulesetID = rulesetId,
+                        Variant = variant
+                    });
+                }
+            }
+        }
+
+        protected override Type[] ValidTypes => new[]
+        {
+            typeof(DatabasedKeyBinding)
+        };
+
+        public IEnumerable<KeyBinding> Query(int? rulesetId = null, int? variant = null) =>
+            Query<DatabasedKeyBinding>(b => b.RulesetID == rulesetId && b.Variant == variant);
+
+        public void Update(KeyBinding keyBinding) => Connection.Update(keyBinding);
+    }
+}

osu.Game/Online/Chat/Channel.cs

@@ -26,6 +26,8 @@ namespace osu.Game.Online.Chat
 
         public readonly SortedList<Message> Messages = new SortedList<Message>(Comparer<Message>.Default);
 
+        private readonly List<LocalEchoMessage> pendingMessages = new List<LocalEchoMessage>();
+
         public Bindable<bool> Joined = new Bindable<bool>();
 
         public bool ReadOnly => Name != "#lazer";
@@ -38,6 +40,16 @@ namespace osu.Game.Online.Chat
         }
 
         public event Action<IEnumerable<Message>> NewMessagesArrived;
+        public event Action<LocalEchoMessage, Message> PendingMessageResolved;
+        public event Action<Message> MessageRemoved;
+
+        public void AddLocalEcho(LocalEchoMessage message)
+        {
+            pendingMessages.Add(message);
+            Messages.Add(message);
+
+            NewMessagesArrived?.Invoke(new[] { message });
+        }
 
         public void AddNewMessages(params Message[] messages)
         {
@@ -52,11 +64,42 @@ namespace osu.Game.Online.Chat
 
         private void purgeOldMessages()
         {
-            int messageCount = Messages.Count;
+            // never purge local echos
+            int messageCount = Messages.Count - pendingMessages.Count;
             if (messageCount > MAX_HISTORY)
                 Messages.RemoveRange(0, messageCount - MAX_HISTORY);
         }
 
+        /// <summary>
+        /// Replace or remove a message from the channel.
+        /// </summary>
+        /// <param name="echo">The local echo message (client-side).</param>
+        /// <param name="final">The response message, or null if the message became invalid.</param>
+        public void ReplaceMessage(LocalEchoMessage echo, Message final)
+        {
+            if (!pendingMessages.Remove(echo))
+                throw new InvalidOperationException("Attempted to remove echo that wasn't present");
+
+            Messages.Remove(echo);
+
+            if (final == null)
+            {
+                MessageRemoved?.Invoke(echo);
+                return;
+            }
+
+            if (Messages.Contains(final))
+            {
+                // message already inserted, so let's throw away this update.
+                // we may want to handle this better in the future, but for the time being api requests are single-threaded so order is assumed.
+                MessageRemoved?.Invoke(echo);
+                return;
+            }
+
+            Messages.Add(final);
+            PendingMessageResolved?.Invoke(echo, final);
+        }
+
         public override string ToString() => Name;
     }
 }

osu.Game/Online/Chat/LocalEchoMessage.cs

@@ -0,0 +1,12 @@
+// 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.Online.Chat
+{
+    public class LocalEchoMessage : Message
+    {
+        public LocalEchoMessage() : base(null)
+        {
+        }
+    }
+}

osu.Game/Online/Chat/Message.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Online.Chat
     public class Message : IComparable<Message>, IEquatable<Message>
     {
         [JsonProperty(@"message_id")]
-        public readonly long Id;
+        public readonly long? Id;
 
         //todo: this should be inside sender.
         [JsonProperty(@"sender_id")]
@@ -37,14 +37,22 @@ namespace osu.Game.Online.Chat
         {
         }
 
-        public Message(long id)
+        public Message(long? id)
         {
             Id = id;
         }
 
-        public int CompareTo(Message other) => Id.CompareTo(other.Id);
+        public int CompareTo(Message other)
+        {
+            if (!Id.HasValue)
+                return other.Id.HasValue ? 1 : Timestamp.CompareTo(other.Timestamp);
+            if (!other.Id.HasValue)
+                return -1;
 
-        public bool Equals(Message other) => Id == other?.Id;
+            return Id.Value.CompareTo(other.Id.Value);
+        }
+
+        public virtual bool Equals(Message other) => Id == other?.Id;
 
         public override int GetHashCode() => Id.GetHashCode();
     }

osu.Game/OsuGame.cs

@@ -8,7 +8,6 @@ using osu.Game.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Overlays;
-using osu.Framework.Input;
 using osu.Framework.Logging;
 using osu.Game.Graphics.UserInterface.Volume;
 using osu.Framework.Allocation;
@@ -160,7 +159,7 @@ namespace osu.Game
                 new VolumeControlReceptor
                 {
                     RelativeSizeAxes = Axes.Both,
-                    ActionRequested = delegate(InputState state) { volume.Adjust(state); }
+                    ActionRequested = action => volume.Adjust(action)
                 },
                 mainContent = new Container
                 {
@@ -182,7 +181,11 @@ namespace osu.Game
             LoadComponentAsync(direct = new DirectOverlay { Depth = -1 }, mainContent.Add);
             LoadComponentAsync(social = new SocialOverlay { Depth = -1 }, mainContent.Add);
             LoadComponentAsync(chat = new ChatOverlay { Depth = -1 }, mainContent.Add);
-            LoadComponentAsync(settings = new SettingsOverlay { Depth = -1 }, overlayContent.Add);
+            LoadComponentAsync(settings = new MainSettings
+            {
+                GetToolbarHeight = () => ToolbarOffset,
+                Depth = -1
+            }, overlayContent.Add);
             LoadComponentAsync(userProfile = new UserProfileOverlay { Depth = -2 }, mainContent.Add);
             LoadComponentAsync(musicController = new MusicController
             {
@@ -355,6 +358,13 @@ namespace osu.Game
         {
             base.UpdateAfterChildren();
 
+            // we only want to apply these restrictions when we are inside a screen stack.
+            // the use case for not applying is in visual/unit tests.
+            bool applyRestrictions = !currentScreen?.AllowBeatmapRulesetChange ?? false;
+
+            Ruleset.Disabled = applyRestrictions;
+            Beatmap.Disabled = applyRestrictions;
+
             mainContent.Padding = new MarginPadding { Top = ToolbarOffset };
 
             Cursor.State = currentScreen?.HasLocalCursorDisplayed == false ? Visibility.Visible : Visibility.Hidden;

osu.Game/OsuGameBase.cs

@@ -39,7 +39,7 @@ namespace osu.Game
 
         protected ScoreStore ScoreStore;
 
-        protected BindingStore BindingStore;
+        protected KeyBindingStore KeyBindingStore;
 
         protected override string MainResourceFile => @"osu.Game.Resources.dll";
 
@@ -94,21 +94,23 @@ namespace osu.Game
         protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) =>
             dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
 
+        private SQLiteConnection connection;
+
         [BackgroundDependencyLoader]
         private void load()
         {
             dependencies.Cache(this);
             dependencies.Cache(LocalConfig);
 
-            SQLiteConnection connection = Host.Storage.GetDatabase(@"client");
+            connection = Host.Storage.GetDatabase(@"client");
 
             connection.CreateTable<StoreVersion>();
 
             dependencies.Cache(RulesetStore = new RulesetStore(connection));
             dependencies.Cache(FileStore = new FileStore(connection, Host.Storage));
             dependencies.Cache(BeatmapManager = new BeatmapManager(Host.Storage, FileStore, connection, RulesetStore, Host));
-            dependencies.Cache(ScoreStore = new ScoreStore(Host.Storage, connection, Host, BeatmapManager));
-            dependencies.Cache(BindingStore = new BindingStore(connection));
+            dependencies.Cache(ScoreStore = new ScoreStore(Host.Storage, connection, Host, BeatmapManager, RulesetStore));
+            dependencies.Cache(KeyBindingStore = new KeyBindingStore(connection, RulesetStore));
             dependencies.Cache(new OsuColour());
 
             //this completely overrides the framework default. will need to change once we make a proper FontStore.
@@ -183,12 +185,14 @@ namespace osu.Game
         {
             base.LoadComplete();
 
+            GlobalKeyBindingInputManager globalBinding;
+
             base.Content.Add(new RatioAdjust
             {
                 Children = new Drawable[]
                 {
                     Cursor = new MenuCursor(),
-                    new GlobalBindingInputManager(this)
+                    globalBinding = new GlobalKeyBindingInputManager(this)
                     {
                         RelativeSizeAxes = Axes.Both,
                         Child = new OsuTooltipContainer(Cursor)
@@ -200,6 +204,9 @@ namespace osu.Game
                 }
             });
 
+            KeyBindingStore.Register(globalBinding);
+            dependencies.Cache(globalBinding);
+
             // TODO: This is temporary until we reimplement the local FPS display.
             // It's just to allow end-users to access the framework FPS display without knowing the shortcut key.
             fpsDisplayVisible = LocalConfig.GetBindable<bool>(OsuSetting.ShowFpsDisplay);
@@ -232,6 +239,8 @@ namespace osu.Game
                 LocalConfig.Save();
             }
 
+            connection.Dispose();
+
             base.Dispose(isDisposing);
         }
     }

osu.Game/Overlays/Chat/ChannelSelectionOverlay.cs

@@ -152,7 +152,7 @@ namespace osu.Game.Overlays.Chat
 
         protected override void OnFocus(InputState state)
         {
-            InputManager.ChangeFocus(search);
+            GetContainingInputManager().ChangeFocus(search);
             base.OnFocus(state);
         }
 

osu.Game/Overlays/Chat/ChatLine.cs

@@ -2,26 +2,24 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Online.Chat;
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Framework.Graphics.Effects;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Allocation;
 using osu.Game.Users;
-using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Overlays.Chat
 {
     public class ChatLine : Container
     {
-        public readonly Message Message;
-
-        private static readonly Color4[] username_colours = {
+        private static readonly Color4[] username_colours =
+        {
             OsuColour.FromHex("588c7e"),
             OsuColour.FromHex("b2a367"),
             OsuColour.FromHex("c98f65"),
@@ -69,6 +67,8 @@ namespace osu.Game.Overlays.Chat
 
         private Color4 customUsernameColour;
 
+        private OsuSpriteText timestamp;
+
         public ChatLine(Message message)
         {
             Message = message;
@@ -79,6 +79,26 @@ namespace osu.Game.Overlays.Chat
             Padding = new MarginPadding { Left = padding, Right = padding };
         }
 
+        private Message message;
+        private OsuSpriteText username;
+        private OsuTextFlowContainer contentFlow;
+
+        public Message Message
+        {
+            get { return message; }
+            set
+            {
+                if (message == value) return;
+
+                message = value;
+
+                if (!IsLoaded)
+                    return;
+
+                updateMessageContent();
+            }
+        }
+
         [BackgroundDependencyLoader(true)]
         private void load(OsuColour colours, UserProfileOverlay profile)
         {
@@ -86,49 +106,54 @@ namespace osu.Game.Overlays.Chat
             loadProfile = u => profile?.ShowUser(u);
         }
 
+        private bool senderHasBackground => !string.IsNullOrEmpty(message.Sender.Colour);
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            bool hasBackground = !string.IsNullOrEmpty(Message.Sender.Colour);
-            Drawable username = new OsuSpriteText
+            bool hasBackground = senderHasBackground;
+
+            Drawable effectedUsername = username = new OsuSpriteText
             {
                 Font = @"Exo2.0-BoldItalic",
-                Text = $@"{Message.Sender.Username}" + (hasBackground ? "" : ":"),
-                Colour = hasBackground ? customUsernameColour : username_colours[Message.UserId % username_colours.Length],
+                Colour = hasBackground ? customUsernameColour : username_colours[message.Sender.Id % username_colours.Length],
                 TextSize = text_size,
             };
 
             if (hasBackground)
             {
                 // Background effect
-                username = username.WithEffect(new EdgeEffect
+                effectedUsername = new Container
                 {
+                    AutoSizeAxes = Axes.Both,
+                    Masking = true,
                     CornerRadius = 4,
-                    Parameters = new EdgeEffectParameters
-                    {
-                        Radius = 1,
-                        Colour = OsuColour.FromHex(Message.Sender.Colour),
-                        Type = EdgeEffectType.Shadow,
-                    }
-                }, d =>
-                {
-                    d.Padding = new MarginPadding { Left = 3, Right = 3, Bottom = 1, Top = -3 };
-                    d.Y = 3;
-                })
-                // Drop shadow effect
-                .WithEffect(new EdgeEffect
-                {
-                    CornerRadius = 4,
-                    Parameters = new EdgeEffectParameters
+                    EdgeEffect = new EdgeEffectParameters
                     {
                         Roundness = 1,
                         Offset = new Vector2(0, 3),
                         Radius = 3,
                         Colour = Color4.Black.Opacity(0.3f),
                         Type = EdgeEffectType.Shadow,
+                    },
+                    // Drop shadow effect
+                    Child = new Container
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Masking = true,
+                        CornerRadius = 4,
+                        EdgeEffect = new EdgeEffectParameters
+                        {
+                            Radius = 1,
+                            Colour = OsuColour.FromHex(message.Sender.Colour),
+                            Type = EdgeEffectType.Shadow,
+                        },
+                        Padding = new MarginPadding { Left = 3, Right = 3, Bottom = 1, Top = -3 },
+                        Y = 3,
+                        Child = username,
                     }
-                });
+                };
             }
 
             Children = new Drawable[]
@@ -138,23 +163,21 @@ namespace osu.Game.Overlays.Chat
                     Size = new Vector2(message_padding, text_size),
                     Children = new Drawable[]
                     {
-                        new OsuSpriteText
+                        timestamp = new OsuSpriteText
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
                             Font = @"Exo2.0-SemiBold",
-                            Text = $@"{Message.Timestamp.LocalDateTime:HH:mm:ss}",
                             FixedWidth = true,
                             TextSize = text_size * 0.75f,
-                            Alpha = 0.4f,
                         },
                         new ClickableContainer
                         {
                             AutoSizeAxes = Axes.Both,
                             Origin = Anchor.TopRight,
                             Anchor = Anchor.TopRight,
-                            Child = username,
-                            Action = () => loadProfile(Message.Sender),
+                            Child = effectedUsername,
+                            Action = () => loadProfile(message.Sender),
                         },
                     }
                 },
@@ -165,18 +188,27 @@ namespace osu.Game.Overlays.Chat
                     Padding = new MarginPadding { Left = message_padding + padding },
                     Children = new Drawable[]
                     {
-                        new OsuTextFlowContainer(t =>
+                        contentFlow = new OsuTextFlowContainer(t => { t.TextSize = text_size; })
                         {
-                            t.TextSize = text_size;
-                        })
-                        {
-                            Text = Message.Content,
                             AutoSizeAxes = Axes.Y,
                             RelativeSizeAxes = Axes.X,
                         }
                     }
                 }
             };
+
+            updateMessageContent();
+            FinishTransforms(true);
+        }
+
+        private void updateMessageContent()
+        {
+            this.FadeTo(message is LocalEchoMessage ? 0.4f : 1.0f, 500, Easing.OutQuint);
+            timestamp.FadeTo(message is LocalEchoMessage ? 0 : 1, 500, Easing.OutQuint);
+
+            timestamp.Text = $@"{message.Timestamp.LocalDateTime:HH:mm:ss}";
+            username.Text = $@"{message.Sender.Username}" + (senderHasBackground ? "" : ":");
+            contentFlow.Text = message.Content;
         }
     }
 }

osu.Game/Overlays/Chat/DrawableChannel.cs

@@ -3,7 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using OpenTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -14,8 +16,19 @@ namespace osu.Game.Overlays.Chat
 {
     public class DrawableChannel : Container
     {
+        private class ChatLineContainer : FillFlowContainer<ChatLine>
+        {
+            protected override int Compare(Drawable x, Drawable y)
+            {
+                var xC = (ChatLine)x;
+                var yC = (ChatLine)y;
+
+                return xC.Message.CompareTo(yC.Message);
+            }
+        }
+
         public readonly Channel Channel;
-        private readonly FillFlowContainer<ChatLine> flow;
+        private readonly ChatLineContainer flow;
         private readonly ScrollContainer scroll;
 
         public DrawableChannel(Channel channel)
@@ -32,20 +45,19 @@ namespace osu.Game.Overlays.Chat
                     // Some chat lines have effects that slightly protrude to the bottom,
                     // which we do not want to mask away, hence the padding.
                     Padding = new MarginPadding { Bottom = 5 },
-                    Children = new Drawable[]
+                    Child = flow = new ChatLineContainer
                     {
-                        flow = new FillFlowContainer<ChatLine>
-                        {
-                            Direction = FillDirection.Vertical,
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            Padding = new MarginPadding { Left = 20, Right = 20 }
-                        }
-                    }
+                        Padding = new MarginPadding { Left = 20, Right = 20 },
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Direction = FillDirection.Vertical,
+                    },
                 }
             };
 
-            channel.NewMessagesArrived += newMessagesArrived;
+            Channel.NewMessagesArrived += newMessagesArrived;
+            Channel.MessageRemoved += messageRemoved;
+            Channel.PendingMessageResolved += pendingMessageResolved;
         }
 
         [BackgroundDependencyLoader]
@@ -63,14 +75,17 @@ namespace osu.Game.Overlays.Chat
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
+
             Channel.NewMessagesArrived -= newMessagesArrived;
+            Channel.MessageRemoved -= messageRemoved;
+            Channel.PendingMessageResolved -= pendingMessageResolved;
         }
 
         private void newMessagesArrived(IEnumerable<Message> newMessages)
         {
+            // Add up to last Channel.MAX_HISTORY messages
             var displayMessages = newMessages.Skip(Math.Max(0, newMessages.Count() - Channel.MAX_HISTORY));
 
-            //up to last Channel.MAX_HISTORY messages
             flow.AddRange(displayMessages.Select(m => new ChatLine(m)));
 
             if (!IsLoaded) return;
@@ -90,6 +105,24 @@ namespace osu.Game.Overlays.Chat
             }
         }
 
+        private void pendingMessageResolved(Message existing, Message updated)
+        {
+            var found = flow.Children.LastOrDefault(c => c.Message == existing);
+            if (found != null)
+            {
+                Trace.Assert(updated.Id.HasValue, "An updated message was returned with no ID.");
+
+                flow.Remove(found);
+                found.Message = updated;
+                flow.Add(found);
+            }
+        }
+
+        private void messageRemoved(Message removed)
+        {
+            flow.Children.FirstOrDefault(c => c.Message == removed)?.FadeColour(Color4.Red, 400).FadeOut(600).Expire();
+        }
+
         private void scrollToEnd() => ScheduleAfterChildren(() => scroll.ScrollToEnd());
     }
 }

osu.Game/Overlays/ChatOverlay.cs

@@ -6,23 +6,23 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using OpenTK;
+using OpenTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
 using osu.Framework.Threading;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.Chat;
-using osu.Game.Graphics.UserInterface;
-using osu.Framework.Graphics.UserInterface;
-using OpenTK.Graphics;
-using osu.Framework.Input;
-using osu.Game.Configuration;
-using osu.Game.Graphics;
 using osu.Game.Overlays.Chat;
-using osu.Game.Graphics.Containers;
 
 namespace osu.Game.Overlays
 {
@@ -37,7 +37,7 @@ namespace osu.Game.Overlays
 
         private readonly LoadingAnimation loading;
 
-        private readonly FocusedTextBox inputTextBox;
+        private readonly FocusedTextBox textbox;
 
         private APIAccess api;
 
@@ -130,7 +130,7 @@ namespace osu.Game.Overlays
                                     },
                                     Children = new Drawable[]
                                     {
-                                        inputTextBox = new FocusedTextBox
+                                        textbox = new FocusedTextBox
                                         {
                                             RelativeSizeAxes = Axes.Both,
                                             Height = 1,
@@ -176,7 +176,7 @@ namespace osu.Game.Overlays
 
                 if (state == Visibility.Visible)
                 {
-                    inputTextBox.HoldFocus = false;
+                    textbox.HoldFocus = false;
                     if (1f - chatHeight.Value < channel_selection_min_height)
                     {
                         chatContainer.ResizeHeightTo(1f - channel_selection_min_height, 800, Easing.OutQuint);
@@ -187,7 +187,7 @@ namespace osu.Game.Overlays
                 }
                 else
                 {
-                    inputTextBox.HoldFocus = true;
+                    textbox.HoldFocus = true;
                 }
             };
         }
@@ -243,8 +243,8 @@ namespace osu.Game.Overlays
 
         protected override void OnFocus(InputState state)
         {
-            //this is necessary as inputTextBox is masked away and therefore can't get focus :(
-            InputManager.ChangeFocus(inputTextBox);
+            //this is necessary as textbox is masked away and therefore can't get focus :(
+            GetContainingInputManager().ChangeFocus(textbox);
             base.OnFocus(state);
         }
 
@@ -253,7 +253,7 @@ namespace osu.Game.Overlays
             this.MoveToY(0, transition_length, Easing.OutQuint);
             this.FadeIn(transition_length, Easing.OutQuint);
 
-            inputTextBox.HoldFocus = true;
+            textbox.HoldFocus = true;
             base.PopIn();
         }
 
@@ -262,7 +262,7 @@ namespace osu.Game.Overlays
             this.MoveToY(Height, transition_length, Easing.InSine);
             this.FadeOut(transition_length, Easing.InSine);
 
-            inputTextBox.HoldFocus = false;
+            textbox.HoldFocus = false;
             base.PopOut();
         }
 
@@ -338,7 +338,7 @@ namespace osu.Game.Overlays
 
                 currentChannel = value;
 
-                inputTextBox.Current.Disabled = currentChannel.ReadOnly;
+                textbox.Current.Disabled = currentChannel.ReadOnly;
                 channelTabs.Current.Value = value;
 
                 var loaded = loadedChannels.Find(d => d.Channel == value);
@@ -433,6 +433,7 @@ namespace osu.Game.Overlays
             if (fetchReq != null) return;
 
             fetchReq = new GetMessagesRequest(careChannels, lastMessageId);
+
             fetchReq.Success += delegate (List<Message> messages)
             {
                 foreach (var group in messages.Where(m => m.TargetType == TargetType.Channel).GroupBy(m => m.TargetId))
@@ -443,6 +444,7 @@ namespace osu.Game.Overlays
                 Debug.Write("success!");
                 fetchReq = null;
             };
+
             fetchReq.Failure += delegate
             {
                 Debug.Write("failure!");
@@ -456,51 +458,42 @@ namespace osu.Game.Overlays
         {
             var postText = textbox.Text;
 
+            textbox.Text = string.Empty;
+
             if (string.IsNullOrEmpty(postText))
                 return;
 
+            var target = currentChannel;
+
+            if (target == null) return;
+
             if (!api.IsLoggedIn)
             {
-                currentChannel?.AddNewMessages(new ErrorMessage("Please login to participate in chat!"));
-                textbox.Text = string.Empty;
+                target.AddNewMessages(new ErrorMessage("Please login to participate in chat!"));
                 return;
             }
 
-            if (currentChannel == null) return;
-
             if (postText[0] == '/')
             {
                 // TODO: handle commands
-                currentChannel.AddNewMessages(new ErrorMessage("Chat commands are not supported yet!"));
-                textbox.Text = string.Empty;
+                target.AddNewMessages(new ErrorMessage("Chat commands are not supported yet!"));
                 return;
             }
 
-            var message = new Message
+            var message = new LocalEchoMessage
             {
                 Sender = api.LocalUser.Value,
                 Timestamp = DateTimeOffset.Now,
-                TargetType = TargetType.Channel, //TODO: read this from currentChannel
-                TargetId = currentChannel.Id,
+                TargetType = TargetType.Channel, //TODO: read this from channel
+                TargetId = target.Id,
                 Content = postText
             };
 
-            textbox.ReadOnly = true;
             var req = new PostMessageRequest(message);
 
-            req.Failure += e =>
-            {
-                textbox.FlashColour(Color4.Red, 1000);
-                textbox.ReadOnly = false;
-            };
-
-            req.Success += m =>
-            {
-                currentChannel.AddNewMessages(m);
-
-                textbox.ReadOnly = false;
-                textbox.Text = string.Empty;
-            };
+            target.AddLocalEcho(message);
+            req.Failure += e => target.ReplaceMessage(message, null);
+            req.Success += m => target.ReplaceMessage(message, m);
 
             api.Queue(req);
         }

osu.Game/Overlays/KeyBinding/GlobalKeyBindingsSection.cs

@@ -0,0 +1,31 @@
+// 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.Input.Bindings;
+using osu.Game.Graphics;
+using osu.Game.Overlays.Settings;
+
+namespace osu.Game.Overlays.KeyBinding
+{
+    public class GlobalKeyBindingsSection : SettingsSection
+    {
+        public override FontAwesome Icon => FontAwesome.fa_osu_hot;
+        public override string Header => "Global";
+
+        public GlobalKeyBindingsSection(KeyBindingInputManager manager)
+        {
+            Add(new DefaultBindingsSubsection(manager));
+        }
+
+        private class DefaultBindingsSubsection : KeyBindingsSubsection
+        {
+            protected override string Header => string.Empty;
+
+            public DefaultBindingsSubsection(KeyBindingInputManager manager)
+                : base(null)
+            {
+                Defaults = manager.DefaultKeyBindings;
+            }
+        }
+    }
+}