2018-01-05 11:21:19 +00:00
|
|
|
// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
|
2017-08-21 03:31:21 +00:00
|
|
|
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
|
|
|
|
|
2017-08-24 06:23:17 +00:00
|
|
|
using System.Collections.Generic;
|
2017-08-21 03:31:21 +00:00
|
|
|
using System.Linq;
|
2017-08-24 06:23:17 +00:00
|
|
|
using osu.Framework.Allocation;
|
|
|
|
using osu.Framework.Configuration;
|
2017-12-06 14:03:31 +00:00
|
|
|
using osu.Framework.Graphics;
|
|
|
|
using osu.Framework.Graphics.Containers;
|
2017-08-24 06:23:17 +00:00
|
|
|
using osu.Framework.Input;
|
2017-08-21 03:31:21 +00:00
|
|
|
using osu.Framework.Input.Bindings;
|
2017-08-24 06:23:17 +00:00
|
|
|
using osu.Framework.Timing;
|
|
|
|
using osu.Game.Configuration;
|
2017-08-21 03:31:21 +00:00
|
|
|
using osu.Game.Input.Bindings;
|
2017-08-24 06:23:17 +00:00
|
|
|
using osu.Game.Input.Handlers;
|
2017-08-21 03:31:21 +00:00
|
|
|
using osu.Game.Screens.Play;
|
2017-08-24 06:23:17 +00:00
|
|
|
using OpenTK.Input;
|
2017-08-21 03:31:21 +00:00
|
|
|
|
|
|
|
namespace osu.Game.Rulesets.UI
|
|
|
|
{
|
2017-12-06 14:03:31 +00:00
|
|
|
public abstract class RulesetInputManager<T> : PassThroughInputManager, ICanAttachKeyCounter, IHasReplayHandler
|
2017-08-21 03:31:21 +00:00
|
|
|
where T : struct
|
|
|
|
{
|
2018-01-30 05:49:12 +00:00
|
|
|
public class RulesetKeyBindingContainer : DatabasedKeyBindingContainer<T>
|
2017-08-21 03:31:21 +00:00
|
|
|
{
|
2017-12-06 14:03:31 +00:00
|
|
|
public RulesetKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
|
|
|
|
: base(ruleset, variant, unique)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2017-08-21 03:31:21 +00:00
|
|
|
}
|
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
#region Action mapping (for replays)
|
|
|
|
|
2017-08-24 06:23:17 +00:00
|
|
|
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))
|
2017-12-06 14:03:31 +00:00
|
|
|
KeyBindingContainer.TriggerReleased(released);
|
2017-08-24 06:23:17 +00:00
|
|
|
|
|
|
|
foreach (var pressed in newActions.Except(lastPressedActions))
|
2017-12-06 14:03:31 +00:00
|
|
|
KeyBindingContainer.TriggerPressed(pressed);
|
2017-08-24 06:23:17 +00:00
|
|
|
|
|
|
|
lastPressedActions = newActions;
|
|
|
|
}
|
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
#endregion
|
|
|
|
|
|
|
|
#region IHasReplayHandler
|
2017-08-24 06:23:17 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
#endregion
|
2017-08-24 06:23:17 +00:00
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
#region Clock control
|
|
|
|
|
2017-11-13 10:02:53 +00:00
|
|
|
protected override bool ShouldProcessClock => false; // We handle processing the clock ourselves
|
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
private ManualClock clock;
|
|
|
|
private IFrameBasedClock parentClock;
|
2017-08-24 06:23:17 +00:00
|
|
|
|
|
|
|
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>
|
2017-08-24 11:32:55 +00:00
|
|
|
/// Whether we are running up-to-date with our parent clock.
|
2017-08-24 06:23:17 +00:00
|
|
|
/// If not, we will need to keep processing children until we catch up.
|
|
|
|
/// </summary>
|
|
|
|
private bool requireMoreUpdateLoops;
|
|
|
|
|
|
|
|
/// <summary>
|
2017-08-24 11:32:55 +00:00
|
|
|
/// Whether we are in a valid state (ie. should we keep processing children frames).
|
2017-08-24 06:23:17 +00:00
|
|
|
/// 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)
|
2018-01-25 08:39:10 +00:00
|
|
|
{
|
2017-08-24 06:23:17 +00:00
|
|
|
if (!base.UpdateSubTree())
|
|
|
|
return false;
|
|
|
|
|
2018-01-25 08:39:10 +00:00
|
|
|
if (isAttached)
|
|
|
|
{
|
|
|
|
// When handling replay input, we need to consider the possibility of fast-forwarding, which may cause the clock to be updated
|
|
|
|
// to a point very far into the future, then playing a frame at that time. In such a case, lifetime MUST be updated before
|
|
|
|
// input is handled. This is why base.Update is not called from the derived Update when handling replay input, and is instead
|
|
|
|
// called manually at the correct time here.
|
|
|
|
base.Update();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-24 06:23:17 +00:00
|
|
|
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;
|
2017-11-13 10:02:53 +00:00
|
|
|
|
|
|
|
// The manual clock time has changed in the above code. The framed clock now needs to be updated
|
|
|
|
// to ensure that the its time is valid for our children before input is processed
|
|
|
|
Clock.ProcessFrame();
|
|
|
|
|
2018-01-25 08:39:10 +00:00
|
|
|
if (!isAttached)
|
|
|
|
{
|
|
|
|
// For non-replay input handling, this provides equivalent input ordering as if Update was not overridden
|
|
|
|
base.Update();
|
|
|
|
}
|
2017-08-24 06:23:17 +00:00
|
|
|
}
|
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
#endregion
|
|
|
|
|
|
|
|
#region Setting application (disables etc.)
|
|
|
|
|
|
|
|
private Bindable<bool> mouseDisabled;
|
|
|
|
|
|
|
|
[BackgroundDependencyLoader]
|
|
|
|
private void load(OsuConfigManager config)
|
|
|
|
{
|
|
|
|
mouseDisabled = config.GetBindable<bool>(OsuSetting.MouseDisableButtons);
|
|
|
|
}
|
|
|
|
|
2017-08-24 06:23:17 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
#endregion
|
|
|
|
|
|
|
|
#region Key Counter Attachment
|
|
|
|
|
2017-08-21 03:31:21 +00:00
|
|
|
public void Attach(KeyCounterCollection keyCounter)
|
|
|
|
{
|
|
|
|
var receptor = new ActionReceptor(keyCounter);
|
|
|
|
Add(receptor);
|
|
|
|
keyCounter.SetReceptor(receptor);
|
|
|
|
|
2017-12-06 14:03:31 +00:00
|
|
|
keyCounter.AddRange(KeyBindingContainer.DefaultKeyBindings.Select(b => b.GetAction<T>()).Distinct().Select(b => new KeyCounterAction<T>(b)));
|
2017-08-21 03:31:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public class ActionReceptor : KeyCounterCollection.Receptor, IKeyBindingHandler<T>
|
|
|
|
{
|
|
|
|
public ActionReceptor(KeyCounterCollection target)
|
|
|
|
: base(target)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
public bool OnPressed(T action) => Target.Children.OfType<KeyCounterAction<T>>().Any(c => c.OnPressed(action));
|
|
|
|
|
|
|
|
public bool OnReleased(T action) => Target.Children.OfType<KeyCounterAction<T>>().Any(c => c.OnReleased(action));
|
|
|
|
}
|
2017-08-24 06:48:40 +00:00
|
|
|
|
|
|
|
#endregion
|
2017-08-21 03:31:21 +00:00
|
|
|
}
|
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Expose the <see cref="ReplayInputHandler"/> in a capable <see cref="InputManager"/>.
|
|
|
|
/// </summary>
|
2017-08-24 06:23:17 +00:00
|
|
|
public interface IHasReplayHandler
|
|
|
|
{
|
|
|
|
ReplayInputHandler ReplayInputHandler { get; set; }
|
|
|
|
}
|
|
|
|
|
2017-08-24 06:48:40 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Supports attaching a <see cref="KeyCounterCollection"/>.
|
|
|
|
/// Keys will be populated automatically and a receptor will be injected inside.
|
|
|
|
/// </summary>
|
2017-08-21 03:31:21 +00:00
|
|
|
public interface ICanAttachKeyCounter
|
|
|
|
{
|
|
|
|
void Attach(KeyCounterCollection keyCounter);
|
|
|
|
}
|
2017-08-24 11:32:55 +00:00
|
|
|
}
|