add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Camera/Cutscene/pauseOrResumePlayerControllerAndCameraSystem.cs

@@ -0,0 +1,469 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class pauseOrResumePlayerControllerAndCameraSystem : MonoBehaviour
+{
+    [Header ("Main Settings")]
+    [Space]
+
+    public bool searchPlayerOnSceneIfNotAssigned = true;
+    public bool assignPlayerManually;
+    public GameObject currentPlayer;
+    public GameObject playerCameraGameObject;
+
+    public bool unlockCursor;
+
+    public bool enableGamepadCursor;
+
+    public bool resumePlayerAfterDelay;
+    public float delayToResumePlayer;
+
+    public bool activatePlayerMeshModel = true;
+
+    public bool pauseEscapeMenu;
+
+    [Space]
+    [Header ("Time Scale Settings")]
+    [Space]
+
+    public bool setCustomTimeScale;
+    public float customTimeScale;
+
+    public bool pauseAIWhenOpenMenu;
+
+    public int pauseCharacterPriority = 1;
+
+    public bool ignoreChangeFixedDeltaTime;
+
+    [Space]
+    [Header ("Camera Settings")]
+    [Space]
+
+    public bool cameraIsMoved;
+
+    public float resetCameraPositionSpeed;
+    public bool setCameraDirectionAtEnd;
+    public Transform cameraDirection;
+    public Transform pivotDirection;
+
+    [Space]
+
+    public bool setNewCameraParent;
+    public Transform newCameraParent;
+
+    [Space]
+    [Header ("HUD Settings")]
+    [Space]
+
+    public bool disableSecondaryPlayerHUD;
+    public bool disableAllPlayerHUD = true;
+    public bool disableTouchControls = true;
+    public bool disableDynamiUIElements;
+
+    [Space]
+    [Header ("Debug")]
+    [Space]
+
+    public bool playerComponentsPaused;
+
+    [Space]
+    [Header ("Event Settings")]
+    [Space]
+
+    public bool useEventOnPause;
+    public UnityEvent eventOnPause;
+    public eventParameters.eventToCallWithGameObject eventToSendCamera;
+    public bool useEventOnResume;
+    public UnityEvent eventOnResume;
+
+    playerController playerControllerManager;
+    playerCamera playerCameraManager;
+    headBob headBobManager;
+    playerStatesManager statesManager;
+    menuPause pauseManager;
+    playerComponentsManager mainPlayerComponentsManager;
+    playerInputManager playerInput;
+
+    headTrack mainHeadTrack;
+
+    Transform previousCameraParent;
+    Vector3 previousCameraPosition;
+    Transform mainCamera;
+
+    Coroutine resetCameraPositionCoroutine;
+
+    bool playerIsDriving;
+
+    bool usingDevicePreviously;
+
+    bool headScaleChanged;
+
+    Coroutine resumePlayerCoroutine;
+
+    bool playerAssignedProperly;
+
+    void Start ()
+    {
+        if (assignPlayerManually) {
+            getCurrentPlayer (currentPlayer);
+        }
+    }
+
+    public void getCurrentPlayer (GameObject player)
+    {
+        if (playerComponentsPaused) {
+            return;
+        }
+
+        currentPlayer = player;
+
+        if (currentPlayer == null) {
+            return;
+        }
+
+        mainPlayerComponentsManager = currentPlayer.GetComponent<playerComponentsManager> ();
+
+        if (mainPlayerComponentsManager != null) {
+            playerControllerManager = mainPlayerComponentsManager.getPlayerController ();
+
+            playerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();
+
+            playerCameraGameObject = playerCameraManager.gameObject;
+
+            mainCamera = playerCameraManager.getMainCamera ().transform;
+
+            headBobManager = mainPlayerComponentsManager.getHeadBob ();
+
+            statesManager = mainPlayerComponentsManager.getPlayerStatesManager ();
+
+            pauseManager = mainPlayerComponentsManager.getPauseManager ();
+
+            playerInput = mainPlayerComponentsManager.getPlayerInputManager ();
+
+            mainHeadTrack = mainPlayerComponentsManager.getHeadTrack ();
+
+            playerAssignedProperly = true;
+        }
+    }
+
+    public void pauseOrPlayPlayerComponents (bool state)
+    {
+        if (currentPlayer == null || !playerAssignedProperly) {
+
+            findPlayerOnScene ();
+
+            if (currentPlayer == null) {
+                print ("WARNING: no player controller has been assigned to the mission." +
+                " Make sure to use a trigger to activate the mission or assign the player manually");
+
+                return;
+            }
+        }
+
+        if (playerComponentsPaused == state) {
+            if (playerComponentsPaused) {
+                print ("Trying to pause the player when it is already paused, avoiding function call to keep the player in same state");
+            } else {
+                print ("Trying to resume the player when it is already resumed, avoiding function call to keep the player in same state");
+            }
+
+            return;
+        }
+
+        playerComponentsPaused = state;
+
+        playerIsDriving = playerControllerManager.isPlayerDriving ();
+
+        playerInput.setAvoidInputActiveState (state);
+
+        if (playerComponentsPaused) {
+            usingDevicePreviously = playerControllerManager.isUsingDevice ();
+        }
+
+        if (!playerIsDriving) {
+            if (!usingDevicePreviously) {
+                playerControllerManager.smoothChangeScriptState (!state);
+
+                mainHeadTrack.setSmoothHeadTrackDisableState (state);
+
+                playerControllerManager.setHeadTrackCanBeUsedState (!state);
+
+                playerControllerManager.setUsingDeviceState (state);
+
+                if (playerComponentsPaused) {
+                    headBobManager.stopAllHeadbobMovements ();
+                }
+
+                headBobManager.playOrPauseHeadBob (!state);
+
+                statesManager.checkPlayerStates (false, true, false, true, false, false, true, true);
+
+                playerCameraManager.pauseOrPlayCamera (!state);
+            }
+        }
+
+        if (playerIsDriving) {
+            if (playerComponentsPaused) {
+                headScaleChanged = playerControllerManager.isHeadScaleChanged ();
+
+                if (headScaleChanged) {
+                    playerControllerManager.changeHeadScale (false);
+                }
+            } else {
+                if (headScaleChanged) {
+                    playerControllerManager.changeHeadScale (true);
+                }
+            }
+        } else {
+            checkCharacterMesh (state);
+        }
+
+        if (unlockCursor) {
+            pauseManager.showOrHideCursor (playerComponentsPaused);
+            pauseManager.usingDeviceState (playerComponentsPaused);
+            pauseManager.usingSubMenuState (playerComponentsPaused);
+
+            if (enableGamepadCursor) {
+                pauseManager.showOrHideMouseCursorController (playerComponentsPaused);
+            }
+        }
+
+        if (playerIsDriving) {
+            if (disableAllPlayerHUD) {
+                pauseManager.enableOrDisableVehicleHUD (!playerComponentsPaused);
+            }
+        } else {
+            if (!usingDevicePreviously) {
+                if (disableAllPlayerHUD) {
+                    pauseManager.enableOrDisablePlayerHUD (!playerComponentsPaused);
+                } else {
+                    if (disableSecondaryPlayerHUD) {
+                        pauseManager.enableOrDisableSecondaryPlayerHUD (!playerComponentsPaused);
+                    }
+                }
+            }
+        }
+
+        if (disableDynamiUIElements) {
+            pauseManager.enableOrDisableDynamicElementsOnScreen (!playerComponentsPaused);
+        }
+
+        if (disableTouchControls) {
+            if (!usingDevicePreviously) {
+                if (pauseManager.isUsingTouchControls ()) {
+                    pauseManager.enableOrDisableTouchControlsExternally (!playerComponentsPaused);
+                }
+            }
+        }
+
+        if (!usingDevicePreviously) {
+            pauseManager.enableOrDisableDynamicElementsOnScreen (!playerComponentsPaused);
+        }
+
+        playerInput.setInputPausedForExternalComponentsState (playerComponentsPaused);
+
+        if (playerComponentsPaused) {
+            if (useEventOnPause) {
+                eventToSendCamera.Invoke (mainCamera.gameObject);
+                eventOnPause.Invoke ();
+            }
+            if (cameraIsMoved) {
+                previousCameraParent = mainCamera.parent;
+                previousCameraPosition = mainCamera.localPosition;
+
+                if (setNewCameraParent) {
+                    mainCamera.SetParent (newCameraParent);
+                } else {
+                    mainCamera.SetParent (null);
+                }
+            }
+        } else {
+            if (useEventOnResume) {
+                eventOnResume.Invoke ();
+            }
+        }
+
+        stopResumePlayerAfterTimeDelay ();
+
+        if (state) {
+            if (resumePlayerAfterDelay) {
+                resumePlayerAfterTimeDelay ();
+            }
+        }
+
+        if (pauseEscapeMenu) {
+            pauseManager.setPauseGameInputPausedState (state);
+        }
+
+        if (setCustomTimeScale) {
+            if (state) {
+                setTimeScale (customTimeScale);
+            } else {
+                setTimeScale (1);
+            }
+        }
+
+        if (pauseAIWhenOpenMenu) {
+            GKC_Utils.pauseOrResumeAIOnScene (state, pauseCharacterPriority);
+        }
+    }
+
+    public void setTimeScale (float newValue)
+    {
+        Time.timeScale = newValue;
+
+        if (!ignoreChangeFixedDeltaTime) {
+            if (newValue != 0) {
+                Time.fixedDeltaTime = newValue * 0.02f;
+            }
+        }
+    }
+
+    public void checkCharacterMesh (bool state)
+    {
+        if (activatePlayerMeshModel) {
+            bool firstCameraEnabled = playerCameraManager.isFirstPersonActive ();
+
+            if (firstCameraEnabled) {
+                playerControllerManager.setCharacterMeshGameObjectState (state);
+            }
+
+            if (usingDevicePreviously && !playerControllerManager.isFullBodyAwarenessActive ()) {
+                playerControllerManager.getGravityCenter ().gameObject.SetActive (state);
+            }
+        }
+    }
+
+    public void resetCameraPositionIfCharacterPaused ()
+    {
+        if (playerComponentsPaused) {
+            resetCameraPosition ();
+        }
+    }
+
+    public void resetCameraPositionIfCharacterPausedWithoutTransition ()
+    {
+        if (!playerComponentsPaused) {
+            return;
+        }
+
+        if (!cameraIsMoved) {
+            return;
+        }
+
+        setCameraDirection ();
+
+        mainCamera.SetParent (previousCameraParent);
+
+        mainCamera.localPosition = previousCameraPosition;
+        mainCamera.localRotation = Quaternion.identity;
+      
+        pauseOrPlayPlayerComponents (false);
+    }
+
+    public void resetCameraPosition ()
+    {
+        if (!cameraIsMoved) {
+            return;
+        }
+
+        if (resetCameraPositionCoroutine != null) {
+            StopCoroutine (resetCameraPositionCoroutine);
+        }
+
+        resetCameraPositionCoroutine = StartCoroutine (resetCameraCoroutine ());
+    }
+
+    IEnumerator resetCameraCoroutine ()
+    {
+        setCameraDirection ();
+
+        mainCamera.SetParent (previousCameraParent);
+
+        Vector3 targetPosition = previousCameraPosition;
+        Quaternion targeRotation = Quaternion.identity;
+
+        Vector3 worldTargetPosition = previousCameraParent.position;
+        float dist = GKC_Utils.distance (mainCamera.position, worldTargetPosition);
+        float duration = dist / resetCameraPositionSpeed;
+        float t = 0;
+
+        float movementTimer = 0;
+
+        bool targetReached = false;
+
+        float angleDifference = 0;
+
+        float currentDistance = 0;
+
+        while (!targetReached) {
+            t += Time.deltaTime / duration;
+
+            mainCamera.localPosition = Vector3.Lerp (mainCamera.localPosition, targetPosition, t);
+            mainCamera.localRotation = Quaternion.Lerp (mainCamera.localRotation, targeRotation, t);
+
+            angleDifference = Quaternion.Angle (mainCamera.localRotation, targeRotation);
+
+            currentDistance = GKC_Utils.distance (mainCamera.localPosition, targetPosition);
+
+            movementTimer += Time.deltaTime;
+
+            if ((currentDistance < 0.001f && angleDifference < 0.1f) || movementTimer > (duration + 1)) {
+                targetReached = true;
+            }
+
+            yield return null;
+        }
+
+        pauseOrPlayPlayerComponents (false);
+    }
+
+    public void setCameraDirection ()
+    {
+        if (setCameraDirectionAtEnd) {
+            playerCameraGameObject.transform.rotation = cameraDirection.rotation;
+
+            Quaternion newCameraRotation = pivotDirection.localRotation;
+
+            playerCameraManager.getPivotCameraTransform ().localRotation = newCameraRotation;
+
+            float newLookAngleValue = newCameraRotation.eulerAngles.x;
+
+            if (newLookAngleValue > 180) {
+                newLookAngleValue -= 360;
+            }
+
+            playerCameraManager.setLookAngleValue (new Vector2 (0, newLookAngleValue));
+        }
+    }
+
+    public void resumePlayerAfterTimeDelay ()
+    {
+        stopResumePlayerAfterTimeDelay ();
+
+        resumePlayerCoroutine = StartCoroutine (resumePlayerAfterTimeDelayCoroutine ());
+    }
+
+    public void stopResumePlayerAfterTimeDelay ()
+    {
+        if (resumePlayerCoroutine != null) {
+            StopCoroutine (resumePlayerCoroutine);
+        }
+    }
+
+    IEnumerator resumePlayerAfterTimeDelayCoroutine ()
+    {
+        yield return new WaitForSeconds (delayToResumePlayer);
+
+        pauseOrPlayPlayerComponents (false);
+    }
+
+    public void findPlayerOnScene ()
+    {
+        if (searchPlayerOnSceneIfNotAssigned) {
+            getCurrentPlayer (GKC_Utils.findMainPlayerOnScene ());
+        }
+    }
+}