Merge remote-tracking branch 'origin/master' into taiko-timingchanges-2

# Conflicts:
#	osu.Game.Rulesets.Taiko/UI/TaikoRulesetContainer.cs

osu-framework

@@ -1 +1 @@
-Subproject commit 3b858d078cf54465d9af8e2bb9e1a144bcfcdbf4
+Subproject commit 67d89a36016f98c0ede576b859a2ccafe114fce8

osu-resources

@@ -1 +1 @@
-Subproject commit 76656c51f281e7934159e9ed4414378fef24d130
+Subproject commit f6042e1cb37cfad6c879d0e1245f7880c7fcd5f5

osu.Desktop.Tests/Visual/TestCaseCatcher.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Catch.UI;
+using OpenTK;
+
+namespace osu.Desktop.Tests.Visual
+{
+    internal class TestCaseCatcher : OsuTestCase
+    {
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            Children = new Drawable[]
+            {
+                new CatchInputManager(rulesets.GetRuleset(2))
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = new CatcherArea
+                    {
+                        RelativePositionAxes = Axes.Both,
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                        Size = new Vector2(1, 0.2f),
+                    }
+                },
+            };
+        }
+    }
+}

osu.Desktop.Tests/Visual/TestCaseGamefield.cs

@@ -11,11 +11,15 @@ using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Taiko;
 using osu.Game.Rulesets.Taiko.UI;
 using OpenTK;
 
@@ -84,25 +88,25 @@ namespace osu.Desktop.Tests.Visual
                     Clock = new FramedClock(),
                     Children = new Drawable[]
                     {
-                        new OsuHitRenderer(beatmap, false)
+                        new OsuRulesetContainer(new OsuRuleset(new RulesetInfo()), beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.TopLeft,
                             Origin = Anchor.TopLeft
                         },
-                        new TaikoHitRenderer(beatmap, false)
+                        new TaikoRulesetContainer(new TaikoRuleset(new RulesetInfo()),beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.TopRight,
                             Origin = Anchor.TopRight
                         },
-                        new CatchHitRenderer(beatmap, false)
+                        new CatchRulesetContainer(new CatchRuleset(new RulesetInfo()),beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.BottomLeft,
                             Origin = Anchor.BottomLeft
                         },
-                        new ManiaHitRenderer(beatmap, false)
+                        new ManiaRulesetContainer(new ManiaRuleset(new RulesetInfo()),beatmap, false)
                         {
                             Scale = new Vector2(0.5f),
                             Anchor = Anchor.BottomRight,

osu.Desktop.Tests/Visual/TestCaseScrollingPlayfield.cs

@@ -50,17 +50,27 @@ namespace osu.Desktop.Tests.Visual
 
             WorkingBeatmap beatmap = new TestWorkingBeatmap(b);
 
-            TestHitRenderer hitRenderer;
+            TestRulesetContainer horizontalRulesetContainer;
-            Add(hitRenderer = new TestHitRenderer(beatmap, true));
+            Add(horizontalRulesetContainer = new TestRulesetContainer(Axes.X, beatmap, true));
 
-            AddStep("Reverse direction", () => hitRenderer.Playfield.Reversed.Value = !hitRenderer.Playfield.Reversed);
+            TestRulesetContainer verticalRulesetContainer;
+            Add(verticalRulesetContainer = new TestRulesetContainer(Axes.Y, beatmap, true));
+
+            AddStep("Reverse direction", () =>
+            {
+                horizontalRulesetContainer.Playfield.Reversed.Toggle();
+                verticalRulesetContainer.Playfield.Reversed.Toggle();
+            });
         }
 
-        private class TestHitRenderer : ScrollingHitRenderer<TestPlayfield, TestHitObject, TestJudgement>
+        private class TestRulesetContainer : ScrollingRulesetContainer<TestPlayfield, TestHitObject, TestJudgement>
         {
-            public TestHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+            private readonly Axes scrollingAxes;
-                : base(beatmap, isForCurrentRuleset)
+
+            public TestRulesetContainer(Axes scrollingAxes, WorkingBeatmap beatmap, bool isForCurrentRuleset)
+                : base(null, beatmap, isForCurrentRuleset)
             {
+                this.scrollingAxes = scrollingAxes;
             }
 
             public new TestPlayfield Playfield => base.Playfield;
@@ -69,9 +79,9 @@ namespace osu.Desktop.Tests.Visual
 
             protected override BeatmapConverter<TestHitObject> CreateBeatmapConverter() => new TestBeatmapConverter();
 
-            protected override Playfield<TestHitObject, TestJudgement> CreatePlayfield() => new TestPlayfield();
+            protected override Playfield<TestHitObject, TestJudgement> CreatePlayfield() => new TestPlayfield(scrollingAxes);
 
-            protected override DrawableHitObject<TestHitObject, TestJudgement> GetVisualRepresentation(TestHitObject h) => new DrawableTestHitObject(h);
+            protected override DrawableHitObject<TestHitObject, TestJudgement> GetVisualRepresentation(TestHitObject h) => new DrawableTestHitObject(scrollingAxes, h);
         }
 
         private class TestScoreProcessor : ScoreProcessor<TestHitObject, TestJudgement>
@@ -93,10 +103,10 @@ namespace osu.Desktop.Tests.Visual
 
         private class DrawableTestHitObject : DrawableScrollingHitObject<TestHitObject, TestJudgement>
         {
-            public DrawableTestHitObject(TestHitObject hitObject)
+            public DrawableTestHitObject(Axes scrollingAxes, TestHitObject hitObject)
                 : base(hitObject)
             {
-                Anchor = Anchor.CentreLeft;
+                Anchor = scrollingAxes == Axes.Y ? Anchor.TopCentre : Anchor.CentreLeft;
                 Origin = Anchor.Centre;
 
                 AutoSizeAxes = Axes.Both;
@@ -119,8 +129,8 @@ namespace osu.Desktop.Tests.Visual
             protected override Container<Drawable> Content => content;
             private readonly Container<Drawable> content;
 
-            public TestPlayfield()
+            public TestPlayfield(Axes scrollingAxes)
-                : base(Axes.X)
+                : base(scrollingAxes)
             {
                 InternalChildren = new Drawable[]
                 {

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

@@ -71,6 +71,7 @@
     <Compile Include="Visual\TestCaseBeatmapOptionsOverlay.cs" />
     <Compile Include="Visual\TestCaseBeatSyncedContainer.cs" />
     <Compile Include="Visual\TestCaseBreadcrumbs.cs" />
+    <Compile Include="Visual\TestCaseCatcher.cs" />
     <Compile Include="Visual\TestCaseChatDisplay.cs" />
     <Compile Include="Visual\TestCaseContextMenu.cs" />
     <Compile Include="Visual\TestCaseDialogOverlay.cs" />

osu.Desktop/osu.Desktop.csproj

@@ -103,6 +103,7 @@
     <LangVersion>6</LangVersion>
     <ErrorReport>prompt</ErrorReport>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <StartArguments>--tests</StartArguments>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="DeltaCompressionDotNet, Version=1.1.0.0, Culture=neutral, PublicKeyToken=1d14d6e5194e7f4a, processorArchitecture=MSIL">

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs

@@ -8,6 +8,7 @@ using System;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.UI;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
@@ -15,9 +16,16 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
     {
         protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(IHasXPosition) };
 
-        protected override IEnumerable<CatchBaseHit> ConvertHitObject(HitObject original, Beatmap beatmap)
+        protected override IEnumerable<CatchBaseHit> ConvertHitObject(HitObject obj, Beatmap beatmap)
         {
-            yield return null;
+            if (!(obj is IHasXPosition))
+                yield break;
+
+            yield return new Fruit
+            {
+                StartTime = obj.StartTime,
+                Position = ((IHasXPosition)obj).X / OsuPlayfield.BASE_SIZE.X
+            };
         }
     }
 }

osu.Game.Rulesets.Catch/CatchInputManager.cs

@@ -0,0 +1,32 @@
+// 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.Game.Input;
+using OpenTK.Input;
+
+namespace osu.Game.Rulesets.Catch
+{
+    public class CatchInputManager : ActionMappingInputManager<CatchAction>
+    {
+        public CatchInputManager(RulesetInfo ruleset) : base(ruleset)
+        {
+            Mappings = new Dictionary<Key, CatchAction>
+            {
+                { Key.Z, CatchAction.MoveLeft },
+                { Key.Left, CatchAction.MoveLeft },
+                { Key.X, CatchAction.MoveRight },
+                { Key.Right, CatchAction.MoveRight },
+                { Key.LShift, CatchAction.Dash },
+                { Key.RShift, CatchAction.Dash },
+            };
+        }
+    }
+
+    public enum CatchAction
+    {
+        MoveLeft,
+        MoveRight,
+        Dash
+    }
+}

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Catch
 {
     public class CatchRuleset : Ruleset
     {
-        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchHitRenderer(beatmap, isForCurrentRuleset);
+        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchRulesetContainer(this, beatmap, isForCurrentRuleset);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
@@ -102,5 +102,10 @@ namespace osu.Game.Rulesets.Catch
         public override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor();
 
         public override int LegacyID => 2;
+
+        public CatchRuleset(RulesetInfo rulesetInfo)
+            : base(rulesetInfo)
+        {
+        }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableFruit.cs

@@ -1,36 +1,128 @@
 // 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.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Textures;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.MathUtils;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Objects.Drawables;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
-    internal class DrawableFruit : Sprite
+    public class DrawableFruit : DrawableScrollingHitObject<CatchBaseHit, CatchJudgement>
     {
-        //private readonly CatchBaseHit h;
+        private const float pulp_size = 30;
 
-        public DrawableFruit(CatchBaseHit h)
+        private class Pulp : Circle, IHasAccentColour
         {
-            //this.h = h;
+            public Pulp()
+            {
+                Size = new Vector2(pulp_size);
 
-            Origin = Anchor.Centre;
+                EdgeEffect = new EdgeEffectParameters
-            Scale = new Vector2(0.1f);
+                {
-            RelativePositionAxes = Axes.Y;
+                    Type = EdgeEffectType.Glow,
-            Position = new Vector2(h.Position, -0.1f);
+                    Radius = 5,
+                    Colour = AccentColour.Opacity(0.5f),
+                };
+            }
+
+            public Color4 AccentColour { get; set; } = Color4.White;
         }
 
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            Texture = textures.Get(@"Menu/logo");
 
-            //Transforms.Add(new TransformPosition { StartTime = h.StartTime - 200, EndTime = h.StartTime, StartValue = new Vector2(h.Position, -0.1f), EndValue = new Vector2(h.Position, 0.9f) });
+        public DrawableFruit(CatchBaseHit h)
-            //Transforms.Add(new TransformAlpha { StartTime = h.StartTime + duration + 200, EndTime = h.StartTime + duration + 400, StartValue = 1, EndValue = 0 });
+            : base(h)
-            Expire(true);
+        {
+            Origin = Anchor.Centre;
+            Size = new Vector2(pulp_size * 2, pulp_size * 2.6f);
+
+            RelativePositionAxes = Axes.Both;
+            X = h.Position;
+
+            Colour = new Color4(RNG.NextSingle(), RNG.NextSingle(), RNG.NextSingle(), 1);
+
+            Rotation = (float)(RNG.NextDouble() - 0.5f) * 40;
+        }
+
+        public Func<CatchBaseHit, bool> CheckPosition;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Framework.Graphics.Drawable[]
+            {
+                //todo: share this more
+                new BufferedContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CacheDrawnFrameBuffer = true,
+                    Children = new Framework.Graphics.Drawable[]
+                    {
+                        new Pulp
+                        {
+                            RelativePositionAxes = Axes.Both,
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            Scale = new Vector2(0.6f),
+                        },
+                        new Pulp
+                        {
+                            RelativePositionAxes = Axes.Both,
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Y = -0.08f
+                        },
+                        new Pulp
+                        {
+                            RelativePositionAxes = Axes.Both,
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                            Y = -0.08f
+                        },
+                        new Pulp
+                        {
+                            RelativePositionAxes = Axes.Both,
+                            Anchor = Anchor.BottomCentre,
+                            Origin = Anchor.BottomCentre,
+                        },
+                    }
+                }
+            };
+        }
+
+        protected override CatchJudgement CreateJudgement() => new CatchJudgement();
+
+        private const float preempt = 1000;
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (Judgement.TimeOffset > 0)
+                Judgement.Result = CheckPosition?.Invoke(HitObject) ?? false ? HitResult.Hit : HitResult.Miss;
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            using (BeginAbsoluteSequence(HitObject.StartTime - preempt))
+            {
+                // animation
+                this.FadeIn(200);
+            }
+
+            switch (state)
+            {
+                case ArmedState.Miss:
+                    using (BeginAbsoluteSequence(HitObject.StartTime, true))
+                        this.FadeOut(250).RotateTo(Rotation * 2, 250, Easing.Out);
+                    break;
+            }
         }
     }
 }

osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs

@@ -14,11 +14,19 @@ namespace osu.Game.Rulesets.Catch.Scoring
         {
         }
 
-        public CatchScoreProcessor(HitRenderer<CatchBaseHit, CatchJudgement> hitRenderer)
+        public CatchScoreProcessor(RulesetContainer<CatchBaseHit, CatchJudgement> rulesetContainer)
-            : base(hitRenderer)
+            : base(rulesetContainer)
         {
         }
 
+        protected override void Reset()
+        {
+            base.Reset();
+
+            Health.Value = 1;
+            Accuracy.Value = 1;
+        }
+
         protected override void OnNewJudgement(CatchJudgement judgement)
         {
         }

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

@@ -2,23 +2,65 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.UI;
 using OpenTK;
 using osu.Game.Rulesets.Catch.Judgements;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class CatchPlayfield : Playfield<CatchBaseHit, CatchJudgement>
+    public class CatchPlayfield : ScrollingPlayfield<CatchBaseHit, CatchJudgement>
     {
-        public CatchPlayfield()
+        protected override Container<Drawable> Content => content;
-        {
+        private readonly Container<Drawable> content;
-            Size = new Vector2(1, 0.9f);
+        private readonly CatcherArea catcherArea;
-            Anchor = Anchor.BottomCentre;
-            Origin = Anchor.BottomCentre;
 
-            Add(new Box { RelativeSizeAxes = Axes.Both, Alpha = 0.5f });
+        public CatchPlayfield()
+            : base(Axes.Y)
+        {
+            Reversed.Value = true;
+
+            Size = new Vector2(1);
+
+            Anchor = Anchor.TopCentre;
+            Origin = Anchor.TopCentre;
+
+            InternalChildren = new Drawable[]
+            {
+                content = new Container<Drawable>
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                catcherArea = new CatcherArea
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.TopLeft,
+                    Height = 0.3f
+                }
+            };
+        }
+
+        public override void Add(DrawableHitObject<CatchBaseHit, CatchJudgement> h)
+        {
+            base.Add(h);
+
+            var fruit = (DrawableFruit)h;
+            fruit.CheckPosition = catcherArea.CheckIfWeCanCatch;
+            fruit.OnJudgement += Fruit_OnJudgement;
+        }
+
+        private void Fruit_OnJudgement(DrawableHitObject<CatchBaseHit, CatchJudgement> obj)
+        {
+            if (obj.Judgement.Result == HitResult.Hit)
+            {
+                Vector2 screenPosition = obj.ScreenSpaceDrawQuad.Centre;
+                Remove(obj);
+                catcherArea.Add(obj, screenPosition);
+            }
         }
     }
 }

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

@@ -1,11 +1,13 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
@@ -13,10 +15,10 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class CatchHitRenderer : HitRenderer<CatchBaseHit, CatchJudgement>
+    public class CatchRulesetContainer : ScrollingRulesetContainer<CatchPlayfield, CatchBaseHit, CatchJudgement>
     {
-        public CatchHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+        public CatchRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
         {
         }
 
@@ -26,6 +28,14 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override Playfield<CatchBaseHit, CatchJudgement> CreatePlayfield() => new CatchPlayfield();
 
-        protected override DrawableHitObject<CatchBaseHit, CatchJudgement> GetVisualRepresentation(CatchBaseHit h) => null;
+        protected override PassThroughInputManager CreateActionMappingInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
+
+        protected override DrawableHitObject<CatchBaseHit, CatchJudgement> GetVisualRepresentation(CatchBaseHit h)
+        {
+            if (h is Fruit)
+                return new DrawableFruit(h);
+
+            return null;
+        }
     }
 }

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

@@ -0,0 +1,186 @@
+// 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.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.MathUtils;
+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.Objects.Drawable;
+using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatcherArea : Container
+    {
+        private Catcher catcher;
+
+        public void Add(DrawableHitObject<CatchBaseHit, CatchJudgement> fruit, Vector2 screenPosition) => catcher.AddToStack(fruit, screenPosition);
+
+        public bool CheckIfWeCanCatch(CatchBaseHit obj) => Math.Abs(catcher.Position.X - obj.Position) < catcher.DrawSize.X / DrawSize.X / 2;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                catcher = new Catcher
+                {
+                    RelativePositionAxes = Axes.Both,
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopCentre,
+                    X = 0.5f,
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            catcher.Size = new Vector2(DrawSize.Y);
+        }
+
+        private class Catcher : Container
+        {
+            private Texture texture;
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                texture = textures.Get(@"Play/Catch/fruit-catcher-idle");
+
+                Child = createCatcherSprite();
+            }
+
+            private int currentDirection;
+
+            private bool dashing;
+
+            protected bool Dashing
+            {
+                get { return dashing; }
+                set
+                {
+                    if (value == dashing) return;
+
+                    dashing = value;
+
+                    if (dashing)
+                        Schedule(addAdditiveSprite);
+                }
+            }
+
+            private void addAdditiveSprite()
+            {
+                if (!dashing) return;
+
+                var additive = createCatcherSprite();
+
+                additive.RelativePositionAxes = Axes.Both;
+                additive.BlendingMode = BlendingMode.Additive;
+                additive.Position = Position;
+                additive.Scale = Scale;
+
+                ((CatcherArea)Parent).Add(additive);
+
+                additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint).Expire();
+
+                Scheduler.AddDelayed(addAdditiveSprite, 50);
+            }
+
+            private Sprite createCatcherSprite() => new Sprite
+            {
+                RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit,
+                Texture = texture,
+                OriginPosition = new Vector2(DrawWidth / 2, 10) //temporary until the sprite is aligned correctly.
+            };
+
+            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+            {
+                if (args.Repeat) return true;
+
+                if (state.Data is CatchAction)
+                {
+                    switch ((CatchAction)state.Data)
+                    {
+                        case CatchAction.MoveLeft:
+                            currentDirection--;
+                            return true;
+                        case CatchAction.MoveRight:
+                            currentDirection++;
+                            return true;
+                        case CatchAction.Dash:
+                            Dashing = true;
+                            return true;
+                    }
+                }
+
+                return base.OnKeyDown(state, args);
+            }
+
+            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+            {
+                if (state.Data is CatchAction)
+                {
+                    switch ((CatchAction)state.Data)
+                    {
+                        case CatchAction.MoveLeft:
+                            currentDirection++;
+                            return true;
+                        case CatchAction.MoveRight:
+                            currentDirection--;
+                            return true;
+                        case CatchAction.Dash:
+                            Dashing = false;
+                            return true;
+                    }
+                }
+
+                return base.OnKeyUp(state, args);
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (currentDirection == 0) return;
+
+                float speed = Dashing ? 1.5f : 1;
+
+                Scale = new Vector2(Math.Sign(currentDirection), 1);
+                X = (float)MathHelper.Clamp(X + Math.Sign(currentDirection) * Clock.ElapsedFrameTime / 1800 * speed, 0, 1);
+            }
+
+            public void AddToStack(DrawableHitObject<CatchBaseHit, CatchJudgement> fruit, Vector2 absolutePosition)
+            {
+                fruit.RelativePositionAxes = Axes.None;
+                fruit.Position = new Vector2(ToLocalSpace(absolutePosition).X - DrawSize.X / 2, 0);
+
+                fruit.Anchor = Anchor.TopCentre;
+                fruit.Origin = Anchor.BottomCentre;
+                fruit.Scale *= 0.7f;
+                fruit.LifetimeEnd = double.MaxValue;
+                fruit.Depth = (float)Time.Current;
+
+                float distance = fruit.DrawSize.X / 2 * fruit.Scale.X;
+
+                while (Children.OfType<DrawableFruit>().Any(f => Vector2.DistanceSquared(f.Position, fruit.Position) < distance * distance))
+                {
+                    fruit.X += RNG.Next(-5, 5);
+                    fruit.Y -= RNG.Next(0, 5);
+                }
+
+                Add(fruit);
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/osu.Game.Rulesets.Catch.csproj

@@ -38,6 +38,7 @@
       <Private>True</Private>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.Collections" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
@@ -50,6 +51,7 @@
   <ItemGroup>
     <Compile Include="Beatmaps\CatchBeatmapConverter.cs" />
     <Compile Include="CatchDifficultyCalculator.cs" />
+    <Compile Include="CatchInputManager.cs" />
     <Compile Include="Scoring\CatchScoreProcessor.cs" />
     <Compile Include="Judgements\CatchJudgement.cs" />
     <Compile Include="Objects\CatchBaseHit.cs" />
@@ -57,7 +59,8 @@
     <Compile Include="Objects\Droplet.cs" />
     <Compile Include="Objects\Fruit.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="UI\CatchHitRenderer.cs" />
+    <Compile Include="UI\CatcherArea.cs" />
+    <Compile Include="UI\CatchRulesetContainer.cs" />
     <Compile Include="UI\CatchPlayfield.cs" />
     <Compile Include="CatchRuleset.cs" />
     <Compile Include="Mods\CatchMod.cs" />

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

@@ -33,12 +33,6 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             float positionSeparation = ((positionData?.Position ?? Vector2.Zero) - previousPosition).Length;
             double timeSeparation = hitObject.StartTime - previousTime;
 
-            if (timeSeparation <= 125)
-            {
-                // More than 120 BPM
-                convertType |= PatternType.ForceNotStack;
-            }
-
             if (timeSeparation <= 80)
             {
                 // More than 187 BPM
@@ -64,7 +58,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 // More than 111 BPM stream
                 convertType |= PatternType.Cycle | PatternType.KeepSingle;
             }
-            else if (timeSeparation <= 150 & positionSeparation < 20)
+            else if (timeSeparation <= 150 && positionSeparation < 20)
             {
                 // More than 100 BPM stream
                 convertType |= PatternType.ForceStack | PatternType.LowProbability;

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaRuleset : Ruleset
     {
-        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new ManiaHitRenderer(beatmap, isForCurrentRuleset);
+        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new ManiaRulesetContainer(this, beatmap, isForCurrentRuleset);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
@@ -118,5 +118,10 @@ namespace osu.Game.Rulesets.Mania
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor();
 
         public override int LegacyID => 3;
+
+        public ManiaRuleset(RulesetInfo rulesetInfo)
+            : base(rulesetInfo)
+        {
+        }
     }
 }

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

@@ -15,9 +15,9 @@ namespace osu.Game.Rulesets.Mania.Mods
         /// <summary>
         /// Applies this mod to a hit renderer.
         /// </summary>
-        /// <param name="hitRenderer">The hit renderer to apply to.</param>
+        /// <param name="rulesetContainer">The hit renderer to apply to.</param>
         /// <param name="hitObjectTimingChanges">The per-column list of speed adjustments for hit objects.</param>
         /// <param name="barlineTimingChanges">The list of speed adjustments for bar lines.</param>
-        void ApplyToHitRenderer(ManiaHitRenderer hitRenderer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges);
+        void ApplyToRulesetContainer(ManiaRulesetContainer rulesetContainer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges);
     }
 }

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

@@ -20,12 +20,12 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public override FontAwesome Icon => FontAwesome.fa_sort_desc;
 
-        public void ApplyToHitRenderer(ManiaHitRenderer hitRenderer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges)
+        public void ApplyToRulesetContainer(ManiaRulesetContainer rulesetContainer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges)
         {
             // We have to generate one speed adjustment per hit object for gravity
-            foreach (ManiaHitObject obj in hitRenderer.Objects)
+            foreach (ManiaHitObject obj in rulesetContainer.Objects)
             {
-                MultiplierControlPoint controlPoint = hitRenderer.CreateControlPointAt(obj.StartTime);
+                MultiplierControlPoint controlPoint = rulesetContainer.CreateControlPointAt(obj.StartTime);
                 // Beat length has too large of an effect for gravity, so we'll force it to a constant value for now
                 controlPoint.TimingPoint.BeatLength = 1000;
 
@@ -33,9 +33,9 @@ namespace osu.Game.Rulesets.Mania.Mods
             }
 
             // Like with hit objects, we need to generate one speed adjustment per bar line
-            foreach (DrawableBarLine barLine in hitRenderer.BarLines)
+            foreach (DrawableBarLine barLine in rulesetContainer.BarLines)
             {
-                var controlPoint = hitRenderer.CreateControlPointAt(barLine.HitObject.StartTime);
+                var controlPoint = rulesetContainer.CreateControlPointAt(barLine.HitObject.StartTime);
                 // Beat length has too large of an effect for gravity, so we'll force it to a constant value for now
                 controlPoint.TimingPoint.BeatLength = 1000;
 

osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs

@@ -155,8 +155,8 @@ namespace osu.Game.Rulesets.Mania.Scoring
         {
         }
 
-        public ManiaScoreProcessor(HitRenderer<ManiaHitObject, ManiaJudgement> hitRenderer)
+        public ManiaScoreProcessor(RulesetContainer<ManiaHitObject, ManiaJudgement> rulesetContainer)
-            : base(hitRenderer)
+            : base(rulesetContainer)
         {
         }
 

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

@@ -29,7 +29,7 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaHitRenderer : ScrollingHitRenderer<ManiaPlayfield, ManiaHitObject, ManiaJudgement>
+    public class ManiaRulesetContainer : ScrollingRulesetContainer<ManiaPlayfield, ManiaHitObject, ManiaJudgement>
     {
         /// <summary>
         /// Preferred column count. This will only have an effect during the initialization of the play field.
@@ -38,8 +38,8 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public IEnumerable<DrawableBarLine> BarLines;
 
-        public ManiaHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+        public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
         {
             // Generate the bar lines
             double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;

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

@@ -82,7 +82,7 @@
     <Compile Include="Timing\GravityScrollingContainer.cs" />
     <Compile Include="Timing\ScrollingAlgorithm.cs" />
     <Compile Include="UI\Column.cs" />
-    <Compile Include="UI\ManiaHitRenderer.cs" />
+    <Compile Include="UI\ManiaRulesetContainer.cs" />
     <Compile Include="UI\ManiaPlayfield.cs" />
     <Compile Include="ManiaRuleset.cs" />
     <Compile Include="Mods\ManiaMod.cs" />

osu.Game.Rulesets.Osu/OsuKeyConversionInputManager.cs

@@ -3,14 +3,13 @@
 
 using System.Linq;
 using osu.Framework.Input;
-using osu.Game.Screens.Play;
 using OpenTK.Input;
 using KeyboardState = osu.Framework.Input.KeyboardState;
 using MouseState = osu.Framework.Input.MouseState;
 
 namespace osu.Game.Rulesets.Osu
 {
-    public class OsuKeyConversionInputManager : KeyConversionInputManager
+    public class OsuKeyConversionInputManager : PassThroughInputManager
     {
         private bool leftViaKeyboard;
         private bool rightViaKeyboard;

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu
 {
     public class OsuRuleset : Ruleset
     {
-        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new OsuHitRenderer(beatmap, isForCurrentRuleset);
+        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new OsuRulesetContainer(this, beatmap, isForCurrentRuleset);
 
         public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
         {
@@ -126,5 +126,10 @@ namespace osu.Game.Rulesets.Osu
         public override SettingsSubsection CreateSettings() => new OsuSettings();
 
         public override int LegacyID => 0;
+
+        public OsuRuleset(RulesetInfo rulesetInfo)
+            : base(rulesetInfo)
+        {
+        }
     }
 }

osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs

@@ -18,8 +18,8 @@ namespace osu.Game.Rulesets.Osu.Scoring
         {
         }
 
-        public OsuScoreProcessor(HitRenderer<OsuHitObject, OsuJudgement> hitRenderer)
+        public OsuScoreProcessor(RulesetContainer<OsuHitObject, OsuJudgement> rulesetContainer)
-            : base(hitRenderer)
+            : base(rulesetContainer)
         {
         }
 

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

@@ -80,9 +80,9 @@ namespace osu.Game.Rulesets.Osu.UI
 
         public override void PostProcess()
         {
-            connectionLayer.HitObjects = HitObjects.Children
+            connectionLayer.HitObjects = HitObjects.Objects
                 .Select(d => d.HitObject)
-                .OrderBy(h => h.StartTime);
+                .OrderBy(h => h.StartTime).OfType<OsuHitObject>();
         }
 
         public override void OnJudgement(DrawableHitObject<OsuHitObject, OsuJudgement> judgedObject)

osu.Game.Rulesets.Osu/UI/OsuRulesetContainer.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 osu.Framework.Input;
 using OpenTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Beatmaps;
@@ -12,14 +13,13 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
-using osu.Game.Screens.Play;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
-    public class OsuHitRenderer : HitRenderer<OsuHitObject, OsuJudgement>
+    public class OsuRulesetContainer : RulesetContainer<OsuHitObject, OsuJudgement>
     {
-        public OsuHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+        public OsuRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
         {
         }
 
@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override Playfield<OsuHitObject, OsuJudgement> CreatePlayfield() => new OsuPlayfield();
 
-        protected override KeyConversionInputManager CreateKeyConversionInputManager() => new OsuKeyConversionInputManager();
+        protected override PassThroughInputManager CreateActionMappingInputManager() => new OsuKeyConversionInputManager();
 
         protected override DrawableHitObject<OsuHitObject, OsuJudgement> GetVisualRepresentation(OsuHitObject h)
         {

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

@@ -80,7 +80,7 @@
     <Compile Include="OsuKeyConversionInputManager.cs" />
     <Compile Include="UI\OsuSettings.cs" />
     <Compile Include="Scoring\OsuScoreProcessor.cs" />
-    <Compile Include="UI\OsuHitRenderer.cs" />
+    <Compile Include="UI\OsuRulesetContainer.cs" />
     <Compile Include="UI\OsuPlayfield.cs" />
     <Compile Include="OsuRuleset.cs" />
     <Compile Include="Objects\HitCircle.cs" />

osu.Game.Rulesets.Taiko/Scoring/TaikoScoreProcessor.cs

@@ -113,8 +113,8 @@ namespace osu.Game.Rulesets.Taiko.Scoring
         {
         }
 
-        public TaikoScoreProcessor(HitRenderer<TaikoHitObject, TaikoJudgement> hitRenderer)
+        public TaikoScoreProcessor(RulesetContainer<TaikoHitObject, TaikoJudgement> rulesetContainer)
-            : base(hitRenderer)
+            : base(rulesetContainer)
         {
         }
 

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Taiko
 {
     public class TaikoRuleset : Ruleset
     {
-        public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new TaikoHitRenderer(beatmap, isForCurrentRuleset);
+        public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new TaikoRulesetContainer(this, beatmap, isForCurrentRuleset);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
@@ -103,5 +103,10 @@ namespace osu.Game.Rulesets.Taiko
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor();
 
         public override int LegacyID => 1;
+
+        public TaikoRuleset(RulesetInfo rulesetInfo)
+            : base(rulesetInfo)
+        {
+        }
     }
 }

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

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Taiko.UI
     public class TaikoPlayfield : ScrollingPlayfield<TaikoHitObject, TaikoJudgement>
     {
         /// <summary>
-        /// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="TaikoHitRenderer"/>.
+        /// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="TaikoRulesetContainer"/>.
         /// </summary>
         public const float DEFAULT_HEIGHT = 178;
 

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

@@ -21,10 +21,10 @@ using System.Linq;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
-    public class TaikoHitRenderer : ScrollingHitRenderer<TaikoPlayfield, TaikoHitObject, TaikoJudgement>
+    public class TaikoRulesetContainer : ScrollingRulesetContainer<TaikoPlayfield, TaikoHitObject, TaikoJudgement>
     {
-        public TaikoHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+        public TaikoRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
         {
         }
 
@@ -93,7 +93,6 @@ namespace osu.Game.Rulesets.Taiko.UI
             return new Vector2(1, default_relative_height * aspectAdjust);
         }
 
-
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor(this);
 
         protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter();

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

@@ -91,7 +91,7 @@
     <Compile Include="UI\KiaiHitExplosion.cs" />
     <Compile Include="UI\DrawableTaikoJudgement.cs" />
     <Compile Include="UI\HitExplosion.cs" />
-    <Compile Include="UI\TaikoHitRenderer.cs" />
+    <Compile Include="UI\TaikoRulesetContainer.cs" />
     <Compile Include="UI\TaikoPlayfield.cs" />
     <Compile Include="TaikoRuleset.cs" />
     <Compile Include="Mods\TaikoMod.cs" />

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -54,7 +54,7 @@ namespace osu.Game.Beatmaps
 
         private class DummyRulesetInfo : RulesetInfo
         {
-            public override Ruleset CreateInstance() => new DummyRuleset();
+            public override Ruleset CreateInstance() => new DummyRuleset(this);
 
             private class DummyRuleset : Ruleset
             {
@@ -62,7 +62,7 @@ namespace osu.Game.Beatmaps
 
                 public override Mod GetAutoplayMod() => new ModAutoplay();
 
-                public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+                public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset)
                 {
                     throw new NotImplementedException();
                 }
@@ -77,6 +77,11 @@ 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/Input/ActionMappingInputManager.cs

@@ -0,0 +1,74 @@
+// 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;
+using osu.Game.Rulesets;
+using OpenTK.Input;
+
+namespace osu.Game.Input
+{
+    /// <summary>
+    /// Maps custom action data of type <see cref="T"/> and stores to <see cref="InputState.Data"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the custom action.</typeparam>
+    public class ActionMappingInputManager<T> : PassThroughInputManager
+        where T : struct
+    {
+        private readonly RulesetInfo ruleset;
+
+        private readonly int? variant;
+
+        /// <summary>
+        /// Create a new instance.
+        /// </summary>
+        /// <param name="ruleset">A reference to identify the current <see cref="Ruleset"/>. Used to lookup mappings. Null for global mappings.</param>
+        /// <param name="variant">An optional variant for the specified <see cref="Ruleset"/>. Used when a ruleset has more than one possible keyboard layouts.</param>
+        protected ActionMappingInputManager(RulesetInfo ruleset = null, int? variant = null)
+        {
+            this.ruleset = ruleset;
+            this.variant = variant;
+        }
+
+        protected IDictionary<Key, T> Mappings { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load(BindingStore bindings)
+        {
+            var rulesetId = ruleset?.ID;
+            foreach (var b in bindings.Query<Binding>(b => b.RulesetID == rulesetId && b.Variant == variant))
+                Mappings[b.Key] = (T)(object)b.Action;
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            mapKey(state, args.Key);
+            return base.OnKeyDown(state, args);
+        }
+
+        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
+        {
+            mapKey(state, args.Key);
+            return base.OnKeyUp(state, args);
+        }
+
+        private void mapKey(InputState state, Key key)
+        {
+            T mappedData;
+            if (Mappings.TryGetValue(key, out mappedData))
+                state.Data = mappedData;
+        }
+
+        private T parseStringRepresentation(string str)
+        {
+            T res;
+
+            if (Enum.TryParse(str, out res))
+                return res;
+
+            return default(T);
+        }
+    }
+}

osu.Game/Input/Binding.cs

@@ -0,0 +1,23 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets;
+using OpenTK.Input;
+using SQLite.Net.Attributes;
+using SQLiteNetExtensions.Attributes;
+
+namespace osu.Game.Input
+{
+    public class Binding
+    {
+        [ForeignKey(typeof(RulesetInfo))]
+        public int? RulesetID { get; set; }
+
+        [Indexed]
+        public int? Variant { get; set; }
+
+        public Key Key { get; set; }
+
+        public int Action { get; set; }
+    }
+}

osu.Game/Input/BindingStore.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;
+using osu.Framework.Platform;
+using osu.Game.Database;
+using SQLite.Net;
+
+namespace osu.Game.Input
+{
+    public class BindingStore : DatabaseBackedStore
+    {
+        public BindingStore(SQLiteConnection connection, Storage storage = null)
+            : base(connection, storage)
+        {
+        }
+
+        protected override void Prepare(bool reset = false)
+        {
+            Connection.CreateTable<Binding>();
+        }
+
+        protected override Type[] ValidTypes => new[]
+        {
+            typeof(Binding)
+        };
+
+    }
+}

osu.Game/OsuGameBase.cs

@@ -19,6 +19,7 @@ using osu.Game.Online.API;
 using SQLite.Net;
 using osu.Framework.Graphics.Performance;
 using osu.Game.Database;
+using osu.Game.Input;
 using osu.Game.IO;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Scoring;
@@ -37,6 +38,8 @@ namespace osu.Game
 
         protected ScoreStore ScoreStore;
 
+        protected BindingStore BindingStore;
+
         protected override string MainResourceFile => @"osu.Game.Resources.dll";
 
         public APIAccess API;
@@ -104,6 +107,7 @@ namespace osu.Game
             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(new OsuColour());
 
             //this completely overrides the framework default. will need to change once we make a proper FontStore.

osu.Game/Rulesets/Mods/IApplicableMod.cs

@@ -7,16 +7,16 @@ using osu.Game.Rulesets.UI;
 namespace osu.Game.Rulesets.Mods
 {
     /// <summary>
-    /// An interface for mods that are applied to a HitRenderer.
+    /// An interface for mods that are applied to a RulesetContainer.
     /// </summary>
-    /// <typeparam name="TObject">The type of HitObject the HitRenderer contains.</typeparam>
+    /// <typeparam name="TObject">The type of HitObject the RulesetContainer contains.</typeparam>
     public interface IApplicableMod<TObject>
         where TObject : HitObject
     {
         /// <summary>
-        /// Applies the mod to a HitRenderer.
+        /// Applies the mod to a RulesetContainer.
         /// </summary>
-        /// <param name="hitRenderer">The HitRenderer to apply the mod to.</param>
+        /// <param name="rulesetContainer">The RulesetContainer to apply the mod to.</param>
-        void ApplyToHitRenderer(HitRenderer<TObject> hitRenderer);
+        void ApplyToRulesetContainer(RulesetContainer<TObject> rulesetContainer);
     }
 }

osu.Game/Rulesets/Mods/ModAutoplay.cs

@@ -15,9 +15,9 @@ namespace osu.Game.Rulesets.Mods
     {
         protected abstract Score CreateReplayScore(Beatmap<T> beatmap);
 
-        public void ApplyToHitRenderer(HitRenderer<T> hitRenderer)
+        public void ApplyToRulesetContainer(RulesetContainer<T> rulesetContainer)
         {
-            hitRenderer.SetReplay(CreateReplayScore(hitRenderer.Beatmap)?.Replay);
+            rulesetContainer.SetReplay(CreateReplayScore(rulesetContainer.Beatmap)?.Replay);
         }
     }
 

osu.Game/Rulesets/Ruleset.cs

@@ -15,12 +15,19 @@ namespace osu.Game.Rulesets
 {
     public abstract class Ruleset
     {
+        public readonly RulesetInfo RulesetInfo;
+
         public virtual IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new BeatmapStatistic[] { };
 
         public abstract IEnumerable<Mod> GetModsFor(ModType type);
 
         public abstract Mod GetAutoplayMod();
 
+        protected Ruleset(RulesetInfo rulesetInfo)
+        {
+            RulesetInfo = rulesetInfo;
+        }
+
         /// <summary>
         /// Attempt to create a hit renderer for a beatmap
         /// </summary>
@@ -28,7 +35,7 @@ namespace osu.Game.Rulesets
         /// <param name="isForCurrentRuleset">Whether the hit renderer should assume the beatmap is for the current ruleset.</param>
         /// <exception cref="BeatmapInvalidForRulesetException">Unable to successfully load the beatmap to be usable with this ruleset.</exception>
         /// <returns></returns>
-        public abstract HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset);
+        public abstract RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset);
 
         public abstract DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap);
 

osu.Game/Rulesets/RulesetInfo.cs

@@ -20,6 +20,6 @@ namespace osu.Game.Rulesets
         [Indexed]
         public bool Available { get; set; }
 
-        public virtual Ruleset CreateInstance() => (Ruleset)Activator.CreateInstance(Type.GetType(InstantiationInfo));
+        public virtual Ruleset CreateInstance() => (Ruleset)Activator.CreateInstance(Type.GetType(InstantiationInfo), this);
     }
 }

osu.Game/Rulesets/RulesetStore.cs

@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets
                         continue;
 
                     foreach (Type rulesetType in rulesets)
-                        instances.Add((Ruleset)Activator.CreateInstance(rulesetType));
+                        instances.Add((Ruleset)Activator.CreateInstance(rulesetType, new RulesetInfo()));
                 }
                 catch (Exception) { }
             }

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -150,13 +150,13 @@ namespace osu.Game.Rulesets.Scoring
         {
         }
 
-        protected ScoreProcessor(HitRenderer<TObject, TJudgement> hitRenderer)
+        protected ScoreProcessor(RulesetContainer<TObject, TJudgement> rulesetContainer)
         {
-            Judgements.Capacity = hitRenderer.Beatmap.HitObjects.Count;
+            Judgements.Capacity = rulesetContainer.Beatmap.HitObjects.Count;
 
-            hitRenderer.OnJudgement += AddJudgement;
+            rulesetContainer.OnJudgement += AddJudgement;
 
-            ComputeTargets(hitRenderer.Beatmap);
+            ComputeTargets(rulesetContainer.Beatmap);
 
             Reset();
         }

osu.Game/Rulesets/Timing/ScrollingContainer.cs

@@ -17,15 +17,10 @@ namespace osu.Game.Rulesets.Timing
     /// </summary>
     public abstract class ScrollingContainer : Container<DrawableHitObject>
     {
-        private readonly BindableDouble visibleTimeRange = new BindableDouble { Default = 1000 };
         /// <summary>
         /// Gets or sets the range of time that is visible by the length of the scrolling axes.
         /// </summary>
-        public BindableDouble VisibleTimeRange
+        public readonly BindableDouble VisibleTimeRange = new BindableDouble { Default = 1000 };
-        {
-            get { return visibleTimeRange; }
-            set { visibleTimeRange.BindTo(value); }
-        }
 
         /// <summary>
         /// The axes through which this <see cref="ScrollingContainer"/> scrolls. This is set by the <see cref="SpeedAdjustmentContainer"/>.

osu.Game/Rulesets/Timing/SpeedAdjustmentContainer.cs

@@ -16,25 +16,15 @@ namespace osu.Game.Rulesets.Timing
     /// </summary>
     public class SpeedAdjustmentContainer : Container<DrawableHitObject>
     {
-        private readonly Bindable<double> visibleTimeRange = new Bindable<double> { Default = 1000 };
         /// <summary>
         /// Gets or sets the range of time that is visible by the length of the scrolling axes.
         /// </summary>
-        public Bindable<double> VisibleTimeRange
+        public readonly Bindable<double> VisibleTimeRange = new Bindable<double> { Default = 1000 };
-        {
-            get { return visibleTimeRange; }
-            set { visibleTimeRange.BindTo(value); }
-        }
 
-        private readonly BindableBool reversed = new BindableBool();
         /// <summary>
         /// Whether to reverse the scrolling direction is reversed.
         /// </summary>
-        public BindableBool Reversed
+        public readonly BindableBool Reversed = new BindableBool();
-        {
-            get { return reversed; }
-            set { reversed.BindTo(value); }
-        }
 
         protected override Container<DrawableHitObject> Content => content;
         private Container<DrawableHitObject> content;
@@ -85,13 +75,13 @@ namespace osu.Game.Rulesets.Timing
             {
                 RelativeChildSize = new Vector2((ScrollingAxes & Axes.X) > 0 ? (float)-VisibleTimeRange : 1, (ScrollingAxes & Axes.Y) > 0 ? (float)-VisibleTimeRange : 1);
                 RelativeChildOffset = new Vector2((ScrollingAxes & Axes.X) > 0 ? (float)VisibleTimeRange : 0, (ScrollingAxes & Axes.Y) > 0 ? (float)VisibleTimeRange : 0);
-                Origin = Anchor = Anchor.BottomLeft;
+                Origin = Anchor = Anchor.BottomRight;
             }
             else
             {
                 RelativeChildSize = new Vector2((ScrollingAxes & Axes.X) > 0 ? (float)VisibleTimeRange : 1, (ScrollingAxes & Axes.Y) > 0 ? (float)VisibleTimeRange : 1);
                 RelativeChildOffset = Vector2.Zero;
-                Anchor = Anchor = Anchor.TopLeft;
+                Origin = Anchor = Anchor.TopLeft;
             }
         }
 

osu.Game/Rulesets/UI/Playfield.cs

@@ -9,6 +9,8 @@ using osu.Game.Rulesets.Objects.Drawables;
 using OpenTK;
 using osu.Game.Rulesets.Judgements;
 using osu.Framework.Allocation;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace osu.Game.Rulesets.UI
 {
@@ -19,7 +21,7 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// The HitObjects contained in this Playfield.
         /// </summary>
-        public HitObjectContainer<DrawableHitObject<TObject, TJudgement>> HitObjects { get; protected set; }
+        public HitObjectContainer HitObjects { get; protected set; }
 
         internal Container<Drawable> ScaledContent;
 
@@ -53,7 +55,7 @@ namespace osu.Game.Rulesets.UI
                 }
             });
 
-            HitObjects = new HitObjectContainer<DrawableHitObject<TObject, TJudgement>>
+            HitObjects = new HitObjectContainer
             {
                 RelativeSizeAxes = Axes.Both,
             };
@@ -94,6 +96,13 @@ namespace osu.Game.Rulesets.UI
         /// <param name="judgedObject">The object that Judgement has been updated for.</param>
         public virtual void OnJudgement(DrawableHitObject<TObject, TJudgement> judgedObject) { }
 
+        public class HitObjectContainer : CompositeDrawable
+        {
+            public virtual IEnumerable<DrawableHitObject> Objects => InternalChildren.OfType<DrawableHitObject>();
+            public virtual void Add(DrawableHitObject hitObject) => AddInternal(hitObject);
+            public virtual bool Remove(DrawableHitObject hitObject) => RemoveInternal(hitObject);
+        }
+
         private class ScaledContainer : Container
         {
             /// <summary>
@@ -104,10 +113,5 @@ namespace osu.Game.Rulesets.UI
             //dividing by the customwidth will effectively scale our content to the required container size.
             protected override Vector2 DrawScale => CustomWidth.HasValue ? new Vector2(DrawSize.X / CustomWidth.Value) : base.DrawScale;
         }
-
-        public class HitObjectContainer<U> : Container<U>
-            where U : Drawable
-        {
-        }
     }
 }

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -14,6 +14,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using osu.Framework.Input;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using OpenTK;
@@ -22,12 +23,12 @@ using osu.Game.Rulesets.Beatmaps;
 namespace osu.Game.Rulesets.UI
 {
     /// <summary>
-    /// Base HitRenderer. Doesn't hold objects.
+    /// Base RulesetContainer. Doesn't hold objects.
     /// <para>
-    /// Should not be derived - derive <see cref="HitRenderer{TObject, TJudgement}"/> instead.
+    /// Should not be derived - derive <see cref="RulesetContainer{TObject,TJudgement}"/> instead.
     /// </para>
     /// </summary>
-    public abstract class HitRenderer : Container
+    public abstract class RulesetContainer : Container
     {
         /// <summary>
         /// Invoked when all the judgeable HitObjects have been judged.
@@ -40,14 +41,14 @@ namespace osu.Game.Rulesets.UI
         public bool AspectAdjust = true;
 
         /// <summary>
-        /// The input manager for this HitRenderer.
+        /// The input manager for this RulesetContainer.
         /// </summary>
         internal readonly PlayerInputManager InputManager = new PlayerInputManager();
 
         /// <summary>
-        /// The key conversion input manager for this HitRenderer.
+        /// The key conversion input manager for this RulesetContainer.
         /// </summary>
-        protected readonly KeyConversionInputManager KeyConversionInputManager;
+        protected readonly PassThroughInputManager KeyConversionInputManager;
 
         /// <summary>
         /// Whether we are currently providing the local user a gameplay cursor.
@@ -66,9 +67,16 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         protected abstract bool AllObjectsJudged { get; }
 
-        internal HitRenderer()
+        protected readonly Ruleset Ruleset;
+
+        /// <summary>
+        /// A visual representation of a <see cref="Rulesets.Ruleset"/>.
+        /// </summary>
+        /// <param name="ruleset">The ruleset being repesented.</param>
+        internal RulesetContainer(Ruleset ruleset)
         {
-            KeyConversionInputManager = CreateKeyConversionInputManager();
+            Ruleset = ruleset;
+            KeyConversionInputManager = CreateActionMappingInputManager();
             KeyConversionInputManager.RelativeSizeAxes = Axes.Both;
         }
 
@@ -87,7 +95,7 @@ namespace osu.Game.Rulesets.UI
         /// Creates a key conversion input manager.
         /// </summary>
         /// <returns>The input manager.</returns>
-        protected virtual KeyConversionInputManager CreateKeyConversionInputManager() => new KeyConversionInputManager();
+        protected virtual PassThroughInputManager CreateActionMappingInputManager() => new PassThroughInputManager();
 
         protected virtual FramedReplayInputHandler CreateReplayInputHandler(Replay replay) => new FramedReplayInputHandler(replay);
 
@@ -105,14 +113,14 @@ namespace osu.Game.Rulesets.UI
     }
 
     /// <summary>
-    /// HitRenderer that applies conversion to Beatmaps. Does not contain a Playfield
+    /// RulesetContainer that applies conversion to Beatmaps. Does not contain a Playfield
     /// and does not load drawable hit objects.
     /// <para>
-    /// Should not be derived - derive <see cref="HitRenderer{TObject, TJudgement}"/> instead.
+    /// Should not be derived - derive <see cref="RulesetContainer{TObject,TJudgement}"/> instead.
     /// </para>
     /// </summary>
-    /// <typeparam name="TObject">The type of HitObject contained by this HitRenderer.</typeparam>
+    /// <typeparam name="TObject">The type of HitObject contained by this RulesetContainer.</typeparam>
-    public abstract class HitRenderer<TObject> : HitRenderer
+    public abstract class RulesetContainer<TObject> : RulesetContainer
         where TObject : HitObject
     {
         /// <summary>
@@ -133,11 +141,12 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// Creates a hit renderer for a beatmap.
         /// </summary>
+        /// <param name="ruleset">The ruleset being repesented.</param>
         /// <param name="beatmap">The beatmap to create the hit renderer for.</param>
         /// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
-        internal HitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+        internal RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset) : base(ruleset)
         {
-            Debug.Assert(beatmap != null, "HitRenderer initialized with a null beatmap.");
+            Debug.Assert(beatmap != null, "RulesetContainer initialized with a null beatmap.");
 
             Mods = beatmap.Mods.Value;
 
@@ -171,7 +180,7 @@ namespace osu.Game.Rulesets.UI
         }
 
         /// <summary>
-        /// Applies the active mods to this HitRenderer.
+        /// Applies the active mods to this RulesetContainer.
         /// </summary>
         /// <param name="mods"></param>
         private void applyMods(IEnumerable<Mod> mods)
@@ -180,7 +189,7 @@ namespace osu.Game.Rulesets.UI
                 return;
 
             foreach (var mod in mods.OfType<IApplicableMod<TObject>>())
-                mod.ApplyToHitRenderer(this);
+                mod.ApplyToRulesetContainer(this);
         }
 
         /// <summary>
@@ -203,11 +212,11 @@ namespace osu.Game.Rulesets.UI
     }
 
     /// <summary>
-    /// A derivable HitRenderer that manages the Playfield and HitObjects.
+    /// A derivable RulesetContainer that manages the Playfield and HitObjects.
     /// </summary>
-    /// <typeparam name="TObject">The type of HitObject contained by this HitRenderer.</typeparam>
+    /// <typeparam name="TObject">The type of HitObject contained by this RulesetContainer.</typeparam>
-    /// <typeparam name="TJudgement">The type of Judgement of DrawableHitObjects contained by this HitRenderer.</typeparam>
+    /// <typeparam name="TJudgement">The type of Judgement of DrawableHitObjects contained by this RulesetContainer.</typeparam>
-    public abstract class HitRenderer<TObject, TJudgement> : HitRenderer<TObject>
+    public abstract class RulesetContainer<TObject, TJudgement> : RulesetContainer<TObject>
         where TObject : HitObject
         where TJudgement : Judgement
     {
@@ -225,7 +234,7 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// The playfield.
         /// </summary>
-        protected Playfield<TObject, TJudgement> Playfield { get; private set; }
+        public Playfield<TObject, TJudgement> Playfield { get; private set; }
 
         protected override Container<Drawable> Content => content;
         private readonly Container content;
@@ -235,10 +244,11 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// Creates a hit renderer for a beatmap.
         /// </summary>
+        /// <param name="ruleset">The ruleset being repesented.</param>
         /// <param name="beatmap">The beatmap to create the hit renderer for.</param>
         /// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
-        protected HitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+        protected RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
         {
             InputManager.Add(content = new Container
             {
@@ -324,12 +334,12 @@ namespace osu.Game.Rulesets.UI
     }
 
     /// <summary>
-    /// A derivable HitRenderer that manages the Playfield and HitObjects.
+    /// A derivable RulesetContainer that manages the Playfield and HitObjects.
     /// </summary>
-    /// <typeparam name="TPlayfield">The type of Playfield contained by this HitRenderer.</typeparam>
+    /// <typeparam name="TPlayfield">The type of Playfield contained by this RulesetContainer.</typeparam>
-    /// <typeparam name="TObject">The type of HitObject contained by this HitRenderer.</typeparam>
+    /// <typeparam name="TObject">The type of HitObject contained by this RulesetContainer.</typeparam>
-    /// <typeparam name="TJudgement">The type of Judgement of DrawableHitObjects contained by this HitRenderer.</typeparam>
+    /// <typeparam name="TJudgement">The type of Judgement of DrawableHitObjects contained by this RulesetContainer.</typeparam>
-    public abstract class HitRenderer<TPlayfield, TObject, TJudgement> : HitRenderer<TObject, TJudgement>
+    public abstract class RulesetContainer<TPlayfield, TObject, TJudgement> : RulesetContainer<TObject, TJudgement>
         where TObject : HitObject
         where TJudgement : Judgement
         where TPlayfield : Playfield<TObject, TJudgement>
@@ -342,10 +352,11 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// Creates a hit renderer for a beatmap.
         /// </summary>
+        /// <param name="ruleset">The ruleset being repesented.</param>
         /// <param name="beatmap">The beatmap to create the hit renderer for.</param>
         /// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
-        protected HitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+        protected RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
         {
         }
     }

osu.Game/Rulesets/UI/ScrollingPlayfield.cs

@@ -7,7 +7,6 @@ using System.Linq;
 using OpenTK.Input;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Transforms;
 using osu.Framework.Input;
 using osu.Framework.MathUtils;
@@ -72,12 +71,9 @@ namespace osu.Game.Rulesets.UI
         protected ScrollingPlayfield(Axes scrollingAxes, float? customWidth = null)
             : base(customWidth)
         {
-            base.HitObjects = HitObjects = new ScrollingHitObjectContainer(scrollingAxes)
+            base.HitObjects = HitObjects = new ScrollingHitObjectContainer(scrollingAxes) { RelativeSizeAxes = Axes.Both };
-            {
+            HitObjects.VisibleTimeRange.BindTo(VisibleTimeRange);
-                RelativeSizeAxes = Axes.Both,
+            HitObjects.Reversed.BindTo(Reversed);
-                VisibleTimeRange = VisibleTimeRange,
-                Reversed = Reversed
-            };
         }
 
         private List<ScrollingPlayfield<TObject, TJudgement>> nestedPlayfields;
@@ -141,36 +137,24 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// A container that provides the foundation for sorting <see cref="DrawableHitObject"/>s into <see cref="SpeedAdjustmentContainer"/>s.
         /// </summary>
-        internal class ScrollingHitObjectContainer : HitObjectContainer<DrawableHitObject<TObject, TJudgement>>
+        internal class ScrollingHitObjectContainer : HitObjectContainer
         {
-            private readonly BindableDouble visibleTimeRange = new BindableDouble { Default = 1000 };
             /// <summary>
             /// Gets or sets the range of time that is visible by the length of the scrolling axes.
             /// For example, only hit objects with start time less than or equal to 1000 will be visible with <see cref="VisibleTimeRange"/> = 1000.
             /// </summary>
-            public Bindable<double> VisibleTimeRange
+            public readonly BindableDouble VisibleTimeRange = new BindableDouble { Default = 1000 };
-            {
-                get { return visibleTimeRange; }
-                set { visibleTimeRange.BindTo(value); }
-            }
 
-            private readonly BindableBool reversed = new BindableBool();
             /// <summary>
             /// Whether to reverse the scrolling direction is reversed.
             /// </summary>
-            public BindableBool Reversed
+            public readonly BindableBool Reversed = new BindableBool();
-            {
-                get { return reversed; }
-                set { reversed.BindTo(value); }
-            }
-
-            protected override Container<DrawableHitObject<TObject, TJudgement>> Content => content;
-            private readonly Container<DrawableHitObject<TObject, TJudgement>> content;
 
             /// <summary>
             /// Hit objects that are to be re-processed on the next update.
             /// </summary>
-            private readonly List<DrawableHitObject<TObject, TJudgement>> queuedHitObjects = new List<DrawableHitObject<TObject, TJudgement>>();
+            private readonly List<DrawableHitObject> queuedHitObjects = new List<DrawableHitObject>();
+            private readonly List<SpeedAdjustmentContainer> speedAdjustments = new List<SpeedAdjustmentContainer>();
 
             private readonly Axes scrollingAxes;
 
@@ -181,9 +165,6 @@ namespace osu.Game.Rulesets.UI
             public ScrollingHitObjectContainer(Axes scrollingAxes)
             {
                 this.scrollingAxes = scrollingAxes;
-
-                // The following is never used - it only exists for the purpose of being able to use AddInternal below.
-                content = new Container<DrawableHitObject<TObject, TJudgement>>();
             }
 
             /// <summary>
@@ -192,18 +173,22 @@ namespace osu.Game.Rulesets.UI
             /// <param name="speedAdjustment">The <see cref="SpeedAdjustmentContainer"/>.</param>
             public void AddSpeedAdjustment(SpeedAdjustmentContainer speedAdjustment)
             {
-                speedAdjustment.VisibleTimeRange.BindTo(VisibleTimeRange);
                 speedAdjustment.ScrollingAxes = scrollingAxes;
-                speedAdjustment.Reversed = Reversed;
+                speedAdjustment.VisibleTimeRange.BindTo(VisibleTimeRange);
+                speedAdjustment.Reversed.BindTo(Reversed);
+
+                speedAdjustments.Add(speedAdjustment);
                 AddInternal(speedAdjustment);
             }
 
+            public override IEnumerable<DrawableHitObject> Objects => speedAdjustments.SelectMany(s => s.Children);
+
             /// <summary>
             /// Adds a hit object to this <see cref="ScrollingHitObjectContainer"/>. The hit objects will be queued to be processed
             /// new <see cref="SpeedAdjustmentContainer"/>s are added to this <see cref="ScrollingHitObjectContainer"/>.
             /// </summary>
             /// <param name="hitObject">The hit object to add.</param>
-            public override void Add(DrawableHitObject<TObject, TJudgement> hitObject)
+            public override void Add(DrawableHitObject hitObject)
             {
                 if (!(hitObject is IScrollingHitObject))
                     throw new InvalidOperationException($"Hit objects added to a {nameof(ScrollingHitObjectContainer)} must implement {nameof(IScrollingHitObject)}.");
@@ -211,13 +196,7 @@ namespace osu.Game.Rulesets.UI
                 queuedHitObjects.Add(hitObject);
             }
 
-            public override bool Remove(DrawableHitObject<TObject, TJudgement> hitObject)
+            public override bool Remove(DrawableHitObject hitObject) => speedAdjustments.Any(s => s.Remove(hitObject)) || queuedHitObjects.Remove(hitObject);
-            {
-                bool removed = InternalChildren.OfType<SpeedAdjustmentContainer>().Any(c => c.Remove(hitObject));
-                removed = removed || queuedHitObjects.Remove(hitObject);
-
-                return removed;
-            }
 
             protected override void Update()
             {
@@ -246,7 +225,7 @@ namespace osu.Game.Rulesets.UI
             /// </summary>
             /// <param name="hitObject">The hit object to find the active <see cref="SpeedAdjustmentContainer"/> for.</param>
             /// <returns>The <see cref="SpeedAdjustmentContainer"/> active at <paramref name="hitObject"/>'s start time. Null if there are no speed adjustments.</returns>
-            private SpeedAdjustmentContainer adjustmentContainerFor(DrawableHitObject hitObject) => InternalChildren.OfType<SpeedAdjustmentContainer>().FirstOrDefault(c => c.CanContain(hitObject)) ?? InternalChildren.OfType<SpeedAdjustmentContainer>().LastOrDefault();
+            private SpeedAdjustmentContainer adjustmentContainerFor(DrawableHitObject hitObject) => speedAdjustments.FirstOrDefault(c => c.CanContain(hitObject)) ?? speedAdjustments.LastOrDefault();
 
             /// <summary>
             /// Finds the <see cref="SpeedAdjustmentContainer"/> which provides the speed adjustment active at a time.
@@ -254,7 +233,7 @@ namespace osu.Game.Rulesets.UI
             /// </summary>
             /// <param name="time">The time to find the active <see cref="SpeedAdjustmentContainer"/> at.</param>
             /// <returns>The <see cref="SpeedAdjustmentContainer"/> active at <paramref name="time"/>. Null if there are no speed adjustments.</returns>
-            private SpeedAdjustmentContainer adjustmentContainerAt(double time) => InternalChildren.OfType<SpeedAdjustmentContainer>().FirstOrDefault(c => c.CanContain(time)) ?? InternalChildren.OfType<SpeedAdjustmentContainer>().LastOrDefault();
+            private SpeedAdjustmentContainer adjustmentContainerAt(double time) => speedAdjustments.FirstOrDefault(c => c.CanContain(time)) ?? speedAdjustments.LastOrDefault();
         }
     }
 }

osu.Game/Rulesets/UI/ScrollingRulesetContainer.cs

@@ -17,23 +17,23 @@ using osu.Game.Rulesets.Timing;
 namespace osu.Game.Rulesets.UI
 {
     /// <summary>
-    /// A type of <see cref="HitRenderer{TPlayfield, TObject, TJudgement}"/> that supports a <see cref="ScrollingPlayfield{TObject, TJudgement}"/>.
+    /// A type of <see cref="RulesetContainer{TPlayfield,TObject,TJudgement}"/> that supports a <see cref="ScrollingPlayfield{TObject, TJudgement}"/>.
-    /// <see cref="HitObject"/>s inside this <see cref="HitRenderer{TPlayfield, TObject, TJudgement}"/> will scroll within the playfield.
+    /// <see cref="HitObject"/>s inside this <see cref="RulesetContainer{TPlayfield,TObject,TJudgement}"/> will scroll within the playfield.
     /// </summary>
-    public abstract class ScrollingHitRenderer<TPlayfield, TObject, TJudgement> : HitRenderer<TPlayfield, TObject, TJudgement>
+    public abstract class ScrollingRulesetContainer<TPlayfield, TObject, TJudgement> : RulesetContainer<TPlayfield, TObject, TJudgement>
         where TObject : HitObject
         where TJudgement : Judgement
         where TPlayfield : ScrollingPlayfield<TObject, TJudgement>
     {
         /// <summary>
         /// Provides the default <see cref="MultiplierControlPoint"/>s that adjust the scrolling rate of <see cref="HitObject"/>s
-        /// inside this <see cref="HitRenderer{TPlayfield, TObject, TJudgement}"/>.
+        /// inside this <see cref="RulesetContainer{TPlayfield,TObject,TJudgement}"/>.
         /// </summary>
         /// <returns></returns>
         protected readonly SortedList<MultiplierControlPoint> DefaultControlPoints = new SortedList<MultiplierControlPoint>(Comparer<MultiplierControlPoint>.Default);
 
-        protected ScrollingHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
+        protected ScrollingRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
-            : base(beatmap, isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
         {
         }
 

osu.Game/Screens/Play/HUDOverlay.cs

@@ -90,11 +90,11 @@ namespace osu.Game.Screens.Play
             }
         }
 
-        public virtual void BindHitRenderer(HitRenderer hitRenderer)
+        public virtual void BindRulesetContainer(RulesetContainer rulesetContainer)
         {
-            hitRenderer.InputManager.Add(KeyCounter.GetReceptor());
+            rulesetContainer.InputManager.Add(KeyCounter.GetReceptor());
 
-            replayLoaded = hitRenderer.HasReplayLoaded;
+            replayLoaded = rulesetContainer.HasReplayLoaded;
 
             // in the case a replay isn't loaded, we want some elements to only appear briefly.
             if (!replayLoaded)

osu.Game/Screens/Play/KeyConversionInputManager.cs

@@ -1,16 +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 osu.Framework.Input;
-
-namespace osu.Game.Screens.Play
-{
-    /// <summary>
-    /// An InputManager primarily used to map keys to new functions.
-    /// By default this does nothing; override TransformState to make alterations.
-    /// </summary>
-    public class KeyConversionInputManager : PassThroughInputManager
-    {
-
-    }
-}

osu.Game/Screens/Play/Player.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Screens.Play
 
         internal override bool ShowOverlays => false;
 
-        internal override bool HasLocalCursorDisplayed => !pauseContainer.IsPaused && !HasFailed && HitRenderer.ProvidingUserCursor;
+        internal override bool HasLocalCursorDisplayed => !pauseContainer.IsPaused && !HasFailed && RulesetContainer.ProvidingUserCursor;
 
         public Action RestartRequested;
 
@@ -51,7 +51,7 @@ namespace osu.Game.Screens.Play
         private RulesetInfo ruleset;
 
         private ScoreProcessor scoreProcessor;
-        protected HitRenderer HitRenderer;
+        protected RulesetContainer RulesetContainer;
 
         #region User Settings
 
@@ -66,7 +66,7 @@ namespace osu.Game.Screens.Play
         private HUDOverlay hudOverlay;
         private FailOverlay failOverlay;
 
-        private bool loadedSuccessfully => HitRenderer?.Objects.Any() == true;
+        private bool loadedSuccessfully => RulesetContainer?.Objects.Any() == true;
 
         [BackgroundDependencyLoader(permitNulls: true)]
         private void load(AudioManager audio, OsuConfigManager config, OsuGame osu)
@@ -93,18 +93,18 @@ namespace osu.Game.Screens.Play
 
                 try
                 {
-                    HitRenderer = rulesetInstance.CreateHitRendererWith(working, ruleset.ID == beatmap.BeatmapInfo.Ruleset.ID);
+                    RulesetContainer = rulesetInstance.CreateRulesetContainerWith(working, ruleset.ID == beatmap.BeatmapInfo.Ruleset.ID);
                 }
                 catch (BeatmapInvalidForRulesetException)
                 {
-                    // we may fail to create a HitRenderer if the beatmap cannot be loaded with the user's preferred ruleset
+                    // we may fail to create a RulesetContainer if the beatmap cannot be loaded with the user's preferred ruleset
                     // let's try again forcing the beatmap's ruleset.
                     ruleset = beatmap.BeatmapInfo.Ruleset;
                     rulesetInstance = ruleset.CreateInstance();
-                    HitRenderer = rulesetInstance.CreateHitRendererWith(Beatmap, true);
+                    RulesetContainer = rulesetInstance.CreateRulesetContainerWith(Beatmap, true);
                 }
 
-                if (!HitRenderer.Objects.Any())
+                if (!RulesetContainer.Objects.Any())
                     throw new InvalidOperationException("Beatmap contains no hit objects!");
             }
             catch (Exception e)
@@ -119,7 +119,7 @@ namespace osu.Game.Screens.Play
             adjustableSourceClock = (IAdjustableClock)working.Track ?? new StopwatchClock();
             decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
 
-            var firstObjectTime = HitRenderer.Objects.First().StartTime;
+            var firstObjectTime = RulesetContainer.Objects.First().StartTime;
             decoupledClock.Seek(Math.Min(0, firstObjectTime - Math.Max(beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, beatmap.BeatmapInfo.AudioLeadIn)));
             decoupledClock.ProcessFrame();
 
@@ -147,7 +147,7 @@ namespace osu.Game.Screens.Play
                     FramedClock = offsetClock,
                     OnRetry = Restart,
                     OnQuit = Exit,
-                    CheckCanPause = () => ValidForResume && !HasFailed && !HitRenderer.HasReplayLoaded,
+                    CheckCanPause = () => ValidForResume && !HasFailed && !RulesetContainer.HasReplayLoaded,
                     Retries = RestartCount,
                     OnPause = () => {
                         hudOverlay.KeyCounter.IsCounting = pauseContainer.IsPaused;
@@ -164,7 +164,7 @@ namespace osu.Game.Screens.Play
                             Clock = offsetClock,
                             Children = new Drawable[]
                             {
-                                HitRenderer,
+                                RulesetContainer,
                             }
                         },
                         hudOverlay = new HUDOverlay
@@ -184,27 +184,27 @@ namespace osu.Game.Screens.Play
                     Action = () => {
                         //we want to hide the hitrenderer immediately (looks better).
                         //we may be able to remove this once the mouse cursor trail is improved.
-                        HitRenderer?.Hide();
+                        RulesetContainer?.Hide();
                         Restart();
                     },
                 }
             };
 
-            scoreProcessor = HitRenderer.CreateScoreProcessor();
+            scoreProcessor = RulesetContainer.CreateScoreProcessor();
 
             hudOverlay.KeyCounter.AddRange(rulesetInstance.CreateGameplayKeys());
             hudOverlay.BindProcessor(scoreProcessor);
-            hudOverlay.BindHitRenderer(HitRenderer);
+            hudOverlay.BindRulesetContainer(RulesetContainer);
 
-            hudOverlay.Progress.Objects = HitRenderer.Objects;
+            hudOverlay.Progress.Objects = RulesetContainer.Objects;
             hudOverlay.Progress.AudioClock = decoupledClock;
-            hudOverlay.Progress.AllowSeeking = HitRenderer.HasReplayLoaded;
+            hudOverlay.Progress.AllowSeeking = RulesetContainer.HasReplayLoaded;
             hudOverlay.Progress.OnSeek = pos => decoupledClock.Seek(pos);
 
             hudOverlay.ModDisplay.Current.BindTo(working.Mods);
 
-            //bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
+            //bind RulesetContainer to ScoreProcessor and ourselves (for a pass situation)
-            HitRenderer.OnAllJudged += onCompletion;
+            RulesetContainer.OnAllJudged += onCompletion;
 
             //bind ScoreProcessor to ourselves (for a fail situation)
             scoreProcessor.Failed += onFail;
@@ -238,7 +238,7 @@ namespace osu.Game.Screens.Play
                         Ruleset = ruleset
                     };
                     scoreProcessor.PopulateScore(score);
-                    score.User = HitRenderer.Replay?.User ?? (Game as OsuGame)?.API?.LocalUser?.Value;
+                    score.User = RulesetContainer.Replay?.User ?? (Game as OsuGame)?.API?.LocalUser?.Value;
                     Push(new Results(score));
                 });
             }
@@ -295,7 +295,7 @@ namespace osu.Game.Screens.Play
 
         protected override bool OnExiting(Screen next)
         {
-            if (HasFailed || !ValidForResume || pauseContainer?.AllowExit != false || HitRenderer?.HasReplayLoaded != false)
+            if (HasFailed || !ValidForResume || pauseContainer?.AllowExit != false || RulesetContainer?.HasReplayLoaded != false)
             {
                 fadeOut();
                 return base.OnExiting(next);
@@ -313,7 +313,7 @@ namespace osu.Game.Screens.Play
         {
             const float fade_out_duration = 250;
 
-            HitRenderer?.FadeOut(fade_out_duration);
+            RulesetContainer?.FadeOut(fade_out_duration);
             Content.FadeOut(fade_out_duration);
 
             hudOverlay?.ScaleTo(0.7f, fade_out_duration * 3, Easing.In);

osu.Game/Screens/Play/ReplayPlayer.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Screens.Play
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            HitRenderer.SetReplay(Replay);
+            RulesetContainer.SetReplay(Replay);
         }
     }
 }

osu.Game/osu.Game.csproj

@@ -92,6 +92,8 @@
     <Compile Include="Graphics\UserInterface\MenuItemType.cs" />
     <Compile Include="Graphics\UserInterface\OsuContextMenu.cs" />
     <Compile Include="Graphics\UserInterface\OsuContextMenuItem.cs" />
+    <Compile Include="Input\Binding.cs" />
+    <Compile Include="Input\BindingStore.cs" />
     <Compile Include="IO\FileStore.cs" />
     <Compile Include="IO\FileInfo.cs" />
     <Compile Include="Online\API\Requests\GetUsersRequest.cs" />
@@ -118,6 +120,7 @@
     <Compile Include="Overlays\Profile\Sections\RecentSection.cs" />
     <Compile Include="Graphics\Containers\ConstrainedIconContainer.cs" />
     <Compile Include="Rulesets\Mods\IApplicableToDifficulty.cs" />
+    <Compile Include="Input\ActionMappingInputManager.cs" />
     <Compile Include="Users\UserCoverBackground.cs" />
     <Compile Include="Overlays\UserProfileOverlay.cs" />
     <Compile Include="Overlays\Profile\ProfileHeader.cs" />
@@ -309,7 +312,6 @@
     <Compile Include="Screens\Multiplayer\MatchCreate.cs" />
     <Compile Include="Screens\Play\FailOverlay.cs" />
     <Compile Include="Screens\Play\MenuOverlay.cs" />
-    <Compile Include="Screens\Play\KeyConversionInputManager.cs" />
     <Compile Include="Screens\Play\PlayerInputManager.cs" />
     <Compile Include="Screens\Play\PlayerLoader.cs" />
     <Compile Include="Screens\Play\ReplayPlayer.cs" />
@@ -338,9 +340,9 @@
     <Compile Include="Screens\Select\Options\BeatmapOptionsOverlay.cs" />
     <Compile Include="Screens\Select\PlaySongSelect.cs" />
     <Compile Include="Screens\Select\SongSelect.cs" />
-    <Compile Include="Rulesets\UI\HitRenderer.cs" />
+    <Compile Include="Rulesets\UI\RulesetContainer.cs" />
     <Compile Include="Rulesets\UI\Playfield.cs" />
-    <Compile Include="Rulesets\UI\ScrollingHitRenderer.cs" />
+    <Compile Include="Rulesets\UI\ScrollingRulesetContainer.cs" />
     <Compile Include="Rulesets\UI\ScrollingPlayfield.cs" />
     <Compile Include="Screens\Select\EditSongSelect.cs" />
     <Compile Include="Screens\Play\HUD\ComboCounter.cs" />