RewiredのイベントをUniRxで受けられるようにする【Unity】

using System;
using System.Linq;
using Rewired;
using UniRx;
using UnityEngine;

namespace Norakyo.System
{
    public static class RewiredObservables
    {
        public readonly struct InputEvent
        {
            public readonly InputActionEventType EventType;
            public readonly int ID;
            public readonly Player Player;

            public InputEvent(InputActionEventType eventType, int id, Player player)
            {
                EventType = eventType;
                ID = id;
                Player = player;
            }
        }
        
        #region Fields
        
        private static readonly Subject<InputEvent> AllInputEvent = new Subject<InputEvent>();
        private static Subject<InputEvent> _pressedEvent;
        private static Subject<InputEvent> _repeatingEvent;
        private static Subject<InputEvent> _unpressedEvent;
        private static Subject<InputEvent> _doublePressedEvent;
        private static Subject<InputEvent> _justPressedEvent;
        private static Subject<InputEvent> _justReleasedEvent;
        private static Subject<InputEvent> _longPressedEvent;
        private static Subject<InputEvent> _shortPressedEvent;
        private static Subject<InputEvent> _singlePressedEvent;
        private static Subject<InputEvent> _justDoublePressedEvent;
        private static Subject<InputEvent> _justLongPressedEvent;
        private static Subject<InputEvent> _justShortPressedEvent;
        private static Subject<InputEvent> _justSinglePressedEvent;
        private static Subject<InputEvent> _doublePressJustReleasedEvent;
        private static Subject<InputEvent> _longPressJustReleasedEvent;
        private static Subject<InputEvent> _shortPressJustReleasedEvent;
        private static Subject<InputEvent> _singlePressJustReleasedEvent;
        private static Subject<InputEvent> _negativePressedEvent;
        private static Subject<InputEvent> _negativeRepeatingEvent;
        private static Subject<InputEvent> _negativeUnpressedEvent;
        private static Subject<InputEvent> _negativeDoublePressedEvent;
        private static Subject<InputEvent> _negativeJustPressedEvent;
        private static Subject<InputEvent> _negativeJustReleasedEvent;
        private static Subject<InputEvent> _negativeLongPressedEvent;
        private static Subject<InputEvent> _negativeShortPressedEvent;
        private static Subject<InputEvent> _negativeSinglePressedEvent;
        private static Subject<InputEvent> _negativeJustDoublePressedEvent;
        private static Subject<InputEvent> _negativeJustLongPressedEvent;
        private static Subject<InputEvent> _negativeJustShortPressedEvent;
        private static Subject<InputEvent> _negativeJustSinglePressedEvent;
        private static Subject<InputEvent> _negativeDoublePressJustReleasedEvent;
        private static Subject<InputEvent> _negativeLongPressJustReleasedEvent;
        private static Subject<InputEvent> _negativeShortPressJustReleasedEvent;
        private static Subject<InputEvent> _negativeSinglePressJustReleasedEvent;
        
        #endregion

        #region Initialize

        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
        private static void OnLoad()
        {
            ReInput.InitializedEvent += Initialize;
        }

        private static void Initialize()
        {
            var players = ReInput.players.Players;
            
            void Callback(InputActionEventData eventData)
            {
                AllInputEvent.OnNext(new InputEvent(eventData.eventType, eventData.actionId, eventData.player));
            }
            
            var eventTypes = Enum.GetValues(typeof(InputActionEventType)).Cast<InputActionEventType>()
                .Where(type =>
                    type != InputActionEventType.Update
                    && type != InputActionEventType.ButtonJustPressedForTime
                    && type != InputActionEventType.ButtonPressedForTimeJustReleased
                    && type != InputActionEventType.ButtonPressedForTime
                    && type != InputActionEventType.NegativeButtonPressedForTime
                    && type != InputActionEventType.NegativeButtonJustPressedForTime
                    && type != InputActionEventType.NegativeButtonPressedForTimeJustReleased).ToArray();
            
            foreach (var player in players)
            {
                foreach (var type in eventTypes)
                {
                    player.AddInputEventDelegate(Callback, UpdateLoopType.Update, type);
                }
                
            }
        }

        #endregion
        
        #region Functions
        
        public static IObservable<InputEvent> AnyButtonJustPressed(Player player = null)
        {
            if (_justPressedEvent == null)
            {
                _justPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonJustPressed).Subscribe(_justPressedEvent);
            }
            return _justPressedEvent.Where(x => player == null || x.Player == player);
        }
        
        public static IObservable<InputEvent> AnyButtonPressed(Player player = null)
        {
            if (_pressedEvent == null)
            {
                _pressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonPressed).Subscribe(_pressedEvent);
            }
            return _pressedEvent.Where(x => player == null || x.Player == player);
        }
        
        public static IObservable<InputEvent> AnyButtonJustReleased(Player player = null)
        {
            if (_justReleasedEvent == null)
            {
                _justReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonJustReleased).Subscribe(_justReleasedEvent);
            }
            return _justReleasedEvent.Where(x => player == null || x.Player == player);
        }
        
        public static IObservable<InputEvent> AnyNegativeButtonJustPressed(Player player = null)
        {
            if (_negativeJustPressedEvent == null)
            {
                _negativeJustPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonJustPressed).Subscribe(_negativeJustPressedEvent);
            }
            return _negativeJustPressedEvent.Where(x => player == null || x.Player == player);
        }
        
        public static IObservable<InputEvent> AnyNegativeButtonPressed(Player player = null)
        {
            if (_negativePressedEvent == null)
            {
                _negativePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonPressed).Subscribe(_negativePressedEvent);
            }
            return _negativePressedEvent.Where(x => player == null || x.Player == player);
        }
        
        public static IObservable<InputEvent> AnyNegativeButtonJustReleased(Player player = null)
        {
            if (_negativeJustReleasedEvent == null)
            {
                _negativeJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonJustReleased).Subscribe(_negativeJustReleasedEvent);
            }
            return _negativeJustReleasedEvent.Where(x => player == null || x.Player == player);
        }
        
        public static IObservable<InputEvent> ButtonJustPressed(int id, Player player = null)
        {
            if (_justPressedEvent == null)
            {
                _justPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonJustPressed).Subscribe(_justPressedEvent);
            }
            return _justPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonJustPressed(string name, Player player = null)
        {
            return ButtonJustPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonPressed(int id, Player player = null)
        {
            if (_pressedEvent == null)
            {
                _pressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonPressed).Subscribe(_pressedEvent);
            }
            return _pressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonPressed(string name, Player player = null)
        {
            return ButtonPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonJustReleased(int id, Player player = null)
        {
            if (_justReleasedEvent == null)
            {
                _justReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonJustReleased).Subscribe(_justReleasedEvent);
            }
            return _justReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonJustReleased(string name, Player player = null)
        {
            return ButtonJustReleased(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonRepeating(int id, Player player = null)
        {
            if (_repeatingEvent == null)
            {
                _repeatingEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonRepeating).Subscribe(_repeatingEvent);
            }
            return _repeatingEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonRepeating(string name, Player player = null)
        {
            return ButtonRepeating(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonUnpressed(int id, Player player = null)
        {
            if (_unpressedEvent == null)
            {
                _unpressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonUnpressed).Subscribe(_unpressedEvent);
            }
            return _unpressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonUnpressed(string name, Player player = null)
        {
            return ButtonUnpressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonDoublePressed(int id, Player player = null)
        {
            if (_doublePressedEvent == null)
            {
                _doublePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonDoublePressed).Subscribe(_doublePressedEvent);
            }
            return _doublePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonDoublePressed(string name, Player player = null)
        {
            return ButtonDoublePressed(ReInput.mapping.GetActionId(name), player);
        }
        public static IObservable<InputEvent> ButtonLongPressed(int id, Player player = null)
        {
            if (_longPressedEvent == null)
            {
                _longPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonLongPressed).Subscribe(_longPressedEvent);
            }
            return _longPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonLongPressed(string name, Player player = null)
        {
            return ButtonLongPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonShortPressed(int id, Player player = null)
        {
            if (_shortPressedEvent == null)
            {
                _shortPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonShortPressed).Subscribe(_shortPressedEvent);

            }
            return _shortPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonShortPressed(string name, Player player = null)
        {
            return ButtonShortPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonSinglePressed(int id, Player player = null)
        {
            if (_singlePressedEvent == null)
            {
                _singlePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonSinglePressed).Subscribe(_singlePressedEvent);
            }
            return _singlePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonSinglePressed(string name, Player player = null)
        {
            return ButtonSinglePressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonPressed(int id, Player player = null)
        {
            if (_negativePressedEvent == null)
            {
                _negativePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonPressed).Subscribe(_negativePressedEvent);
            }
            return _negativePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonPressed(string name, Player player = null)
        {
            return NegativeButtonPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonRepeating(int id, Player player = null)
        {
            if (_negativeRepeatingEvent == null)
            {
                _negativeRepeatingEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonRepeating).Subscribe(_negativeRepeatingEvent);
            }
            return _negativePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonRepeating(string name, Player player = null)
        {
            return NegativeButtonRepeating(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonUnpressed(int id, Player player = null)
        {
            if (_negativeUnpressedEvent == null)
            {
                _negativeUnpressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonUnpressed).Subscribe(_negativeUnpressedEvent);
            }
            return _negativeUnpressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonUnpressed(string name, Player player = null)
        {
            return NegativeButtonUnpressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonJustDoublePressed(int id, Player player = null)
        {
            if (_justDoublePressedEvent == null)
            {
                _justDoublePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonJustDoublePressed).Subscribe(_justDoublePressedEvent);
            }
            return _justDoublePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonJustDoublePressed(string name, Player player = null)
        {
            return ButtonJustDoublePressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonJustLongPressed(int id, Player player = null)
        {
            if (_justLongPressedEvent == null)
            {
                _justLongPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonJustLongPressed).Subscribe(_justLongPressedEvent);
            }
            return _justLongPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonJustLongPressed(string name, Player player = null)
        {
            return ButtonJustLongPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonJustShortPressed(int id, Player player = null)
        {
            if (_justShortPressedEvent == null)
            {
                _justShortPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonJustShortPressed).Subscribe(_justShortPressedEvent);
            }
            return _justShortPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonJustShortPressed(string name, Player player = null)
        {
            return ButtonJustShortPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonJustSinglePressed(int id, Player player = null)
        {
            if (_justSinglePressedEvent == null)
            {
                _justSinglePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonJustSinglePressed).Subscribe(_justSinglePressedEvent);
            }
            return _justSinglePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonJustSinglePressed(string name, Player player = null)
        {
            return ButtonJustSinglePressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonDoublePressed(int id, Player player = null)
        {
            if (_negativeDoublePressedEvent == null)
            {
                _negativeDoublePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonDoublePressed).Subscribe(_negativeDoublePressedEvent);
            }
            return _negativeDoublePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonDoublePressed(string name, Player player = null)
        {
            return NegativeButtonDoublePressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonJustPressed(int id, Player player = null)
        {
            if (_negativeJustPressedEvent == null)
            {
                _negativeJustPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonJustPressed).Subscribe(_negativeJustPressedEvent);
            }
            return _negativeJustPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonJustPressed(string name, Player player = null)
        {
            return NegativeButtonJustPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonJustReleased(int id, Player player = null)
        {
            if (_negativeJustReleasedEvent == null)
            {
                _negativeJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonJustReleased).Subscribe(_negativeJustReleasedEvent);
            }
            return _negativeJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonJustReleased(string name, Player player = null)
        {
            return NegativeButtonJustReleased(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonLongPressed(int id, Player player = null)
        {
            if (_negativeLongPressedEvent == null)
            {
                _negativeLongPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonLongPressed).Subscribe(_negativeLongPressedEvent);
            }
            return _negativeLongPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonLongPressed(string name, Player player = null)
        {
            return NegativeButtonLongPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonShortPressed(int id, Player player = null)
        {
            if (_negativeShortPressedEvent == null)
            {
                _negativeShortPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonShortPressed).Subscribe(_negativeShortPressedEvent);
            }
            return _negativeShortPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonShortPressed(string name, Player player = null)
        {
            return NegativeButtonShortPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonSinglePressed(int id, Player player = null)
        {
            if (_negativeSinglePressedEvent == null)
            {
                _negativeSinglePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonSinglePressed).Subscribe(_negativeSinglePressedEvent);
            }
            return _negativeSinglePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonSinglePressed(string name, Player player = null)
        {
            return NegativeButtonSinglePressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonDoublePressJustReleased(int id, Player player = null)
        {
            if (_doublePressJustReleasedEvent == null)
            {
                _doublePressJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonDoublePressJustReleased).Subscribe(_doublePressJustReleasedEvent);
            }
            return _doublePressJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonDoublePressJustReleased(string name, Player player = null)
        {
            return ButtonDoublePressJustReleased(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonLongPressJustReleased(int id, Player player = null)
        {
            if (_longPressJustReleasedEvent == null)
            {
                _longPressJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonLongPressJustReleased).Subscribe(_longPressJustReleasedEvent);
            }
            return _longPressJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonLongPressJustReleased(string name, Player player = null)
        {
            return ButtonLongPressJustReleased(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> ButtonShortPressJustReleased(int id, Player player = null)
        {
            if (_shortPressJustReleasedEvent == null)
            {
                _shortPressJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonShortPressJustReleased).Subscribe(_shortPressJustReleasedEvent);
            }
            return _shortPressJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonShortPressJustReleased(string name, Player player = null)
        {
            return ButtonShortPressJustReleased(ReInput.mapping.GetActionId(name), player);
        }

        public static IObservable<InputEvent> ButtonSinglePressJustReleased(int id, Player player = null)
        {
            if (_singlePressJustReleasedEvent == null)
            {
                _singlePressJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonSinglePressJustReleased).Subscribe(_singlePressJustReleasedEvent);
            }
            return _singlePressJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> ButtonSinglePressJustReleased(string name, Player player = null)
        {
            return ButtonSinglePressJustReleased(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonJustDoublePressed(int id, Player player = null)
        {
            if (_negativeJustDoublePressedEvent == null)
            {
                _negativeJustDoublePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonJustDoublePressed).Subscribe(_negativeJustDoublePressedEvent);
            }
            return _negativeJustDoublePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonJustDoublePressed(string name, Player player = null)
        {
            return NegativeButtonJustDoublePressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonJustLongPressed(int id, Player player = null)
        {
            if (_negativeJustLongPressedEvent == null)
            {
                _negativeJustLongPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonJustLongPressed).Subscribe(_negativeJustLongPressedEvent);
            }
            return _negativeJustLongPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonJustLongPressed(string name, Player player = null)
        {
            return NegativeButtonJustLongPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonJustShortPressed(int id, Player player = null)
        {
            if (_negativeJustShortPressedEvent == null)
            {
                _negativeJustShortPressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonJustShortPressed).Subscribe(_negativeJustShortPressedEvent);
            }
            return _negativeJustShortPressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonJustShortPressed(string name, Player player = null)
        {
            return NegativeButtonJustShortPressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonJustSinglePressed(int id, Player player = null)
        {
            if (_negativeJustSinglePressedEvent == null)
            {
                _negativeJustSinglePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonJustSinglePressed).Subscribe(_negativeJustSinglePressedEvent);
            }
            return _negativeJustSinglePressedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonJustSinglePressed(string name, Player player = null)
        {
            return NegativeButtonJustSinglePressed(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonDoublePressJustReleased(int id, Player player = null)
        {
            if (_negativeDoublePressJustReleasedEvent == null)
            {
                _negativeDoublePressJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonDoublePressJustReleased).Subscribe(_negativeDoublePressJustReleasedEvent);
            }
            return _negativeDoublePressJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonDoublePressJustReleased(string name, Player player = null)
        {
            return NegativeButtonDoublePressJustReleased(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonLongPressJustReleased(int id, Player player = null)
        {
            if (_negativeLongPressJustReleasedEvent == null)
            {
                _negativeLongPressJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonLongPressJustReleased).Subscribe(_negativeLongPressJustReleasedEvent);
            }
            return _negativeLongPressJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonLongPressJustReleased(string name, Player player = null)
        {
            return NegativeButtonLongPressJustReleased(ReInput.mapping.GetActionId(name), player);
        }
        
        public static IObservable<InputEvent> NegativeButtonShortPressJustReleased(int id, Player player = null)
        {
            if (_negativeShortPressJustReleasedEvent == null)
            {
                _negativeShortPressJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonShortPressJustReleased).Subscribe(_negativeShortPressJustReleasedEvent);
            }
            return _negativeShortPressJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonShortPressJustReleased(string name, Player player = null)
        {
            return NegativeButtonShortPressJustReleased(ReInput.mapping.GetActionId(name), player);
        }

        public static IObservable<InputEvent> NegativeButtonSinglePressJustReleased(int id, Player player = null)
        {
            if (_negativeSinglePressJustReleasedEvent == null)
            {
                _negativeSinglePressJustReleasedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonSinglePressJustReleased).Subscribe(_negativeSinglePressJustReleasedEvent);
            }
            return _negativeSinglePressJustReleasedEvent.Where(x => x.ID == id && (player == null || x.Player == player));
        }
        
        public static IObservable<InputEvent> NegativeButtonSinglePressJustReleased(string name, Player player = null)
        {
            return NegativeButtonSinglePressJustReleased(ReInput.mapping.GetActionId(name), player);
        }

        private static IObservable<InputEvent> ButtonTimedPressedWithoutRepeat(int id, float time, Player player = null)
        {
            if (_pressedEvent == null)
            {
                _pressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.ButtonPressed).Subscribe(_pressedEvent);
            }

            return _pressedEvent
                .Where(x => x.ID == id && (player == null || x.Player == player))
                .Skip(TimeSpan.FromSeconds(time))
                .TakeUntil(ButtonUnpressed(id, player));
        }
        
        public static IObservable<InputEvent> ButtonTimedPressed(int id, float time, Player player = null)
        {
            return ButtonTimedPressedWithoutRepeat(id, time, player).Repeat();
        }
        
        public static IObservable<InputEvent> ButtonTimedJustPressed(int id, float time, Player player = null)
        {
            return ButtonTimedPressedWithoutRepeat(id, time, player)
                .DistinctUntilChanged(x => true) //最初の1回だけ発行（OnCompleteを発生させずに）（別の方法があるかも）
                .Repeat(); 
        }
        
        public static IObservable<InputEvent> ButtonTimedJustReleased(int id, float time, Player player = null)
        {
            return ButtonTimedPressedWithoutRepeat(id, time, player)
                .Last()
                .Repeat()
                .Retry();
        }
        
        private static IObservable<InputEvent> NegativeButtonTimedPressedWithoutRepeat(int id, float time, Player player = null)
        {
            if (_negativePressedEvent == null)
            {
                _negativePressedEvent = new Subject<InputEvent>();
                AllInputEvent.Where(x => x.EventType == InputActionEventType.NegativeButtonPressed).Subscribe(_negativePressedEvent);
            }

            return _negativePressedEvent
                .Where(x => x.ID == id && (player == null || x.Player == player))
                .Skip(TimeSpan.FromSeconds(time))
                .TakeUntil(NegativeButtonUnpressed(id, player));
        }
        
        public static IObservable<InputEvent> NegativeButtonTimedPressed(int id, float time, Player player = null)
        {
            return NegativeButtonTimedPressedWithoutRepeat(id, time, player).Repeat();
        }
        
        public static IObservable<InputEvent> NegativeButtonTimedJustPressed(int id, float time, Player player = null)
        {
            return NegativeButtonTimedPressedWithoutRepeat(id, time, player)
                .DistinctUntilChanged(x => true) //最初の1回だけ発行（OnCompleteを発生させずに）（別の方法があるかも）
                .Repeat(); 
        }
        
        public static IObservable<InputEvent> NegativeButtonTimedJustReleased(int id, float time, Player player = null)
        {
            return NegativeButtonTimedPressedWithoutRepeat(id, time, player)
                .Last()
                .Repeat()
                .Retry();
        }
        
        #endregion 
    }
}