add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Abilities System/Custom Abilities/playerTeleportSystem.cs

@@ -0,0 +1,721 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.UIElements;
+
+public class playerTeleportSystem : abilityInfo
+{
+    [Header ("Custom Settings")]
+    [Space]
+
+    //Teleport ability variables
+    public bool teleportingEnabled;
+    public LayerMask teleportLayerMask;
+
+    [Space]
+
+    public float maxDistanceToTeleport = 100;
+    public bool useTeleportIfSurfaceNotFound = true;
+    public float maxDistanceToTeleportAir = 10;
+
+    [Space]
+
+    public float holdButtonTimeToActivateTeleport = 0.4f;
+    public bool stopTeleportIfMoving;
+    public bool addForceIfTeleportStops;
+    public float forceIfTeleportStops;
+
+    public bool canTeleportOnZeroGravity;
+
+    public bool teleportInstantlyToPosition;
+
+    public bool useFixedTeleportHookPointsEnabled = true;
+
+    [Space]
+    [Header ("Capsule Cast Settings")]
+    [Space]
+
+    public bool useCapsuleCastToCheckTargetReached = true;
+    public float capsuleCastRadius = 0.5f;
+    public float maxCapsuleCastDistance = 1.3f;
+
+    [Space]
+    [Header ("Camera Settings")]
+    [Space]
+
+    public bool useSmoothCameraFollowStateOnTeleport = true;
+    public float smoothCameraFollowDuration = 3;
+
+    [Space]
+
+    public bool allowQuickTeleportIfLockonTargetActive;
+
+    public LayerMask checkLockonTargetsLayermask;
+
+    [Space]
+    [Header ("Movement/Rotation Settings")]
+    [Space]
+
+    public float teleportSpeed = 10;
+
+    public bool rotateTowardTeleportPosition;
+
+    public float teleportRotationSpeed = 5;
+    public float minAngleToRotateTowardTeleportDirection = 15;
+
+    [Space]
+    [Header ("Effect Settings")]
+    [Space]
+
+    public bool useBulletTimeOnTeleport;
+    public float bulletTimeScaleOnTeleport = 0.5f;
+
+    public bool useTeleportMark;
+
+    public bool changeCameraFovOnTeleport;
+    public float cameraFovOnTeleport;
+    public float cameraFovOnTeleportSpeed;
+
+    [Space]
+    [Header ("Animation Settings")]
+    [Space]
+
+    public bool useActionSystemOnTeleport = true;
+    public string actionNameUsedOnTeleport = "Teleport Pose";
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool teleportCanBeExecuted;
+    public bool searchingForTeleport;
+
+    public bool teleportSurfaceFound;
+    public bool teleportInProcess;
+
+    public Transform currentTeleportHookTarget;
+
+    public bool teleportActivateByHookTarget;
+
+    [Space]
+    [Header ("Events Settings")]
+    [Space]
+
+    public bool useEventsOnStartTeleport;
+    public UnityEvent eventsOnStartTeleport;
+    public bool useEventsOnEndTeleport;
+    public UnityEvent eventsOnEndTeleport;
+
+    [Space]
+    [Header ("Component Elements")]
+    [Space]
+
+    public GameObject teleportMark;
+    public Transform playerControllerTransform;
+    public Transform mainCameraTransform;
+    public gravitySystem mainGravitySystem;
+    public playerController mainPlayerController;
+    public timeBullet mainTimeBullet;
+    public playerCamera mainPlayerCamera;
+
+
+    float lastTimeTeleportButtonPressed;
+    Coroutine teleportCoroutine;
+    Vector3 currentTeleportPosition;
+    Vector3 teleportMarkDirection;
+    Vector3 currentTeleportPositionNormal;
+
+    RaycastHit hit;
+
+
+    public override void updateAbilityState ()
+    {
+        if (teleportingEnabled && !mainGravitySystem.isSearchingSurface () && (!mainPlayerController.isPlayerOnZeroGravityMode () || canTeleportOnZeroGravity)) {
+            if (searchingForTeleport) {
+                bool activateTeleportResult = false;
+
+                if (!teleportCanBeExecuted) {
+                    if (Time.time > lastTimeTeleportButtonPressed + holdButtonTimeToActivateTeleport || teleportInProcess) {
+                        activateTeleportResult = true;
+                    }
+
+                    if (!teleportInProcess && currentTeleportHookTarget != null) {
+                        activateTeleportResult = true;
+
+                        teleportActivateByHookTarget = true;
+                    }
+                }
+
+                if (activateTeleportResult) {
+                    teleportCanBeExecuted = true;
+
+                    if (useTeleportMark) {
+                        teleportMark.SetActive (true);
+                    }
+
+                    bool canActivateTeleportOnAir = teleportInProcess || !mainPlayerController.isPlayerOnGround ();
+
+                    if (canActivateTeleportOnAir) {
+                        stopTeleporting ();
+                    }
+
+                    if (useBulletTimeOnTeleport) {
+                        mainTimeBullet.setBulletTimeState (true, bulletTimeScaleOnTeleport);
+                    }
+
+                    if (canActivateTeleportOnAir) {
+                        setPlayerControlState (false);
+                    }
+                }
+
+                if (teleportCanBeExecuted && useTeleportMark) {
+                    Vector3 raycastDirection = Vector3.zero;
+                    Vector3 raycastPosition = Vector3.zero;
+
+                    bool isCameraTypeFree = mainPlayerCamera.isCameraTypeFree ();
+
+                    if (currentTeleportHookTarget != null) {
+                        raycastPosition = playerControllerTransform.position + playerControllerTransform.up;
+
+                        raycastDirection = currentTeleportHookTarget.position - raycastPosition;
+
+                        raycastDirection.Normalize ();
+                    } else {
+                        if (isCameraTypeFree) {
+                            raycastDirection = mainCameraTransform.TransformDirection (Vector3.forward);
+
+                            raycastPosition = mainCameraTransform.position;
+                        } else {
+                            raycastDirection = playerControllerTransform.forward;
+
+                            raycastPosition = playerControllerTransform.position + playerControllerTransform.up;
+                        }
+                    }
+
+                    if (Physics.Raycast (raycastPosition, raycastDirection, out hit, maxDistanceToTeleport, teleportLayerMask)) {
+                        currentTeleportPosition = hit.point + hit.normal * 0.4f;
+                        teleportMark.transform.position = hit.point + hit.normal * 0.1f;
+
+                        currentTeleportPositionNormal = hit.normal;
+
+                        teleportSurfaceFound = true;
+                    } else {
+                        teleportSurfaceFound = false;
+
+                        if (isCameraTypeFree) {
+                            currentTeleportPosition = mainCameraTransform.position + mainCameraTransform.forward * maxDistanceToTeleportAir;
+                        } else {
+                            currentTeleportPosition = playerControllerTransform.position + playerControllerTransform.forward * maxDistanceToTeleportAir;
+                        }
+
+                        teleportMark.transform.position = currentTeleportPosition;
+
+                        currentTeleportPositionNormal = Vector3.up;
+                    }
+
+                    if (useTeleportIfSurfaceNotFound || (!useTeleportIfSurfaceNotFound && teleportSurfaceFound)) {
+                        Quaternion teleportMarkTargetRotation = Quaternion.LookRotation (currentTeleportPositionNormal);
+
+                        teleportMark.transform.rotation = teleportMarkTargetRotation;
+
+                        if (!teleportMark.activeSelf) {
+                            teleportMark.SetActive (true);
+                        }
+                    } else {
+                        if (teleportMark.activeSelf) {
+                            teleportMark.SetActive (false);
+                        }
+                    }
+                }
+
+                if (mainPlayerAbilitiesSystem.isPlayerCurrentlyBusy () ||
+                    (stopTeleportIfMoving && mainPlayerController.isPlayerUsingInput () && !teleportActivateByHookTarget)) {
+
+                    stopTeleportInProcess ();
+                }
+            }
+
+            if (teleportInProcess && stopTeleportIfMoving && mainPlayerController.isPlayerUsingInput () && !teleportActivateByHookTarget) {
+                stopTeleporting ();
+
+                setTeleportEndState ();
+
+                if (addForceIfTeleportStops) {
+                    Vector3 targetPositionDirection = currentTeleportPosition - playerControllerTransform.position;
+
+                    targetPositionDirection = targetPositionDirection / targetPositionDirection.magnitude;
+
+                    mainPlayerController.addExternalForce (targetPositionDirection * forceIfTeleportStops);
+                }
+            }
+        }
+    }
+
+    public void stopTeleportInProcess ()
+    {
+        if (teleportInProcess || searchingForTeleport) {
+            teleportCanBeExecuted = false;
+
+            if (useBulletTimeOnTeleport) {
+                mainTimeBullet.disableTimeBulletTotally ();
+            }
+
+            teleportActivateByHookTarget = false;
+
+            searchingForTeleport = false;
+
+            if (useTeleportMark) {
+                teleportMark.SetActive (false);
+            }
+
+            stopTeleporting ();
+        }
+    }
+
+    public void teleportPlayer (Transform objectToMove, Vector3 teleportPosition, bool checkPositionAngle, bool changeFov,
+                                float newFovValue, float fovChangeSpeed, float teleportSpeed, bool rotatePlayerTowardPosition,
+                                bool teleportInstantlyToPositionValue, bool useActionSystemOnTeleportValue,
+                                bool useSmoothCameraFollowStateOnTeleportValue, float smoothCameraFollowDurationValue,
+                                float teleportDistanceOffsetValue, LayerMask layermaskToDetect, bool checkPlayerHeightToTeleportPosition)
+    {
+        stopTeleporting ();
+
+        teleportCoroutine = StartCoroutine (teleportPlayerCoroutine (objectToMove, teleportPosition, checkPositionAngle,
+            changeFov, newFovValue, fovChangeSpeed, teleportSpeed, rotatePlayerTowardPosition, teleportInstantlyToPositionValue,
+            useActionSystemOnTeleportValue, useSmoothCameraFollowStateOnTeleportValue, smoothCameraFollowDurationValue,
+            teleportDistanceOffsetValue, layermaskToDetect, checkPlayerHeightToTeleportPosition));
+    }
+
+    public void stopTeleporting ()
+    {
+        if (teleportCoroutine != null) {
+            StopCoroutine (teleportCoroutine);
+        }
+
+        setPlayerControlState (true);
+    }
+
+    public void resumeIfTeleportActive ()
+    {
+        if (teleportInProcess) {
+            stopTeleporting ();
+
+            setTeleportEndState ();
+        }
+    }
+
+    bool currentUseActionSystemOnTeleportValue;
+
+    public void setTeleportEndState ()
+    {
+        if (teleportInProcess) {
+            teleportInProcess = false;
+
+            if (currentUseActionSystemOnTeleportValue && actionNameUsedOnTeleport != "") {
+                mainPlayerController.stopCustomAction (actionNameUsedOnTeleport);
+            }
+
+            if (changeCameraFovOnTeleport) {
+                mainPlayerCamera.setOriginalCameraFov ();
+            }
+
+            checkEventOnTeleport (false);
+        }
+    }
+
+    public void setPlayerControlState (bool state)
+    {
+        if (state) {
+            mainPlayerController.setFallDamageCheckPausedState (true);
+        }
+
+        mainPlayerController.changeScriptState (state);
+
+        mainPlayerController.setGravityForcePuase (!state);
+
+        mainPlayerController.setRigidbodyVelocityToZero ();
+
+        mainPlayerController.setPhysicMaterialAssigmentPausedState (!state);
+
+        mainPlayerController.setUsingAbilityActiveState (!state);
+
+        mainPlayerController.setCheckOnGroungPausedState (!state);
+
+        if (!state) {
+            mainPlayerController.setZeroFrictionMaterial ();
+
+            mainPlayerController.setPlayerOnGroundState (false);
+
+            mainPlayerController.setLastTimeFalling ();
+
+            mainPlayerController.setFallDamageCheckPausedState (false);
+        }
+    }
+
+    IEnumerator teleportPlayerCoroutine (Transform objectToMove, Vector3 targetPosition, bool checkPositionAngle,
+                                         bool changeFov, float newFovValue, float fovChangeSpeed, float currentTeleportSpeed,
+                                         bool rotatePlayerTowardPosition, bool teleportInstantlyToPositionValue, bool useActionSystemOnTeleportValue,
+                                         bool useSmoothCameraFollowStateOnTeleportValue, float smoothCameraFollowDurationValue,
+                                         float teleportDistanceOffsetValue, LayerMask layermaskToDetect, bool checkPlayerHeightToTeleportPosition)
+    {
+        teleportInProcess = true;
+
+        checkEventOnTeleport (true);
+
+        currentUseActionSystemOnTeleportValue = useActionSystemOnTeleportValue;
+
+        if (currentUseActionSystemOnTeleportValue && actionNameUsedOnTeleport != "") {
+            mainPlayerController.activateCustomAction (actionNameUsedOnTeleport);
+        }
+
+        if (useSmoothCameraFollowStateOnTeleportValue) {
+            mainPlayerCamera.activateUseSmoothCameraFollowStateDuration (smoothCameraFollowDurationValue);
+        }
+
+        setPlayerControlState (false);
+
+        if (changeCameraFovOnTeleport && changeFov) {
+            mainPlayerCamera.setMainCameraFov (newFovValue, fovChangeSpeed);
+        }
+
+        if (checkPlayerHeightToTeleportPosition) {
+            Vector3 currentNormal = mainGravitySystem.getCurrentNormal ();
+
+            Vector3 raycastDirection = targetPosition - currentNormal * 0.5f;
+            Vector3 raycastPosition = targetPosition;
+
+            float raycastDistance = mainPlayerController.getCharacterHeight () + 0.2f;
+
+            //Debug.DrawRay (raycastPosition, raycastDirection * 2, Color.green, 10);
+
+            if (Physics.Raycast (raycastPosition, raycastDirection, out hit, raycastDistance, layermaskToDetect)) {
+                targetPosition -= currentNormal * raycastDistance;
+
+                //				print ("adjusting teleport position to player height");
+            } else {
+                raycastDirection = targetPosition + currentNormal * 0.5f;
+
+                if (Physics.Raycast (raycastPosition, raycastDirection, out hit, raycastDistance, layermaskToDetect)) {
+                    targetPosition -= currentNormal * raycastDistance;
+
+                    //					print ("adjusting teleport position to player height");
+                }
+            }
+        }
+
+        float dist = GKC_Utils.distance (objectToMove.position, targetPosition);
+        float duration = dist / currentTeleportSpeed;
+        float t = 0;
+
+        Vector3 targetPositionDirection = targetPosition - objectToMove.position;
+        targetPositionDirection = targetPositionDirection / targetPositionDirection.magnitude;
+
+        if (checkPositionAngle) {
+            float targetNormalAngle = Vector3.Angle (objectToMove.up, currentTeleportPositionNormal);
+
+            if (targetNormalAngle > 150) {
+                targetPosition += currentTeleportPositionNormal * 2;
+            }
+        }
+
+        float targetEulerRotation = 0;
+
+        bool targetReached = false;
+
+        float movementTimer = 0;
+
+        float positionDifference = 0;
+
+        float positionDifferenceAmount = 0.01f;
+
+        if (teleportDistanceOffsetValue > 0) {
+            positionDifferenceAmount = teleportDistanceOffsetValue;
+        }
+
+        float lastTimeDistanceChecked = 0;
+
+        bool isPlayerMovingOn3dWorld = mainPlayerController.isPlayerMovingOn3dWorld ();
+
+        if (teleportInstantlyToPositionValue) {
+            if (positionDifferenceAmount > 0) {
+                targetPosition -= targetPositionDirection * positionDifferenceAmount;
+            }
+
+            objectToMove.position = targetPosition;
+
+            if (rotatePlayerTowardPosition && isPlayerMovingOn3dWorld) {
+
+                Vector3 teleportDirection = targetPositionDirection;
+
+                teleportDirection = teleportDirection - objectToMove.up * objectToMove.InverseTransformDirection (teleportDirection).y;
+
+                targetEulerRotation = Vector3.SignedAngle (objectToMove.forward, teleportDirection, objectToMove.up);
+
+                objectToMove.Rotate (0, targetEulerRotation, 0);
+            }
+
+            yield return null;
+        } else {
+
+            while (!targetReached) {
+                t += Time.deltaTime / duration;
+
+                objectToMove.position = Vector3.Lerp (objectToMove.position, targetPosition, t);
+
+                if (rotatePlayerTowardPosition && isPlayerMovingOn3dWorld) {
+
+                    Vector3 teleportDirection = targetPosition - objectToMove.position;
+                    teleportDirection = teleportDirection / teleportDirection.magnitude;
+
+                    teleportDirection = teleportDirection - objectToMove.up * objectToMove.InverseTransformDirection (teleportDirection).y;
+
+                    targetEulerRotation = Vector3.SignedAngle (objectToMove.forward, teleportDirection, objectToMove.up);
+
+                    if (Mathf.Abs (targetEulerRotation) > minAngleToRotateTowardTeleportDirection) {
+                        objectToMove.Rotate (0, (targetEulerRotation / 2) * teleportRotationSpeed * Time.deltaTime, 0);
+                    }
+                }
+
+                positionDifference = GKC_Utils.distance (objectToMove.position, targetPosition);
+
+                if (lastTimeDistanceChecked == 0) {
+                    if (positionDifference < 1) {
+                        lastTimeDistanceChecked = Time.time;
+                    }
+                } else {
+                    if (Time.time > lastTimeDistanceChecked + 0.5f) {
+                        //						print ("too much time without moving");
+
+                        targetReached = true;
+                    }
+                }
+
+                movementTimer += Time.deltaTime;
+
+                if (positionDifference < positionDifferenceAmount || movementTimer > (duration + 0.5f)) {
+                    targetReached = true;
+                }
+
+                if (useCapsuleCastToCheckTargetReached) {
+                    if (movementTimer > 0.7f) {
+                        Vector3 currentObjectPosition = objectToMove.position;
+
+                        Vector3 point1 = currentObjectPosition;
+                        Vector3 point2 = currentObjectPosition + objectToMove.up * 2;
+
+                        if (Physics.CapsuleCast (point1, point2, capsuleCastRadius, targetPositionDirection, out hit, maxCapsuleCastDistance, teleportLayerMask)) {
+                            //							print ("surface detected");
+
+                            targetReached = true;
+                        }
+                    }
+                }
+
+                yield return null;
+            }
+        }
+
+        setPlayerControlState (true);
+
+        setTeleportEndState ();
+    }
+
+    public void holdTeleport ()
+    {
+        if (!mainPlayerAbilitiesSystem.isPlayerCurrentlyBusy () &&
+            teleportingEnabled &&
+            (!mainPlayerController.isPlayerUsingInput () || currentTeleportHookTarget != null) &&
+            !mainGravitySystem.isSearchingSurface () &&
+            (!mainPlayerController.isPlayerOnZeroGravityMode () || canTeleportOnZeroGravity)) {
+
+            searchingForTeleport = true;
+
+            lastTimeTeleportButtonPressed = Time.time;
+        }
+    }
+
+    LayerMask currentLayermask;
+
+    public void releaseTeleport ()
+    {
+        if (!mainPlayerAbilitiesSystem.isPlayerCurrentlyBusy () && teleportingEnabled) {
+            currentLayermask = teleportLayerMask;
+
+            bool checkPositionAngleValue = true;
+
+            if (allowQuickTeleportIfLockonTargetActive) {
+                if (mainPlayerCamera.isPlayerLookingAtTarget ()) {
+                    Transform currentTargetToLook = mainPlayerCamera.getLastCharacterToLook ();
+
+                    Vector3 raycastDirection = Vector3.zero;
+                    Vector3 raycastPosition = Vector3.zero;
+
+                    Vector3 targetPositionDirection = currentTargetToLook.position - mainCameraTransform.position;
+
+                    targetPositionDirection = targetPositionDirection / targetPositionDirection.magnitude;
+
+                    raycastDirection = targetPositionDirection;
+
+                    raycastPosition = mainCameraTransform.position;
+
+                    if (Physics.Raycast (raycastPosition, raycastDirection, out hit, maxDistanceToTeleport, checkLockonTargetsLayermask)) {
+                        bool checkResult = false;
+
+                        if (hit.collider.transform == currentTargetToLook) {
+                            checkResult = true;
+                        }
+
+                        if (!checkResult) {
+                            Transform [] children = hit.collider.transform.GetComponentsInChildren<Transform> ();
+
+                            if (children.Contains (currentTargetToLook)) {
+                                checkResult = true;
+                            }
+                        }
+
+                        if (checkResult) {
+                            Vector3 currentPosition = playerControllerTransform.position;
+
+                            Vector3 targetToUsePosition = hit.collider.transform.position;
+
+                            float distanceToTarget = GKC_Utils.distance (targetToUsePosition, currentPosition);
+
+                            Vector3 direction = targetToUsePosition - currentPosition;
+
+                            direction = direction / direction.magnitude;
+
+                            Vector3 targetPosition = currentPosition + direction * (distanceToTarget - 1);
+
+                            currentTeleportPosition = targetPosition;
+
+
+                            currentTeleportPositionNormal = hit.collider.transform.up;
+
+                            teleportCanBeExecuted = true;
+
+                            currentLayermask = checkLockonTargetsLayermask;
+
+                            checkPositionAngleValue = false;
+
+                            //Debug.DrawLine (currentPosition, currentTeleportPosition, Color.green, 10);
+                        }
+                    }
+                }
+            }
+
+            if (teleportCanBeExecuted) {
+                if (useTeleportIfSurfaceNotFound || (!useTeleportIfSurfaceNotFound && teleportSurfaceFound)) {
+                    teleportPlayer (playerControllerTransform, currentTeleportPosition, checkPositionAngleValue, true, cameraFovOnTeleport,
+                        cameraFovOnTeleportSpeed, teleportSpeed, rotateTowardTeleportPosition, teleportInstantlyToPosition,
+                        useActionSystemOnTeleport, useSmoothCameraFollowStateOnTeleport, smoothCameraFollowDuration, 0,
+                        currentLayermask, false);
+
+                    mainPlayerController.setCheckOnGroungPausedState (true);
+
+                    mainPlayerController.setPlayerOnGroundState (false);
+
+                } else {
+                    stopTeleporting ();
+                }
+
+                if (useBulletTimeOnTeleport) {
+                    mainTimeBullet.setBulletTimeState (false, 1);
+                }
+            }
+
+            teleportCanBeExecuted = false;
+
+            searchingForTeleport = false;
+
+            if (useTeleportMark) {
+                teleportMark.SetActive (false);
+            }
+        }
+    }
+
+    public void setTeleportingEnabledState (bool state)
+    {
+        teleportingEnabled = state;
+    }
+
+    public bool isTeleportInProcess ()
+    {
+        return teleportInProcess;
+    }
+
+    public bool isSearchingForTeleport ()
+    {
+        return searchingForTeleport;
+    }
+
+    public bool getTeleportCanBeExecutedState ()
+    {
+        return teleportCanBeExecuted;
+    }
+
+    public override void enableAbility ()
+    {
+
+    }
+
+    public override void disableAbility ()
+    {
+        stopTeleportInProcess ();
+
+        teleportingEnabled = false;
+    }
+
+    public override void deactivateAbility ()
+    {
+        stopTeleportInProcess ();
+    }
+
+    public override void activateSecondaryActionOnAbility ()
+    {
+
+    }
+
+    public override void useAbilityPressDown ()
+    {
+        holdTeleport ();
+
+        checkUseEventOnUseAbility ();
+    }
+
+    public override void useAbilityPressHold ()
+    {
+
+    }
+
+    public override void useAbilityPressUp ()
+    {
+        releaseTeleport ();
+
+        disableAbilityCurrentActiveFromPressState ();
+    }
+
+    void checkEventOnTeleport (bool state)
+    {
+        if (state) {
+            if (useEventsOnStartTeleport) {
+                eventsOnStartTeleport.Invoke ();
+            }
+        } else {
+            if (useEventsOnEndTeleport) {
+                eventsOnEndTeleport.Invoke ();
+            }
+        }
+    }
+
+    public void setTeleportHookTarget (Transform newTarget)
+    {
+        if (!useFixedTeleportHookPointsEnabled) {
+            return;
+        }
+
+        currentTeleportHookTarget = newTarget;
+    }
+
+}