add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Camera/Camera Effect/photoModeSystem.cs

@@ -0,0 +1,395 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class photoModeSystem : MonoBehaviour
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool photoModeEnabled = true;
+
+	public float rotationSpeed;
+
+	public float smoothCameraRotationSpeedVertical;
+	public float smoothCameraRotationSpeedHorizontal;
+
+	public Vector2 clampTiltX;
+
+	public float movementSpeed;
+
+	public float sidesRotationSpeed = 1;
+
+	public bool clampCameraDistance;
+	public float maxCameraRadius;
+
+	public bool setCustomTimeScale;
+	public float customTimeScale;
+
+	public bool freezeAllCharactersOnScene;
+
+	public bool canUseTurboEnabled = true;
+	public float turboSpeedMultiplier = 2;
+
+	[Space]
+	[Header ("Events Settings")]
+	[Space]
+
+	public UnityEvent eventOnPhotoModeActive;
+	public UnityEvent eventOnPhotoModeDeactive;
+
+	public UnityEvent eventOnTakePhoto;
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public Vector2 movementAxisValues;
+	public Vector2 mouseAxisValues;
+
+	public Vector2 currentLookAngle;
+
+	public bool photoModeInputActive;
+
+	public bool photoModeActive;
+
+	public bool turboActive;
+
+	[Space]
+	[Header ("Component Elements")]
+	[Space]
+
+	public Transform mainTransform;
+	public Transform pivotTransform;
+
+	public Transform mainCameraTransform;
+
+	public playerInputManager playerInput;
+	public playerCamera mainPlayerCamera;
+
+	public timeBullet mainTimeBullet;
+	public menuPause pauseManager;
+
+	Transform previousMainCameraParent;
+
+	Quaternion currentPivotRotation;
+	float currentCameraUpRotation;
+
+	Vector3 moveInput;
+
+	bool movingCameraUp;
+	bool movingCameraDown;
+	bool rotatingCameraToRight;
+	bool rotatingCameraToLeft;
+
+	Vector3 lastCameraPosition;
+
+	bool cameraRotationActive = true;
+
+	bool resetingCamera;
+
+	float previosScaleTime;
+	Coroutine resetCameraPositionCoroutine;
+
+	Coroutine mainUpdateCoroutine;
+
+
+	public void stopUpdateCoroutine ()
+	{
+		if (mainUpdateCoroutine != null) {
+			StopCoroutine (mainUpdateCoroutine);
+		}
+	}
+
+	IEnumerator updateCoroutine ()
+	{
+		var waitTime = new WaitForSeconds (0.00001f);
+
+		while (true) {
+			
+//	void Update ()
+//	{
+			if (photoModeActive && photoModeInputActive) {
+				movementAxisValues = playerInput.getPlayerRawMovementAxisWithoutCheckingEnabled ();
+
+				mouseAxisValues = playerInput.getPlayerMouseAxis ();
+
+				//get the look angle value
+				if (cameraRotationActive) {
+					currentLookAngle.x = mouseAxisValues.x * rotationSpeed;
+					currentLookAngle.y -= mouseAxisValues.y * rotationSpeed;
+				}
+
+				//clamp these values to limit the camera rotation
+				currentLookAngle.y = Mathf.Clamp (currentLookAngle.y, -clampTiltX.x, clampTiltX.y);
+
+				//set every angle in the camera and the pivot
+				currentPivotRotation = Quaternion.Euler (currentLookAngle.y, 0, 0);
+
+				pivotTransform.localRotation = Quaternion.Slerp (pivotTransform.localRotation, currentPivotRotation, smoothCameraRotationSpeedVertical * Time.unscaledDeltaTime);
+
+				currentCameraUpRotation = Mathf.Lerp (currentCameraUpRotation, currentLookAngle.x, smoothCameraRotationSpeedHorizontal * Time.unscaledDeltaTime);
+
+				mainTransform.Rotate (0, currentCameraUpRotation, 0);					
+
+				if (rotatingCameraToRight) {
+					mainTransform.Rotate (0, 0, -sidesRotationSpeed);	
+
+					rotatingCameraToRight = false;
+				}
+
+				if (rotatingCameraToLeft) {
+					mainTransform.Rotate (0, 0, sidesRotationSpeed);		
+
+					rotatingCameraToLeft = false;
+				}
+
+				float currentSpeed = movementSpeed;
+
+				if (turboActive) {
+					currentSpeed *= turboSpeedMultiplier;
+				}
+
+				moveInput = (movementAxisValues.y * pivotTransform.forward + movementAxisValues.x * pivotTransform.right) * currentSpeed;
+
+				if (movingCameraUp) {
+					moveInput += Vector3.up * currentSpeed;
+
+					movingCameraUp = false;
+				}
+
+				if (movingCameraDown) {
+					moveInput -= Vector3.up * currentSpeed;
+
+					movingCameraDown = false;
+				}
+
+				mainTransform.position += (moveInput * Time.unscaledDeltaTime);
+
+				if (clampCameraDistance) {
+
+					Vector3 newLocation = mainTransform.position;
+					
+					Vector3 centerPosition = lastCameraPosition;
+					float distance = GKC_Utils.distance (newLocation, centerPosition);
+
+					if (distance > maxCameraRadius) {
+						Vector3 fromOriginToObject = newLocation - centerPosition;
+						fromOriginToObject *= maxCameraRadius / distance;
+						newLocation = centerPosition + fromOriginToObject;
+					}
+
+					mainTransform.position = newLocation;
+				}
+			}
+
+			yield return waitTime;
+		}
+	}
+
+	public void setPhotoModeActiveState (bool state)
+	{
+		if (state == photoModeActive) {
+			return;
+		}
+
+		if (resetingCamera) {
+			return;
+		}
+
+		photoModeActive = state;
+
+		stopUpdateCoroutine ();
+
+		if (photoModeActive) {
+			mainUpdateCoroutine = StartCoroutine (updateCoroutine ());
+		}
+
+		if (setCustomTimeScale) {
+			if (photoModeActive) {
+				previosScaleTime = Time.timeScale;
+
+				mainTimeBullet.setTimeValues (true, customTimeScale);
+
+				pauseManager.setTimeScale (customTimeScale);
+
+			} else {
+				if (previosScaleTime < 1) {
+					mainTimeBullet.setTimeValues (true, previosScaleTime);
+
+					pauseManager.setTimeScale (previosScaleTime);
+				} else {
+					mainTimeBullet.disableTimeBullet ();
+
+					pauseManager.setTimeScale (1);
+				}
+			}
+		}
+
+		if (freezeAllCharactersOnScene) {
+			GKC_Utils.pauseOrResumeAllCharactersScene (state);
+		}
+
+		currentLookAngle = Vector2.zero;
+
+		if (photoModeActive) {
+			eventOnPhotoModeActive.Invoke ();
+
+			movementAxisValues = Vector2.zero;
+			mouseAxisValues = Vector2.zero;
+
+			lastCameraPosition = mainCameraTransform.position;
+
+			previousMainCameraParent = mainCameraTransform.parent;
+
+			mainTransform.position = mainCameraTransform.position;
+
+			mainTransform.rotation = mainPlayerCamera.transform.rotation;
+
+            mainTransform.eulerAngles = new Vector3 (mainTransform.eulerAngles.x, mainCameraTransform.eulerAngles.y, mainTransform.eulerAngles.z);
+
+			pivotTransform.rotation = mainCameraTransform.rotation;
+			pivotTransform.localEulerAngles = new Vector3 (pivotTransform.localEulerAngles.x, 0, 0);
+
+			currentLookAngle.y = pivotTransform.localEulerAngles.x;
+
+			if (currentLookAngle.y > 180) {
+				currentLookAngle.y -= 360;
+			}
+
+			mainCameraTransform.SetParent (pivotTransform);
+
+			photoModeInputActive = true;
+		} else {
+			photoModeInputActive = false;
+
+			resetCameraPosition ();
+		}
+
+		turboActive = false;
+	}
+
+	public void enableOrDisablePhotoMode ()
+	{
+		setPhotoModeActiveState (!photoModeActive);
+	}
+
+	public void takePhoto ()
+	{
+		eventOnTakePhoto.Invoke ();
+	}
+
+	public void resetCameraPosition ()
+	{
+		if (resetCameraPositionCoroutine != null) {
+			StopCoroutine (resetCameraPositionCoroutine);
+		}
+
+		resetCameraPositionCoroutine = StartCoroutine (resetCameraCoroutine ());
+	}
+
+	IEnumerator resetCameraCoroutine ()
+	{
+		setCameraDirection ();
+
+		if (previousMainCameraParent) {
+			resetingCamera = true;
+
+			mainCameraTransform.SetParent (previousMainCameraParent);
+
+			Vector3	worldTargetPosition = previousMainCameraParent.position;
+
+			float dist = GKC_Utils.distance (mainCameraTransform.position, worldTargetPosition);
+
+			float duration = dist / movementSpeed;
+
+			float t = 0;
+
+			while ((t < 1 && (mainCameraTransform.localPosition != Vector3.zero || mainCameraTransform.localRotation != Quaternion.identity))) {
+				t += Time.unscaledDeltaTime / duration;
+
+				mainCameraTransform.localPosition = Vector3.Lerp (mainCameraTransform.localPosition, Vector3.zero, t);
+				mainCameraTransform.localRotation = Quaternion.Lerp (mainCameraTransform.localRotation, Quaternion.identity, t);
+
+				yield return null;
+			}
+
+			resetingCamera = false;
+		}
+
+		eventOnPhotoModeDeactive.Invoke ();
+	}
+
+	public void setCameraDirection ()
+	{
+		if (mainPlayerCamera.isUsingRegularGravity ()) {
+			mainPlayerCamera.transform.eulerAngles = (mainPlayerCamera.transform.up * mainTransform.eulerAngles.y);
+		} else {
+			float angleToRotate = Vector3.SignedAngle (mainPlayerCamera.transform.forward, mainTransform.forward, mainPlayerCamera.transform.up);
+
+            mainPlayerCamera.transform.Rotate (0, angleToRotate, 0);
+        }
+
+		Quaternion newCameraRotation = pivotTransform.localRotation;
+
+		mainPlayerCamera.getPivotCameraTransform ().localRotation = newCameraRotation;
+
+		float newLookAngleValue = newCameraRotation.eulerAngles.x;
+
+		if (newLookAngleValue > 180) {
+			newLookAngleValue -= 360;
+		}
+
+		mainPlayerCamera.setLookAngleValue (new Vector2 (0, newLookAngleValue));
+	}
+
+
+	public void inputTakePhoto ()
+	{
+		if (photoModeActive) {
+			takePhoto ();
+		}
+	}
+
+	public void inputToogleCameraRotation ()
+	{
+		if (photoModeActive) {
+			cameraRotationActive = !cameraRotationActive;
+		}
+	}
+
+	public void inputEnableOrDisablePhotoMode ()
+	{
+		enableOrDisablePhotoMode ();
+	}
+
+	public void inputSetTurboMode (bool state)
+	{
+		if (photoModeActive) {
+			if (canUseTurboEnabled) {
+				turboActive = state;
+			}
+		}
+	}
+
+	public void inputMoveCameraUp ()
+	{
+		movingCameraUp = true;
+	}
+
+	public void inputMoveCameraDown ()
+	{
+		movingCameraDown = true;
+	}
+
+	public void inputRotategCameraToRight ()
+	{
+		rotatingCameraToRight = true;
+	}
+
+	public void inputRotateCameraToLeft ()
+	{
+		rotatingCameraToLeft = true;
+	}
+}