Rewiredの各種入力イベントをUniRxのObservableで受けられるようにするクラスを作りました。
当然ですが、RewiredとUniRxが必要になります。
Rewired | Utilities Tools | Unity Asset Store
Use the Rewired from Guavaman Enterprises on your next project. Find this utility tool & more on the Unity Asset Store.
UniRx - Reactive Extensions for Unity | Integration | Unity Asset Store
Use the UniRx - Reactive Extensions for Unity from neuecc on your next project. Find this integration tool & more on the Unity Asset Store.
ソースコード
コードブロックの右上のアイコンをクリックするとコピーできます。
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
}
}
使い方
特にすることはありません。ソースコードをコピペするだけで使えます。
使用例
using Norakyo.System;
using UniRx;
using UnityEngine;
namespace Norakyo
{
public class Sample : MonoBehaviour
{
private void Start()
{
RewiredObservables.ButtonJustPressed("Jump")
.Subscribe(x => Debug.Log("JumpButtonJustPressed"))
.AddTo(this);
}
}
}
コメント