add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Mobile/touchJoystick.cs

@@ -0,0 +1,450 @@
+using UnityEngine;
+using System.Reflection;
+using UnityEngine.UI;
+
+public class touchJoystick : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public int fingerId = 666;
+
+    public float dragDistance = 1;
+    public bool snapsToFinger = true;
+    public bool hideOnRelease = false;
+    public bool touchPad;
+
+    public float touchPadHorizontalExtraValue = 1;
+    public float touchPadVerticalExtraValue = 1;
+    public bool showJoystick;
+
+    [Space]
+    [Header ("Other Settings")]
+    [Space]
+
+    public bool clampJoystickToScreenSide;
+    public bool joystickOnRightScreenSide;
+
+    [Space]
+
+    public bool checkIfPressInsideTouchZone;
+    public RectTransform touchZoneRectTransform;
+
+    [Space]
+    [Header ("Colors Settings")]
+    [Space]
+
+    public bool useChaneColor;
+    public float changeColorSpeed;
+    public Color regularBaseColor;
+    public Color regularStickColor;
+    public Color pressedBaseColor;
+    public Color pressedStickColor;
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool showDebugPrint;
+    public Vector2 currentAxisValue;
+    public Vector2 currentTouchPosition;
+    public bool touching;
+    public bool hoveringJoystick;
+    public bool touchingPreviously;
+
+    public bool adjustinColors;
+
+    public bool buttonColorVisible = true;
+
+    public bool joystickClampedToScreenSideActive;
+
+    [Space]
+    [Header ("Components")]
+    [Space]
+
+    public GameObject stickBase;
+    public GameObject stick;
+    public RectTransform baseRectTransform;
+    public RectTransform stickRectTransform;
+    public RawImage baseRenderer;
+    public RawImage stickRenderer;
+
+
+    bool touchPlatform;
+
+    Color currentBaseColor;
+    Color currentStickColor;
+
+    Vector3 previousPosition;
+    Vector2 originalStickPosition;
+    Vector2 originalBasePosition;
+    Vector3 globalTouchPosition;
+    Vector3 differenceVector;
+    Vector3 difference;
+    int touchCount;
+
+    Touch currentPressedTouch;
+    Touch currentTouch;
+
+    int currentFingerId;
+
+    int currentTouchIndex;
+
+    bool firstTouchActive;
+
+    float screenWidth;
+
+
+    void Start ()
+    {
+        touchPlatform = checkTouchPlatform ();
+
+        if (!showJoystick) {
+            setSticksState (false, false);
+        }
+
+        originalStickPosition = stickRectTransform.anchoredPosition;
+        originalBasePosition = baseRectTransform.anchoredPosition;
+
+        if (clampJoystickToScreenSide) {
+            screenWidth = GKC_Utils.getScreenResolution ().x / 2;
+
+            if (screenWidth <= 0) {
+                screenWidth = Screen.width / 2;
+            }
+        }
+    }
+
+    void Update ()
+    {
+        setJoystickColors ();
+
+        if (currentFingerId > -1) {
+            moveJoystick ();
+        }
+    }
+
+    public void setHoverState (bool state)
+    {
+        hoveringJoystick = state;
+
+        if (hoveringJoystick && !touching) {
+            touchCount = Input.touchCount;
+
+            if (!touchPlatform) {
+                touchCount++;
+            }
+
+            for (currentTouchIndex = 0; currentTouchIndex < touchCount; currentTouchIndex++) {
+                if (!touchPlatform) {
+                    currentTouch = convertMouseIntoFinger ();
+                } else {
+                    currentTouch = Input.GetTouch (currentTouchIndex);
+                }
+
+                //if the touch action has started, check if the finger is inside the touch zone rect, visible in the editor
+                if (currentTouch.phase == TouchPhase.Began) {
+                    currentTouchPosition = currentTouch.position;
+
+                    if (clampJoystickToScreenSide) {
+                        joystickClampedToScreenSideActive = false;
+
+                        bool isScreenRightSide = currentTouchPosition.x > screenWidth;
+
+                        if (joystickOnRightScreenSide) {
+                            if (!isScreenRightSide) {
+                                joystickClampedToScreenSideActive = true;
+                            }
+                        } else {
+                            if (isScreenRightSide) {
+                                joystickClampedToScreenSideActive = true;
+                            }
+                        }
+
+                        if (showDebugPrint) {
+                            print ("joystick Clamped " + joystickClampedToScreenSideActive +
+                                " isScreenRightSide " + isScreenRightSide + " " + currentTouchPosition.x +
+                                " " + screenWidth);
+                        }
+
+                        if (joystickClampedToScreenSideActive) {
+                            return;
+                        }
+                    }
+
+                    if (checkIfPressInsideTouchZone) {
+                        if (!RectTransformUtility.RectangleContainsScreenPoint (touchZoneRectTransform, currentTouchPosition)) {
+                            if (showDebugPrint) {
+                                print ("outside touch press " + fingerId);
+                            }
+
+                            return;
+                        }
+                    }
+
+                    currentFingerId = currentTouch.fingerId;
+
+                    fingerTouching (true);
+
+                    if (snapsToFinger) {
+                        stickRectTransform.position = currentTouchPosition;
+                        baseRectTransform.position = stickRectTransform.position;
+                    }
+
+                    if (touchPad) {
+                        previousPosition = currentTouchPosition;
+                    }
+
+
+                }
+            }
+        }
+    }
+
+    // set the value of touching to activate of deactivate the icons of the joystick
+    void fingerTouching (bool state)
+    {
+        touching = state;
+
+        if (showJoystick) {
+            if (hideOnRelease) {
+                setSticksState (state, state);
+            } else if ((!stickBase.gameObject.activeSelf || !stick.gameObject.activeSelf)) {
+                setSticksState (true, true);
+            }
+        } else {
+            setSticksState (false, false);
+        }
+    }
+
+    void setSticksState (bool stickBaseState, bool stickState)
+    {
+        if (stickBase.activeSelf != stickBaseState) {
+            stickBase.SetActive (stickBaseState);
+        }
+
+        if (stick.activeSelf != stickState) {
+            stick.SetActive (stickState);
+        }
+    }
+
+    //if the joystick is released, the icons back to their default positions
+    void resetJoystickPosition ()
+    {
+        stickRectTransform.anchoredPosition = originalStickPosition;
+        baseRectTransform.anchoredPosition = originalBasePosition;
+
+        currentAxisValue = Vector2.zero;
+
+        fingerTouching (false);
+    }
+
+    //check if the joystick is being used and set the icons position according to the finger or mouse movement
+    void moveJoystick ()
+    {
+        if (touching) {
+            touchCount = Input.touchCount;
+
+            if (!touchPlatform) {
+                touchCount++;
+            }
+
+            currentPressedTouch.fingerId = fingerId;
+
+            for (currentTouchIndex = 0; currentTouchIndex < touchCount; currentTouchIndex++) {
+                if (!touchPlatform) {
+                    currentTouch = convertMouseIntoFinger ();
+                } else {
+                    currentTouch = Input.GetTouch (currentTouchIndex);
+                }
+
+                if (currentTouch.fingerId == currentFingerId) {
+                    currentPressedTouch = currentTouch;
+                }
+            }
+
+            if (currentPressedTouch.fingerId == fingerId || currentPressedTouch.phase == TouchPhase.Ended) {
+                resetJoystickPosition ();
+
+                currentFingerId = -1;
+
+                return;
+            }
+
+            globalTouchPosition = currentPressedTouch.position;
+
+            differenceVector = globalTouchPosition - stickBase.transform.position;
+
+            if (differenceVector.sqrMagnitude > dragDistance * dragDistance) {
+                differenceVector.Normalize ();
+
+                differenceVector *= dragDistance;
+
+                stickRectTransform.position = baseRectTransform.position + differenceVector;
+            } else {
+                stickRectTransform.position = globalTouchPosition;
+            }
+
+            if (!touchPad) {
+                currentAxisValue = differenceVector / dragDistance;
+            } else {
+                difference = globalTouchPosition - previousPosition;
+
+                if (differenceVector.sqrMagnitude > dragDistance * dragDistance) {
+                    difference.Normalize ();
+                }
+
+                currentAxisValue = (difference / dragDistance);
+
+                currentAxisValue.x *= touchPadHorizontalExtraValue;
+                currentAxisValue.y *= touchPadVerticalExtraValue;
+
+                previousPosition = globalTouchPosition;
+            }
+        }
+    }
+
+    //get the vertical and horizontal axis values
+    public Vector2 GetAxis ()
+    {
+        return currentAxisValue;
+    }
+
+    public Vector2 getRawAxis ()
+    {
+        Vector2 axisValues = Vector2.zero;
+
+        if (currentAxisValue.x > 0) {
+            axisValues.x = 1;
+        } else if (currentAxisValue.x < 0) {
+            axisValues.x = -1;
+        } else {
+            axisValues.x = 0;
+        }
+
+        if (currentAxisValue.y > 0) {
+            axisValues.y = 1;
+        } else if (currentAxisValue.y < 0) {
+            axisValues.y = -1;
+        } else {
+            axisValues.y = 0;
+        }
+
+        return axisValues;
+    }
+
+    void setJoystickColors ()
+    {
+        if (useChaneColor) {
+            if (buttonColorVisible) {
+                if (touching != touchingPreviously || !firstTouchActive) {
+                    touchingPreviously = touching;
+
+                    adjustinColors = true;
+
+                    firstTouchActive = true;
+                }
+
+                if (adjustinColors) {
+                    if (touching) {
+                        currentBaseColor = pressedBaseColor;
+                        currentStickColor = pressedStickColor;
+                    } else {
+                        currentBaseColor = regularBaseColor;
+                        currentStickColor = regularStickColor;
+                    }
+
+                    baseRenderer.color = Color.Lerp (baseRenderer.color, currentBaseColor, Time.deltaTime * changeColorSpeed);
+
+                    stickRenderer.color = Color.Lerp (stickRenderer.color, currentStickColor, Time.deltaTime * changeColorSpeed);
+
+                    if (baseRenderer.color == currentBaseColor && stickRenderer.color == currentStickColor) {
+                        adjustinColors = false;
+                    }
+                }
+            }
+        }
+    }
+
+    //it simulates touch control in the game with the mouse position, using left button as tap finger with press, hold and release actions
+    public static Touch convertMouseIntoFinger ()
+    {
+        object mouseFinger = new Touch ();
+
+        FieldInfo phase = mouseFinger.GetType ().GetField ("m_Phase", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        FieldInfo fingerId = mouseFinger.GetType ().GetField ("m_FingerId", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        FieldInfo position = mouseFinger.GetType ().GetField ("m_Position", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        if (Input.GetMouseButtonDown (0)) {
+            phase.SetValue (mouseFinger, TouchPhase.Began);
+        } else if (Input.GetMouseButtonUp (0)) {
+            phase.SetValue (mouseFinger, TouchPhase.Ended);
+        } else {
+            phase.SetValue (mouseFinger, TouchPhase.Moved);
+        }
+
+        fingerId.SetValue (mouseFinger, 11);
+
+        position.SetValue (mouseFinger, new Vector2 (Input.mousePosition.x, Input.mousePosition.y));
+
+        return (Touch)mouseFinger;
+    }
+
+    //check the if the current platform is a touch device
+    public static bool checkTouchPlatform ()
+    {
+        if (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.IPhonePlayer) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public void setTouchPadState (bool state)
+    {
+        touchPad = state;
+    }
+
+    public void setShowJoystickState (bool state)
+    {
+        showJoystick = state;
+
+        setSticksState (showJoystick, showJoystick);
+    }
+
+    public void setSnapsToFingerState (bool state)
+    {
+        snapsToFinger = state;
+    }
+
+    public void setHideOnReleaseState (bool state)
+    {
+        hideOnRelease = state;
+    }
+
+    public void setJoystickColorVisibleState (bool state)
+    {
+        buttonColorVisible = state;
+
+        Color targetColorBase = baseRenderer.color;
+        Color targetColorStick = stickRenderer.color;
+
+        if (buttonColorVisible) {
+            targetColorBase.a = regularBaseColor.a;
+            targetColorStick.a = regularStickColor.a;
+        } else {
+            targetColorBase.a = 0;
+            targetColorStick.a = 0;
+        }
+
+        baseRenderer.color = targetColorBase;
+        stickRenderer.color = targetColorStick;
+    }
+
+    public bool touchJoystickIsPressed ()
+    {
+        return touching;
+    }
+}