*renameHEADmaster

5 files changed, 2293 insertions, 0 deletions

diff --git a/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/PlayerPointerEventData.cs b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/PlayerPointerEventData.cs
new file mode 100644
index 0000000..0c95915
--- /dev/null
+++ b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/PlayerPointerEventData.cs
@@ -0,0 +1,41 @@
+using System.Text;
+using Rewired.UI;
+using UnityEngine.EventSystems;
+
+namespace Rewired.Integration.UnityUI;
+
+public class PlayerPointerEventData : PointerEventData
+{
+	public int playerId { get; set; }
+
+	public int inputSourceIndex { get; set; }
+
+	public IMouseInputSource mouseSource { get; set; }
+
+	public ITouchInputSource touchSource { get; set; }
+
+	public PointerEventType sourceType { get; set; }
+
+	public int buttonIndex { get; set; }
+
+	public PlayerPointerEventData(EventSystem eventSystem)
+		: base(eventSystem)
+	{
+		playerId = -1;
+		inputSourceIndex = -1;
+		buttonIndex = -1;
+	}
+
+	public override string ToString()
+	{
+		StringBuilder stringBuilder = new StringBuilder();
+		stringBuilder.AppendLine("<b>Player Id</b>: " + playerId);
+		stringBuilder.AppendLine("<b>Mouse Source</b>: " + mouseSource);
+		stringBuilder.AppendLine("<b>Input Source Index</b>: " + inputSourceIndex);
+		stringBuilder.AppendLine("<b>Touch Source/b>: " + touchSource);
+		stringBuilder.AppendLine("<b>Source Type</b>: " + sourceType);
+		stringBuilder.AppendLine("<b>Button Index</b>: " + buttonIndex);
+		stringBuilder.Append(base.ToString());
+		return stringBuilder.ToString();
+	}
+}
diff --git a/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/PointerEventType.cs b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/PointerEventType.cs
new file mode 100644
index 0000000..ce70ee8
--- /dev/null
+++ b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/PointerEventType.cs
@@ -0,0 +1,7 @@
+namespace Rewired.Integration.UnityUI;
+
+public enum PointerEventType
+{
+	Mouse,
+	Touch
+}
diff --git a/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredEventSystem.cs b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredEventSystem.cs
new file mode 100644
index 0000000..c46b002
--- /dev/null
+++ b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredEventSystem.cs
@@ -0,0 +1,49 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace Rewired.Integration.UnityUI;
+
+[AddComponentMenu("Rewired/Rewired Event System")]
+public class RewiredEventSystem : EventSystem
+{
+	[Tooltip("If enabled, the Event System will be updated every frame even if other Event Systems are enabled. Otherwise, only EventSystem.current will be updated.")]
+	[SerializeField]
+	private bool _alwaysUpdate;
+
+	public bool alwaysUpdate
+	{
+		get
+		{
+			return _alwaysUpdate;
+		}
+		set
+		{
+			_alwaysUpdate = value;
+		}
+	}
+
+	protected override void Update()
+	{
+		if (alwaysUpdate)
+		{
+			EventSystem eventSystem = EventSystem.current;
+			if (eventSystem != this)
+			{
+				EventSystem.current = this;
+			}
+			try
+			{
+				base.Update();
+				return;
+			}
+			finally
+			{
+				if (eventSystem != this)
+				{
+					EventSystem.current = eventSystem;
+				}
+			}
+		}
+		base.Update();
+	}
+}
diff --git a/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredPointerInputModule.cs b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredPointerInputModule.cs
new file mode 100644
index 0000000..27d419b
--- /dev/null
+++ b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredPointerInputModule.cs
@@ -0,0 +1,781 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Rewired.UI;
+using Rewired.Utils;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace Rewired.Integration.UnityUI;
+
+public abstract class RewiredPointerInputModule : BaseInputModule
+{
+	protected class MouseState
+	{
+		private List<ButtonState> m_TrackedButtons = new List<ButtonState>();
+
+		public bool AnyPressesThisFrame()
+		{
+			for (int i = 0; i < m_TrackedButtons.Count; i++)
+			{
+				if (m_TrackedButtons[i].eventData.PressedThisFrame())
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+
+		public bool AnyReleasesThisFrame()
+		{
+			for (int i = 0; i < m_TrackedButtons.Count; i++)
+			{
+				if (m_TrackedButtons[i].eventData.ReleasedThisFrame())
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+
+		public ButtonState GetButtonState(int button)
+		{
+			ButtonState buttonState = null;
+			for (int i = 0; i < m_TrackedButtons.Count; i++)
+			{
+				if (m_TrackedButtons[i].button == button)
+				{
+					buttonState = m_TrackedButtons[i];
+					break;
+				}
+			}
+			if (buttonState == null)
+			{
+				buttonState = new ButtonState
+				{
+					button = button,
+					eventData = new MouseButtonEventData()
+				};
+				m_TrackedButtons.Add(buttonState);
+			}
+			return buttonState;
+		}
+
+		public void SetButtonState(int button, PointerEventData.FramePressState stateForMouseButton, PlayerPointerEventData data)
+		{
+			ButtonState buttonState = GetButtonState(button);
+			buttonState.eventData.buttonState = stateForMouseButton;
+			buttonState.eventData.buttonData = data;
+		}
+	}
+
+	public class MouseButtonEventData
+	{
+		public PointerEventData.FramePressState buttonState;
+
+		public PlayerPointerEventData buttonData;
+
+		public bool PressedThisFrame()
+		{
+			if (buttonState != 0)
+			{
+				return buttonState == PointerEventData.FramePressState.PressedAndReleased;
+			}
+			return true;
+		}
+
+		public bool ReleasedThisFrame()
+		{
+			if (buttonState != PointerEventData.FramePressState.Released)
+			{
+				return buttonState == PointerEventData.FramePressState.PressedAndReleased;
+			}
+			return true;
+		}
+	}
+
+	protected class ButtonState
+	{
+		private int m_Button;
+
+		private MouseButtonEventData m_EventData;
+
+		public MouseButtonEventData eventData
+		{
+			get
+			{
+				return m_EventData;
+			}
+			set
+			{
+				m_EventData = value;
+			}
+		}
+
+		public int button
+		{
+			get
+			{
+				return m_Button;
+			}
+			set
+			{
+				m_Button = value;
+			}
+		}
+	}
+
+	private sealed class UnityInputSource : IMouseInputSource, ITouchInputSource
+	{
+		private Vector2 m_MousePosition;
+
+		private Vector2 m_MousePositionPrev;
+
+		private int m_LastUpdatedFrame = -1;
+
+		int IMouseInputSource.playerId
+		{
+			get
+			{
+				TryUpdate();
+				return 0;
+			}
+		}
+
+		int ITouchInputSource.playerId
+		{
+			get
+			{
+				TryUpdate();
+				return 0;
+			}
+		}
+
+		bool IMouseInputSource.enabled
+		{
+			get
+			{
+				TryUpdate();
+				return Input.mousePresent;
+			}
+		}
+
+		bool IMouseInputSource.locked
+		{
+			get
+			{
+				TryUpdate();
+				return Cursor.lockState == CursorLockMode.Locked;
+			}
+		}
+
+		int IMouseInputSource.buttonCount
+		{
+			get
+			{
+				TryUpdate();
+				return 3;
+			}
+		}
+
+		Vector2 IMouseInputSource.screenPosition
+		{
+			get
+			{
+				TryUpdate();
+				return Input.mousePosition;
+			}
+		}
+
+		Vector2 IMouseInputSource.screenPositionDelta
+		{
+			get
+			{
+				TryUpdate();
+				return m_MousePosition - m_MousePositionPrev;
+			}
+		}
+
+		Vector2 IMouseInputSource.wheelDelta
+		{
+			get
+			{
+				TryUpdate();
+				return Input.mouseScrollDelta;
+			}
+		}
+
+		bool ITouchInputSource.touchSupported
+		{
+			get
+			{
+				TryUpdate();
+				return Input.touchSupported;
+			}
+		}
+
+		int ITouchInputSource.touchCount
+		{
+			get
+			{
+				TryUpdate();
+				return Input.touchCount;
+			}
+		}
+
+		bool IMouseInputSource.GetButtonDown(int button)
+		{
+			TryUpdate();
+			return Input.GetMouseButtonDown(button);
+		}
+
+		bool IMouseInputSource.GetButtonUp(int button)
+		{
+			TryUpdate();
+			return Input.GetMouseButtonUp(button);
+		}
+
+		bool IMouseInputSource.GetButton(int button)
+		{
+			TryUpdate();
+			return Input.GetMouseButton(button);
+		}
+
+		Touch ITouchInputSource.GetTouch(int index)
+		{
+			TryUpdate();
+			return Input.GetTouch(index);
+		}
+
+		private void TryUpdate()
+		{
+			if (Time.frameCount != m_LastUpdatedFrame)
+			{
+				m_LastUpdatedFrame = Time.frameCount;
+				m_MousePositionPrev = m_MousePosition;
+				m_MousePosition = Input.mousePosition;
+			}
+		}
+	}
+
+	public const int kMouseLeftId = -1;
+
+	public const int kMouseRightId = -2;
+
+	public const int kMouseMiddleId = -3;
+
+	public const int kFakeTouchesId = -4;
+
+	private const int customButtonsStartingId = -2147483520;
+
+	private const int customButtonsMaxCount = 128;
+
+	private const int customButtonsLastId = -2147483392;
+
+	private readonly List<IMouseInputSource> m_MouseInputSourcesList = new List<IMouseInputSource>();
+
+	private Dictionary<int, Dictionary<int, PlayerPointerEventData>[]> m_PlayerPointerData = new Dictionary<int, Dictionary<int, PlayerPointerEventData>[]>();
+
+	private ITouchInputSource m_UserDefaultTouchInputSource;
+
+	private UnityInputSource __m_DefaultInputSource;
+
+	private readonly MouseState m_MouseState = new MouseState();
+
+	private UnityInputSource defaultInputSource
+	{
+		get
+		{
+			if (__m_DefaultInputSource == null)
+			{
+				return __m_DefaultInputSource = new UnityInputSource();
+			}
+			return __m_DefaultInputSource;
+		}
+	}
+
+	private IMouseInputSource defaultMouseInputSource => defaultInputSource;
+
+	protected ITouchInputSource defaultTouchInputSource => defaultInputSource;
+
+	protected virtual bool isMouseSupported
+	{
+		get
+		{
+			int count = m_MouseInputSourcesList.Count;
+			if (count == 0)
+			{
+				return defaultMouseInputSource.enabled;
+			}
+			for (int i = 0; i < count; i++)
+			{
+				if (m_MouseInputSourcesList[i].enabled)
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+
+	protected bool IsDefaultMouse(IMouseInputSource mouse)
+	{
+		return defaultMouseInputSource == mouse;
+	}
+
+	public IMouseInputSource GetMouseInputSource(int playerId, int mouseIndex)
+	{
+		if (mouseIndex < 0)
+		{
+			throw new ArgumentOutOfRangeException("mouseIndex");
+		}
+		if (m_MouseInputSourcesList.Count == 0 && IsDefaultPlayer(playerId))
+		{
+			return defaultMouseInputSource;
+		}
+		int count = m_MouseInputSourcesList.Count;
+		int num = 0;
+		for (int i = 0; i < count; i++)
+		{
+			IMouseInputSource mouseInputSource = m_MouseInputSourcesList[i];
+			if (!UnityTools.IsNullOrDestroyed(mouseInputSource) && mouseInputSource.playerId == playerId)
+			{
+				if (mouseIndex == num)
+				{
+					return mouseInputSource;
+				}
+				num++;
+			}
+		}
+		return null;
+	}
+
+	public void RemoveMouseInputSource(IMouseInputSource source)
+	{
+		if (source == null)
+		{
+			throw new ArgumentNullException("source");
+		}
+		m_MouseInputSourcesList.Remove(source);
+	}
+
+	public void AddMouseInputSource(IMouseInputSource source)
+	{
+		if (UnityTools.IsNullOrDestroyed(source))
+		{
+			throw new ArgumentNullException("source");
+		}
+		m_MouseInputSourcesList.Add(source);
+	}
+
+	public int GetMouseInputSourceCount(int playerId)
+	{
+		if (m_MouseInputSourcesList.Count == 0 && IsDefaultPlayer(playerId))
+		{
+			return 1;
+		}
+		int count = m_MouseInputSourcesList.Count;
+		int num = 0;
+		for (int i = 0; i < count; i++)
+		{
+			IMouseInputSource mouseInputSource = m_MouseInputSourcesList[i];
+			if (!UnityTools.IsNullOrDestroyed(mouseInputSource) && mouseInputSource.playerId == playerId)
+			{
+				num++;
+			}
+		}
+		return num;
+	}
+
+	public ITouchInputSource GetTouchInputSource(int playerId, int sourceIndex)
+	{
+		if (!UnityTools.IsNullOrDestroyed(m_UserDefaultTouchInputSource))
+		{
+			return m_UserDefaultTouchInputSource;
+		}
+		return defaultTouchInputSource;
+	}
+
+	public void RemoveTouchInputSource(ITouchInputSource source)
+	{
+		if (source == null)
+		{
+			throw new ArgumentNullException("source");
+		}
+		if (m_UserDefaultTouchInputSource == source)
+		{
+			m_UserDefaultTouchInputSource = null;
+		}
+	}
+
+	public void AddTouchInputSource(ITouchInputSource source)
+	{
+		if (UnityTools.IsNullOrDestroyed(source))
+		{
+			throw new ArgumentNullException("source");
+		}
+		m_UserDefaultTouchInputSource = source;
+	}
+
+	public int GetTouchInputSourceCount(int playerId)
+	{
+		if (!IsDefaultPlayer(playerId))
+		{
+			return 0;
+		}
+		return 1;
+	}
+
+	protected void ClearMouseInputSources()
+	{
+		m_MouseInputSourcesList.Clear();
+	}
+
+	protected abstract bool IsDefaultPlayer(int playerId);
+
+	protected bool GetPointerData(int playerId, int pointerIndex, int pointerTypeId, out PlayerPointerEventData data, bool create, PointerEventType pointerEventType)
+	{
+		if (!m_PlayerPointerData.TryGetValue(playerId, out var value))
+		{
+			value = new Dictionary<int, PlayerPointerEventData>[pointerIndex + 1];
+			for (int i = 0; i < value.Length; i++)
+			{
+				value[i] = new Dictionary<int, PlayerPointerEventData>();
+			}
+			m_PlayerPointerData.Add(playerId, value);
+		}
+		if (pointerIndex >= value.Length)
+		{
+			Dictionary<int, PlayerPointerEventData>[] array = new Dictionary<int, PlayerPointerEventData>[pointerIndex + 1];
+			for (int j = 0; j < value.Length; j++)
+			{
+				array[j] = value[j];
+			}
+			array[pointerIndex] = new Dictionary<int, PlayerPointerEventData>();
+			value = array;
+			m_PlayerPointerData[playerId] = value;
+		}
+		Dictionary<int, PlayerPointerEventData> dictionary = value[pointerIndex];
+		if (!dictionary.TryGetValue(pointerTypeId, out data))
+		{
+			if (!create)
+			{
+				return false;
+			}
+			data = CreatePointerEventData(playerId, pointerIndex, pointerTypeId, pointerEventType);
+			dictionary.Add(pointerTypeId, data);
+			return true;
+		}
+		data.mouseSource = ((pointerEventType == PointerEventType.Mouse) ? GetMouseInputSource(playerId, pointerIndex) : null);
+		data.touchSource = ((pointerEventType == PointerEventType.Touch) ? GetTouchInputSource(playerId, pointerIndex) : null);
+		return false;
+	}
+
+	private PlayerPointerEventData CreatePointerEventData(int playerId, int pointerIndex, int pointerTypeId, PointerEventType pointerEventType)
+	{
+		PlayerPointerEventData playerPointerEventData = new PlayerPointerEventData(base.eventSystem)
+		{
+			playerId = playerId,
+			inputSourceIndex = pointerIndex,
+			pointerId = pointerTypeId,
+			sourceType = pointerEventType
+		};
+		switch (pointerEventType)
+		{
+		case PointerEventType.Mouse:
+			playerPointerEventData.mouseSource = GetMouseInputSource(playerId, pointerIndex);
+			break;
+		case PointerEventType.Touch:
+			playerPointerEventData.touchSource = GetTouchInputSource(playerId, pointerIndex);
+			break;
+		}
+		if (pointerTypeId == -1)
+		{
+			playerPointerEventData.buttonIndex = 0;
+		}
+		else if (pointerTypeId == -2)
+		{
+			playerPointerEventData.buttonIndex = 1;
+		}
+		else if (pointerTypeId == -3)
+		{
+			playerPointerEventData.buttonIndex = 2;
+		}
+		else if (pointerTypeId >= -2147483520 && pointerTypeId <= -2147483392)
+		{
+			playerPointerEventData.buttonIndex = pointerTypeId - -2147483520;
+		}
+		return playerPointerEventData;
+	}
+
+	protected void RemovePointerData(PlayerPointerEventData data)
+	{
+		if (m_PlayerPointerData.TryGetValue(data.playerId, out var value) && (uint)data.inputSourceIndex < (uint)value.Length)
+		{
+			value[data.inputSourceIndex].Remove(data.pointerId);
+		}
+	}
+
+	protected PlayerPointerEventData GetTouchPointerEventData(int playerId, int touchDeviceIndex, Touch input, out bool pressed, out bool released)
+	{
+		PlayerPointerEventData data;
+		bool pointerData = GetPointerData(playerId, touchDeviceIndex, input.fingerId, out data, create: true, PointerEventType.Touch);
+		data.Reset();
+		pressed = pointerData || input.phase == TouchPhase.Began;
+		released = input.phase == TouchPhase.Canceled || input.phase == TouchPhase.Ended;
+		if (pointerData)
+		{
+			data.position = input.position;
+		}
+		if (pressed)
+		{
+			data.delta = Vector2.zero;
+		}
+		else
+		{
+			data.delta = input.position - data.position;
+		}
+		data.position = input.position;
+		data.button = PointerEventData.InputButton.Left;
+		base.eventSystem.RaycastAll(data, m_RaycastResultCache);
+		RaycastResult pointerCurrentRaycast = BaseInputModule.FindFirstRaycast(m_RaycastResultCache);
+		data.pointerCurrentRaycast = pointerCurrentRaycast;
+		m_RaycastResultCache.Clear();
+		return data;
+	}
+
+	protected virtual MouseState GetMousePointerEventData(int playerId, int mouseIndex)
+	{
+		IMouseInputSource mouseInputSource = GetMouseInputSource(playerId, mouseIndex);
+		if (mouseInputSource == null)
+		{
+			return null;
+		}
+		PlayerPointerEventData data;
+		bool pointerData = GetPointerData(playerId, mouseIndex, -1, out data, create: true, PointerEventType.Mouse);
+		data.Reset();
+		if (pointerData)
+		{
+			data.position = mouseInputSource.screenPosition;
+		}
+		Vector2 screenPosition = mouseInputSource.screenPosition;
+		if (mouseInputSource.locked || !mouseInputSource.enabled)
+		{
+			data.position = new Vector2(-1f, -1f);
+			data.delta = Vector2.zero;
+		}
+		else
+		{
+			data.delta = screenPosition - data.position;
+			data.position = screenPosition;
+		}
+		data.scrollDelta = mouseInputSource.wheelDelta;
+		data.button = PointerEventData.InputButton.Left;
+		base.eventSystem.RaycastAll(data, m_RaycastResultCache);
+		RaycastResult pointerCurrentRaycast = BaseInputModule.FindFirstRaycast(m_RaycastResultCache);
+		data.pointerCurrentRaycast = pointerCurrentRaycast;
+		m_RaycastResultCache.Clear();
+		GetPointerData(playerId, mouseIndex, -2, out var data2, create: true, PointerEventType.Mouse);
+		CopyFromTo(data, data2);
+		data2.button = PointerEventData.InputButton.Right;
+		GetPointerData(playerId, mouseIndex, -3, out var data3, create: true, PointerEventType.Mouse);
+		CopyFromTo(data, data3);
+		data3.button = PointerEventData.InputButton.Middle;
+		for (int i = 3; i < mouseInputSource.buttonCount; i++)
+		{
+			GetPointerData(playerId, mouseIndex, -2147483520 + i, out var data4, create: true, PointerEventType.Mouse);
+			CopyFromTo(data, data4);
+			data4.button = (PointerEventData.InputButton)(-1);
+		}
+		m_MouseState.SetButtonState(0, StateForMouseButton(playerId, mouseIndex, 0), data);
+		m_MouseState.SetButtonState(1, StateForMouseButton(playerId, mouseIndex, 1), data2);
+		m_MouseState.SetButtonState(2, StateForMouseButton(playerId, mouseIndex, 2), data3);
+		for (int j = 3; j < mouseInputSource.buttonCount; j++)
+		{
+			GetPointerData(playerId, mouseIndex, -2147483520 + j, out var data5, create: false, PointerEventType.Mouse);
+			m_MouseState.SetButtonState(j, StateForMouseButton(playerId, mouseIndex, j), data5);
+		}
+		return m_MouseState;
+	}
+
+	protected PlayerPointerEventData GetLastPointerEventData(int playerId, int pointerIndex, int pointerTypeId, bool ignorePointerTypeId, PointerEventType pointerEventType)
+	{
+		if (!ignorePointerTypeId)
+		{
+			GetPointerData(playerId, pointerIndex, pointerTypeId, out var data, create: false, pointerEventType);
+			return data;
+		}
+		if (!m_PlayerPointerData.TryGetValue(playerId, out var value))
+		{
+			return null;
+		}
+		if ((uint)pointerIndex >= (uint)value.Length)
+		{
+			return null;
+		}
+		using (Dictionary<int, PlayerPointerEventData>.Enumerator enumerator = value[pointerIndex].GetEnumerator())
+		{
+			if (enumerator.MoveNext())
+			{
+				return enumerator.Current.Value;
+			}
+		}
+		return null;
+	}
+
+	private static bool ShouldStartDrag(Vector2 pressPos, Vector2 currentPos, float threshold, bool useDragThreshold)
+	{
+		if (!useDragThreshold)
+		{
+			return true;
+		}
+		return (pressPos - currentPos).sqrMagnitude >= threshold * threshold;
+	}
+
+	protected virtual void ProcessMove(PlayerPointerEventData pointerEvent)
+	{
+		GameObject newEnterTarget;
+		if (pointerEvent.sourceType == PointerEventType.Mouse)
+		{
+			IMouseInputSource mouseInputSource = GetMouseInputSource(pointerEvent.playerId, pointerEvent.inputSourceIndex);
+			newEnterTarget = ((mouseInputSource == null) ? null : ((!mouseInputSource.enabled || mouseInputSource.locked) ? null : pointerEvent.pointerCurrentRaycast.gameObject));
+		}
+		else
+		{
+			if (pointerEvent.sourceType != PointerEventType.Touch)
+			{
+				throw new NotImplementedException();
+			}
+			newEnterTarget = pointerEvent.pointerCurrentRaycast.gameObject;
+		}
+		HandlePointerExitAndEnter(pointerEvent, newEnterTarget);
+	}
+
+	protected virtual void ProcessDrag(PlayerPointerEventData pointerEvent)
+	{
+		if (!pointerEvent.IsPointerMoving() || pointerEvent.pointerDrag == null)
+		{
+			return;
+		}
+		if (pointerEvent.sourceType == PointerEventType.Mouse)
+		{
+			IMouseInputSource mouseInputSource = GetMouseInputSource(pointerEvent.playerId, pointerEvent.inputSourceIndex);
+			if (mouseInputSource == null || mouseInputSource.locked || !mouseInputSource.enabled)
+			{
+				return;
+			}
+		}
+		if (!pointerEvent.dragging && ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, base.eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
+		{
+			ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
+			pointerEvent.dragging = true;
+		}
+		if (pointerEvent.dragging)
+		{
+			if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
+			{
+				ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
+				pointerEvent.eligibleForClick = false;
+				pointerEvent.pointerPress = null;
+				pointerEvent.rawPointerPress = null;
+			}
+			ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
+		}
+	}
+
+	public override bool IsPointerOverGameObject(int pointerTypeId)
+	{
+		foreach (KeyValuePair<int, Dictionary<int, PlayerPointerEventData>[]> playerPointerDatum in m_PlayerPointerData)
+		{
+			Dictionary<int, PlayerPointerEventData>[] value = playerPointerDatum.Value;
+			for (int i = 0; i < value.Length; i++)
+			{
+				if (value[i].TryGetValue(pointerTypeId, out var value2) && value2.pointerEnter != null)
+				{
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	protected void ClearSelection()
+	{
+		BaseEventData baseEventData = GetBaseEventData();
+		foreach (KeyValuePair<int, Dictionary<int, PlayerPointerEventData>[]> playerPointerDatum in m_PlayerPointerData)
+		{
+			Dictionary<int, PlayerPointerEventData>[] value = playerPointerDatum.Value;
+			for (int i = 0; i < value.Length; i++)
+			{
+				foreach (KeyValuePair<int, PlayerPointerEventData> item in value[i])
+				{
+					HandlePointerExitAndEnter(item.Value, null);
+				}
+				value[i].Clear();
+			}
+		}
+		base.eventSystem.SetSelectedGameObject(null, baseEventData);
+	}
+
+	public override string ToString()
+	{
+		StringBuilder stringBuilder = new StringBuilder("<b>Pointer Input Module of type: </b>" + GetType());
+		stringBuilder.AppendLine();
+		foreach (KeyValuePair<int, Dictionary<int, PlayerPointerEventData>[]> playerPointerDatum in m_PlayerPointerData)
+		{
+			stringBuilder.AppendLine("<B>Player Id:</b> " + playerPointerDatum.Key);
+			Dictionary<int, PlayerPointerEventData>[] value = playerPointerDatum.Value;
+			for (int i = 0; i < value.Length; i++)
+			{
+				stringBuilder.AppendLine("<B>Pointer Index:</b> " + i);
+				foreach (KeyValuePair<int, PlayerPointerEventData> item in value[i])
+				{
+					stringBuilder.AppendLine("<B>Button Id:</b> " + item.Key);
+					stringBuilder.AppendLine(item.Value.ToString());
+				}
+			}
+		}
+		return stringBuilder.ToString();
+	}
+
+	protected void DeselectIfSelectionChanged(GameObject currentOverGo, BaseEventData pointerEvent)
+	{
+		if (ExecuteEvents.GetEventHandler<ISelectHandler>(currentOverGo) != base.eventSystem.currentSelectedGameObject)
+		{
+			base.eventSystem.SetSelectedGameObject(null, pointerEvent);
+		}
+	}
+
+	protected void CopyFromTo(PointerEventData from, PointerEventData to)
+	{
+		to.position = from.position;
+		to.delta = from.delta;
+		to.scrollDelta = from.scrollDelta;
+		to.pointerCurrentRaycast = from.pointerCurrentRaycast;
+		to.pointerEnter = from.pointerEnter;
+	}
+
+	protected PointerEventData.FramePressState StateForMouseButton(int playerId, int mouseIndex, int buttonId)
+	{
+		IMouseInputSource mouseInputSource = GetMouseInputSource(playerId, mouseIndex);
+		if (mouseInputSource == null)
+		{
+			return PointerEventData.FramePressState.NotChanged;
+		}
+		bool buttonDown = mouseInputSource.GetButtonDown(buttonId);
+		bool buttonUp = mouseInputSource.GetButtonUp(buttonId);
+		if (buttonDown && buttonUp)
+		{
+			return PointerEventData.FramePressState.PressedAndReleased;
+		}
+		if (buttonDown)
+		{
+			return PointerEventData.FramePressState.Pressed;
+		}
+		if (buttonUp)
+		{
+			return PointerEventData.FramePressState.Released;
+		}
+		return PointerEventData.FramePressState.NotChanged;
+	}
+}
diff --git a/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredStandaloneInputModule.cs b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredStandaloneInputModule.cs
new file mode 100644
index 0000000..02245ab
--- /dev/null
+++ b/Thronefall_v1.0/Rewired/Rewired.Integration.UnityUI/RewiredStandaloneInputModule.cs
@@ -0,0 +1,1415 @@
+using System;
+using System.Collections.Generic;
+using Rewired.Components;
+using Rewired.UI;
+using Rewired.Utils;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.Serialization;
+
+namespace Rewired.Integration.UnityUI;
+
+[AddComponentMenu("Rewired/Rewired Standalone Input Module")]
+public sealed class RewiredStandaloneInputModule : RewiredPointerInputModule
+{
+	[Serializable]
+	public class PlayerSetting
+	{
+		public int playerId;
+
+		public List<Rewired.Components.PlayerMouse> playerMice = new List<Rewired.Components.PlayerMouse>();
+
+		public PlayerSetting()
+		{
+		}
+
+		private PlayerSetting(PlayerSetting other)
+		{
+			if (other == null)
+			{
+				throw new ArgumentNullException("other");
+			}
+			playerId = other.playerId;
+			playerMice = new List<Rewired.Components.PlayerMouse>();
+			if (other.playerMice == null)
+			{
+				return;
+			}
+			foreach (Rewired.Components.PlayerMouse item in other.playerMice)
+			{
+				playerMice.Add(item);
+			}
+		}
+
+		public PlayerSetting Clone()
+		{
+			return new PlayerSetting(this);
+		}
+	}
+
+	private const string DEFAULT_ACTION_MOVE_HORIZONTAL = "UIHorizontal";
+
+	private const string DEFAULT_ACTION_MOVE_VERTICAL = "UIVertical";
+
+	private const string DEFAULT_ACTION_SUBMIT = "UISubmit";
+
+	private const string DEFAULT_ACTION_CANCEL = "UICancel";
+
+	[Tooltip("(Optional) Link the Rewired Input Manager here for easier access to Player ids, etc.")]
+	[SerializeField]
+	private InputManager_Base rewiredInputManager;
+
+	[SerializeField]
+	[Tooltip("Use all Rewired game Players to control the UI. This does not include the System Player. If enabled, this setting overrides individual Player Ids set in Rewired Player Ids.")]
+	private bool useAllRewiredGamePlayers;
+
+	[SerializeField]
+	[Tooltip("Allow the Rewired System Player to control the UI.")]
+	private bool useRewiredSystemPlayer;
+
+	[SerializeField]
+	[Tooltip("A list of Player Ids that are allowed to control the UI. If Use All Rewired Game Players = True, this list will be ignored.")]
+	private int[] rewiredPlayerIds = new int[1];
+
+	[SerializeField]
+	[Tooltip("Allow only Players with Player.isPlaying = true to control the UI.")]
+	private bool usePlayingPlayersOnly;
+
+	[SerializeField]
+	[Tooltip("Player Mice allowed to interact with the UI. Each Player that owns a Player Mouse must also be allowed to control the UI or the Player Mouse will not function.")]
+	private List<Rewired.Components.PlayerMouse> playerMice = new List<Rewired.Components.PlayerMouse>();
+
+	[SerializeField]
+	[Tooltip("Makes an axis press always move only one UI selection. Enable if you do not want to allow scrolling through UI elements by holding an axis direction.")]
+	private bool moveOneElementPerAxisPress;
+
+	[SerializeField]
+	[Tooltip("If enabled, Action Ids will be used to set the Actions. If disabled, string names will be used to set the Actions.")]
+	private bool setActionsById;
+
+	[SerializeField]
+	[Tooltip("Id of the horizontal Action for movement (if axis events are used).")]
+	private int horizontalActionId = -1;
+
+	[SerializeField]
+	[Tooltip("Id of the vertical Action for movement (if axis events are used).")]
+	private int verticalActionId = -1;
+
+	[SerializeField]
+	[Tooltip("Id of the Action used to submit.")]
+	private int submitActionId = -1;
+
+	[SerializeField]
+	[Tooltip("Id of the Action used to cancel.")]
+	private int cancelActionId = -1;
+
+	[SerializeField]
+	[Tooltip("Name of the horizontal axis for movement (if axis events are used).")]
+	private string m_HorizontalAxis = "UIHorizontal";
+
+	[SerializeField]
+	[Tooltip("Name of the vertical axis for movement (if axis events are used).")]
+	private string m_VerticalAxis = "UIVertical";
+
+	[SerializeField]
+	[Tooltip("Name of the action used to submit.")]
+	private string m_SubmitButton = "UISubmit";
+
+	[SerializeField]
+	[Tooltip("Name of the action used to cancel.")]
+	private string m_CancelButton = "UICancel";
+
+	[SerializeField]
+	[Tooltip("Number of selection changes allowed per second when a movement button/axis is held in a direction.")]
+	private float m_InputActionsPerSecond = 10f;
+
+	[SerializeField]
+	[Tooltip("Delay in seconds before vertical/horizontal movement starts repeating continouously when a movement direction is held.")]
+	private float m_RepeatDelay;
+
+	[SerializeField]
+	[Tooltip("Allows the mouse to be used to select elements.")]
+	private bool m_allowMouseInput = true;
+
+	[SerializeField]
+	[Tooltip("Allows the mouse to be used to select elements if the device also supports touch control.")]
+	private bool m_allowMouseInputIfTouchSupported = true;
+
+	[SerializeField]
+	[Tooltip("Allows touch input to be used to select elements.")]
+	private bool m_allowTouchInput = true;
+
+	[SerializeField]
+	[Tooltip("Deselects the current selection on mouse/touch click when the pointer is not over a selectable object.")]
+	private bool m_deselectIfBackgroundClicked = true;
+
+	[SerializeField]
+	[Tooltip("Deselects the current selection on mouse/touch click before selecting the next object.")]
+	private bool m_deselectBeforeSelecting = true;
+
+	[SerializeField]
+	[FormerlySerializedAs("m_AllowActivationOnMobileDevice")]
+	[Tooltip("Forces the module to always be active.")]
+	private bool m_ForceModuleActive;
+
+	[NonSerialized]
+	private int[] playerIds;
+
+	private bool recompiling;
+
+	[NonSerialized]
+	private bool isTouchSupported;
+
+	[NonSerialized]
+	private double m_PrevActionTime;
+
+	[NonSerialized]
+	private Vector2 m_LastMoveVector;
+
+	[NonSerialized]
+	private int m_ConsecutiveMoveCount;
+
+	[NonSerialized]
+	private bool m_HasFocus = true;
+
+	public InputManager_Base RewiredInputManager
+	{
+		get
+		{
+			return rewiredInputManager;
+		}
+		set
+		{
+			rewiredInputManager = value;
+		}
+	}
+
+	public bool UseAllRewiredGamePlayers
+	{
+		get
+		{
+			return useAllRewiredGamePlayers;
+		}
+		set
+		{
+			bool num = value != useAllRewiredGamePlayers;
+			useAllRewiredGamePlayers = value;
+			if (num)
+			{
+				SetupRewiredVars();
+			}
+		}
+	}
+
+	public bool UseRewiredSystemPlayer
+	{
+		get
+		{
+			return useRewiredSystemPlayer;
+		}
+		set
+		{
+			bool num = value != useRewiredSystemPlayer;
+			useRewiredSystemPlayer = value;
+			if (num)
+			{
+				SetupRewiredVars();
+			}
+		}
+	}
+
+	public int[] RewiredPlayerIds
+	{
+		get
+		{
+			return (int[])rewiredPlayerIds.Clone();
+		}
+		set
+		{
+			rewiredPlayerIds = ((value != null) ? ((int[])value.Clone()) : new int[0]);
+			SetupRewiredVars();
+		}
+	}
+
+	public bool UsePlayingPlayersOnly
+	{
+		get
+		{
+			return usePlayingPlayersOnly;
+		}
+		set
+		{
+			usePlayingPlayersOnly = value;
+		}
+	}
+
+	public List<Rewired.Components.PlayerMouse> PlayerMice
+	{
+		get
+		{
+			return new List<Rewired.Components.PlayerMouse>(playerMice);
+		}
+		set
+		{
+			if (value == null)
+			{
+				playerMice = new List<Rewired.Components.PlayerMouse>();
+				SetupRewiredVars();
+			}
+			else
+			{
+				playerMice = new List<Rewired.Components.PlayerMouse>(value);
+				SetupRewiredVars();
+			}
+		}
+	}
+
+	public bool MoveOneElementPerAxisPress
+	{
+		get
+		{
+			return moveOneElementPerAxisPress;
+		}
+		set
+		{
+			moveOneElementPerAxisPress = value;
+		}
+	}
+
+	public bool allowMouseInput
+	{
+		get
+		{
+			return m_allowMouseInput;
+		}
+		set
+		{
+			m_allowMouseInput = value;
+		}
+	}
+
+	public bool allowMouseInputIfTouchSupported
+	{
+		get
+		{
+			return m_allowMouseInputIfTouchSupported;
+		}
+		set
+		{
+			m_allowMouseInputIfTouchSupported = value;
+		}
+	}
+
+	public bool allowTouchInput
+	{
+		get
+		{
+			return m_allowTouchInput;
+		}
+		set
+		{
+			m_allowTouchInput = value;
+		}
+	}
+
+	public bool deselectIfBackgroundClicked
+	{
+		get
+		{
+			return m_deselectIfBackgroundClicked;
+		}
+		set
+		{
+			m_deselectIfBackgroundClicked = value;
+		}
+	}
+
+	private bool deselectBeforeSelecting
+	{
+		get
+		{
+			return m_deselectBeforeSelecting;
+		}
+		set
+		{
+			m_deselectBeforeSelecting = value;
+		}
+	}
+
+	public bool SetActionsById
+	{
+		get
+		{
+			return setActionsById;
+		}
+		set
+		{
+			if (setActionsById != value)
+			{
+				setActionsById = value;
+				SetupRewiredVars();
+			}
+		}
+	}
+
+	public int HorizontalActionId
+	{
+		get
+		{
+			return horizontalActionId;
+		}
+		set
+		{
+			if (value != horizontalActionId)
+			{
+				horizontalActionId = value;
+				if (ReInput.isReady)
+				{
+					m_HorizontalAxis = ((ReInput.mapping.GetAction(value) != null) ? ReInput.mapping.GetAction(value).name : string.Empty);
+				}
+			}
+		}
+	}
+
+	public int VerticalActionId
+	{
+		get
+		{
+			return verticalActionId;
+		}
+		set
+		{
+			if (value != verticalActionId)
+			{
+				verticalActionId = value;
+				if (ReInput.isReady)
+				{
+					m_VerticalAxis = ((ReInput.mapping.GetAction(value) != null) ? ReInput.mapping.GetAction(value).name : string.Empty);
+				}
+			}
+		}
+	}
+
+	public int SubmitActionId
+	{
+		get
+		{
+			return submitActionId;
+		}
+		set
+		{
+			if (value != submitActionId)
+			{
+				submitActionId = value;
+				if (ReInput.isReady)
+				{
+					m_SubmitButton = ((ReInput.mapping.GetAction(value) != null) ? ReInput.mapping.GetAction(value).name : string.Empty);
+				}
+			}
+		}
+	}
+
+	public int CancelActionId
+	{
+		get
+		{
+			return cancelActionId;
+		}
+		set
+		{
+			if (value != cancelActionId)
+			{
+				cancelActionId = value;
+				if (ReInput.isReady)
+				{
+					m_CancelButton = ((ReInput.mapping.GetAction(value) != null) ? ReInput.mapping.GetAction(value).name : string.Empty);
+				}
+			}
+		}
+	}
+
+	protected override bool isMouseSupported
+	{
+		get
+		{
+			if (!base.isMouseSupported)
+			{
+				return false;
+			}
+			if (!m_allowMouseInput)
+			{
+				return false;
+			}
+			if (!isTouchSupported)
+			{
+				return true;
+			}
+			return m_allowMouseInputIfTouchSupported;
+		}
+	}
+
+	private bool isTouchAllowed => m_allowTouchInput;
+
+	[Obsolete("allowActivationOnMobileDevice has been deprecated. Use forceModuleActive instead")]
+	public bool allowActivationOnMobileDevice
+	{
+		get
+		{
+			return m_ForceModuleActive;
+		}
+		set
+		{
+			m_ForceModuleActive = value;
+		}
+	}
+
+	public bool forceModuleActive
+	{
+		get
+		{
+			return m_ForceModuleActive;
+		}
+		set
+		{
+			m_ForceModuleActive = value;
+		}
+	}
+
+	public float inputActionsPerSecond
+	{
+		get
+		{
+			return m_InputActionsPerSecond;
+		}
+		set
+		{
+			m_InputActionsPerSecond = value;
+		}
+	}
+
+	public float repeatDelay
+	{
+		get
+		{
+			return m_RepeatDelay;
+		}
+		set
+		{
+			m_RepeatDelay = value;
+		}
+	}
+
+	public string horizontalAxis
+	{
+		get
+		{
+			return m_HorizontalAxis;
+		}
+		set
+		{
+			if (!(m_HorizontalAxis == value))
+			{
+				m_HorizontalAxis = value;
+				if (ReInput.isReady)
+				{
+					horizontalActionId = ReInput.mapping.GetActionId(value);
+				}
+			}
+		}
+	}
+
+	public string verticalAxis
+	{
+		get
+		{
+			return m_VerticalAxis;
+		}
+		set
+		{
+			if (!(m_VerticalAxis == value))
+			{
+				m_VerticalAxis = value;
+				if (ReInput.isReady)
+				{
+					verticalActionId = ReInput.mapping.GetActionId(value);
+				}
+			}
+		}
+	}
+
+	public string submitButton
+	{
+		get
+		{
+			return m_SubmitButton;
+		}
+		set
+		{
+			if (!(m_SubmitButton == value))
+			{
+				m_SubmitButton = value;
+				if (ReInput.isReady)
+				{
+					submitActionId = ReInput.mapping.GetActionId(value);
+				}
+			}
+		}
+	}
+
+	public string cancelButton
+	{
+		get
+		{
+			return m_CancelButton;
+		}
+		set
+		{
+			if (!(m_CancelButton == value))
+			{
+				m_CancelButton = value;
+				if (ReInput.isReady)
+				{
+					cancelActionId = ReInput.mapping.GetActionId(value);
+				}
+			}
+		}
+	}
+
+	private RewiredStandaloneInputModule()
+	{
+	}
+
+	protected override void Awake()
+	{
+		base.Awake();
+		isTouchSupported = base.defaultTouchInputSource.touchSupported;
+		TouchInputModule component = GetComponent<TouchInputModule>();
+		if (component != null)
+		{
+			component.enabled = false;
+		}
+		ReInput.InitializedEvent += OnRewiredInitialized;
+		InitializeRewired();
+	}
+
+	public override void UpdateModule()
+	{
+		CheckEditorRecompile();
+		if (!recompiling && ReInput.isReady && !m_HasFocus)
+		{
+			ShouldIgnoreEventsOnNoFocus();
+		}
+	}
+
+	public override bool IsModuleSupported()
+	{
+		return true;
+	}
+
+	public override bool ShouldActivateModule()
+	{
+		if (!base.ShouldActivateModule())
+		{
+			return false;
+		}
+		if (recompiling)
+		{
+			return false;
+		}
+		if (!ReInput.isReady)
+		{
+			return false;
+		}
+		bool flag = m_ForceModuleActive;
+		for (int i = 0; i < playerIds.Length; i++)
+		{
+			Player player = ReInput.players.GetPlayer(playerIds[i]);
+			if (player != null && (!usePlayingPlayersOnly || player.isPlaying))
+			{
+				flag |= GetButtonDown(player, submitActionId);
+				flag |= GetButtonDown(player, cancelActionId);
+				if (moveOneElementPerAxisPress)
+				{
+					flag |= GetButtonDown(player, horizontalActionId) || GetNegativeButtonDown(player, horizontalActionId);
+					flag |= GetButtonDown(player, verticalActionId) || GetNegativeButtonDown(player, verticalActionId);
+				}
+				else
+				{
+					flag |= !Mathf.Approximately(GetAxis(player, horizontalActionId), 0f);
+					flag |= !Mathf.Approximately(GetAxis(player, verticalActionId), 0f);
+				}
+			}
+		}
+		if (isMouseSupported)
+		{
+			flag |= DidAnyMouseMove();
+			flag |= GetMouseButtonDownOnAnyMouse(0);
+		}
+		if (isTouchAllowed)
+		{
+			for (int j = 0; j < base.defaultTouchInputSource.touchCount; j++)
+			{
+				Touch touch = base.defaultTouchInputSource.GetTouch(j);
+				flag |= touch.phase == TouchPhase.Began || touch.phase == TouchPhase.Moved || touch.phase == TouchPhase.Stationary;
+			}
+		}
+		return flag;
+	}
+
+	public override void ActivateModule()
+	{
+		if (m_HasFocus || !ShouldIgnoreEventsOnNoFocus())
+		{
+			base.ActivateModule();
+			GameObject gameObject = base.eventSystem.currentSelectedGameObject;
+			if (gameObject == null)
+			{
+				gameObject = base.eventSystem.firstSelectedGameObject;
+			}
+			base.eventSystem.SetSelectedGameObject(gameObject, GetBaseEventData());
+		}
+	}
+
+	public override void DeactivateModule()
+	{
+		base.DeactivateModule();
+		ClearSelection();
+	}
+
+	public override void Process()
+	{
+		if (!ReInput.isReady || (!m_HasFocus && ShouldIgnoreEventsOnNoFocus()) || !base.enabled || !base.gameObject.activeInHierarchy)
+		{
+			return;
+		}
+		bool flag = SendUpdateEventToSelectedObject();
+		if (base.eventSystem.sendNavigationEvents)
+		{
+			if (!flag)
+			{
+				flag |= SendMoveEventToSelectedObject();
+			}
+			if (!flag)
+			{
+				SendSubmitEventToSelectedObject();
+			}
+		}
+		if (!ProcessTouchEvents() && isMouseSupported)
+		{
+			ProcessMouseEvents();
+		}
+	}
+
+	private bool ProcessTouchEvents()
+	{
+		if (!isTouchAllowed)
+		{
+			return false;
+		}
+		for (int i = 0; i < base.defaultTouchInputSource.touchCount; i++)
+		{
+			Touch touch = base.defaultTouchInputSource.GetTouch(i);
+			if (touch.type != TouchType.Indirect)
+			{
+				bool pressed;
+				bool released;
+				PlayerPointerEventData touchPointerEventData = GetTouchPointerEventData(0, 0, touch, out pressed, out released);
+				ProcessTouchPress(touchPointerEventData, pressed, released);
+				if (!released)
+				{
+					ProcessMove(touchPointerEventData);
+					ProcessDrag(touchPointerEventData);
+				}
+				else
+				{
+					RemovePointerData(touchPointerEventData);
+				}
+			}
+		}
+		return base.defaultTouchInputSource.touchCount > 0;
+	}
+
+	private void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released)
+	{
+		GameObject gameObject = pointerEvent.pointerCurrentRaycast.gameObject;
+		if (pressed)
+		{
+			pointerEvent.eligibleForClick = true;
+			pointerEvent.delta = Vector2.zero;
+			pointerEvent.dragging = false;
+			pointerEvent.useDragThreshold = true;
+			pointerEvent.pressPosition = pointerEvent.position;
+			pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast;
+			HandleMouseTouchDeselectionOnSelectionChanged(gameObject, pointerEvent);
+			if (pointerEvent.pointerEnter != gameObject)
+			{
+				HandlePointerExitAndEnter(pointerEvent, gameObject);
+				pointerEvent.pointerEnter = gameObject;
+			}
+			GameObject gameObject2 = ExecuteEvents.ExecuteHierarchy(gameObject, pointerEvent, ExecuteEvents.pointerDownHandler);
+			if (gameObject2 == null)
+			{
+				gameObject2 = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
+			}
+			double unscaledTime = ReInput.time.unscaledTime;
+			if (gameObject2 == pointerEvent.lastPress)
+			{
+				if (unscaledTime - (double)pointerEvent.clickTime < 0.30000001192092896)
+				{
+					int clickCount = pointerEvent.clickCount + 1;
+					pointerEvent.clickCount = clickCount;
+				}
+				else
+				{
+					pointerEvent.clickCount = 1;
+				}
+				pointerEvent.clickTime = (float)unscaledTime;
+			}
+			else
+			{
+				pointerEvent.clickCount = 1;
+			}
+			pointerEvent.pointerPress = gameObject2;
+			pointerEvent.rawPointerPress = gameObject;
+			pointerEvent.clickTime = (float)unscaledTime;
+			pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(gameObject);
+			if (pointerEvent.pointerDrag != null)
+			{
+				ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
+			}
+		}
+		if (released)
+		{
+			ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
+			GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
+			if (pointerEvent.pointerPress == eventHandler && pointerEvent.eligibleForClick)
+			{
+				ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler);
+			}
+			else if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
+			{
+				ExecuteEvents.ExecuteHierarchy(gameObject, pointerEvent, ExecuteEvents.dropHandler);
+			}
+			pointerEvent.eligibleForClick = false;
+			pointerEvent.pointerPress = null;
+			pointerEvent.rawPointerPress = null;
+			if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
+			{
+				ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
+			}
+			pointerEvent.dragging = false;
+			pointerEvent.pointerDrag = null;
+			if (pointerEvent.pointerDrag != null)
+			{
+				ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
+			}
+			pointerEvent.pointerDrag = null;
+			ExecuteEvents.ExecuteHierarchy(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler);
+			pointerEvent.pointerEnter = null;
+		}
+	}
+
+	private bool SendSubmitEventToSelectedObject()
+	{
+		if (base.eventSystem.currentSelectedGameObject == null)
+		{
+			return false;
+		}
+		if (recompiling)
+		{
+			return false;
+		}
+		BaseEventData baseEventData = GetBaseEventData();
+		for (int i = 0; i < playerIds.Length; i++)
+		{
+			Player player = ReInput.players.GetPlayer(playerIds[i]);
+			if (player != null && (!usePlayingPlayersOnly || player.isPlaying))
+			{
+				if (GetButtonDown(player, submitActionId))
+				{
+					ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.submitHandler);
+					break;
+				}
+				if (GetButtonDown(player, cancelActionId))
+				{
+					ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.cancelHandler);
+					break;
+				}
+			}
+		}
+		return baseEventData.used;
+	}
+
+	private Vector2 GetRawMoveVector()
+	{
+		if (recompiling)
+		{
+			return Vector2.zero;
+		}
+		Vector2 zero = Vector2.zero;
+		for (int i = 0; i < playerIds.Length; i++)
+		{
+			Player player = ReInput.players.GetPlayer(playerIds[i]);
+			if (player == null || (usePlayingPlayersOnly && !player.isPlaying))
+			{
+				continue;
+			}
+			float num = GetAxis(player, horizontalActionId);
+			float num2 = GetAxis(player, verticalActionId);
+			if (Mathf.Approximately(num, 0f))
+			{
+				num = 0f;
+			}
+			if (Mathf.Approximately(num2, 0f))
+			{
+				num2 = 0f;
+			}
+			if (moveOneElementPerAxisPress)
+			{
+				if (GetButtonDown(player, horizontalActionId) && num > 0f)
+				{
+					zero.x += 1f;
+				}
+				if (GetNegativeButtonDown(player, horizontalActionId) && num < 0f)
+				{
+					zero.x -= 1f;
+				}
+				if (GetButtonDown(player, verticalActionId) && num2 > 0f)
+				{
+					zero.y += 1f;
+				}
+				if (GetNegativeButtonDown(player, verticalActionId) && num2 < 0f)
+				{
+					zero.y -= 1f;
+				}
+			}
+			else
+			{
+				if (GetButton(player, horizontalActionId) && num > 0f)
+				{
+					zero.x += 1f;
+				}
+				if (GetNegativeButton(player, horizontalActionId) && num < 0f)
+				{
+					zero.x -= 1f;
+				}
+				if (GetButton(player, verticalActionId) && num2 > 0f)
+				{
+					zero.y += 1f;
+				}
+				if (GetNegativeButton(player, verticalActionId) && num2 < 0f)
+				{
+					zero.y -= 1f;
+				}
+			}
+		}
+		return zero;
+	}
+
+	private bool SendMoveEventToSelectedObject()
+	{
+		if (recompiling)
+		{
+			return false;
+		}
+		double unscaledTime = ReInput.time.unscaledTime;
+		Vector2 rawMoveVector = GetRawMoveVector();
+		if (Mathf.Approximately(rawMoveVector.x, 0f) && Mathf.Approximately(rawMoveVector.y, 0f))
+		{
+			m_ConsecutiveMoveCount = 0;
+			return false;
+		}
+		bool flag = Vector2.Dot(rawMoveVector, m_LastMoveVector) > 0f;
+		CheckButtonOrKeyMovement(out var downHorizontal, out var downVertical);
+		AxisEventData axisEventData = null;
+		bool flag2 = downHorizontal || downVertical;
+		if (flag2)
+		{
+			axisEventData = GetAxisEventData(rawMoveVector.x, rawMoveVector.y, 0f);
+			MoveDirection moveDir = axisEventData.moveDir;
+			flag2 = ((moveDir == MoveDirection.Up || moveDir == MoveDirection.Down) && downVertical) || ((moveDir == MoveDirection.Left || moveDir == MoveDirection.Right) && downHorizontal);
+		}
+		if (!flag2)
+		{
+			flag2 = ((!(m_RepeatDelay > 0f)) ? (unscaledTime > m_PrevActionTime + (double)(1f / m_InputActionsPerSecond)) : ((!flag || m_ConsecutiveMoveCount != 1) ? (unscaledTime > m_PrevActionTime + (double)(1f / m_InputActionsPerSecond)) : (unscaledTime > m_PrevActionTime + (double)m_RepeatDelay)));
+		}
+		if (!flag2)
+		{
+			return false;
+		}
+		if (axisEventData == null)
+		{
+			axisEventData = GetAxisEventData(rawMoveVector.x, rawMoveVector.y, 0f);
+		}
+		if (axisEventData.moveDir != MoveDirection.None)
+		{
+			ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, axisEventData, ExecuteEvents.moveHandler);
+			if (!flag)
+			{
+				m_ConsecutiveMoveCount = 0;
+			}
+			if (m_ConsecutiveMoveCount == 0 || !(downHorizontal || downVertical))
+			{
+				m_ConsecutiveMoveCount++;
+			}
+			m_PrevActionTime = unscaledTime;
+			m_LastMoveVector = rawMoveVector;
+		}
+		else
+		{
+			m_ConsecutiveMoveCount = 0;
+		}
+		return axisEventData.used;
+	}
+
+	private void CheckButtonOrKeyMovement(out bool downHorizontal, out bool downVertical)
+	{
+		downHorizontal = false;
+		downVertical = false;
+		for (int i = 0; i < playerIds.Length; i++)
+		{
+			Player player = ReInput.players.GetPlayer(playerIds[i]);
+			if (player != null && (!usePlayingPlayersOnly || player.isPlaying))
+			{
+				downHorizontal |= GetButtonDown(player, horizontalActionId) || GetNegativeButtonDown(player, horizontalActionId);
+				downVertical |= GetButtonDown(player, verticalActionId) || GetNegativeButtonDown(player, verticalActionId);
+			}
+		}
+	}
+
+	private void ProcessMouseEvents()
+	{
+		for (int i = 0; i < playerIds.Length; i++)
+		{
+			Player player = ReInput.players.GetPlayer(playerIds[i]);
+			if (player != null && (!usePlayingPlayersOnly || player.isPlaying))
+			{
+				int mouseInputSourceCount = GetMouseInputSourceCount(playerIds[i]);
+				for (int j = 0; j < mouseInputSourceCount; j++)
+				{
+					ProcessMouseEvent(playerIds[i], j);
+				}
+			}
+		}
+	}
+
+	private void ProcessMouseEvent(int playerId, int pointerIndex)
+	{
+		MouseState mousePointerEventData = GetMousePointerEventData(playerId, pointerIndex);
+		if (mousePointerEventData == null)
+		{
+			return;
+		}
+		MouseButtonEventData eventData = mousePointerEventData.GetButtonState(0).eventData;
+		ProcessMousePress(eventData);
+		ProcessMove(eventData.buttonData);
+		ProcessDrag(eventData.buttonData);
+		ProcessMousePress(mousePointerEventData.GetButtonState(1).eventData);
+		ProcessDrag(mousePointerEventData.GetButtonState(1).eventData.buttonData);
+		ProcessMousePress(mousePointerEventData.GetButtonState(2).eventData);
+		ProcessDrag(mousePointerEventData.GetButtonState(2).eventData.buttonData);
+		IMouseInputSource mouseInputSource = GetMouseInputSource(playerId, pointerIndex);
+		if (mouseInputSource != null)
+		{
+			for (int i = 3; i < mouseInputSource.buttonCount; i++)
+			{
+				ProcessMousePress(mousePointerEventData.GetButtonState(i).eventData);
+				ProcessDrag(mousePointerEventData.GetButtonState(i).eventData.buttonData);
+			}
+			if (!Mathf.Approximately(eventData.buttonData.scrollDelta.sqrMagnitude, 0f))
+			{
+				ExecuteEvents.ExecuteHierarchy(ExecuteEvents.GetEventHandler<IScrollHandler>(eventData.buttonData.pointerCurrentRaycast.gameObject), eventData.buttonData, ExecuteEvents.scrollHandler);
+			}
+		}
+	}
+
+	private bool SendUpdateEventToSelectedObject()
+	{
+		if (base.eventSystem.currentSelectedGameObject == null)
+		{
+			return false;
+		}
+		BaseEventData baseEventData = GetBaseEventData();
+		ExecuteEvents.Execute(base.eventSystem.currentSelectedGameObject, baseEventData, ExecuteEvents.updateSelectedHandler);
+		return baseEventData.used;
+	}
+
+	private void ProcessMousePress(MouseButtonEventData data)
+	{
+		PlayerPointerEventData buttonData = data.buttonData;
+		if (GetMouseInputSource(buttonData.playerId, buttonData.inputSourceIndex) == null)
+		{
+			return;
+		}
+		GameObject gameObject = buttonData.pointerCurrentRaycast.gameObject;
+		if (data.PressedThisFrame())
+		{
+			buttonData.eligibleForClick = true;
+			buttonData.delta = Vector2.zero;
+			buttonData.dragging = false;
+			buttonData.useDragThreshold = true;
+			buttonData.pressPosition = buttonData.position;
+			buttonData.pointerPressRaycast = buttonData.pointerCurrentRaycast;
+			HandleMouseTouchDeselectionOnSelectionChanged(gameObject, buttonData);
+			GameObject gameObject2 = ExecuteEvents.ExecuteHierarchy(gameObject, buttonData, ExecuteEvents.pointerDownHandler);
+			if (gameObject2 == null)
+			{
+				gameObject2 = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
+			}
+			double unscaledTime = ReInput.time.unscaledTime;
+			if (gameObject2 == buttonData.lastPress)
+			{
+				if (unscaledTime - (double)buttonData.clickTime < 0.30000001192092896)
+				{
+					int clickCount = buttonData.clickCount + 1;
+					buttonData.clickCount = clickCount;
+				}
+				else
+				{
+					buttonData.clickCount = 1;
+				}
+				buttonData.clickTime = (float)unscaledTime;
+			}
+			else
+			{
+				buttonData.clickCount = 1;
+			}
+			buttonData.pointerPress = gameObject2;
+			buttonData.rawPointerPress = gameObject;
+			buttonData.clickTime = (float)unscaledTime;
+			buttonData.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(gameObject);
+			if (buttonData.pointerDrag != null)
+			{
+				ExecuteEvents.Execute(buttonData.pointerDrag, buttonData, ExecuteEvents.initializePotentialDrag);
+			}
+		}
+		if (data.ReleasedThisFrame())
+		{
+			ExecuteEvents.Execute(buttonData.pointerPress, buttonData, ExecuteEvents.pointerUpHandler);
+			GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(gameObject);
+			if (buttonData.pointerPress == eventHandler && buttonData.eligibleForClick)
+			{
+				ExecuteEvents.Execute(buttonData.pointerPress, buttonData, ExecuteEvents.pointerClickHandler);
+			}
+			else if (buttonData.pointerDrag != null && buttonData.dragging)
+			{
+				ExecuteEvents.ExecuteHierarchy(gameObject, buttonData, ExecuteEvents.dropHandler);
+			}
+			buttonData.eligibleForClick = false;
+			buttonData.pointerPress = null;
+			buttonData.rawPointerPress = null;
+			if (buttonData.pointerDrag != null && buttonData.dragging)
+			{
+				ExecuteEvents.Execute(buttonData.pointerDrag, buttonData, ExecuteEvents.endDragHandler);
+			}
+			buttonData.dragging = false;
+			buttonData.pointerDrag = null;
+			if (gameObject != buttonData.pointerEnter)
+			{
+				HandlePointerExitAndEnter(buttonData, null);
+				HandlePointerExitAndEnter(buttonData, gameObject);
+			}
+		}
+	}
+
+	private void HandleMouseTouchDeselectionOnSelectionChanged(GameObject currentOverGo, BaseEventData pointerEvent)
+	{
+		if (m_deselectIfBackgroundClicked && m_deselectBeforeSelecting)
+		{
+			DeselectIfSelectionChanged(currentOverGo, pointerEvent);
+			return;
+		}
+		GameObject eventHandler = ExecuteEvents.GetEventHandler<ISelectHandler>(currentOverGo);
+		if (m_deselectIfBackgroundClicked)
+		{
+			if (eventHandler != base.eventSystem.currentSelectedGameObject && eventHandler != null)
+			{
+				base.eventSystem.SetSelectedGameObject(null, pointerEvent);
+			}
+		}
+		else if (m_deselectBeforeSelecting && eventHandler != null && eventHandler != base.eventSystem.currentSelectedGameObject)
+		{
+			base.eventSystem.SetSelectedGameObject(null, pointerEvent);
+		}
+	}
+
+	private void OnApplicationFocus(bool hasFocus)
+	{
+		m_HasFocus = hasFocus;
+	}
+
+	private bool ShouldIgnoreEventsOnNoFocus()
+	{
+		if (!ReInput.isReady)
+		{
+			return true;
+		}
+		return ReInput.configuration.ignoreInputWhenAppNotInFocus;
+	}
+
+	protected override void OnDestroy()
+	{
+		base.OnDestroy();
+		ReInput.InitializedEvent -= OnRewiredInitialized;
+		ReInput.ShutDownEvent -= OnRewiredShutDown;
+		ReInput.EditorRecompileEvent -= OnEditorRecompile;
+	}
+
+	protected override bool IsDefaultPlayer(int playerId)
+	{
+		if (playerIds == null)
+		{
+			return false;
+		}
+		if (!ReInput.isReady)
+		{
+			return false;
+		}
+		for (int i = 0; i < 3; i++)
+		{
+			for (int j = 0; j < playerIds.Length; j++)
+			{
+				Player player = ReInput.players.GetPlayer(playerIds[j]);
+				if (player != null && (i >= 1 || !usePlayingPlayersOnly || player.isPlaying) && (i >= 2 || player.controllers.hasMouse))
+				{
+					return playerIds[j] == playerId;
+				}
+			}
+		}
+		return false;
+	}
+
+	private void InitializeRewired()
+	{
+		if (!ReInput.isReady)
+		{
+			Debug.LogError("Rewired is not initialized! Are you missing a Rewired Input Manager in your scene?");
+			return;
+		}
+		ReInput.ShutDownEvent -= OnRewiredShutDown;
+		ReInput.ShutDownEvent += OnRewiredShutDown;
+		ReInput.EditorRecompileEvent -= OnEditorRecompile;
+		ReInput.EditorRecompileEvent += OnEditorRecompile;
+		SetupRewiredVars();
+	}
+
+	private void SetupRewiredVars()
+	{
+		if (!ReInput.isReady)
+		{
+			return;
+		}
+		SetUpRewiredActions();
+		if (useAllRewiredGamePlayers)
+		{
+			IList<Player> list = (useRewiredSystemPlayer ? ReInput.players.AllPlayers : ReInput.players.Players);
+			playerIds = new int[list.Count];
+			for (int i = 0; i < list.Count; i++)
+			{
+				playerIds[i] = list[i].id;
+			}
+		}
+		else
+		{
+			bool flag = false;
+			List<int> list2 = new List<int>(rewiredPlayerIds.Length + 1);
+			for (int j = 0; j < rewiredPlayerIds.Length; j++)
+			{
+				Player player = ReInput.players.GetPlayer(rewiredPlayerIds[j]);
+				if (player != null && !list2.Contains(player.id))
+				{
+					list2.Add(player.id);
+					if (player.id == 9999999)
+					{
+						flag = true;
+					}
+				}
+			}
+			if (useRewiredSystemPlayer && !flag)
+			{
+				list2.Insert(0, ReInput.players.GetSystemPlayer().id);
+			}
+			playerIds = list2.ToArray();
+		}
+		SetUpRewiredPlayerMice();
+	}
+
+	private void SetUpRewiredPlayerMice()
+	{
+		if (!ReInput.isReady)
+		{
+			return;
+		}
+		ClearMouseInputSources();
+		for (int i = 0; i < playerMice.Count; i++)
+		{
+			Rewired.Components.PlayerMouse playerMouse = playerMice[i];
+			if (!UnityTools.IsNullOrDestroyed(playerMouse))
+			{
+				AddMouseInputSource(playerMouse);
+			}
+		}
+	}
+
+	private void SetUpRewiredActions()
+	{
+		if (!ReInput.isReady)
+		{
+			return;
+		}
+		if (!setActionsById)
+		{
+			horizontalActionId = ReInput.mapping.GetActionId(m_HorizontalAxis);
+			verticalActionId = ReInput.mapping.GetActionId(m_VerticalAxis);
+			submitActionId = ReInput.mapping.GetActionId(m_SubmitButton);
+			cancelActionId = ReInput.mapping.GetActionId(m_CancelButton);
+			return;
+		}
+		InputAction action = ReInput.mapping.GetAction(horizontalActionId);
+		m_HorizontalAxis = ((action != null) ? action.name : string.Empty);
+		if (action == null)
+		{
+			horizontalActionId = -1;
+		}
+		action = ReInput.mapping.GetAction(verticalActionId);
+		m_VerticalAxis = ((action != null) ? action.name : string.Empty);
+		if (action == null)
+		{
+			verticalActionId = -1;
+		}
+		action = ReInput.mapping.GetAction(submitActionId);
+		m_SubmitButton = ((action != null) ? action.name : string.Empty);
+		if (action == null)
+		{
+			submitActionId = -1;
+		}
+		action = ReInput.mapping.GetAction(cancelActionId);
+		m_CancelButton = ((action != null) ? action.name : string.Empty);
+		if (action == null)
+		{
+			cancelActionId = -1;
+		}
+	}
+
+	private bool GetButton(Player player, int actionId)
+	{
+		if (actionId < 0)
+		{
+			return false;
+		}
+		return player.GetButton(actionId);
+	}
+
+	private bool GetButtonDown(Player player, int actionId)
+	{
+		if (actionId < 0)
+		{
+			return false;
+		}
+		return player.GetButtonDown(actionId);
+	}
+
+	private bool GetNegativeButton(Player player, int actionId)
+	{
+		if (actionId < 0)
+		{
+			return false;
+		}
+		return player.GetNegativeButton(actionId);
+	}
+
+	private bool GetNegativeButtonDown(Player player, int actionId)
+	{
+		if (actionId < 0)
+		{
+			return false;
+		}
+		return player.GetNegativeButtonDown(actionId);
+	}
+
+	private float GetAxis(Player player, int actionId)
+	{
+		if (actionId < 0)
+		{
+			return 0f;
+		}
+		return player.GetAxis(actionId);
+	}
+
+	private void CheckEditorRecompile()
+	{
+		if (recompiling && ReInput.isReady)
+		{
+			recompiling = false;
+			InitializeRewired();
+		}
+	}
+
+	private void OnEditorRecompile()
+	{
+		recompiling = true;
+		ClearRewiredVars();
+	}
+
+	private void ClearRewiredVars()
+	{
+		Array.Clear(playerIds, 0, playerIds.Length);
+		ClearMouseInputSources();
+	}
+
+	private bool DidAnyMouseMove()
+	{
+		for (int i = 0; i < playerIds.Length; i++)
+		{
+			int playerId = playerIds[i];
+			Player player = ReInput.players.GetPlayer(playerId);
+			if (player == null || (usePlayingPlayersOnly && !player.isPlaying))
+			{
+				continue;
+			}
+			int mouseInputSourceCount = GetMouseInputSourceCount(playerId);
+			for (int j = 0; j < mouseInputSourceCount; j++)
+			{
+				IMouseInputSource mouseInputSource = GetMouseInputSource(playerId, j);
+				if (mouseInputSource != null && mouseInputSource.screenPositionDelta.sqrMagnitude > 0f)
+				{
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	private bool GetMouseButtonDownOnAnyMouse(int buttonIndex)
+	{
+		for (int i = 0; i < playerIds.Length; i++)
+		{
+			int playerId = playerIds[i];
+			Player player = ReInput.players.GetPlayer(playerId);
+			if (player == null || (usePlayingPlayersOnly && !player.isPlaying))
+			{
+				continue;
+			}
+			int mouseInputSourceCount = GetMouseInputSourceCount(playerId);
+			for (int j = 0; j < mouseInputSourceCount; j++)
+			{
+				IMouseInputSource mouseInputSource = GetMouseInputSource(playerId, j);
+				if (mouseInputSource != null && mouseInputSource.GetButtonDown(buttonIndex))
+				{
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	private void OnRewiredInitialized()
+	{
+		InitializeRewired();
+	}
+
+	private void OnRewiredShutDown()
+	{
+		ClearRewiredVars();
+	}
+}