Input Handling System

OS Input Events
    ↓
OsuUserInputManager
    ↓
GlobalActionContainer (Global key bindings)
    ↓
Screen-specific InputManager
    ↓
Ruleset InputManager (Game mode key bindings)
    ↓
Playfield / Hit Objects

public partial class OsuUserInputManager : UserInputManager
{
    // Disable right-click context menu during gameplay
    protected override bool AllowRightClickFromLongTouch 
        => PlayingState.Value != LocalUserPlayingState.Playing;
    
    // Track playing state
    public readonly IBindable<LocalUserPlayingState> PlayingState = new Bindable<LocalUserPlayingState>();
    
    protected override MouseButtonEventManager CreateButtonEventManagerFor(MouseButton button)
    {
        // Custom right-mouse behavior
        if (button == MouseButton.Right)
            return new RightMouseManager(button);
        
        return base.CreateButtonEventManagerFor(button);
    }
}

public partial class GlobalActionContainer : DatabasedKeyBindingContainer<GlobalAction>, 
    IHandleGlobalKeyboardInput, IKeyBindingHandler<GlobalAction>
{
    // Priority over screen-specific bindings
    protected override bool Prioritised => true;
    
    // All default bindings
    public override IEnumerable<IKeyBinding> DefaultKeyBindings => 
        globalKeyBindings
        .Concat(editorKeyBindings)
        .Concat(inGameKeyBindings)
        .Concat(replayKeyBindings)
        .Concat(songSelectKeyBindings)
        .Concat(audioControlKeyBindings)
        .Concat(overlayKeyBindings);
}

// General navigation
new KeyBinding(InputKey.Up, GlobalAction.SelectPrevious),
new KeyBinding(InputKey.Down, GlobalAction.SelectNext),
new KeyBinding(InputKey.Enter, GlobalAction.Select),
new KeyBinding(InputKey.Escape, GlobalAction.Back),

// Overlays
new KeyBinding(new[] { InputKey.Control, InputKey.O }, GlobalAction.ToggleSettings),
new KeyBinding(InputKey.F8, GlobalAction.ToggleChat),
new KeyBinding(InputKey.F6, GlobalAction.ToggleNowPlaying),

// In-game
new KeyBinding(InputKey.Space, GlobalAction.SkipCutscene),
new KeyBinding(InputKey.Tilde, GlobalAction.QuickRetry),
new KeyBinding(new[] { InputKey.Control, InputKey.R }, GlobalAction.QuickRetry),
new KeyBinding(InputKey.Tab, GlobalAction.ToggleInGameLeaderboard),

// Gameplay adjustments
new KeyBinding(InputKey.Plus, GlobalAction.IncreaseOffset),
new KeyBinding(InputKey.Minus, GlobalAction.DecreaseOffset),
new KeyBinding(InputKey.F3, GlobalAction.DecreaseScrollSpeed),
new KeyBinding(InputKey.F4, GlobalAction.IncreaseScrollSpeed),

// Replay control
new KeyBinding(InputKey.Space, GlobalAction.TogglePauseReplay),
new KeyBinding(InputKey.Left, GlobalAction.SeekReplayBackward),
new KeyBinding(InputKey.Right, GlobalAction.SeekReplayForward),

public class RealmKeyBindingStore
{
    private readonly RealmAccess realm;
    private readonly ReadableKeyCombinationProvider keyCombinationProvider;
    
    // Get human-readable binding string
    public LocalisableString GetBindingsStringFor(GlobalAction globalAction);
    
    // Get all key combinations for an action
    public IReadOnlyList<string> GetReadableKeyCombinationsFor(GlobalAction globalAction);
    
    // Register default bindings
    public void Register(KeyBindingContainer container, IEnumerable<RulesetInfo> rulesets);
    
    // Clear duplicate bindings
    public static int ClearDuplicateBindings(IEnumerable<IKeyBinding> keyBindings);
}

public void Register(KeyBindingContainer container, IEnumerable<RulesetInfo> rulesets)
{
    realm.Run(r =>
    {
        using (var transaction = r.BeginWrite())
        {
            // Get existing bindings
            var existingBindings = r.All<RealmKeyBinding>().ToList();
            
            // Insert defaults for global actions
            insertDefaults(r, existingBindings, container.DefaultKeyBindings);
            
            // Insert defaults for each ruleset
            foreach (var ruleset in rulesets)
            {
                var instance = ruleset.CreateInstance();
                foreach (int variant in instance.AvailableVariants)
                    insertDefaults(r, existingBindings, 
                        instance.GetDefaultKeyBindings(variant), 
                        ruleset.ShortName, variant);
            }
            
            transaction.Commit();
        }
    });
}

public class RealmKeyBinding : RealmObject, IKeyBinding
{
    // The action this binding triggers
    public int ActionInt { get; set; }
    
    // The key combination
    public KeyCombination KeyCombination { get; set; }
    
    // Ruleset-specific binding (null for global)
    public string RulesetName { get; set; }
    
    // Ruleset variant (e.g., mania key count)
    public int? Variant { get; set; }
}

public class OsuInputManager : RulesetInputManager<OsuAction>
{
    public OsuInputManager(RulesetInfo ruleset)
        : base(ruleset, 0, SimultaneousBindingMode.Unique)
    {
    }
}

public enum OsuAction
{
    [Description("Left mouse button")]
    LeftButton,
    
    [Description("Right mouse button")]
    RightButton,
    
    // Smoke effect
    Smoke,
}

// Default bindings
public override IEnumerable<IKeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
{
    new KeyBinding(InputKey.Z, OsuAction.LeftButton),
    new KeyBinding(InputKey.X, OsuAction.RightButton),
    new KeyBinding(InputKey.MouseLeft, OsuAction.LeftButton),
    new KeyBinding(InputKey.MouseRight, OsuAction.RightButton),
    new KeyBinding(InputKey.C, OsuAction.Smoke),
};

public class ManiaInputManager : RulesetInputManager<ManiaAction>
{
    public ManiaInputManager(RulesetInfo ruleset, int variant)
        : base(ruleset, variant, SimultaneousBindingMode.Unique)
    {
    }
}

public enum ManiaAction
{
    [Description("Key 1")]
    Key1,
    [Description("Key 2")]
    Key2,
    [Description("Key 3")]
    Key3,
    // ... up to Key18 for 18K
    
    Special1,
    Special2,
}

// Default bindings vary by key count (variant)
public override IEnumerable<IKeyBinding> GetDefaultKeyBindings(int variant = 0)
{
    switch (variant)
    {
        case 0: // 1K
            return new[] { new KeyBinding(InputKey.Space, ManiaAction.Key1) };
        
        case 1: // 2K
            return new[]
            {
                new KeyBinding(InputKey.F, ManiaAction.Key1),
                new KeyBinding(InputKey.J, ManiaAction.Key2),
            };
        
        case 3: // 4K
            return new[]
            {
                new KeyBinding(InputKey.D, ManiaAction.Key1),
                new KeyBinding(InputKey.F, ManiaAction.Key2),
                new KeyBinding(InputKey.J, ManiaAction.Key3),
                new KeyBinding(InputKey.K, ManiaAction.Key4),
            };
        
        // ... more variants
    }
}

DrawableRuleset
└── FrameStabilityContainer
    └── KeyBindingInputManager (Ruleset-specific)
        └── PlayfieldAdjustmentContainer
            └── Playfield
                └── HitObjectContainer
                    └── DrawableHitObject (receives input events)

public abstract class DrawableHitObject : CompositeDrawable
{
    // Check if an action is valid for this hit object
    public virtual bool OnPressed(KeyBindingPressEvent<TAction> e)
    {
        if (Judged) return false;
        if (!e.Action.IsValidAction()) return false;
        
        // Process input and create judgement
        ApplyResult(r => r.Type = CalculateJudgement());
        return true;
    }
    
    public virtual void OnReleased(KeyBindingReleaseEvent<TAction> e)
    {
        // Handle key release (for hold notes, sliders, etc.)
    }
}

public partial class TouchInputInterceptor : Container
{
    protected override bool OnTouchDown(TouchDownEvent e)
    {
        // Convert touch to mouse click or game action
        return base.OnTouchDown(e);
    }
    
    protected override void OnTouchUp(TouchUpEvent e)
    {
        // Handle touch release
        base.OnTouchUp(e);
    }
}

public partial class PlayerTouchInputDetector : Component
{
    // Detected whether touch input is being used
    public IBindable<bool> TouchInputActive { get; }
    
    protected override bool OnTouchDown(TouchDownEvent e)
    {
        TouchInputActive.Value = true;
        return base.OnTouchDown(e);
    }
}

private static readonly IEnumerable<InputKey> banned_keys = new[]
{
    InputKey.MouseWheelDown,
    InputKey.MouseWheelLeft,
    InputKey.MouseWheelUp,
    InputKey.MouseWheelRight
};

public static bool CheckValidForGameplay(KeyCombination combination)
{
    foreach (var key in banned_keys)
    {
        if (combination.Keys.Contains(key))
            return false;
    }
    return true;
}

// Get current bindings for an action
var bindings = keyBindingStore.GetReadableKeyCombinationsFor(GlobalAction.QuickRetry);

// Modify a binding
realm.Write(r =>
{
    var binding = r.All<RealmKeyBinding>()
        .First(b => b.ActionInt == (int)GlobalAction.QuickRetry);
    
    binding.KeyCombination = new KeyCombination(InputKey.R);
});

// Clear duplicate bindings
var clearedCount = RealmKeyBindingStore.ClearDuplicateBindings(allBindings);

public class IdleTracker : Component
{
    // Time until considered idle
    public double TimeUntilIdle { get; set; } = 10000;
    
    // Is currently idle
    public IBindable<bool> IsIdle { get; }
    
    protected override bool OnMouseMove(MouseMoveEvent e)
    {
        // Reset idle timer
        resetIdleTime();
        return base.OnMouseMove(e);
    }
    
    protected override bool OnKeyDown(KeyDownEvent e)
    {
        // Reset idle timer
        resetIdleTime();
        return base.OnKeyDown(e);
    }
}

public partial class GameIdleTracker : IdleTracker
{
    protected override bool OnKeyDown(KeyDownEvent e)
    {
        // Ignore certain keys for idle detection
        if (e.Key == InputKey.F1 || e.Key == InputKey.F12)
            return false;
        
        return base.OnKeyDown(e);
    }
}

public enum OsuConfineMouseMode
{
    Never,           // Never confine
    DuringGameplay,  // Confine during active gameplay
    Fullscreen,      // Confine in fullscreen mode
    Always           // Always confine
}

public partial class ConfineMouseTracker : Component
{
    private Bindable<OsuConfineMouseMode> confineMode;
    
    private void updateConfineMode()
    {
        bool confine = confineMode.Value switch
        {
            OsuConfineMouseMode.Never => false,
            OsuConfineMouseMode.DuringGameplay => isPlaying,
            OsuConfineMouseMode.Fullscreen => isFullscreen,
            OsuConfineMouseMode.Always => true,
            _ => false
        };
        
        game.Window.ConfineMouseMode.Value = confine 
            ? ConfineMouseMode.Always 
            : ConfineMouseMode.Never;
    }
}