From 189988236b91f63b5e374f9289025ac938cebf4d Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 24 Aug 2017 15:23:17 +0900
Subject: [PATCH 1/8] Move PlayerInputManager logic inside RulesetInputManager

---
 osu.Game/Rulesets/UI/RulesetContainer.cs    |  20 +--
 osu.Game/Rulesets/UI/RulesetInputManager.cs | 163 +++++++++++++++++++-
 osu.Game/Screens/Play/PlayerInputManager.cs | 140 -----------------
 osu.Game/osu.Game.csproj                    |   1 -
 4 files changed, 169 insertions(+), 155 deletions(-)
 delete mode 100644 osu.Game/Screens/Play/PlayerInputManager.cs

diff --git a/osu.Game/Rulesets/UI/RulesetContainer.cs b/osu.Game/Rulesets/UI/RulesetContainer.cs
index 84cadeb2a1..0a16335c77 100644
--- a/osu.Game/Rulesets/UI/RulesetContainer.cs
+++ b/osu.Game/Rulesets/UI/RulesetContainer.cs
@@ -9,7 +9,6 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Screens.Play;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -43,7 +42,7 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// The input manager for this RulesetContainer.
         /// </summary>
-        internal readonly PlayerInputManager InputManager = new PlayerInputManager();
+        internal IHasReplayHandler ReplayInputManager => (IHasReplayHandler)KeyBindingInputManager;
 
         /// <summary>
         /// The key conversion input manager for this RulesetContainer.
@@ -58,7 +57,7 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// Whether we have a replay loaded currently.
         /// </summary>
-        public bool HasReplayLoaded => InputManager.ReplayInputHandler != null;
+        public bool HasReplayLoaded => ReplayInputManager.ReplayInputHandler != null;
 
         public abstract IEnumerable<HitObject> Objects { get; }
 
@@ -76,11 +75,7 @@ namespace osu.Game.Rulesets.UI
         internal RulesetContainer(Ruleset ruleset)
         {
             Ruleset = ruleset;
-        }
 
-        [BackgroundDependencyLoader]
-        private void load()
-        {
             KeyBindingInputManager = CreateInputManager();
             KeyBindingInputManager.RelativeSizeAxes = Axes.Both;
         }
@@ -113,7 +108,7 @@ namespace osu.Game.Rulesets.UI
         public virtual void SetReplay(Replay replay)
         {
             Replay = replay;
-            InputManager.ReplayInputHandler = replay != null ? CreateReplayInputHandler(replay) : null;
+            ReplayInputManager.ReplayInputHandler = replay != null ? CreateReplayInputHandler(replay) : null;
         }
     }
 
@@ -267,13 +262,12 @@ namespace osu.Game.Rulesets.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            InputManager.Add(content = new Container
+            KeyBindingInputManager.Add(content = new Container
             {
                 RelativeSizeAxes = Axes.Both,
-                Children = new[] { KeyBindingInputManager }
             });
 
-            AddInternal(InputManager);
+            AddInternal(KeyBindingInputManager);
             KeyBindingInputManager.Add(Playfield = CreatePlayfield());
 
             loadObjects();
@@ -283,8 +277,8 @@ namespace osu.Game.Rulesets.UI
         {
             base.SetReplay(replay);
 
-            if (InputManager?.ReplayInputHandler != null)
-                InputManager.ReplayInputHandler.ToScreenSpace = Playfield.ScaledContent.ToScreenSpace;
+            if (ReplayInputManager?.ReplayInputHandler != null)
+                ReplayInputManager.ReplayInputHandler.ToScreenSpace = input => Playfield.ScaledContent.ToScreenSpace(input);
         }
 
         /// <summary>
diff --git a/osu.Game/Rulesets/UI/RulesetInputManager.cs b/osu.Game/Rulesets/UI/RulesetInputManager.cs
index 6d22b2e91e..bd7e51e937 100644
--- a/osu.Game/Rulesets/UI/RulesetInputManager.cs
+++ b/osu.Game/Rulesets/UI/RulesetInputManager.cs
@@ -1,20 +1,176 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Timing;
+using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
+using osu.Game.Input.Handlers;
 using osu.Game.Screens.Play;
+using OpenTK.Input;
 
 namespace osu.Game.Rulesets.UI
 {
-    public abstract class RulesetInputManager<T> : DatabasedKeyBindingInputManager<T>, ICanAttachKeyCounter
+    public abstract class RulesetInputManager<T> : DatabasedKeyBindingInputManager<T>, ICanAttachKeyCounter, IHasReplayHandler
         where T : struct
     {
         protected RulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique) : base(ruleset, variant, unique)
         {
         }
 
+        private List<T> lastPressedActions = new List<T>();
+
+        protected override void HandleNewState(InputState state)
+        {
+            base.HandleNewState(state);
+
+            var replayState = state as ReplayInputHandler.ReplayState<T>;
+
+            if (replayState == null) return;
+
+            // Here we handle states specifically coming from a replay source.
+            // These have extra action information rather than keyboard keys or mouse buttons.
+
+            List<T> newActions = replayState.PressedActions;
+
+            foreach (var released in lastPressedActions.Except(newActions))
+                PropagateReleased(KeyBindingInputQueue, released);
+
+            foreach (var pressed in newActions.Except(lastPressedActions))
+                PropagatePressed(KeyBindingInputQueue, pressed);
+
+            lastPressedActions = newActions;
+        }
+
+        private ManualClock clock;
+        private IFrameBasedClock parentClock;
+
+        private ReplayInputHandler replayInputHandler;
+        public ReplayInputHandler ReplayInputHandler
+        {
+            get
+            {
+                return replayInputHandler;
+            }
+            set
+            {
+                if (replayInputHandler != null) RemoveHandler(replayInputHandler);
+
+                replayInputHandler = value;
+                UseParentState = replayInputHandler == null;
+
+                if (replayInputHandler != null)
+                    AddHandler(replayInputHandler);
+            }
+        }
+
+        private Bindable<bool> mouseDisabled;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            //our clock will now be our parent's clock, but we want to replace this to allow manual control.
+            parentClock = Clock;
+
+            Clock = new FramedClock(clock = new ManualClock
+            {
+                CurrentTime = parentClock.CurrentTime,
+                Rate = parentClock.Rate,
+            });
+        }
+
+        /// <summary>
+        /// Whether we running up-to-date with our parent clock.
+        /// If not, we will need to keep processing children until we catch up.
+        /// </summary>
+        private bool requireMoreUpdateLoops;
+
+        /// <summary>
+        /// Whether we in a valid state (ie. should we keep processing children frames).
+        /// This should be set to false when the replay is, for instance, waiting for future frames to arrive.
+        /// </summary>
+        private bool validState;
+
+        protected override bool RequiresChildrenUpdate => base.RequiresChildrenUpdate && validState;
+
+        private bool isAttached => replayInputHandler != null && !UseParentState;
+
+        private const int max_catch_up_updates_per_frame = 50;
+
+        public override bool UpdateSubTree()
+        {
+            requireMoreUpdateLoops = true;
+            validState = true;
+
+            int loops = 0;
+
+            while (validState && requireMoreUpdateLoops && loops++ < max_catch_up_updates_per_frame)
+                if (!base.UpdateSubTree())
+                    return false;
+
+            return true;
+        }
+
+        protected override void Update()
+        {
+            if (parentClock == null) return;
+
+            clock.Rate = parentClock.Rate;
+            clock.IsRunning = parentClock.IsRunning;
+
+            if (!isAttached)
+            {
+                clock.CurrentTime = parentClock.CurrentTime;
+            }
+            else
+            {
+                double? newTime = replayInputHandler.SetFrameFromTime(parentClock.CurrentTime);
+
+                if (newTime == null)
+                {
+                    // we shouldn't execute for this time value. probably waiting on more replay data.
+                    validState = false;
+                    return;
+                }
+
+                clock.CurrentTime = newTime.Value;
+            }
+
+            requireMoreUpdateLoops = clock.CurrentTime != parentClock.CurrentTime;
+            base.Update();
+        }
+
+        protected override void TransformState(InputState state)
+        {
+            base.TransformState(state);
+
+            // we don't want to transform the state if a replay is present (for now, at least).
+            if (replayInputHandler != null) return;
+
+            var mouse = state.Mouse as Framework.Input.MouseState;
+
+            if (mouse != null)
+            {
+                if (mouseDisabled.Value)
+                {
+                    mouse.SetPressed(MouseButton.Left, false);
+                    mouse.SetPressed(MouseButton.Right, false);
+                }
+            }
+        }
+
         public void Attach(KeyCounterCollection keyCounter)
         {
             var receptor = new ActionReceptor(keyCounter);
@@ -37,6 +193,11 @@ namespace osu.Game.Rulesets.UI
         }
     }
 
+    public interface IHasReplayHandler
+    {
+        ReplayInputHandler ReplayInputHandler { get; set; }
+    }
+
     public interface ICanAttachKeyCounter
     {
         void Attach(KeyCounterCollection keyCounter);
diff --git a/osu.Game/Screens/Play/PlayerInputManager.cs b/osu.Game/Screens/Play/PlayerInputManager.cs
deleted file mode 100644
index f5e57f9e9d..0000000000
--- a/osu.Game/Screens/Play/PlayerInputManager.cs
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using OpenTK.Input;
-using osu.Framework.Allocation;
-using osu.Framework.Configuration;
-using osu.Framework.Input;
-using osu.Framework.Timing;
-using osu.Game.Configuration;
-using osu.Game.Input.Handlers;
-
-namespace osu.Game.Screens.Play
-{
-    public class PlayerInputManager : PassThroughInputManager
-    {
-        private ManualClock clock;
-        private IFrameBasedClock parentClock;
-
-        private ReplayInputHandler replayInputHandler;
-        public ReplayInputHandler ReplayInputHandler
-        {
-            get
-            {
-                return replayInputHandler;
-            }
-            set
-            {
-                if (replayInputHandler != null) RemoveHandler(replayInputHandler);
-
-                replayInputHandler = value;
-                UseParentState = replayInputHandler == null;
-
-                if (replayInputHandler != null)
-                    AddHandler(replayInputHandler);
-            }
-        }
-
-        private Bindable<bool> mouseDisabled;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            //our clock will now be our parent's clock, but we want to replace this to allow manual control.
-            parentClock = Clock;
-
-            Clock = new FramedClock(clock = new ManualClock
-            {
-                CurrentTime = parentClock.CurrentTime,
-                Rate = parentClock.Rate,
-            });
-        }
-
-        /// <summary>
-        /// Whether we running up-to-date with our parent clock.
-        /// If not, we will need to keep processing children until we catch up.
-        /// </summary>
-        private bool requireMoreUpdateLoops;
-
-        /// <summary>
-        /// Whether we in a valid state (ie. should we keep processing children frames).
-        /// This should be set to false when the replay is, for instance, waiting for future frames to arrive.
-        /// </summary>
-        private bool validState;
-
-        protected override bool RequiresChildrenUpdate => base.RequiresChildrenUpdate && validState;
-
-        private bool isAttached => replayInputHandler != null && !UseParentState;
-
-        private const int max_catch_up_updates_per_frame = 50;
-
-        public override bool UpdateSubTree()
-        {
-            requireMoreUpdateLoops = true;
-            validState = true;
-
-            int loops = 0;
-
-            while (validState && requireMoreUpdateLoops && loops++ < max_catch_up_updates_per_frame)
-                if (!base.UpdateSubTree())
-                    return false;
-
-            return true;
-        }
-
-        protected override void Update()
-        {
-            if (parentClock == null) return;
-
-            clock.Rate = parentClock.Rate;
-            clock.IsRunning = parentClock.IsRunning;
-
-            if (!isAttached)
-            {
-                clock.CurrentTime = parentClock.CurrentTime;
-            }
-            else
-            {
-                double? newTime = replayInputHandler.SetFrameFromTime(parentClock.CurrentTime);
-
-                if (newTime == null)
-                {
-                    // we shouldn't execute for this time value. probably waiting on more replay data.
-                    validState = false;
-                    return;
-                }
-
-                clock.CurrentTime = newTime.Value;
-            }
-
-            requireMoreUpdateLoops = clock.CurrentTime != parentClock.CurrentTime;
-            base.Update();
-        }
-
-        protected override void TransformState(InputState state)
-        {
-            base.TransformState(state);
-
-            // we don't want to transform the state if a replay is present (for now, at least).
-            if (replayInputHandler != null) return;
-
-            var mouse = state.Mouse as Framework.Input.MouseState;
-
-            if (mouse != null)
-            {
-                if (mouseDisabled.Value)
-                {
-                    mouse.SetPressed(MouseButton.Left, false);
-                    mouse.SetPressed(MouseButton.Right, false);
-                }
-            }
-        }
-    }
-}
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index 32a8df6357..4e9e769cb7 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -321,7 +321,6 @@
     <Compile Include="Screens\Multiplayer\MatchCreate.cs" />
     <Compile Include="Screens\Play\FailOverlay.cs" />
     <Compile Include="Screens\Play\MenuOverlay.cs" />
-    <Compile Include="Screens\Play\PlayerInputManager.cs" />
     <Compile Include="Screens\Play\PlayerLoader.cs" />
     <Compile Include="Screens\Play\ReplayPlayer.cs" />
     <Compile Include="Screens\Play\SkipButton.cs" />

From a7a7e0323f8ff199d10b3ccb11d6c3c9539348b8 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 24 Aug 2017 15:36:42 +0900
Subject: [PATCH 2/8] Update autoplay and replay handling to result in actions,
 not keys

---
 .../Replays/OsuReplayInputHandler.cs          | 32 +++++++++++++++++++
 .../UI/OsuRulesetContainer.cs                 |  4 +++
 .../osu.Game.Rulesets.Osu.csproj              |  1 +
 .../Replays/TaikoFramedReplayInputHandler.cs  | 16 ++++------
 osu.Game/Input/Handlers/ReplayInputHandler.cs | 15 +++++++++
 .../Replays/FramedReplayInputHandler.cs       | 28 +++-------------
 osu.Game/Rulesets/UI/RulesetContainer.cs      |  2 +-
 7 files changed, 64 insertions(+), 34 deletions(-)
 create mode 100644 osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs

diff --git a/osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs b/osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs
new file mode 100644
index 0000000000..a54679b8cc
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs
@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using osu.Framework.Input;
+using osu.Game.Rulesets.Replays;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Replays
+{
+    public class OsuReplayInputHandler : FramedReplayInputHandler
+    {
+        public OsuReplayInputHandler(Replay replay)
+            : base(replay)
+        {
+        }
+
+        public override List<InputState> GetPendingStates()
+        {
+            List<OsuAction> actions = new List<OsuAction>();
+
+            if (CurrentFrame?.MouseLeft ?? false) actions.Add(OsuAction.LeftButton);
+            if (CurrentFrame?.MouseRight ?? false) actions.Add(OsuAction.RightButton);
+
+            return new List<InputState>
+            {
+                new ReplayState<OsuAction>
+                {
+                    Mouse = new ReplayMouseState(ToScreenSpace(Position ?? Vector2.Zero)),
+                    PressedActions = actions
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/OsuRulesetContainer.cs b/osu.Game.Rulesets.Osu/UI/OsuRulesetContainer.cs
index 083f11945c..0b87bf7346 100644
--- a/osu.Game.Rulesets.Osu/UI/OsuRulesetContainer.cs
+++ b/osu.Game.Rulesets.Osu/UI/OsuRulesetContainer.cs
@@ -10,9 +10,11 @@ using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
@@ -49,6 +51,8 @@ namespace osu.Game.Rulesets.Osu.UI
             return null;
         }
 
+        protected override FramedReplayInputHandler CreateReplayInputHandler(Replay replay) => new OsuReplayInputHandler(replay);
+
         protected override Vector2 GetPlayfieldAspectAdjust() => new Vector2(0.75f);
     }
 }
diff --git a/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj b/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
index 1422ded407..0c9e53cf69 100644
--- a/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
+++ b/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
@@ -78,6 +78,7 @@
     <Compile Include="OsuDifficulty\Skills\Speed.cs" />
     <Compile Include="OsuDifficulty\Utils\History.cs" />
     <Compile Include="OsuInputManager.cs" />
+    <Compile Include="Replays\OsuReplayInputHandler.cs" />
     <Compile Include="UI\Cursor\CursorTrail.cs" />
     <Compile Include="UI\Cursor\GameplayCursor.cs" />
     <Compile Include="UI\OsuSettings.cs" />
diff --git a/osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs b/osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs
index f6425dd66f..89093ae05e 100644
--- a/osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs
+++ b/osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs
@@ -4,7 +4,6 @@
 using osu.Game.Rulesets.Replays;
 using System.Collections.Generic;
 using osu.Framework.Input;
-using OpenTK.Input;
 
 namespace osu.Game.Rulesets.Taiko.Replays
 {
@@ -17,21 +16,18 @@ namespace osu.Game.Rulesets.Taiko.Replays
 
         public override List<InputState> GetPendingStates()
         {
-            var keys = new List<Key>();
+            var keys = new List<TaikoAction>();
 
             if (CurrentFrame?.MouseRight1 == true)
-                keys.Add(Key.F);
+                keys.Add(TaikoAction.LeftCentre);
             if (CurrentFrame?.MouseRight2 == true)
-                keys.Add(Key.J);
+                keys.Add(TaikoAction.RightCentre);
             if (CurrentFrame?.MouseLeft1 == true)
-                keys.Add(Key.D);
+                keys.Add(TaikoAction.LeftRim);
             if (CurrentFrame?.MouseLeft2 == true)
-                keys.Add(Key.K);
+                keys.Add(TaikoAction.RightRim);
 
-            return new List<InputState>
-            {
-                new InputState { Keyboard = new ReplayKeyboardState(keys) }
-            };
+            return new List<InputState> { new ReplayState<TaikoAction> { PressedActions = keys } };
         }
     }
 }
diff --git a/osu.Game/Input/Handlers/ReplayInputHandler.cs b/osu.Game/Input/Handlers/ReplayInputHandler.cs
index 76e038048c..5f86495580 100644
--- a/osu.Game/Input/Handlers/ReplayInputHandler.cs
+++ b/osu.Game/Input/Handlers/ReplayInputHandler.cs
@@ -2,6 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
+using osu.Framework.Input;
 using osu.Framework.Input.Handlers;
 using osu.Framework.Platform;
 using OpenTK;
@@ -29,5 +31,18 @@ namespace osu.Game.Input.Handlers
         public override bool IsActive => true;
 
         public override int Priority => 0;
+
+        public class ReplayState<T> : InputState
+            where T : struct
+        {
+            public List<T> PressedActions;
+
+            public override InputState Clone()
+            {
+                var clone = (ReplayState<T>)base.Clone();
+                clone.PressedActions = new List<T>(PressedActions);
+                return clone;
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/osu.Game/Rulesets/Replays/FramedReplayInputHandler.cs b/osu.Game/Rulesets/Replays/FramedReplayInputHandler.cs
index 60da35fd91..f0d68c0467 100644
--- a/osu.Game/Rulesets/Replays/FramedReplayInputHandler.cs
+++ b/osu.Game/Rulesets/Replays/FramedReplayInputHandler.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Input;
 using osu.Framework.MathUtils;
 using osu.Game.Input.Handlers;
@@ -18,7 +17,7 @@ namespace osu.Game.Rulesets.Replays
     /// The ReplayHandler will take a replay and handle the propagation of updates to the input stack.
     /// It handles logic of any frames which *must* be executed.
     /// </summary>
-    public class FramedReplayInputHandler : ReplayInputHandler
+    public abstract class FramedReplayInputHandler : ReplayInputHandler
     {
         private readonly Replay replay;
 
@@ -31,7 +30,7 @@ namespace osu.Game.Rulesets.Replays
 
         private int nextFrameIndex => MathHelper.Clamp(currentFrameIndex + (currentDirection > 0 ? 1 : -1), 0, Frames.Count - 1);
 
-        public FramedReplayInputHandler(Replay replay)
+        protected FramedReplayInputHandler(Replay replay)
         {
             this.replay = replay;
         }
@@ -51,7 +50,7 @@ namespace osu.Game.Rulesets.Replays
         {
         }
 
-        private Vector2? position
+        protected Vector2? Position
         {
             get
             {
@@ -62,23 +61,7 @@ namespace osu.Game.Rulesets.Replays
             }
         }
 
-        public override List<InputState> GetPendingStates()
-        {
-            var buttons = new HashSet<MouseButton>();
-            if (CurrentFrame?.MouseLeft ?? false)
-                buttons.Add(MouseButton.Left);
-            if (CurrentFrame?.MouseRight ?? false)
-                buttons.Add(MouseButton.Right);
-
-            return new List<InputState>
-            {
-                new InputState
-                {
-                    Mouse = new ReplayMouseState(ToScreenSpace(position ?? Vector2.Zero), buttons),
-                    Keyboard = new ReplayKeyboardState(new List<Key>())
-                }
-            };
-        }
+        public override List<InputState> GetPendingStates() => new List<InputState>();
 
         public bool AtLastFrame => currentFrameIndex == Frames.Count - 1;
         public bool AtFirstFrame => currentFrameIndex == 0;
@@ -133,10 +116,9 @@ namespace osu.Game.Rulesets.Replays
 
         protected class ReplayMouseState : MouseState
         {
-            public ReplayMouseState(Vector2 position, IEnumerable<MouseButton> list)
+            public ReplayMouseState(Vector2 position)
             {
                 Position = position;
-                list.ForEach(b => SetPressed(b, true));
             }
         }
 
diff --git a/osu.Game/Rulesets/UI/RulesetContainer.cs b/osu.Game/Rulesets/UI/RulesetContainer.cs
index 0a16335c77..17417856a1 100644
--- a/osu.Game/Rulesets/UI/RulesetContainer.cs
+++ b/osu.Game/Rulesets/UI/RulesetContainer.cs
@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.UI
         /// <returns>The input manager.</returns>
         public abstract PassThroughInputManager CreateInputManager();
 
-        protected virtual FramedReplayInputHandler CreateReplayInputHandler(Replay replay) => new FramedReplayInputHandler(replay);
+        protected virtual FramedReplayInputHandler CreateReplayInputHandler(Replay replay) => null;
 
         public Replay Replay { get; private set; }
 

From f0635af40deeae8f3c44bcd328a9a39a6c9c7583 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 24 Aug 2017 15:48:40 +0900
Subject: [PATCH 3/8] Add documentation and regions to RulesetInputManager

---
 osu.Game/Rulesets/UI/RulesetInputManager.cs | 43 +++++++++++++++++----
 1 file changed, 35 insertions(+), 8 deletions(-)

diff --git a/osu.Game/Rulesets/UI/RulesetInputManager.cs b/osu.Game/Rulesets/UI/RulesetInputManager.cs
index bd7e51e937..75e273adea 100644
--- a/osu.Game/Rulesets/UI/RulesetInputManager.cs
+++ b/osu.Game/Rulesets/UI/RulesetInputManager.cs
@@ -23,6 +23,8 @@ namespace osu.Game.Rulesets.UI
         {
         }
 
+        #region Action mapping (for replays)
+
         private List<T> lastPressedActions = new List<T>();
 
         protected override void HandleNewState(InputState state)
@@ -47,8 +49,9 @@ namespace osu.Game.Rulesets.UI
             lastPressedActions = newActions;
         }
 
-        private ManualClock clock;
-        private IFrameBasedClock parentClock;
+        #endregion
+
+        #region IHasReplayHandler
 
         private ReplayInputHandler replayInputHandler;
         public ReplayInputHandler ReplayInputHandler
@@ -69,13 +72,12 @@ namespace osu.Game.Rulesets.UI
             }
         }
 
-        private Bindable<bool> mouseDisabled;
+        #endregion
 
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
-        }
+        #region Clock control
+
+        private ManualClock clock;
+        private IFrameBasedClock parentClock;
 
         protected override void LoadComplete()
         {
@@ -152,6 +154,18 @@ namespace osu.Game.Rulesets.UI
             base.Update();
         }
 
+        #endregion
+
+        #region Setting application (disables etc.)
+
+        private Bindable<bool> mouseDisabled;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
+        }
+
         protected override void TransformState(InputState state)
         {
             base.TransformState(state);
@@ -171,6 +185,10 @@ namespace osu.Game.Rulesets.UI
             }
         }
 
+        #endregion
+
+        #region Key Counter Attachment
+
         public void Attach(KeyCounterCollection keyCounter)
         {
             var receptor = new ActionReceptor(keyCounter);
@@ -191,13 +209,22 @@ namespace osu.Game.Rulesets.UI
 
             public bool OnReleased(T action) => Target.Children.OfType<KeyCounterAction<T>>().Any(c => c.OnReleased(action));
         }
+
+        #endregion
     }
 
+    /// <summary>
+    /// Expose the <see cref="ReplayInputHandler"/>  in a capable <see cref="InputManager"/>.
+    /// </summary>
     public interface IHasReplayHandler
     {
         ReplayInputHandler ReplayInputHandler { get; set; }
     }
 
+    /// <summary>
+    /// Supports attaching a <see cref="KeyCounterCollection"/>.
+    /// Keys will be populated automatically and a receptor will be injected inside.
+    /// </summary>
     public interface ICanAttachKeyCounter
     {
         void Attach(KeyCounterCollection keyCounter);

From dac54c362a4050107ac11135ecf1445aff8af809 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 24 Aug 2017 15:39:35 +0900
Subject: [PATCH 4/8] Update framework

---
 osu-framework | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu-framework b/osu-framework
index 1ba1e8ef1e..da5fbf8c58 160000
--- a/osu-framework
+++ b/osu-framework
@@ -1 +1 @@
-Subproject commit 1ba1e8ef1e5ec0466632be02492023a081cb85ab
+Subproject commit da5fbf8c580b079671298f6da54be10a00bf434c

From a7e6efd34fc83ceb33cf7c8a31200d3d709e1dad Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 24 Aug 2017 20:30:18 +0900
Subject: [PATCH 5/8] Rename keys -> actions

---
 .../Replays/TaikoFramedReplayInputHandler.cs         | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs b/osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs
index 89093ae05e..fce0179721 100644
--- a/osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs
+++ b/osu.Game.Rulesets.Taiko/Replays/TaikoFramedReplayInputHandler.cs
@@ -16,18 +16,18 @@ namespace osu.Game.Rulesets.Taiko.Replays
 
         public override List<InputState> GetPendingStates()
         {
-            var keys = new List<TaikoAction>();
+            var actions = new List<TaikoAction>();
 
             if (CurrentFrame?.MouseRight1 == true)
-                keys.Add(TaikoAction.LeftCentre);
+                actions.Add(TaikoAction.LeftCentre);
             if (CurrentFrame?.MouseRight2 == true)
-                keys.Add(TaikoAction.RightCentre);
+                actions.Add(TaikoAction.RightCentre);
             if (CurrentFrame?.MouseLeft1 == true)
-                keys.Add(TaikoAction.LeftRim);
+                actions.Add(TaikoAction.LeftRim);
             if (CurrentFrame?.MouseLeft2 == true)
-                keys.Add(TaikoAction.RightRim);
+                actions.Add(TaikoAction.RightRim);
 
-            return new List<InputState> { new ReplayState<TaikoAction> { PressedActions = keys } };
+            return new List<InputState> { new ReplayState<TaikoAction> { PressedActions = actions } };
         }
     }
 }

From c9f90efb8ac418d52949628a0018f31bf605b0a1 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 24 Aug 2017 20:31:57 +0900
Subject: [PATCH 6/8] Add more checks and remove direct cast

---
 osu.Game/Rulesets/UI/RulesetContainer.cs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/osu.Game/Rulesets/UI/RulesetContainer.cs b/osu.Game/Rulesets/UI/RulesetContainer.cs
index 17417856a1..a7472f4dbc 100644
--- a/osu.Game/Rulesets/UI/RulesetContainer.cs
+++ b/osu.Game/Rulesets/UI/RulesetContainer.cs
@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// The input manager for this RulesetContainer.
         /// </summary>
-        internal IHasReplayHandler ReplayInputManager => (IHasReplayHandler)KeyBindingInputManager;
+        internal IHasReplayHandler ReplayInputManager => KeyBindingInputManager as IHasReplayHandler;
 
         /// <summary>
         /// The key conversion input manager for this RulesetContainer.
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// Whether we have a replay loaded currently.
         /// </summary>
-        public bool HasReplayLoaded => ReplayInputManager.ReplayInputHandler != null;
+        public bool HasReplayLoaded => ReplayInputManager?.ReplayInputHandler != null;
 
         public abstract IEnumerable<HitObject> Objects { get; }
 
@@ -107,6 +107,9 @@ namespace osu.Game.Rulesets.UI
         /// <param name="replay">The replay, null for local input.</param>
         public virtual void SetReplay(Replay replay)
         {
+            if (ReplayInputManager == null)
+                throw new InvalidOperationException($"A {nameof(KeyBindingInputManager)} which supports replay loading is not available");
+
             Replay = replay;
             ReplayInputManager.ReplayInputHandler = replay != null ? CreateReplayInputHandler(replay) : null;
         }

From 2b667cf789a57ac5c73a5c274dbceef2ba544086 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 24 Aug 2017 20:32:55 +0900
Subject: [PATCH 7/8] Fix typos

---
 osu.Game/Rulesets/UI/RulesetInputManager.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/osu.Game/Rulesets/UI/RulesetInputManager.cs b/osu.Game/Rulesets/UI/RulesetInputManager.cs
index 75e273adea..0419070b42 100644
--- a/osu.Game/Rulesets/UI/RulesetInputManager.cs
+++ b/osu.Game/Rulesets/UI/RulesetInputManager.cs
@@ -94,13 +94,13 @@ namespace osu.Game.Rulesets.UI
         }
 
         /// <summary>
-        /// Whether we running up-to-date with our parent clock.
+        /// Whether we are running up-to-date with our parent clock.
         /// If not, we will need to keep processing children until we catch up.
         /// </summary>
         private bool requireMoreUpdateLoops;
 
         /// <summary>
-        /// Whether we in a valid state (ie. should we keep processing children frames).
+        /// Whether we are in a valid state (ie. should we keep processing children frames).
         /// This should be set to false when the replay is, for instance, waiting for future frames to arrive.
         /// </summary>
         private bool validState;
@@ -229,4 +229,4 @@ namespace osu.Game.Rulesets.UI
     {
         void Attach(KeyCounterCollection keyCounter);
     }
-}
\ No newline at end of file
+}

From 1b0a1dd4108285dbec840ad8cf9a9ef1b014d066 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Thu, 24 Aug 2017 20:37:03 +0900
Subject: [PATCH 8/8] Add missing licence header

---
 osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs b/osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs
index a54679b8cc..0811a68392 100644
--- a/osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs
+++ b/osu.Game.Rulesets.Osu/Replays/OsuReplayInputHandler.cs
@@ -1,4 +1,7 @@
-using System.Collections.Generic;
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
 using osu.Framework.Input;
 using osu.Game.Rulesets.Replays;
 using OpenTK;