From 38740bfef035f7b96642f63a4a9773d2dbfaf1c1 Mon Sep 17 00:00:00 2001 From: "Simon (darkside) Jackson" Date: Mon, 12 Oct 2020 23:27:57 +0100 Subject: [PATCH] Finalised new InputManagerHelper, which translates input based on the operating input system, new or old Updated CardStack2D to have defined keyboard input or specific gamepad input over the older axisname for new input system. --- .../Layout/CardUI/2D Cards/CardStack2D.cs | 187 ++++++++-------- .../Utilities/UIExtensionsInputManager.cs | 206 ++++++++++++++++++ Runtime/UnityUIExtensions.asmdef | 6 +- 3 files changed, 305 insertions(+), 94 deletions(-) diff --git a/Runtime/Scripts/Layout/CardUI/2D Cards/CardStack2D.cs b/Runtime/Scripts/Layout/CardUI/2D Cards/CardStack2D.cs index 453f8dd..61487c1 100644 --- a/Runtime/Scripts/Layout/CardUI/2D Cards/CardStack2D.cs +++ b/Runtime/Scripts/Layout/CardUI/2D Cards/CardStack2D.cs @@ -3,118 +3,121 @@ /// Sourced from - https://github.com/ryanslikesocool/Unity-Card-UI /// - using System.Collections; -using System.Collections.Generic; -using UnityEngine; -using UnityEngine.UI; +using System.Collections; namespace UnityEngine.UI.Extensions { -public class CardStack2D : MonoBehaviour -{ - - [SerializeField] - private float cardMoveSpeed = 8f; - [SerializeField] - private float buttonCooldownTime = 0.125f; - [SerializeField] - private int cardZMultiplier = 32; - [SerializeField] - private bool useDefaultUsedXPos = true; - [SerializeField] - private int usedCardXPos = 1280; - [SerializeField] - private Transform[] cards = null; - - private int cardArrayOffset; - private Vector3[] cardPositions; - private int xPowerDifference; - - ///Static variables can be used across the scene if this script is in it. - ///Thankfully it doesn't matter if another script attempts to use the variable and this script isn't in the scene. - public static bool canUseHorizontalAxis = true; - - void Start() + public class CardStack2D : MonoBehaviour { - ///I've found that 9 is a good number for this. - ///I wouldn't really recommend changing it, but go ahead if you want to. - xPowerDifference = 9 - cards.Length; - ///This is optional, but makes it super easy to figure out the off screen position for cards. - ///Unfortunately, it's only really useful if the cards are the same width. - if (useDefaultUsedXPos) + [SerializeField] + private float cardMoveSpeed = 8f; + [SerializeField] + private float buttonCooldownTime = 0.125f; + [SerializeField] + private int cardZMultiplier = 32; + [SerializeField] + private bool useDefaultUsedXPos = true; + [SerializeField] + private int usedCardXPos = 1280; + [SerializeField] + private KeyCode leftButton = KeyCode.LeftArrow; + [SerializeField] + private KeyCode rightButton = KeyCode.RightArrow; + [SerializeField] + private Transform[] cards = null; + + + + private int cardArrayOffset; + private Vector3[] cardPositions; + private int xPowerDifference; + + ///Static variables can be used across the scene if this script is in it. + ///Thankfully it doesn't matter if another script attempts to use the variable and this script isn't in the scene. + public static bool canUseHorizontalAxis = true; + + void Start() { - int cardWidth = (int)(cards[0].GetComponent().rect.width); - usedCardXPos = (int)(Screen.width * 0.5f + cardWidth); - } + ///I've found that 9 is a good number for this. + ///I wouldn't really recommend changing it, but go ahead if you want to. + xPowerDifference = 9 - cards.Length; - cardPositions = new Vector3[cards.Length * 2 - 1]; - - ///This loop is for cards still in the stack. - for (int i = cards.Length; i > -1; i--) - { - if (i < cards.Length - 1) + ///This is optional, but makes it super easy to figure out the off screen position for cards. + ///Unfortunately, it's only really useful if the cards are the same width. + if (useDefaultUsedXPos) { - cardPositions[i] = new Vector3(-Mathf.Pow(2, i + xPowerDifference) + cardPositions[i + 1].x, 0, cardZMultiplier * Mathf.Abs(i + 1 - cards.Length)); + int cardWidth = (int)(cards[0].GetComponent().rect.width); + usedCardXPos = (int)(Screen.width * 0.5f + cardWidth); } - else - { - cardPositions[i] = Vector3.zero; - } - } - ///This loop is for cards outside of the stack. - for (int i = cards.Length; i < cardPositions.Length; i++) - { - cardPositions[i] = new Vector3(usedCardXPos + 4 * (i - cards.Length), 0, -2 + -2 * (i - cards.Length)); - } - } + cardPositions = new Vector3[cards.Length * 2 - 1]; - void Update() - { - if (canUseHorizontalAxis) - { - ///Controls for the cards. - if (UIExtensionsInputManager.GetAxisRaw("Horizontal") < 0 && cardArrayOffset > 0) + ///This loop is for cards still in the stack. + for (int i = cards.Length; i > -1; i--) { - cardArrayOffset--; - StartCoroutine(ButtonCooldown()); - } - else if (UIExtensionsInputManager.GetAxisRaw("Horizontal") > 0 && cardArrayOffset < cards.Length - 1) - { - cardArrayOffset++; - StartCoroutine(ButtonCooldown()); - } - } - - ///This loop moves the cards. I know that none of my lerps are the "right way," but it looks much nicer. - for (int i = 0; i < cards.Length; i++) - { - cards[i].localPosition = Vector3.Lerp(cards[i].localPosition, cardPositions[i + cardArrayOffset], Time.deltaTime * cardMoveSpeed); - if (Mathf.Abs(cards[i].localPosition.x - cardPositions[i + cardArrayOffset].x) < 0.01f) - { - cards[i].localPosition = cardPositions[i + cardArrayOffset]; - - ///This disables interaction with cards that are not on top of the stack. - if (cards[i].localPosition.x == 0) + if (i < cards.Length - 1) { - cards[i].gameObject.GetComponent().interactable = true; + cardPositions[i] = new Vector3(-Mathf.Pow(2, i + xPowerDifference) + cardPositions[i + 1].x, 0, cardZMultiplier * Mathf.Abs(i + 1 - cards.Length)); } else { - cards[i].gameObject.GetComponent().interactable = false; + cardPositions[i] = Vector3.zero; + } + } + + ///This loop is for cards outside of the stack. + for (int i = cards.Length; i < cardPositions.Length; i++) + { + cardPositions[i] = new Vector3(usedCardXPos + 4 * (i - cards.Length), 0, -2 + -2 * (i - cards.Length)); + } + } + + void Update() + { + if (canUseHorizontalAxis) + { + ///Controls for the cards. + if ((UIExtensionsInputManager.GetAxisRaw("Horizontal") < 0 || UIExtensionsInputManager.GetKey(leftButton)) && cardArrayOffset > 0) + { + cardArrayOffset--; + StartCoroutine(ButtonCooldown()); + } + else if ((UIExtensionsInputManager.GetAxisRaw("Horizontal") > 0 || UIExtensionsInputManager.GetKey(rightButton)) && cardArrayOffset < cards.Length - 1) + { + cardArrayOffset++; + StartCoroutine(ButtonCooldown()); + } + } + + ///This loop moves the cards. I know that none of my lerps are the "right way," but it looks much nicer. + for (int i = 0; i < cards.Length; i++) + { + cards[i].localPosition = Vector3.Lerp(cards[i].localPosition, cardPositions[i + cardArrayOffset], Time.deltaTime * cardMoveSpeed); + if (Mathf.Abs(cards[i].localPosition.x - cardPositions[i + cardArrayOffset].x) < 0.01f) + { + cards[i].localPosition = cardPositions[i + cardArrayOffset]; + + ///This disables interaction with cards that are not on top of the stack. + if (cards[i].localPosition.x == 0) + { + cards[i].gameObject.GetComponent().interactable = true; + } + else + { + cards[i].gameObject.GetComponent().interactable = false; + } } } } - } - ///Stops the cards from scrolling super quickly if a button on the horizontal axis is held down. - IEnumerator ButtonCooldown() - { - canUseHorizontalAxis = false; - yield return new WaitForSeconds(buttonCooldownTime); - canUseHorizontalAxis = true; + ///Stops the cards from scrolling super quickly if a button on the horizontal axis is held down. + IEnumerator ButtonCooldown() + { + canUseHorizontalAxis = false; + yield return new WaitForSeconds(buttonCooldownTime); + canUseHorizontalAxis = true; + } } -} } \ No newline at end of file diff --git a/Runtime/Scripts/Utilities/UIExtensionsInputManager.cs b/Runtime/Scripts/Utilities/UIExtensionsInputManager.cs index df7d9a0..85453f4 100644 --- a/Runtime/Scripts/Utilities/UIExtensionsInputManager.cs +++ b/Runtime/Scripts/Utilities/UIExtensionsInputManager.cs @@ -1,66 +1,272 @@ /// Credit SimonDarksideJ /// Sourced from: https://bitbucket.org/UnityUIExtensions/unity-ui-extensions/issues/348/menu-manager-does-not-work-with-the-new +using System; +using System.Collections.Generic; +using UnityEngine.InputSystem; +using UnityEngine.InputSystem.Controls; namespace UnityEngine.UI.Extensions { public static class UIExtensionsInputManager { +#if !ENABLE_LEGACY_INPUT_MANAGER + private static bool[] mouseButtons = new bool[3] { false, false, false }; + private static Dictionary keys = new Dictionary(); + private static Dictionary buttons = new Dictionary(); +#endif + public static bool GetMouseButton(int button) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetMouseButton(button); +#else + if (Mouse.current == null) + { + return false; + } + + return Mouse.current.leftButton.isPressed; +#endif } public static bool GetMouseButtonDown(int button) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetMouseButtonDown(button); +#else + if (Mouse.current == null) + { + return false; + } + + if (Mouse.current.leftButton.isPressed) + { + if (!mouseButtons[button]) + { + mouseButtons[button] = true; + return true; + } + } + return false; +#endif } public static bool GetMouseButtonUp(int button) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetMouseButtonUp(button); +#else + if (Mouse.current == null) + { + return false; + } + + if (mouseButtons[button] && !Mouse.current.leftButton.isPressed) + { + mouseButtons[button] = false; + return true; + } + return false; +#endif } public static bool GetButton(string input) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetButton(input); +#else + ButtonControl buttonPressed = GetButtonControlFromString(input); + + if (!buttons.ContainsKey(input)) + { + buttons.Add(input, false); + } + + return buttonPressed != null ? buttonPressed.isPressed : false; +#endif + } + + private static ButtonControl GetButtonControlFromString(string input) + { + if (Gamepad.current == null) + { + return null; + } + + switch (input) + { + case "Submit": + return Gamepad.current.aButton; + case "Cancel": + return Gamepad.current.bButton; + default: + return null; + } } public static bool GetButtonDown(string input) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetButtonDown(input); +#else + ButtonControl buttonPressed = GetButtonControlFromString(input); + + if (buttonPressed.isPressed) + { + if (!buttons.ContainsKey(input)) + { + buttons.Add(input, false); + } + + if (!buttons[input]) + { + buttons[input] = true; + return true; + } + } + else + { + buttons[input] = false; + } + return false; +#endif } public static bool GetButtonUp(string input) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetButtonUp(input); +#else + ButtonControl buttonPressed = GetButtonControlFromString(input); + + if (buttons[input] && !buttonPressed.isPressed) + { + buttons[input] = false; + return true; + } + return false; +#endif } public static bool GetKey(KeyCode key) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetKey(key); +#else + KeyControl keyPressed = GetKeyControlFromKeyCode(key); + if (!keys.ContainsKey(key)) + { + keys.Add(key, false); + } + + return keyPressed != null ? keyPressed.isPressed : false; +#endif + } + + private static KeyControl GetKeyControlFromKeyCode(KeyCode key) + { + if (Keyboard.current == null) + { + return null; + } + + switch (key) + { + case KeyCode.Escape: + return Keyboard.current.escapeKey; + case KeyCode.KeypadEnter: + return Keyboard.current.numpadEnterKey; + case KeyCode.UpArrow: + return Keyboard.current.upArrowKey; + case KeyCode.DownArrow: + return Keyboard.current.downArrowKey; + case KeyCode.RightArrow: + return Keyboard.current.rightArrowKey; + case KeyCode.LeftArrow: + return Keyboard.current.leftArrowKey; + case KeyCode.LeftShift: + return Keyboard.current.leftShiftKey; + case KeyCode.Tab: + return Keyboard.current.tabKey; + default: + return null; + } } public static bool GetKeyDown(KeyCode key) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetKeyDown(key); +#else + KeyControl keyPressed = GetKeyControlFromKeyCode(key); + if (keyPressed.isPressed) + { + if (!keys.ContainsKey(key)) + { + keys.Add(key, false); + } + + if (!keys[key]) + { + keys[key] = true; + return true; + } + } + else + { + keys[key] = false; + } + return false; +#endif } public static bool GetKeyUp(KeyCode key) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetKeyUp(key); +#else + KeyControl keyPressed = GetKeyControlFromKeyCode(key); + if (keys[key] && !keyPressed.isPressed) + { + keys[key] = false; + return true; + } + return false; +#endif } public static float GetAxisRaw(string axis) { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.GetAxisRaw(axis); +#else + if (Gamepad.current == null) + { + return 0f; + } + + switch (axis) + { + case "Horizontal": + return Gamepad.current.leftStick.x.ReadValue(); + case "Vertical": + return Gamepad.current.leftStick.y.ReadValue(); + + } + return 0f; +#endif } public static Vector3 MousePosition { get { +#if ENABLE_LEGACY_INPUT_MANAGER return Input.mousePosition; +#else + return Mouse.current.position.ReadValue(); +#endif } } } diff --git a/Runtime/UnityUIExtensions.asmdef b/Runtime/UnityUIExtensions.asmdef index 66e9532..f9b5f8a 100644 --- a/Runtime/UnityUIExtensions.asmdef +++ b/Runtime/UnityUIExtensions.asmdef @@ -1,7 +1,8 @@ { "name": "UnityUIExtensions", "references": [ - "GUID:2bafac87e7f4b9b418d9448d219b01ab" + "GUID:2bafac87e7f4b9b418d9448d219b01ab", + "GUID:75469ad4d38634e559750d17036d5f7c" ], "includePlatforms": [], "excludePlatforms": [], @@ -10,5 +11,6 @@ "precompiledReferences": [], "autoReferenced": true, "defineConstraints": [], - "versionDefines": [] + "versionDefines": [], + "noEngineReferences": false } \ No newline at end of file