Merge remote-tracking branch 'origin/master' into fix-unauthorized-request

osu.Desktop/OsuGameDesktop.cs

@@ -73,7 +73,7 @@ namespace osu.Desktop
             }
 
             public StableStorage()
-                : base(string.Empty)
+                : base(string.Empty, null)
             {
             }
         }

osu.Game.Rulesets.Catch.Tests/TestCaseCatcherArea.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             {
             }
 
-            public void ToggleHyperDash(bool status) => MovableCatcher.HyperDashModifier = status ? 2 : 1;
+            public void ToggleHyperDash(bool status) => MovableCatcher.SetHyperdashState(status ? 2 : 1);
         }
     }
 }

osu.Game.Rulesets.Catch/Replays/CatchFramedReplayInputHandler.cs

@@ -28,9 +28,9 @@ namespace osu.Game.Rulesets.Catch.Replays
             }
         }
 
-        public override List<InputState> GetPendingStates()
+        public override List<IInput> GetPendingInputs()
         {
-            if (!Position.HasValue) return new List<InputState>();
+            if (!Position.HasValue) return new List<IInput>();
 
             var actions = new List<CatchAction>();
 
@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Catch.Replays
             else if (Position.Value < CurrentFrame.Position)
                 actions.Add(CatchAction.MoveLeft);
 
-            return new List<InputState>
+            return new List<IInput>
             {
                 new CatchReplayState
                 {

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

@@ -16,6 +16,7 @@ using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
 using OpenTK;
 using OpenTK.Graphics;
 
@@ -93,7 +94,7 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             base.UpdateAfterChildren();
 
-            var state = GetContainingInputManager().CurrentState as CatchFramedReplayInputHandler.CatchReplayState;
+            var state = (GetContainingInputManager().CurrentState as RulesetInputManagerInputState<CatchAction>)?.LastReplayState as CatchFramedReplayInputHandler.CatchReplayState;
 
             if (state?.CatcherX != null)
                 MovableCatcher.X = state.CatcherX.Value;
@@ -249,51 +250,62 @@ namespace osu.Game.Rulesets.Catch.UI
 
                 if (validCatch && fruit.HyperDash)
                 {
-                    HyperDashModifier = Math.Abs(fruit.HyperDashTarget.X - fruit.X) / Math.Abs(fruit.HyperDashTarget.StartTime - fruit.StartTime) / BASE_SPEED;
+                    var target = fruit.HyperDashTarget;
-                    HyperDashDirection = fruit.HyperDashTarget.X - fruit.X;
+                    double timeDifference = target.StartTime - fruit.StartTime;
+                    double positionDifference = target.X * CatchPlayfield.BASE_WIDTH - catcherPosition;
+                    double velocity = positionDifference / Math.Max(1.0, timeDifference - 1000.0 / 60.0);
+
+                    SetHyperdashState(Math.Abs(velocity), target.X);
                 }
                 else
-                    HyperDashModifier = 1;
+                {
+                    SetHyperdashState();
+                }
 
                 return validCatch;
             }
 
+            private double hyperDashModifier = 1;
+            private int hyperDashDirection;
+            private float hyperDashTargetPosition;
+
             /// <summary>
             /// Whether we are hypderdashing or not.
             /// </summary>
             public bool HyperDashing => hyperDashModifier != 1;
 
-            private double hyperDashModifier = 1;
-
             /// <summary>
-            /// The direction in which hyperdash is allowed. 0 allows both directions.
+            /// Set hyperdash state.
             /// </summary>
-            public double HyperDashDirection;
+            /// <param name="modifier">The speed multiplier. If this is less or equals to 1, this catcher will be non-hyperdashing state.</param>
-
+            /// <param name="targetPosition">When this catcher crosses this position, this catcher ends hyperdashing.</param>
-            /// <summary>
+            public void SetHyperdashState(double modifier = 1, float targetPosition = -1)
-            /// The speed modifier resultant from hyperdash. Will trigger hyperdash when not equal to 1.
-            /// </summary>
-            public double HyperDashModifier
             {
-                get { return hyperDashModifier; }
+                const float hyperdash_transition_length = 180;
-                set
+
+                bool previouslyHyperDashing = HyperDashing;
+                if (modifier <= 1 || X == targetPosition)
                 {
-                    if (value == hyperDashModifier) return;
+                    hyperDashModifier = 1;
-                    hyperDashModifier = value;
+                    hyperDashDirection = 0;
 
-                    const float transition_length = 180;
+                    if (previouslyHyperDashing)
-
-                    if (HyperDashing)
                     {
-                        this.FadeColour(Color4.OrangeRed, transition_length, Easing.OutQuint);
+                        this.FadeColour(Color4.White, hyperdash_transition_length, Easing.OutQuint);
-                        this.FadeTo(0.2f, transition_length, Easing.OutQuint);
+                        this.FadeTo(1, hyperdash_transition_length, Easing.OutQuint);
-                        Trail = true;
                     }
-                    else
+                }
+                else
+                {
+                    hyperDashModifier = modifier;
+                    hyperDashDirection = Math.Sign(targetPosition - X);
+                    hyperDashTargetPosition = targetPosition;
+
+                    if (!previouslyHyperDashing)
                     {
-                        HyperDashDirection = 0;
+                        this.FadeColour(Color4.OrangeRed, hyperdash_transition_length, Easing.OutQuint);
-                        this.FadeColour(Color4.White, transition_length, Easing.OutQuint);
+                        this.FadeTo(0.2f, hyperdash_transition_length, Easing.OutQuint);
-                        this.FadeTo(1, transition_length, Easing.OutQuint);
+                        Trail = true;
                     }
                 }
             }
@@ -348,12 +360,18 @@ namespace osu.Game.Rulesets.Catch.UI
                 var direction = Math.Sign(currentDirection);
 
                 double dashModifier = Dashing ? 1 : 0.5;
-
+                double speed = BASE_SPEED * dashModifier * hyperDashModifier;
-                if (hyperDashModifier != 1 && (HyperDashDirection == 0 || direction == Math.Sign(HyperDashDirection)))
-                    dashModifier = hyperDashModifier;
 
                 Scale = new Vector2(Math.Abs(Scale.X) * direction, Scale.Y);
-                X = (float)MathHelper.Clamp(X + direction * Clock.ElapsedFrameTime * BASE_SPEED * dashModifier, 0, 1);
+                X = (float)MathHelper.Clamp(X + direction * Clock.ElapsedFrameTime * speed, 0, 1);
+
+                // Correct overshooting.
+                if (hyperDashDirection > 0 && hyperDashTargetPosition < X ||
+                    hyperDashDirection < 0 && hyperDashTargetPosition > X)
+                {
+                    X = hyperDashTargetPosition;
+                    SetHyperdashState();
+                }
             }
 
             /// <summary>

osu.Game.Rulesets.Mania.Tests/ManiaInputTestCase.cs

@@ -0,0 +1,45 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Bindings;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public abstract class ManiaInputTestCase : OsuTestCase
+    {
+        private readonly Container<Drawable> content;
+        protected override Container<Drawable> Content => content ?? base.Content;
+
+        protected ManiaInputTestCase(int keys)
+        {
+            base.Content.Add(content = new LocalInputManager(keys));
+        }
+
+        private class LocalInputManager : ManiaInputManager
+        {
+            public LocalInputManager(int variant)
+                : base(new ManiaRuleset().RulesetInfo, variant)
+            {
+            }
+
+            protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+                => new LocalKeyBindingContainer(ruleset, variant, unique);
+
+            private class LocalKeyBindingContainer : RulesetKeyBindingContainer
+            {
+                public LocalKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+                    : base(ruleset, variant, unique)
+                {
+                }
+
+                protected override void ReloadMappings()
+                {
+                    KeyBindings = DefaultKeyBindings;
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/ScrollingTestContainer.cs

@@ -0,0 +1,37 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    /// <summary>
+    /// A container which provides a <see cref="IScrollingInfo"/> to children.
+    /// </summary>
+    public class ScrollingTestContainer : Container
+    {
+        private readonly ScrollingDirection direction;
+
+        public ScrollingTestContainer(ScrollingDirection direction)
+        {
+            this.direction = direction;
+        }
+
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        {
+            var dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            dependencies.CacheAs<IScrollingInfo>(new ScrollingInfo { Direction = { Value = direction }});
+            return dependencies;
+        }
+
+        private class ScrollingInfo : IScrollingInfo
+        {
+            public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+            IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/TestCaseColumn.cs

@@ -0,0 +1,111 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mania.UI.Components;
+using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class TestCaseColumn : ManiaInputTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Column),
+            typeof(ColumnBackground),
+            typeof(ColumnKeyArea),
+            typeof(ColumnHitObjectArea)
+        };
+
+        private readonly List<Column> columns = new List<Column>();
+
+        public TestCaseColumn()
+            : base(2)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Spacing = new Vector2(20, 0),
+                Children = new[]
+                {
+                    createColumn(ScrollingDirection.Up, ManiaAction.Key1),
+                    createColumn(ScrollingDirection.Down, ManiaAction.Key2)
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddStep("note", createNote);
+            AddStep("hold note", createHoldNote);
+        }
+
+        private void createNote()
+        {
+            for (int i = 0; i < columns.Count; i++)
+            {
+                var obj = new Note { Column = i, StartTime = Time.Current + 2000 };
+                obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                columns[i].Add(new DrawableNote(obj, columns[i].Action));
+            }
+        }
+
+        private void createHoldNote()
+        {
+            for (int i = 0; i < columns.Count; i++)
+            {
+                var obj = new HoldNote { Column = i, StartTime = Time.Current + 2000, Duration = 500 };
+                obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                columns[i].Add(new DrawableHoldNote(obj, columns[i].Action));
+            }
+        }
+
+        private Drawable createColumn(ScrollingDirection direction, ManiaAction action)
+        {
+            var column = new Column(direction)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Height = 0.85f,
+                AccentColour = Color4.OrangeRed,
+                Action = action,
+                VisibleTimeRange = { Value = 2000 }
+            };
+
+            columns.Add(column);
+
+            return new ScrollingTestContainer(direction)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.X,
+                RelativeSizeAxes = Axes.Y,
+                Child = column
+            };
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/TestCaseManiaHitObjects.cs

@@ -1,106 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Tests.Visual;
-using OpenTK;
-using OpenTK.Graphics;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public class TestCaseManiaHitObjects : OsuTestCase
-    {
-        public TestCaseManiaHitObjects()
-        {
-            Note note1 = new Note();
-            Note note2 = new Note();
-            HoldNote holdNote = new HoldNote { StartTime = 1000 };
-
-            note1.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-            note2.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-            holdNote.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-
-            Add(new FillFlowContainer
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                RelativeSizeAxes = Axes.Y,
-                Direction = FillDirection.Horizontal,
-                Spacing = new Vector2(10, 0),
-                // Imagine that the containers containing the drawable notes are the "columns"
-                Children = new Drawable[]
-                {
-                    new Container
-                    {
-                        Name = "Normal note column",
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Y,
-                        Width = 50,
-                        Children = new[]
-                        {
-                            new Container
-                            {
-                                Name = "Timing section",
-                                RelativeSizeAxes = Axes.Both,
-                                RelativeChildSize = new Vector2(1, 10000),
-                                Children = new[]
-                                {
-                                    new DrawableNote(note1, ManiaAction.Key1)
-                                    {
-                                        Y = 5000,
-                                        LifetimeStart = double.MinValue,
-                                        LifetimeEnd = double.MaxValue,
-                                        AccentColour = Color4.Red
-                                    },
-                                    new DrawableNote(note2, ManiaAction.Key1)
-                                    {
-                                        Y = 6000,
-                                        LifetimeStart = double.MinValue,
-                                        LifetimeEnd = double.MaxValue,
-                                        AccentColour = Color4.Red
-                                    }
-                                }
-                            }
-                        }
-                    },
-                    new Container
-                    {
-                        Name = "Hold note column",
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Y,
-                        Width = 50,
-                        Children = new[]
-                        {
-                            new Container
-                            {
-                                Name = "Timing section",
-                                RelativeSizeAxes = Axes.Both,
-                                RelativeChildSize = new Vector2(1, 10000),
-                                Children = new[]
-                                {
-                                    new DrawableHoldNote(holdNote, ManiaAction.Key1)
-                                    {
-                                        Y = 5000,
-                                        Height = 1000,
-                                        LifetimeStart = double.MinValue,
-                                        LifetimeEnd = double.MaxValue,
-                                        AccentColour = Color4.Red,
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-        }
-    }
-}

osu.Game.Rulesets.Mania.Tests/TestCaseManiaPlayfield.cs

@@ -1,185 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Timing;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Configuration;
-using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Configuration;
-using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public class TestCaseManiaPlayfield : OsuTestCase
-    {
-        private const double start_time = 500;
-        private const double duration = 500;
-
-        protected override double TimePerAction => 200;
-
-        private RulesetInfo maniaRuleset;
-
-        public TestCaseManiaPlayfield()
-        {
-            var rng = new Random(1337);
-
-            AddStep("1 column", () => createPlayfield(1));
-            AddStep("4 columns", () => createPlayfield(4));
-            AddStep("5 columns", () => createPlayfield(5));
-            AddStep("8 columns", () => createPlayfield(8));
-            AddStep("4 + 4 columns", () =>
-            {
-                var stages = new List<StageDefinition>
-                {
-                    new StageDefinition { Columns = 4 },
-                    new StageDefinition { Columns = 4 },
-                };
-                createPlayfield(stages);
-            });
-
-            AddStep("2 + 4 + 2 columns", () =>
-            {
-                var stages = new List<StageDefinition>
-                {
-                    new StageDefinition { Columns = 2 },
-                    new StageDefinition { Columns = 4 },
-                    new StageDefinition { Columns = 2 },
-                };
-                createPlayfield(stages);
-            });
-
-            AddStep("1 + 8 + 1 columns", () =>
-            {
-                var stages = new List<StageDefinition>
-                {
-                    new StageDefinition { Columns = 1 },
-                    new StageDefinition { Columns = 8 },
-                    new StageDefinition { Columns = 1 },
-                };
-                createPlayfield(stages);
-            });
-
-            AddStep("Reversed", () => createPlayfield(4, true));
-
-            AddStep("Notes with input", () => createPlayfieldWithNotes());
-            AddStep("Notes with input (reversed)", () => createPlayfieldWithNotes(true));
-            AddStep("Notes with gravity", () => createPlayfieldWithNotes());
-            AddStep("Notes with gravity (reversed)", () => createPlayfieldWithNotes(true));
-
-            AddStep("Hit explosion", () =>
-            {
-                var playfield = createPlayfield(4);
-
-                int col = rng.Next(0, 4);
-
-                var note = new Note { Column = col };
-                note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-
-                var drawableNote = new DrawableNote(note, ManiaAction.Key1)
-                {
-                    AccentColour = playfield.Columns.ElementAt(col).AccentColour
-                };
-
-                playfield.OnJudgement(drawableNote, new ManiaJudgement { Result = HitResult.Perfect });
-                playfield.Columns[col].OnJudgement(drawableNote, new ManiaJudgement { Result = HitResult.Perfect });
-            });
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets, SettingsStore settings)
-        {
-            maniaRuleset = rulesets.GetRuleset(3);
-
-            Dependencies.Cache(new ManiaConfigManager(settings, maniaRuleset, 4));
-        }
-
-        private ManiaPlayfield createPlayfield(int cols, bool inverted = false)
-        {
-            var stages = new List<StageDefinition>
-            {
-                new StageDefinition { Columns = cols },
-            };
-
-            return createPlayfield(stages, inverted);
-        }
-
-        private ManiaPlayfield createPlayfield(List<StageDefinition> stages, bool inverted = false)
-        {
-            Clear();
-
-            var inputManager = new ManiaInputManager(maniaRuleset, stages.Sum(g => g.Columns)) { RelativeSizeAxes = Axes.Both };
-            Add(inputManager);
-
-            ManiaPlayfield playfield;
-
-            inputManager.Add(playfield = new ManiaPlayfield(stages)
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-            });
-
-            playfield.Inverted.Value = inverted;
-
-            return playfield;
-        }
-
-        private void createPlayfieldWithNotes(bool inverted = false)
-        {
-            Clear();
-
-            var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
-
-            var inputManager = new ManiaInputManager(maniaRuleset, 4) { RelativeSizeAxes = Axes.Both };
-            Add(inputManager);
-
-            ManiaPlayfield playfield;
-            var stages = new List<StageDefinition>
-            {
-                new StageDefinition { Columns = 4 },
-            };
-
-            inputManager.Add(playfield = new ManiaPlayfield(stages)
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Clock = new FramedClock(rateAdjustClock)
-            });
-
-            playfield.Inverted.Value = inverted;
-
-            for (double t = start_time; t <= start_time + duration; t += 100)
-            {
-                var note1 = new Note { StartTime = t, Column = 0 };
-                var note2 = new Note { StartTime = t, Column = 3 };
-
-                note1.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-                note2.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-
-                playfield.Add(new DrawableNote(note1, ManiaAction.Key1));
-                playfield.Add(new DrawableNote(note2, ManiaAction.Key4));
-            }
-
-            var holdNote1 = new HoldNote { StartTime = start_time, Duration = duration, Column = 1 };
-            var holdNote2 = new HoldNote { StartTime = start_time, Duration = duration, Column = 2 };
-
-            holdNote1.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-            holdNote2.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-
-            playfield.Add(new DrawableHoldNote(holdNote1, ManiaAction.Key2));
-            playfield.Add(new DrawableHoldNote(holdNote2, ManiaAction.Key3));
-        }
-    }
-}

osu.Game.Rulesets.Mania.Tests/TestCaseNotes.cs

@@ -0,0 +1,168 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+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.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class TestCaseNotes : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(DrawableNote),
+            typeof(DrawableHoldNote)
+        };
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Horizontal,
+                Spacing = new Vector2(20),
+                Children = new[]
+                {
+                    createNoteDisplay(ScrollingDirection.Down),
+                    createNoteDisplay(ScrollingDirection.Up),
+                    createHoldNoteDisplay(ScrollingDirection.Down),
+                    createHoldNoteDisplay(ScrollingDirection.Up),
+                }
+            };
+        }
+
+        private Drawable createNoteDisplay(ScrollingDirection direction)
+        {
+            var note = new Note { StartTime = 999999999 };
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            return new ScrollingTestContainer(direction)
+            {
+                AutoSizeAxes = Axes.Both,
+                Child = new NoteContainer(direction, $"note, scrolling {direction.ToString().ToLower()}")
+                {
+                    Child = new DrawableNote(note, ManiaAction.Key1) { AccentColour = Color4.OrangeRed }
+                }
+            };
+        }
+
+        private Drawable createHoldNoteDisplay(ScrollingDirection direction)
+        {
+            var note = new HoldNote { StartTime = 999999999, Duration = 1000 };
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            return new ScrollingTestContainer(direction)
+            {
+                AutoSizeAxes = Axes.Both,
+                Child = new NoteContainer(direction, $"hold note, scrolling {direction.ToString().ToLower()}")
+                {
+                    Child = new DrawableHoldNote(note, ManiaAction.Key1)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        AccentColour = Color4.OrangeRed,
+                    }
+                }
+            };
+        }
+
+        private class NoteContainer : Container
+        {
+            private readonly Container content;
+            protected override Container<Drawable> Content => content;
+
+            private readonly ScrollingDirection direction;
+
+            public NoteContainer(ScrollingDirection direction, string description)
+            {
+                this.direction = direction;
+                AutoSizeAxes = Axes.Both;
+
+                InternalChild = new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Spacing = new Vector2(0, 10),
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            Width = 45,
+                            Height = 100,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 1.25f,
+                                    Colour = Color4.Black.Opacity(0.5f)
+                                },
+                                content = new Container { RelativeSizeAxes = Axes.Both }
+                            }
+                        },
+                        new SpriteText
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            TextSize = 14,
+                            Text = description
+                        }
+                    }
+                };
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                foreach (var obj in content.OfType<DrawableHitObject>())
+                {
+                    if (!(obj.HitObject is IHasEndTime endTime))
+                        continue;
+
+                    if (!obj.HasNestedHitObjects)
+                        continue;
+
+                    foreach (var nested in obj.NestedHitObjects)
+                    {
+                        double finalPosition = (nested.HitObject.StartTime - obj.HitObject.StartTime) / endTime.Duration;
+                        switch (direction)
+                        {
+                            case ScrollingDirection.Up:
+                                nested.Y = (float)(finalPosition * content.DrawHeight);
+                                break;
+                            case ScrollingDirection.Down:
+                                nested.Y = (float)(-finalPosition * content.DrawHeight);
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/TestCaseStage.cs

@@ -0,0 +1,121 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class TestCaseStage : ManiaInputTestCase
+    {
+        private const int columns = 4;
+
+        private readonly List<ManiaStage> stages = new List<ManiaStage>();
+
+        public TestCaseStage()
+            : base(columns)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Spacing = new Vector2(20, 0),
+                Children = new[]
+                {
+                    createStage(ScrollingDirection.Up, ManiaAction.Key1),
+                    createStage(ScrollingDirection.Down, ManiaAction.Key3)
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddStep("note", createNote);
+            AddStep("hold note", createHoldNote);
+            AddStep("minor bar line", () => createBarLine(false));
+            AddStep("major bar line", () => createBarLine(true));
+        }
+
+        private void createNote()
+        {
+            foreach (var stage in stages)
+            {
+                for (int i = 0; i < stage.Columns.Count; i++)
+                {
+                    var obj = new Note { Column = i, StartTime = Time.Current + 2000 };
+                    obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                    stage.Add(new DrawableNote(obj, stage.Columns[i].Action));
+                }
+            }
+        }
+
+        private void createHoldNote()
+        {
+            foreach (var stage in stages)
+            {
+                for (int i = 0; i < stage.Columns.Count; i++)
+                {
+                    var obj = new HoldNote { Column = i, StartTime = Time.Current + 2000, Duration = 500 };
+                    obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                    stage.Add(new DrawableHoldNote(obj, stage.Columns[i].Action));
+                }
+            }
+        }
+
+        private void createBarLine(bool major)
+        {
+            foreach (var stage in stages)
+            {
+                var obj = new BarLine
+                {
+                    StartTime = Time.Current + 2000,
+                    ControlPoint = new TimingControlPoint(),
+                    BeatIndex = major ? 0 : 1
+                };
+
+                obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+                stage.Add(obj);
+            }
+        }
+
+        private Drawable createStage(ScrollingDirection direction, ManiaAction action)
+        {
+            var specialAction = ManiaAction.Special1;
+
+            var stage = new ManiaStage(direction, 0, new StageDefinition { Columns = 2 }, ref action, ref specialAction) { VisibleTimeRange = { Value = 2000 } };
+            stages.Add(stage);
+
+            return new ScrollingTestContainer(direction)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Y,
+                AutoSizeAxes = Axes.X,
+                Child = stage
+            };
+        }
+    }
+}

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

@@ -329,7 +329,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     break;
             }
 
-            bool isDoubleSample(SampleInfo sample) => sample.Name == SampleInfo.HIT_CLAP && sample.Name == SampleInfo.HIT_FINISH;
+            bool isDoubleSample(SampleInfo sample) => sample.Name == SampleInfo.HIT_CLAP || sample.Name == SampleInfo.HIT_FINISH;
 
             bool canGenerateTwoNotes = (convertType & PatternType.LowProbability) == 0;
             canGenerateTwoNotes &= HitObject.Samples.Any(isDoubleSample) || sampleInfoListAt(HitObject.StartTime).Any(isDoubleSample);

osu.Game.Rulesets.Mania/Configuration/ManiaConfigManager.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Configuration.Tracking;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Configuration;
+using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Configuration
 {
@@ -19,6 +20,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
             base.InitialiseDefaults();
 
             Set(ManiaSetting.ScrollTime, 1500.0, 50.0, 10000.0, 50.0);
+            Set(ManiaSetting.ScrollDirection, ManiaScrollingDirection.Down);
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -29,6 +31,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
     public enum ManiaSetting
     {
-        ScrollTime
+        ScrollTime,
+        ScrollDirection
     }
 }

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyAttributes.cs

@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Mania.Difficulty
+{
+    public class ManiaDifficultyAttributes : DifficultyAttributes
+    {
+        public double GreatHitWindow;
+
+        public ManiaDifficultyAttributes(Mod[] mods, double starRating)
+            : base(mods, starRating)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs

@@ -39,6 +39,9 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
         protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
         {
+            if (!beatmap.HitObjects.Any())
+                return new ManiaDifficultyAttributes(mods, 0);
+
             var difficultyHitObjects = new List<ManiaHitObjectDifficulty>();
 
             int columnCount = ((ManiaBeatmap)beatmap).TotalColumns;
@@ -50,9 +53,14 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             if (!calculateStrainValues(difficultyHitObjects, timeRate))
                 return new DifficultyAttributes(mods, 0);
 
+
             double starRating = calculateDifficulty(difficultyHitObjects, timeRate) * star_scaling_factor;
 
-            return new DifficultyAttributes(mods, starRating);
+            return new ManiaDifficultyAttributes(mods, starRating)
+            {
+                // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
+                GreatHitWindow = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / timeRate
+            };
         }
 
         private bool calculateStrainValues(List<ManiaHitObjectDifficulty> objects, double timeRate)

osu.Game.Rulesets.Mania/Difficulty/ManiaPerformanceCalculator.cs

@@ -13,6 +13,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 {
     public class ManiaPerformanceCalculator : PerformanceCalculator
     {
+        protected new ManiaDifficultyAttributes Attributes => (ManiaDifficultyAttributes)base.Attributes;
+
         private Mod[] mods;
 
         // Score after being scaled by non-difficulty-increasing mods
@@ -105,14 +107,12 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
         private double computeAccuracyValue(double strainValue)
         {
-            // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
+            if (Attributes.GreatHitWindow <= 0)
-            double hitWindowGreat = (int)(Beatmap.HitObjects.First().HitWindows.Great / 2) / TimeRate;
-            if (hitWindowGreat <= 0)
                 return 0;
 
             // Lots of arbitrary values from testing.
             // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
-            double accuracyValue = Math.Max(0.0, 0.2 - (hitWindowGreat - 34) * 0.006667)
+            double accuracyValue = Math.Max(0.0, 0.2 - (Attributes.GreatHitWindow - 34) * 0.006667)
                                        * strainValue
                                        * Math.Pow(Math.Max(0.0, scaledScore - 960000) / 40000, 1.1);
 

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -16,6 +16,7 @@ using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
+using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -155,6 +156,8 @@ namespace osu.Game.Rulesets.Mania
 
         public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new ManiaConfigManager(settings, RulesetInfo);
 
+        public override RulesetSettingsSubsection CreateSettings() => new ManiaSettingsSubsection(this);
+
         public ManiaRuleset(RulesetInfo rulesetInfo = null)
             : base(rulesetInfo)
         {

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -0,0 +1,34 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.Mania.UI;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class ManiaSettingsSubsection : RulesetSettingsSubsection
+    {
+        protected override string Header => "osu!mania";
+
+        public ManiaSettingsSubsection(ManiaRuleset ruleset)
+            : base(ruleset)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ManiaConfigManager config)
+        {
+            Children = new Drawable[]
+            {
+                new SettingsEnumDropdown<ManiaScrollingDirection>
+                {
+                    LabelText = "Scrolling direction",
+                    Bindable = config.GetBindable<ManiaScrollingDirection>(ManiaSetting.ScrollDirection)
+                }
+            };
+        }
+    }
+}

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

@@ -10,6 +10,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
@@ -75,6 +76,13 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             AddNested(tail);
         }
 
+        protected override void OnDirectionChanged(ScrollingDirection direction)
+        {
+            base.OnDirectionChanged(direction);
+
+            bodyPiece.Anchor = bodyPiece.Origin = direction == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
+        }
+
         public override Color4 AccentColour
         {
             get { return base.AccentColour; }
@@ -100,7 +108,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             base.Update();
 
             // Make the body piece not lie under the head note
-            bodyPiece.Y = head.Height / 2;
+            bodyPiece.Y = (Direction.Value == ScrollingDirection.Up ? 1 : -1) * head.Height / 2;
             bodyPiece.Height = DrawHeight - head.Height / 2 + tail.Height / 2;
         }
 

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

@@ -1,8 +1,12 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
@@ -16,18 +20,29 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         public new TObject HitObject;
 
+        protected readonly IBindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+
         protected DrawableManiaHitObject(TObject hitObject, ManiaAction? action = null)
             : base(hitObject)
         {
-            Anchor = Anchor.TopCentre;
-            Origin = Anchor.TopCentre;
-
             HitObject = hitObject;
 
             if (action != null)
                 Action = action.Value;
         }
 
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            Direction.BindTo(scrollingInfo.Direction);
+            Direction.BindValueChanged(OnDirectionChanged, true);
+        }
+
+        protected virtual void OnDirectionChanged(ScrollingDirection direction)
+        {
+            Anchor = Origin = direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
+        }
+
         protected override void UpdateState(ArmedState state)
         {
             switch (state)

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

@@ -9,6 +9,7 @@ using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
@@ -28,14 +29,14 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             CornerRadius = 5;
             Masking = true;
 
-            InternalChildren = new Drawable[]
+            InternalChild = headPiece = new NotePiece();
-            {
+        }
-                headPiece = new NotePiece
+
-                {
+        protected override void OnDirectionChanged(ScrollingDirection direction)
-                    Anchor = Anchor.TopCentre,
+        {
-                    Origin = Anchor.TopCentre
+            base.OnDirectionChanged(direction);
-                }
+
-            };
+            headPiece.Anchor = headPiece.Origin = direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
         }
 
         public override Color4 AccentColour

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/NotePiece.cs

@@ -1,12 +1,16 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
 {
@@ -18,6 +22,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
         public const float NOTE_HEIGHT = 10;
         private const float head_colour_height = 6;
 
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
         private readonly Box colouredBox;
 
         public NotePiece()
@@ -33,8 +39,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
                 },
                 colouredBox = new Box
                 {
-                    Anchor = Anchor.TopCentre,
-                    Origin = Anchor.TopCentre,
                     RelativeSizeAxes = Axes.X,
                     Height = head_colour_height,
                     Alpha = 0.2f
@@ -42,6 +46,16 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
             };
         }
 
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(direction =>
+            {
+                colouredBox.Anchor = colouredBox.Origin = direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre;
+            }, true);
+        }
+
         private Color4 accentColour;
         public Color4 AccentColour
         {

osu.Game.Rulesets.Mania/Replays/ManiaFramedReplayInputHandler.cs

@@ -17,6 +17,6 @@ namespace osu.Game.Rulesets.Mania.Replays
 
         protected override bool IsImportant(ManiaReplayFrame frame) => frame.Actions.Any();
 
-        public override List<InputState> GetPendingStates() => new List<InputState> { new ReplayState<ManiaAction> { PressedActions = CurrentFrame.Actions } };
+        public override List<IInput> GetPendingInputs() => new List<IInput> { new ReplayState<ManiaAction> { PressedActions = CurrentFrame.Actions } };
     }
 }

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

@@ -1,50 +1,51 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
 using OpenTK.Graphics;
-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.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
-using System;
 using System.Linq;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class Column : ScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
+    public class Column : ManiaScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
     {
-        private const float key_icon_size = 10;
-        private const float key_icon_corner_radius = 3;
-        private const float key_icon_border_radius = 2;
-
-        private const float hit_target_height = 10;
-        private const float hit_target_bar_height = 2;
-
         private const float column_width = 45;
         private const float special_column_width = 70;
 
-        public ManiaAction Action;
+        private ManiaAction action;
 
-        private readonly Box background;
+        public ManiaAction Action
-        private readonly Box backgroundOverlay;
+        {
-        private readonly Container hitTargetBar;
+            get => action;
-        private readonly Container keyIcon;
+            set
+            {
+                if (action == value)
+                    return;
+                action = value;
+
+                background.Action = value;
+                keyArea.Action = value;
+            }
+        }
+
+        private readonly ColumnBackground background;
+        private readonly ColumnKeyArea keyArea;
+        private readonly ColumnHitObjectArea hitObjectArea;
 
         internal readonly Container TopLevelContainer;
         private readonly Container explosionContainer;
 
-        protected override Container<Drawable> Content => content;
+        protected override Container<Drawable> Content => hitObjectArea;
-        private readonly Container<Drawable> content;
 
-        public Column()
+        public Column(ScrollingDirection direction)
-            : base(ScrollingDirection.Up)
+            : base(direction)
         {
             RelativeSizeAxes = Axes.Y;
             Width = column_width;
@@ -52,71 +53,21 @@ namespace osu.Game.Rulesets.Mania.UI
             Masking = true;
             CornerRadius = 5;
 
-            InternalChildren = new Drawable[]
+            background = new ColumnBackground { RelativeSizeAxes = Axes.Both };
+
+            Container hitTargetContainer;
+
+            InternalChildren = new[]
             {
-                background = new Box
+                // For input purposes, the background is added at the highest depth, but is then proxied back below all other elements
-                {
+                background.CreateProxy(),
-                    Name = "Background",
+                hitTargetContainer = new Container
-                    RelativeSizeAxes = Axes.Both,
-                    Alpha = 0.3f
-                },
-                backgroundOverlay = new Box
-                {
-                    Name = "Background Gradient Overlay",
-                    RelativeSizeAxes = Axes.Both,
-                    Height = 0.5f,
-                    Anchor = Anchor.TopLeft,
-                    Origin = Anchor.TopLeft,
-                    Blending = BlendingMode.Additive,
-                    Alpha = 0
-                },
-                new Container
                 {
                     Name = "Hit target + hit objects",
                     RelativeSizeAxes = Axes.Both,
-                    Padding = new MarginPadding { Top = ManiaStage.HIT_TARGET_POSITION },
                     Children = new Drawable[]
                     {
-                        new Container
+                        hitObjectArea = new ColumnHitObjectArea { RelativeSizeAxes = Axes.Both },
-                        {
-                            Name = "Hit target",
-                            RelativeSizeAxes = Axes.X,
-                            Height = hit_target_height,
-                            Children = new Drawable[]
-                            {
-                                new Box
-                                {
-                                    Name = "Background",
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = Color4.Black
-                                },
-                                hitTargetBar = new Container
-                                {
-                                    Name = "Bar",
-                                    RelativeSizeAxes = Axes.X,
-                                    Height = hit_target_bar_height,
-                                    Masking = true,
-                                    Children = new[]
-                                    {
-                                        new Box
-                                        {
-                                            RelativeSizeAxes = Axes.Both
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        content = new Container
-                        {
-                            Name = "Hit objects",
-                            RelativeSizeAxes = Axes.Both,
-                        },
-                        // For column lighting, we need to capture input events before the notes
-                        new InputTarget
-                        {
-                            Pressed = onPressed,
-                            Released = onReleased
-                        },
                         explosionContainer = new Container
                         {
                             Name = "Hit explosions",
@@ -124,46 +75,27 @@ namespace osu.Game.Rulesets.Mania.UI
                         }
                     }
                 },
-                new Container
+                keyArea = new ColumnKeyArea
                 {
-                    Name = "Key",
                     RelativeSizeAxes = Axes.X,
                     Height = ManiaStage.HIT_TARGET_POSITION,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            Name = "Key gradient",
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = ColourInfo.GradientVertical(Color4.Black, Color4.Black.Opacity(0)),
-                            Alpha = 0.5f
-                        },
-                        keyIcon = new Container
-                        {
-                            Name = "Key icon",
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                            Size = new Vector2(key_icon_size),
-                            Masking = true,
-                            CornerRadius = key_icon_corner_radius,
-                            BorderThickness = 2,
-                            BorderColour = Color4.White, // Not true
-                            Children = new[]
-                            {
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Alpha = 0,
-                                    AlwaysPresent = true
-                                }
-                            }
-                        }
-                    }
                 },
+                background,
                 TopLevelContainer = new Container { RelativeSizeAxes = Axes.Both }
             };
 
             TopLevelContainer.Add(explosionContainer.CreateProxy());
+
+            Direction.BindValueChanged(d =>
+            {
+                hitTargetContainer.Padding = new MarginPadding
+                {
+                    Top = d == ScrollingDirection.Up ? ManiaStage.HIT_TARGET_POSITION : 0,
+                    Bottom = d == ScrollingDirection.Down ? ManiaStage.HIT_TARGET_POSITION : 0,
+                };
+
+                keyArea.Anchor = keyArea.Origin= d == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
+            }, true);
         }
 
         public override Axes RelativeSizeAxes => Axes.Y;
@@ -192,22 +124,9 @@ namespace osu.Game.Rulesets.Mania.UI
                     return;
                 accentColour = value;
 
-                background.Colour = accentColour;
+                background.AccentColour = value;
-                backgroundOverlay.Colour = ColourInfo.GradientVertical(accentColour.Opacity(0.6f), accentColour.Opacity(0));
+                keyArea.AccentColour = value;
-
+                hitObjectArea.AccentColour = value;
-                hitTargetBar.EdgeEffect = new EdgeEffectParameters
-                {
-                    Type = EdgeEffectType.Glow,
-                    Radius = 5,
-                    Colour = accentColour.Opacity(0.5f),
-                };
-
-                keyIcon.EdgeEffect = new EdgeEffectParameters
-                {
-                    Type = EdgeEffectType.Glow,
-                    Radius = 5,
-                    Colour = accentColour.Opacity(0.5f),
-                };
             }
         }
 
@@ -228,48 +147,10 @@ namespace osu.Game.Rulesets.Mania.UI
             if (!judgement.IsHit || !judgedObject.DisplayJudgement)
                 return;
 
-            explosionContainer.Add(new HitExplosion(judgedObject));
+            explosionContainer.Add(new HitExplosion(judgedObject)
-        }
-
-        private bool onPressed(ManiaAction action)
-        {
-            if (action == Action)
             {
-                backgroundOverlay.FadeTo(1, 50, Easing.OutQuint).Then().FadeTo(0.5f, 250, Easing.OutQuint);
+                Anchor = Direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre
-                keyIcon.ScaleTo(1.4f, 50, Easing.OutQuint).Then().ScaleTo(1.3f, 250, Easing.OutQuint);
+            });
-            }
-
-            return false;
-        }
-
-        private bool onReleased(ManiaAction action)
-        {
-            if (action == Action)
-            {
-                backgroundOverlay.FadeTo(0, 250, Easing.OutQuint);
-                keyIcon.ScaleTo(1f, 125, Easing.OutQuint);
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// This is a simple container which delegates various input events that have to be captured before the notes.
-        /// </summary>
-        private class InputTarget : Container, IKeyBindingHandler<ManiaAction>
-        {
-            public Func<ManiaAction, bool> Pressed;
-            public Func<ManiaAction, bool> Released;
-
-            public InputTarget()
-            {
-                RelativeSizeAxes = Axes.Both;
-                AlwaysPresent = true;
-                Alpha = 0;
-            }
-
-            public bool OnPressed(ManiaAction action) => Pressed?.Invoke(action) ?? false;
-            public bool OnReleased(ManiaAction action) => Released?.Invoke(action) ?? false;
         }
 
         public bool OnPressed(ManiaAction action)

osu.Game.Rulesets.Mania/UI/Components/ColumnBackground.cs

@@ -0,0 +1,106 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Bindings;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.UI.Components
+{
+    public class ColumnBackground : CompositeDrawable, IKeyBindingHandler<ManiaAction>, IHasAccentColour
+    {
+        public ManiaAction Action;
+
+        private Box background;
+        private Box backgroundOverlay;
+
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            InternalChildren = new[]
+            {
+                background = new Box
+                {
+                    Name = "Background",
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.3f
+                },
+                backgroundOverlay = new Box
+                {
+                    Name = "Background Gradient Overlay",
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.5f,
+                    Blending = BlendingMode.Additive,
+                    Alpha = 0
+                }
+            };
+
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(direction =>
+            {
+                backgroundOverlay.Anchor = backgroundOverlay.Origin = direction == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
+                updateColours();
+            }, true);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateColours();
+        }
+
+        private Color4 accentColour;
+
+        public Color4 AccentColour
+        {
+            get => accentColour;
+            set
+            {
+                if (accentColour == value)
+                    return;
+                accentColour = value;
+
+                updateColours();
+            }
+        }
+
+        private void updateColours()
+        {
+            if (!IsLoaded)
+                return;
+
+            background.Colour = AccentColour;
+
+            var brightPoint = AccentColour.Opacity(0.6f);
+            var dimPoint = AccentColour.Opacity(0);
+
+            backgroundOverlay.Colour = ColourInfo.GradientVertical(
+                direction.Value == ScrollingDirection.Up ? brightPoint : dimPoint,
+                direction.Value == ScrollingDirection.Up ? dimPoint : brightPoint);
+        }
+
+        public bool OnPressed(ManiaAction action)
+        {
+            if (action == Action)
+                backgroundOverlay.FadeTo(1, 50, Easing.OutQuint).Then().FadeTo(0.5f, 250, Easing.OutQuint);
+            return false;
+        }
+
+        public bool OnReleased(ManiaAction action)
+        {
+            if (action == Action)
+                backgroundOverlay.FadeTo(0, 250, Easing.OutQuint);
+            return false;
+        }
+    }
+}

osu.Game.Rulesets.Mania/UI/Components/ColumnHitObjectArea.cs

@@ -0,0 +1,99 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.UI.Components
+{
+    public class ColumnHitObjectArea : Container, IHasAccentColour
+    {
+        private const float hit_target_height = 10;
+        private const float hit_target_bar_height = 2;
+
+        private Container<Drawable> content;
+        protected override Container<Drawable> Content => content;
+
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        private Container hitTargetLine;
+
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            Drawable hitTargetBar;
+
+            InternalChildren = new[]
+            {
+                hitTargetBar = new Box
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = hit_target_height,
+                    Colour = Color4.Black
+                },
+                hitTargetLine = new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = hit_target_bar_height,
+                    Masking = true,
+                    Child = new Box { RelativeSizeAxes = Axes.Both }
+                },
+                content = new Container
+                {
+                    Name = "Hit objects",
+                    RelativeSizeAxes = Axes.Both,
+                },
+            };
+
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(direction =>
+            {
+                Anchor anchor = direction == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
+
+                hitTargetBar.Anchor = hitTargetBar.Origin = anchor;
+                hitTargetLine.Anchor = hitTargetLine.Origin = anchor;
+            }, true);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateColours();
+        }
+
+        private Color4 accentColour;
+
+        public Color4 AccentColour
+        {
+            get => accentColour;
+            set
+            {
+                if (accentColour == value)
+                    return;
+                accentColour = value;
+
+                updateColours();
+            }
+        }
+
+        private void updateColours()
+        {
+            if (!IsLoaded)
+                return;
+
+            hitTargetLine.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Radius = 5,
+                Colour = accentColour.Opacity(0.5f),
+            };
+        }
+    }
+}

osu.Game.Rulesets.Mania/UI/Components/ColumnKeyArea.cs

@@ -0,0 +1,122 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Bindings;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.UI.Components
+{
+    public class ColumnKeyArea : CompositeDrawable, IKeyBindingHandler<ManiaAction>, IHasAccentColour
+    {
+        private const float key_icon_size = 10;
+        private const float key_icon_corner_radius = 3;
+
+        public ManiaAction Action;
+
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        private Container keyIcon;
+
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            Drawable gradient;
+
+            InternalChildren = new[]
+            {
+                gradient = new Box
+                {
+                    Name = "Key gradient",
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.5f
+                },
+                keyIcon = new Container
+                {
+                    Name = "Key icon",
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(key_icon_size),
+                    Masking = true,
+                    CornerRadius = key_icon_corner_radius,
+                    BorderThickness = 2,
+                    BorderColour = Color4.White, // Not true
+                    Children = new[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0,
+                            AlwaysPresent = true
+                        }
+                    }
+                }
+            };
+
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(direction =>
+            {
+                gradient.Colour = ColourInfo.GradientVertical(
+                    direction == ScrollingDirection.Up ? Color4.Black : Color4.Black.Opacity(0),
+                    direction == ScrollingDirection.Up ? Color4.Black.Opacity(0) : Color4.Black);
+            }, true);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateColours();
+        }
+
+        private Color4 accentColour;
+
+        public Color4 AccentColour
+        {
+            get => accentColour;
+            set
+            {
+                if (accentColour == value)
+                    return;
+                accentColour = value;
+
+                updateColours();
+            }
+        }
+
+        private void updateColours()
+        {
+            if (!IsLoaded)
+                return;
+
+            keyIcon.EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Glow,
+                Radius = 5,
+                Colour = accentColour.Opacity(0.5f),
+            };
+        }
+
+        public bool OnPressed(ManiaAction action)
+        {
+            if (action == Action)
+                keyIcon.ScaleTo(1.4f, 50, Easing.OutQuint).Then().ScaleTo(1.3f, 250, Easing.OutQuint);
+            return false;
+        }
+
+        public bool OnReleased(ManiaAction action)
+        {
+            if (action == Action)
+                keyIcon.ScaleTo(1f, 125, Easing.OutQuint);
+            return false;
+        }
+    }
+}

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

@@ -23,7 +23,6 @@ namespace osu.Game.Rulesets.Mania.UI
         {
             bool isTick = judgedObject is DrawableHoldNoteTick;
 
-            Anchor = Anchor.TopCentre;
             Origin = Anchor.Centre;
 
             RelativeSizeAxes = Axes.X;

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

@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public interface IScrollingInfo
+    {
+        /// <summary>
+        /// The direction <see cref="HitObject"/>s should scroll in.
+        /// </summary>
+        IBindable<ScrollingDirection> Direction { get; }
+    }
+}

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

@@ -8,7 +8,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -17,18 +16,13 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaPlayfield : ScrollingPlayfield
+    public class ManiaPlayfield : ManiaScrollingPlayfield
     {
-        /// <summary>
-        /// Whether this playfield should be inverted. This flips everything inside the playfield.
-        /// </summary>
-        public readonly Bindable<bool> Inverted = new Bindable<bool>(true);
-
         public List<Column> Columns => stages.SelectMany(x => x.Columns).ToList();
         private readonly List<ManiaStage> stages = new List<ManiaStage>();
 
-        public ManiaPlayfield(List<StageDefinition> stageDefinitions)
+        public ManiaPlayfield(ScrollingDirection direction, List<StageDefinition> stageDefinitions)
-            : base(ScrollingDirection.Up)
+            : base(direction)
         {
             if (stageDefinitions == null)
                 throw new ArgumentNullException(nameof(stageDefinitions));
@@ -36,8 +30,6 @@ namespace osu.Game.Rulesets.Mania.UI
             if (stageDefinitions.Count <= 0)
                 throw new ArgumentException("Can't have zero or fewer stages.");
 
-            Inverted.Value = true;
-
             GridContainer playfieldGrid;
             InternalChild = playfieldGrid = new GridContainer
             {
@@ -50,9 +42,8 @@ namespace osu.Game.Rulesets.Mania.UI
             int firstColumnIndex = 0;
             for (int i = 0; i < stageDefinitions.Count; i++)
             {
-                var newStage = new ManiaStage(firstColumnIndex, stageDefinitions[i], ref normalColumnAction, ref specialColumnAction);
+                var newStage = new ManiaStage(direction, firstColumnIndex, stageDefinitions[i], ref normalColumnAction, ref specialColumnAction);
                 newStage.VisibleTimeRange.BindTo(VisibleTimeRange);
-                newStage.Inverted.BindTo(Inverted);
 
                 playfieldGrid.Content[0][i] = newStage;
 

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

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
@@ -12,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Input.Handlers;
 using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -33,6 +35,9 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public IEnumerable<BarLine> BarLines;
 
+        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
+        private ScrollingInfo scrollingInfo;
+
         public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
@@ -65,12 +70,24 @@ namespace osu.Game.Rulesets.Mania.UI
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(ManiaConfigManager config)
         {
             BarLines.ForEach(Playfield.Add);
+
+            config.BindWith(ManiaSetting.ScrollDirection, configDirection);
+            configDirection.BindValueChanged(d => scrollingInfo.Direction.Value = (ScrollingDirection)d, true);
         }
 
-        protected sealed override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        {
+            dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+            dependencies.CacheAs<IScrollingInfo>(scrollingInfo = new ScrollingInfo());
+            return dependencies;
+        }
+
+        protected sealed override Playfield CreatePlayfield() => new ManiaPlayfield(scrollingInfo.Direction, Beatmap.Stages)
         {
             Anchor = Anchor.Centre,
             Origin = Anchor.Centre,
@@ -100,5 +117,11 @@ namespace osu.Game.Rulesets.Mania.UI
         protected override Vector2 PlayfieldArea => new Vector2(1, 0.8f);
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new ManiaFramedReplayInputHandler(replay);
+
+        private class ScrollingInfo : IScrollingInfo
+        {
+            public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
+            IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
+        }
     }
 }

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

@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public enum ManiaScrollingDirection
+    {
+        Up = ScrollingDirection.Up,
+        Down = ScrollingDirection.Down
+    }
+}

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

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class ManiaScrollingPlayfield : ScrollingPlayfield
+    {
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        public ManiaScrollingPlayfield(ScrollingDirection direction)
+            : base(direction)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(direction => Direction.Value = direction, true);
+        }
+    }
+}

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

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -24,20 +23,15 @@ namespace osu.Game.Rulesets.Mania.UI
     /// <summary>
     /// A collection of <see cref="Column"/>s.
     /// </summary>
-    internal class ManiaStage : ScrollingPlayfield
+    internal class ManiaStage : ManiaScrollingPlayfield
     {
         public const float HIT_TARGET_POSITION = 50;
 
-        /// <summary>
-        /// Whether this playfield should be inverted. This flips everything inside the playfield.
-        /// </summary>
-        public readonly Bindable<bool> Inverted = new Bindable<bool>(true);
-
         public IReadOnlyList<Column> Columns => columnFlow.Children;
         private readonly FillFlowContainer<Column> columnFlow;
 
-        protected override Container<Drawable> Content => content;
+        protected override Container<Drawable> Content => barLineContainer;
-        private readonly Container<Drawable> content;
+        private readonly Container<Drawable> barLineContainer;
 
         public Container<DrawableManiaJudgement> Judgements => judgements;
         private readonly JudgementContainer<DrawableManiaJudgement> judgements;
@@ -49,8 +43,8 @@ namespace osu.Game.Rulesets.Mania.UI
 
         private readonly int firstColumnIndex;
 
-        public ManiaStage(int firstColumnIndex, StageDefinition definition, ref ManiaAction normalColumnStartAction, ref ManiaAction specialColumnStartAction)
+        public ManiaStage(ScrollingDirection direction, int firstColumnIndex, StageDefinition definition, ref ManiaAction normalColumnStartAction, ref ManiaAction specialColumnStartAction)
-            : base(ScrollingDirection.Up)
+            : base(direction)
         {
             this.firstColumnIndex = firstColumnIndex;
 
@@ -106,13 +100,12 @@ namespace osu.Game.Rulesets.Mania.UI
                             Width = 1366, // Bar lines should only be masked on the vertical axis
                             BypassAutoSizeAxes = Axes.Both,
                             Masking = true,
-                            Child = content = new Container
+                            Child = barLineContainer = new Container
                             {
                                 Name = "Bar lines",
                                 Anchor = Anchor.TopCentre,
                                 Origin = Anchor.TopCentre,
                                 RelativeSizeAxes = Axes.Y,
-                                Padding = new MarginPadding { Top = HIT_TARGET_POSITION }
                             }
                         },
                         judgements = new JudgementContainer<DrawableManiaJudgement>
@@ -131,7 +124,7 @@ namespace osu.Game.Rulesets.Mania.UI
             for (int i = 0; i < definition.Columns; i++)
             {
                 var isSpecial = definition.IsSpecialColumn(i);
-                var column = new Column
+                var column = new Column(direction)
                 {
                     IsSpecial = isSpecial,
                     Action = isSpecial ? specialColumnStartAction++ : normalColumnStartAction++
@@ -140,14 +133,14 @@ namespace osu.Game.Rulesets.Mania.UI
                 AddColumn(column);
             }
 
-            Inverted.ValueChanged += invertedChanged;
+            Direction.BindValueChanged(d =>
-            Inverted.TriggerChange();
+            {
-        }
+                barLineContainer.Padding = new MarginPadding
-
+                {
-        private void invertedChanged(bool newValue)
+                    Top = d == ScrollingDirection.Up ? HIT_TARGET_POSITION : 0,
-        {
+                    Bottom = d == ScrollingDirection.Down ? HIT_TARGET_POSITION : 0,
-            Scale = new Vector2(1, newValue ? -1 : 1);
+                };
-            Judgements.Scale = Scale;
+            }, true);
         }
 
         public void AddColumn(Column c)
@@ -218,7 +211,7 @@ namespace osu.Game.Rulesets.Mania.UI
         {
             // Due to masking differences, it is not possible to get the width of the columns container automatically
             // While masking on effectively only the Y-axis, so we need to set the width of the bar line container manually
-            content.Width = columnFlow.Width;
+            barLineContainer.Width = columnFlow.Width;
         }
     }
 }

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs

@@ -10,6 +10,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
     {
         public double AimStrain;
         public double SpeedStrain;
+        public double ApproachRate;
+        public double OverallDifficulty;
+        public int MaxCombo;
 
         public OsuDifficultyAttributes(Mod[] mods, double starRating)
             : base(mods, starRating)

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs

@@ -25,6 +25,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
         protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
         {
+            if (!beatmap.HitObjects.Any())
+                return new OsuDifficultyAttributes(mods, 0);
+
             OsuDifficultyBeatmap difficultyBeatmap = new OsuDifficultyBeatmap(beatmap.HitObjects.Cast<OsuHitObject>().ToList(), timeRate);
             Skill[] skills =
             {
@@ -58,10 +61,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
             double starRating = aimRating + speedRating + Math.Abs(aimRating - speedRating) / 2;
 
+            // Todo: These int casts are temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
+            double hitWindowGreat = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / timeRate;
+            double preEmpt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate;
+
+            int maxCombo = beatmap.HitObjects.Count();
+            // Add the ticks + tail of the slider. 1 is subtracted because the "headcircle" would be counted twice (once for the slider itself in the line above)
+            maxCombo += beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
+
             return new OsuDifficultyAttributes(mods, starRating)
             {
                 AimStrain = aimRating,
-                SpeedStrain = speedRating
+                SpeedStrain = speedRating,
+                ApproachRate = preEmpt > 1200 ? (1800 - preEmpt) / 120 : (1200 - preEmpt) / 150 + 5,
+                OverallDifficulty = (80 - hitWindowGreat) / 6,
+                MaxCombo = maxCombo
             };
         }
 

osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs

@@ -22,16 +22,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
         private Mod[] mods;
 
-        /// <summary>
-        /// Approach rate adjusted by mods.
-        /// </summary>
-        private double realApproachRate;
-
-        /// <summary>
-        /// Overall difficulty adjusted by mods.
-        /// </summary>
-        private double realOverallDifficulty;
-
         private double accuracy;
         private int scoreMaxCombo;
         private int countGreat;
@@ -63,13 +53,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             if (mods.Any(m => !m.Ranked))
                 return 0;
 
-            // Todo: These int casts are temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
-            double hitWindowGreat = (int)(Beatmap.HitObjects.First().HitWindows.Great / 2) / TimeRate;
-            double preEmpt = (int)BeatmapDifficulty.DifficultyRange(Beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / TimeRate;
-
-            realApproachRate = preEmpt > 1200 ? (1800 - preEmpt) / 120 : (1200 - preEmpt) / 150 + 5;
-            realOverallDifficulty = (80 - hitWindowGreat) / 6;
-
             // Custom multipliers for NoFail and SpunOut.
             double multiplier = 1.12f; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things
 
@@ -94,8 +77,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 categoryRatings.Add("Aim", aimValue);
                 categoryRatings.Add("Speed", speedValue);
                 categoryRatings.Add("Accuracy", accuracyValue);
-                categoryRatings.Add("OD", realOverallDifficulty);
+                categoryRatings.Add("OD", Attributes.OverallDifficulty);
-                categoryRatings.Add("AR", realApproachRate);
+                categoryRatings.Add("AR", Attributes.ApproachRate);
                 categoryRatings.Add("Max Combo", beatmapMaxCombo);
             }
 
@@ -120,22 +103,22 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 aimValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8f) / Math.Pow(beatmapMaxCombo, 0.8f), 1.0f);
 
             double approachRateFactor = 1.0f;
-            if (realApproachRate > 10.33f)
+            if (Attributes.ApproachRate > 10.33f)
-                approachRateFactor += 0.45f * (realApproachRate - 10.33f);
+                approachRateFactor += 0.45f * (Attributes.ApproachRate - 10.33f);
-            else if (realApproachRate < 8.0f)
+            else if (Attributes.ApproachRate < 8.0f)
             {
                 // HD is worth more with lower ar!
                 if (mods.Any(h => h is OsuModHidden))
-                    approachRateFactor += 0.02f * (8.0f - realApproachRate);
+                    approachRateFactor += 0.02f * (8.0f - Attributes.ApproachRate);
                 else
-                    approachRateFactor += 0.01f * (8.0f - realApproachRate);
+                    approachRateFactor += 0.01f * (8.0f - Attributes.ApproachRate);
             }
 
             aimValue *= approachRateFactor;
 
             // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
             if (mods.Any(h => h is OsuModHidden))
-                aimValue *= 1.02 + (11.0f - realApproachRate) / 50.0; // Gives a 1.04 bonus for AR10, a 1.06 bonus for AR9, a 1.02 bonus for AR11.
+                aimValue *= 1.02 + (11.0f - Attributes.ApproachRate) / 50.0; // Gives a 1.04 bonus for AR10, a 1.06 bonus for AR9, a 1.02 bonus for AR11.
 
             if (mods.Any(h => h is OsuModFlashlight))
             {
@@ -146,7 +129,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             // Scale the aim value with accuracy _slightly_
             aimValue *= 0.5f + accuracy / 2.0f;
             // It is important to also consider accuracy difficulty when doing that
-            aimValue *= 0.98f + Math.Pow(realOverallDifficulty, 2) / 2500;
+            aimValue *= 0.98f + Math.Pow(Attributes.OverallDifficulty, 2) / 2500;
 
             return aimValue;
         }
@@ -172,7 +155,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             // Scale the speed value with accuracy _slightly_
             speedValue *= 0.5f + accuracy / 2.0f;
             // It is important to also consider accuracy difficulty when doing that
-            speedValue *= 0.98f + Math.Pow(realOverallDifficulty, 2) / 2500;
+            speedValue *= 0.98f + Math.Pow(Attributes.OverallDifficulty, 2) / 2500;
 
             return speedValue;
         }
@@ -194,7 +177,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             // Lots of arbitrary values from testing.
             // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
-            double accuracyValue = Math.Pow(1.52163f, realOverallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83f;
+            double accuracyValue = Math.Pow(1.52163f, Attributes.OverallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83f;
 
             // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
             accuracyValue *= Math.Min(1.15f, Math.Pow(amountHitObjectsWithAccuracy / 1000.0f, 0.3f));

osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs

@@ -30,13 +30,16 @@ namespace osu.Game.Rulesets.Osu.Replays
             }
         }
 
-        public override List<InputState> GetPendingStates()
+        public override List<IInput> GetPendingInputs()
         {
-            return new List<InputState>
+            return new List<IInput>
             {
+                new MousePositionAbsoluteInput
+                {
+                    Position = GamefieldToScreenSpace(Position ?? Vector2.Zero)
+                },
                 new ReplayState<OsuAction>
                 {
-                    Mouse = new ReplayMouseState(GamefieldToScreenSpace(Position ?? Vector2.Zero)),
                     PressedActions = CurrentFrame.Actions
                 }
             };

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty
+{
+    public class TaikoDifficultyAttributes : DifficultyAttributes
+    {
+        public double GreatHitWindow;
+        public int MaxCombo;
+
+        public TaikoDifficultyAttributes(Mod[] mods, double starRating)
+            : base(mods, starRating)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
@@ -34,6 +35,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
         protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
         {
+            if (!beatmap.HitObjects.Any())
+                return new TaikoDifficultyAttributes(mods, 0);
+
             var difficultyHitObjects = new List<TaikoHitObjectDifficulty>();
 
             foreach (var hitObject in beatmap.HitObjects)
@@ -47,7 +51,12 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
             double starRating = calculateDifficulty(difficultyHitObjects, timeRate) * star_scaling_factor;
 
-            return new DifficultyAttributes(mods, starRating);
+            return new TaikoDifficultyAttributes(mods, starRating)
+            {
+                // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
+                GreatHitWindow = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / timeRate,
+                MaxCombo = beatmap.HitObjects.Count(h => h is Hit)
+            };
         }
 
         private bool calculateStrainValues(List<TaikoHitObjectDifficulty> objects, double timeRate)

osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs

@@ -8,13 +8,12 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
     public class TaikoPerformanceCalculator : PerformanceCalculator
     {
-        private readonly int beatmapMaxCombo;
+        protected new TaikoDifficultyAttributes Attributes => (TaikoDifficultyAttributes)base.Attributes;
 
         private Mod[] mods;
         private int countGreat;
@@ -25,7 +24,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         public TaikoPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, Score score)
             : base(ruleset, beatmap, score)
         {
-            beatmapMaxCombo = Beatmap.HitObjects.Count(h => h is Hit);
         }
 
         public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
@@ -78,8 +76,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             strainValue *= Math.Pow(0.985, countMiss);
 
             // Combo scaling
-            if (beatmapMaxCombo > 0)
+            if (Attributes.MaxCombo > 0)
-                strainValue *= Math.Min(Math.Pow(Score.MaxCombo, 0.5) / Math.Pow(beatmapMaxCombo, 0.5), 1.0);
+                strainValue *= Math.Min(Math.Pow(Score.MaxCombo, 0.5) / Math.Pow(Attributes.MaxCombo, 0.5), 1.0);
 
             if (mods.Any(m => m is ModHidden))
                 strainValue *= 1.025;
@@ -94,14 +92,12 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
         private double computeAccuracyValue()
         {
-            // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be remoevd in the future
+            if (Attributes.GreatHitWindow <= 0)
-            double hitWindowGreat = (int)(Beatmap.HitObjects.First().HitWindows.Great / 2) / TimeRate;
-            if (hitWindowGreat <= 0)
                 return 0;
 
             // Lots of arbitrary values from testing.
             // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
-            double accValue = Math.Pow(150.0 / hitWindowGreat, 1.1) * Math.Pow(Score.Accuracy, 15) * 22.0;
+            double accValue = Math.Pow(150.0 / Attributes.GreatHitWindow, 1.1) * Math.Pow(Score.Accuracy, 15) * 22.0;
 
             // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
             return accValue * Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));

osu.Game.Rulesets.Taiko/Judgements/TaikoIntermediateSwellJudgement.cs

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Taiko.Judgements
+{
+    public class TaikoIntermediateSwellJudgement : TaikoJudgement
+    {
+        public override HitResult MaxResult => HitResult.Perfect;
+
+        public override bool AffectsCombo => false;
+
+        public TaikoIntermediateSwellJudgement()
+        {
+            Final = false;
+        }
+
+        /// <summary>
+        /// Computes the numeric result value for the combo portion of the score.
+        /// </summary>
+        /// <param name="result">The result to compute the value for.</param>
+        /// <returns>The numeric result value.</returns>
+        protected override int NumericResultFor(HitResult result) => 0;
+    }
+}

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

@@ -86,6 +86,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 switch (State.Value)
                 {
                     case ArmedState.Idle:
+                        SecondHitAllowed = false;
+                        validKeyPressed = false;
+
                         UnproxyContent();
                         this.Delay(HitObject.HitWindows.HalfWindowFor(HitResult.Miss)).Expire();
                         break;
@@ -95,8 +98,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                         break;
                     case ArmedState.Hit:
                         // If we're far enough away from the left stage, we should bring outselves in front of it
-                        if (X >= -0.05f)
+                        ProxyContent();
-                            ProxyContent();
 
                         var flash = circlePiece?.FlashBox;
                         if (flash != null)

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Judgements;
 
@@ -46,6 +47,19 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 AddJudgement(new TaikoStrongHitJudgement { Result = HitResult.Great });
         }
 
+        protected override void UpdateState(ArmedState state)
+        {
+            base.UpdateState(state);
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    firstHitTime = 0;
+                    firstKeyHeld = false;
+                    break;
+            }
+        }
+
         public override bool OnReleased(TaikoAction action)
         {
             if (action == firstHitAction)

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

@@ -2,7 +2,6 @@
 // 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.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -20,6 +19,11 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
     public class DrawableSwell : DrawableTaikoHitObject<Swell>
     {
+        /// <summary>
+        /// A judgement is only displayed when the user has complete the swell (either a hit or miss).
+        /// </summary>
+        public override bool DisplayJudgement => AllJudged;
+
         private const float target_ring_thick_border = 1.4f;
         private const float target_ring_thin_border = 1f;
         private const float target_ring_scale = 5f;
@@ -29,11 +33,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         private readonly CircularContainer targetRing;
         private readonly CircularContainer expandingRing;
 
-        /// <summary>
-        /// The amount of times the user has hit this swell.
-        /// </summary>
-        private int userHits;
-
         private readonly SwellSymbolPiece symbol;
 
         public DrawableSwell(Swell swell)
@@ -129,9 +128,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
             if (userTriggered)
             {
-                userHits++;
+                AddJudgement(new TaikoIntermediateSwellJudgement());
 
-                var completion = (float)userHits / HitObject.RequiredHits;
+                var completion = (float)Judgements.Count / HitObject.RequiredHits;
 
                 expandingRing
                     .FadeTo(expandingRing.Alpha + MathHelper.Clamp(completion / 16, 0.1f, 0.6f), 50)
@@ -142,7 +141,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
                 expandingRing.ScaleTo(1f + Math.Min(target_ring_scale - 1f, (target_ring_scale - 1f) * completion * 1.3f), 260, Easing.OutQuint);
 
-                if (userHits == HitObject.RequiredHits)
+                if (Judgements.Count == HitObject.RequiredHits)
                     AddJudgement(new TaikoJudgement { Result = HitResult.Great });
             }
             else
@@ -151,7 +150,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                     return;
 
                 //TODO: THIS IS SHIT AND CAN'T EXIST POST-TAIKO WORLD CUP
-                AddJudgement(userHits > HitObject.RequiredHits / 2
+                AddJudgement(Judgements.Count > HitObject.RequiredHits / 2
                     ? new TaikoJudgement { Result = HitResult.Good }
                     : new TaikoJudgement { Result = HitResult.Miss });
             }
@@ -162,23 +161,22 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             const float preempt = 100;
             const float out_transition_time = 300;
 
-            double untilStartTime = HitObject.StartTime - Time.Current;
-            double untilJudgement = untilStartTime + (Judgements.FirstOrDefault()?.TimeOffset ?? 0) + HitObject.Duration;
-
-            targetRing.Delay(untilStartTime - preempt).ScaleTo(target_ring_scale, preempt * 4, Easing.OutQuint);
-            this.Delay(untilJudgement).FadeOut(out_transition_time, Easing.Out);
-
             switch (state)
             {
                 case ArmedState.Idle:
                     UnproxyContent();
+                    expandingRing.FadeTo(0);
+                    using (BeginAbsoluteSequence(HitObject.StartTime - preempt, true))
+                        targetRing.ScaleTo(target_ring_scale, preempt * 4, Easing.OutQuint);
                     break;
+                case ArmedState.Miss:
                 case ArmedState.Hit:
-                    bodyContainer.Delay(untilJudgement).ScaleTo(1.4f, out_transition_time);
+                    this.FadeOut(out_transition_time, Easing.Out);
+                    bodyContainer.ScaleTo(1.4f, out_transition_time);
+
+                    Expire();
                     break;
             }
-
-            Expire();
         }
 
         protected override void Update()

osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs

@@ -17,6 +17,6 @@ namespace osu.Game.Rulesets.Taiko.Replays
 
         protected override bool IsImportant(TaikoReplayFrame frame) => frame.Actions.Any();
 
-        public override List<InputState> GetPendingStates() => new List<InputState> { new ReplayState<TaikoAction> { PressedActions = CurrentFrame.Actions } };
+        public override List<IInput> GetPendingInputs() => new List<IInput> { new ReplayState<TaikoAction> { PressedActions = CurrentFrame.Actions } };
     }
 }

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

@@ -69,11 +69,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                 bool isMajor = currentBeat % (int)currentPoint.TimeSignature == 0;
                 Playfield.Add(isMajor ? new DrawableBarLineMajor(barLine) : new DrawableBarLine(barLine));
 
-                double bl = currentPoint.BeatLength;
+                time += currentPoint.BeatLength * (int)currentPoint.TimeSignature;
-                if (bl < 800)
-                    bl *= (int)currentPoint.TimeSignature;
-
-                time += bl;
                 currentBeat++;
             }
         }

osu.Game.Tests/Visual/TestCaseLounge.cs

@@ -167,6 +167,7 @@ namespace osu.Game.Tests.Visual
             AddStep(@"set rooms", () => lounge.Rooms = rooms);
             selectAssert(1);
             AddStep(@"open room 1", () => clickRoom(1));
+            AddUntilStep(() => lounge.ChildScreen?.IsCurrentScreen == true, "wait until room current");
             AddStep(@"make lounge current", lounge.MakeCurrent);
             filterAssert(@"THE FINAL", LoungeTab.Public, 1);
             filterAssert(string.Empty, LoungeTab.Public, 2);

osu.Game.Tests/Visual/TestCaseScrollingHitObjects.cs

@@ -114,7 +114,7 @@ namespace osu.Game.Tests.Visual
 
         private class TestPlayfield : ScrollingPlayfield
         {
-            public readonly ScrollingDirection Direction;
+            public new readonly ScrollingDirection Direction;
 
             public TestPlayfield(ScrollingDirection direction)
                 : base(direction)

osu.Game/Input/Handlers/ReplayInputHandler.cs

@@ -32,16 +32,14 @@ namespace osu.Game.Input.Handlers
 
         public override int Priority => 0;
 
-        public class ReplayState<T> : InputState
+        public class ReplayState<T> : IInput
             where T : struct
         {
             public List<T> PressedActions;
 
-            public override InputState Clone()
+            public void Apply(InputState state, IInputStateChangeHandler handler)
             {
-                var clone = (ReplayState<T>)base.Clone();
+                handler.HandleCustomInput(state, this);
-                clone.PressedActions = new List<T>(PressedActions);
-                return clone;
             }
         }
     }

osu.Game/Rulesets/Replays/FramedReplayInputHandler.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Replays
             return true;
         }
 
-        public override List<InputState> GetPendingStates() => new List<InputState>();
+        public override List<IInput> GetPendingInputs() => new List<IInput>();
 
         public bool AtLastFrame => currentFrameIndex == Frames.Count - 1;
         public bool AtFirstFrame => currentFrameIndex == 0;
@@ -119,7 +119,8 @@ namespace osu.Game.Rulesets.Replays
         {
             public ReplayKeyboardState(List<Key> keys)
             {
-                Keys = keys;
+                foreach (var key in keys)
+                    Keys.Add(key);
             }
         }
     }

osu.Game/Rulesets/UI/RulesetInputManager.cs

@@ -15,6 +15,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.Input.Handlers;
 using osu.Game.Screens.Play;
 using OpenTK.Input;
+using static osu.Game.Input.Handlers.ReplayInputHandler;
 
 namespace osu.Game.Rulesets.UI
 {
@@ -29,26 +30,43 @@ namespace osu.Game.Rulesets.UI
             }
         }
 
+        protected override InputState CreateInitialState()
+        {
+            var state = base.CreateInitialState();
+            return new RulesetInputManagerInputState<T>
+            {
+                Mouse = state.Mouse,
+                Keyboard = state.Keyboard,
+                Joystick = state.Joystick,
+                LastReplayState = null
+            };
+        }
+
         protected readonly KeyBindingContainer<T> KeyBindingContainer;
 
         protected override Container<Drawable> Content => KeyBindingContainer;
 
         protected RulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
         {
-            InternalChild = KeyBindingContainer = new RulesetKeyBindingContainer(ruleset, variant, unique);
+            InternalChild = KeyBindingContainer = CreateKeyBindingContainer(ruleset, variant, unique);
         }
 
         #region Action mapping (for replays)
 
         private List<T> lastPressedActions = new List<T>();
 
-        protected override void HandleNewState(InputState state)
+        public override void HandleCustomInput(InputState state, IInput input)
         {
-            base.HandleNewState(state);
+            if (!(input is ReplayState<T> replayState))
+            {
+                base.HandleCustomInput(state, input);
+                return;
+            }
 
-            var replayState = state as ReplayInputHandler.ReplayState<T>;
+            if (state is RulesetInputManagerInputState<T> inputState)
-
+            {
-            if (replayState == null) return;
+                inputState.LastReplayState = replayState;
+            }
 
             // Here we handle states specifically coming from a replay source.
             // These have extra action information rather than keyboard keys or mouse buttons.
@@ -80,7 +98,7 @@ namespace osu.Game.Rulesets.UI
                 if (replayInputHandler != null) RemoveHandler(replayInputHandler);
 
                 replayInputHandler = value;
-                UseParentState = replayInputHandler == null;
+                UseParentInput = replayInputHandler == null;
 
                 if (replayInputHandler != null)
                     AddHandler(replayInputHandler);
@@ -123,7 +141,7 @@ namespace osu.Game.Rulesets.UI
 
         protected override bool RequiresChildrenUpdate => base.RequiresChildrenUpdate && validState;
 
-        private bool isAttached => replayInputHandler != null && !UseParentState;
+        private bool isAttached => replayInputHandler != null && !UseParentInput;
 
         private const int max_catch_up_updates_per_frame = 50;
 
@@ -249,6 +267,9 @@ namespace osu.Game.Rulesets.UI
         }
 
         #endregion
+
+        protected virtual RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+            => new RulesetKeyBindingContainer(ruleset, variant, unique);
     }
 
     /// <summary>
@@ -267,4 +288,10 @@ namespace osu.Game.Rulesets.UI
     {
         void Attach(KeyCounterCollection keyCounter);
     }
+
+    public class RulesetInputManagerInputState<T> : InputState
+    where T : struct
+    {
+        public ReplayState<T> LastReplayState;
+    }
 }

osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs

@@ -29,17 +29,16 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         protected readonly SortedList<MultiplierControlPoint> ControlPoints = new SortedList<MultiplierControlPoint>();
 
-        private readonly ScrollingDirection direction;
+        public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
         private Cached initialStateCache = new Cached();
 
-        public ScrollingHitObjectContainer(ScrollingDirection direction)
+        public ScrollingHitObjectContainer()
         {
-            this.direction = direction;
-
             RelativeSizeAxes = Axes.Both;
 
-            TimeRange.ValueChanged += v => initialStateCache.Invalidate();
+            TimeRange.ValueChanged += _ => initialStateCache.Invalidate();
+            Direction.ValueChanged += _ => initialStateCache.Invalidate();
         }
 
         private ISpeedChangeVisualiser speedChangeVisualiser;
@@ -100,7 +99,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
             if (!initialStateCache.IsValid)
             {
-                speedChangeVisualiser.ComputeInitialStates(Objects, direction, TimeRange, DrawSize);
+                speedChangeVisualiser.ComputeInitialStates(Objects, Direction, TimeRange, DrawSize);
                 initialStateCache.Validate();
             }
         }
@@ -110,7 +109,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
             base.UpdateAfterChildrenLife();
 
             // We need to calculate this as soon as possible after lifetimes so that hitobjects get the final say in their positions
-            speedChangeVisualiser.UpdatePositions(AliveObjects, direction, Time.Current, TimeRange, DrawSize);
+            speedChangeVisualiser.UpdatePositions(AliveObjects, Direction, Time.Current, TimeRange, DrawSize);
         }
     }
 }

osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs

@@ -54,7 +54,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         public new ScrollingHitObjectContainer HitObjects => (ScrollingHitObjectContainer)base.HitObjects;
 
-        private readonly ScrollingDirection direction;
+        protected readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
         /// <summary>
         /// Creates a new <see cref="ScrollingPlayfield"/>.
@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         protected ScrollingPlayfield(ScrollingDirection direction, float? customWidth = null, float? customHeight = null)
             : base(customWidth, customHeight)
         {
-            this.direction = direction;
+            Direction.Value = direction;
         }
 
         [BackgroundDependencyLoader]
@@ -99,6 +99,11 @@ namespace osu.Game.Rulesets.UI.Scrolling
             return false;
         }
 
-        protected sealed override HitObjectContainer CreateHitObjectContainer() => new ScrollingHitObjectContainer(direction);
+        protected sealed override HitObjectContainer CreateHitObjectContainer()
+        {
+            var container = new ScrollingHitObjectContainer();
+            container.Direction.BindTo(Direction);
+            return container;
+        }
     }
 }

osu.Game/Rulesets/UI/Scrolling/Visualisers/SequentialSpeedChangeVisualiser.cs

@@ -93,6 +93,9 @@ namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
         /// <returns>A positive value indicating the position at <paramref name="time"/>.</returns>
         private double positionAt(double time, double timeRange)
         {
+            if (controlPoints.Count == 0)
+                return time / timeRange;
+
             double length = 0;
 
             // We need to consider all timing points until the specified time and not just the currently-active one,

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

@@ -2,6 +2,7 @@
 // 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;
@@ -182,14 +183,14 @@ namespace osu.Game.Screens.Play.HUD
 
             protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
             {
-                if (!pendingAnimation && state.Mouse.Buttons.Count == 1)
+                if (!pendingAnimation && state.Mouse.Buttons.Count() == 1)
                     BeginConfirm();
                 return true;
             }
 
             protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
             {
-                if (state.Mouse.Buttons.Count == 0)
+                if (!state.Mouse.Buttons.Any())
                     AbortConfirm();
                 return true;
             }

osu.Game/Tests/Platform/TestStorage.cs

@@ -7,7 +7,7 @@ namespace osu.Game.Tests.Platform
 {
     public class TestStorage : DesktopStorage
     {
-        public TestStorage(string baseName) : base(baseName)
+        public TestStorage(string baseName) : base(baseName, null)
         {
         }
 

osu.Game/Tests/Visual/ManualInputManagerTestCase.cs

@@ -23,7 +23,7 @@ namespace osu.Game.Tests.Visual
         /// </summary>
         protected void ReturnUserInput()
         {
-            AddStep("Return user input", () => InputManager.UseParentState = true);
+            AddStep("Return user input", () => InputManager.UseParentInput = true);
         }
     }
 }

osu.Game/osu.Game.csproj

@@ -18,7 +18,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.1.0" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
-    <PackageReference Include="ppy.osu.Framework" Version="2018.619.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2018.622.0" />
     <PackageReference Include="SharpCompress" Version="0.18.1" />
     <PackageReference Include="NUnit" Version="3.10.1" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="4.5.0" />