add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Player/Extra Movements/flySystem.cs

@@ -0,0 +1,561 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Events;
+
+public class flySystem : externalControllerBehavior
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool flyModeEnabled = true;
+
+	public float flyForce;
+
+	public float airFriction = 5;
+
+	public float maxFlyVelocity = 50;
+
+	public float flyHorizontalSpeedMultiplier = 1;
+	public float flyVerticalSpeedMultiplier = 2;
+
+	public bool useForceMode = true;
+
+	public ForceMode flyForceMode;
+
+	[Space]
+	[Header ("Vertical Movement Settings")]
+	[Space]
+
+	public bool moveUpAndDownEnabled = true;
+
+	public float flyMoveUpSpeed = 2;
+	public float flyMoveDownSpeed = 2;
+
+	[Space]
+	[Header ("Dash Settings")]
+	[Space]
+
+	public bool setNewDashID;
+	public int newDashID;
+
+	[Space]
+	[Header ("Turbo Settings")]
+	[Space]
+
+	public bool turboEnabled = true;
+	public float flyTurboSpeed;
+
+	[Space]
+	[Header ("Locked Camera Settings")]
+	[Space]
+
+	public bool useCustomFlyMovementDirectionLockedCamera;
+
+	public Transform customFlyMovementDirectionLockedCamera;
+
+	[Space]
+	[Header ("Other Settings")]
+	[Space]
+
+	public float flyRotationSpeedTowardCameraDirection = 10;
+
+	public float flySpeedOnAimMultiplier = 0.5f;
+
+	public string shakeCameraStateName = "Use Fly Turbo";
+
+	[Space]
+	[Header ("Animation Settings")]
+	[Space]
+
+	public int regularAirID = -1;
+	public int flyingID = 4;
+
+	public string flyingModeName = "Flying Mode";
+
+	public bool useIKFlying;
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public bool flyModeActive;
+	public bool turboActive;
+
+	public bool playerIsMoving;
+
+	public bool movingUp;
+	public bool movingDown;
+
+	public float velocityMagnitude;
+
+	public bool flyForcesPaused;
+
+	[Space]
+	[Header ("Events Settings")]
+	[Space]
+
+	public UnityEvent eventOnStateEnabled;
+	public UnityEvent eventOnStateDisabled;
+
+	[Space]
+	[Header ("Components")]
+	[Space]
+
+	public playerController mainPlayerController;
+	public playerCamera mainPlayerCamera;
+	public IKSystem IKManager;
+	public Rigidbody mainRigidbody;
+	public Transform mainCameraTransform;
+	public Transform playerCameraTransform;
+	public Transform playerTransform;
+	public dashSystem mainDashSystem;
+
+	public Transform COM;
+
+	Coroutine resetCOMCoroutine;
+
+	Vector3 totalForce;
+
+	float currentAimSpeedMultipler;
+
+	bool originalFlyModeEnabled;
+
+	int previousDashID = -1;
+
+	Transform currentLockedCameraTransform;
+
+
+	void Start ()
+	{
+		originalFlyModeEnabled = flyModeEnabled;
+	}
+
+	public override void updateControllerBehavior ()
+	{
+		//if the player is flying
+		if (flyModeActive) {
+			if (flyForcesPaused) {
+				return;
+			}
+
+			Vector3 mainCameraTransformForward = Vector3.zero;
+			Vector3 mainCameraTransformRight = Vector3.zero;
+			Vector3 mainCameraTransformUp = Vector3.zero;
+
+			bool isCameraTypeFree = mainPlayerCamera.isCameraTypeFree ();
+
+			bool isPlayerMovingOn3dWorld = mainPlayerController.isPlayerMovingOn3dWorld ();
+
+			if (isCameraTypeFree) {
+				mainCameraTransformForward = mainCameraTransform.forward;
+				mainCameraTransformRight = mainCameraTransform.right;
+			} else {
+				if (useCustomFlyMovementDirectionLockedCamera && isPlayerMovingOn3dWorld) {
+
+					currentLockedCameraTransform = customFlyMovementDirectionLockedCamera;
+				} else {
+					currentLockedCameraTransform = mainPlayerCamera.getLockedCameraTransform ();
+
+				}
+			
+				mainCameraTransformForward = currentLockedCameraTransform.forward;
+				mainCameraTransformRight = currentLockedCameraTransform.right;
+
+				mainCameraTransformUp = currentLockedCameraTransform.up;
+			}
+
+			Vector3 targetDirection = Vector3.zero;
+
+			if (isPlayerMovingOn3dWorld) {
+				targetDirection = mainCameraTransformForward * (mainPlayerController.getVerticalInput () * flyVerticalSpeedMultiplier) +
+				mainCameraTransformRight * (mainPlayerController.getHorizontalInput () * flyHorizontalSpeedMultiplier);
+				
+				if (!isCameraTypeFree && useCustomFlyMovementDirectionLockedCamera) {
+					Vector3 localMove = playerTransform.InverseTransformDirection (targetDirection);
+
+					targetDirection = localMove;
+				}
+
+			} else {
+				targetDirection = mainCameraTransformUp * (mainPlayerController.getVerticalInput () * flyVerticalSpeedMultiplier) +
+				mainCameraTransformRight * (mainPlayerController.getHorizontalInput () * flyHorizontalSpeedMultiplier);
+			}
+
+			playerIsMoving = mainPlayerController.isPlayerMoving (0.1f);
+
+			if (!mainPlayerController.isPlayerOnFirstPerson () && !mainPlayerController.isPlayerRotatingToSurface ()) {
+				if (isPlayerMovingOn3dWorld) {
+					Quaternion COMTargetRotation = Quaternion.identity;
+
+					bool isPlayerUsingWeapons = mainPlayerController.isPlayerUsingWeapons ();
+						
+					if (mainPlayerController.isFullBodyAwarenessActive () && isPlayerUsingWeapons) {
+						float angleDifference = Quaternion.Angle (COM.localRotation, COMTargetRotation);
+
+						if (angleDifference > 0.05f) {
+							COM.localRotation = Quaternion.Lerp (COM.localRotation, COMTargetRotation,
+								flyRotationSpeedTowardCameraDirection * Time.fixedDeltaTime);
+						}
+					} else {
+						if ((playerIsMoving && targetDirection != Vector3.zero) || (!isCameraTypeFree && !isPlayerUsingWeapons)) {
+							float currentLookAngle = 0;
+
+							if (isCameraTypeFree) {
+								currentLookAngle = Vector3.SignedAngle (playerCameraTransform.forward, mainCameraTransformForward, playerCameraTransform.right);
+							} 
+
+							if (Mathf.Abs (currentLookAngle) > 10 && !mainPlayerController.isPlayerAiming ()) {
+								if (turboActive) {
+									currentLookAngle = Mathf.Clamp (currentLookAngle, -50, 50);
+								} else {
+									currentLookAngle = Mathf.Clamp (currentLookAngle, -30, 30);
+								}
+							} else {
+								currentLookAngle = 0;
+							}
+
+							COMTargetRotation = Quaternion.Euler (Vector3.right * currentLookAngle);
+	
+							Quaternion targetRotation = Quaternion.identity;
+
+							if (isCameraTypeFree) {
+								targetRotation = playerCameraTransform.rotation;
+							} else {
+								targetRotation = currentLockedCameraTransform.rotation;
+							}
+
+							playerTransform.rotation = Quaternion.Lerp (playerTransform.rotation, targetRotation, 
+								flyRotationSpeedTowardCameraDirection * Time.fixedDeltaTime);
+						}
+
+						COM.localRotation = Quaternion.Lerp (COM.localRotation, COMTargetRotation,
+							flyRotationSpeedTowardCameraDirection * Time.fixedDeltaTime);
+					}
+				}
+			}
+
+			currentAimSpeedMultipler = 1;
+
+			if (!mainPlayerController.isPlayerOnFirstPerson () && mainPlayerController.isPlayerAiming ()) {
+				currentAimSpeedMultipler = flySpeedOnAimMultiplier;
+			}
+
+			totalForce = targetDirection * (flyForce * currentAimSpeedMultipler);
+
+			if (isPlayerMovingOn3dWorld) {
+				if (movingUp) {
+					totalForce += playerTransform.up * flyMoveUpSpeed;
+
+					playerIsMoving = true;
+				}
+
+				if (movingDown) {
+					totalForce -= playerTransform.up * flyMoveDownSpeed;
+
+					playerIsMoving = true;
+				}
+			}
+
+			if (playerIsMoving) {
+				if (turboActive) {
+					totalForce *= flyTurboSpeed;
+				}
+
+				velocityMagnitude = totalForce.magnitude;
+
+				if (velocityMagnitude > maxFlyVelocity) {
+					totalForce = Vector3.ClampMagnitude (totalForce, maxFlyVelocity);
+				}
+
+				velocityMagnitude = totalForce.magnitude;
+
+				if (useForceMode) {
+					mainRigidbody.AddForce (totalForce, flyForceMode);
+				} else {
+					mainRigidbody.AddForce (totalForce);
+				}
+			} else {
+				velocityMagnitude = mainRigidbody.linearVelocity.magnitude;
+
+				if (velocityMagnitude > 0) {
+					totalForce = mainRigidbody.linearVelocity * (-1 * airFriction);
+				}
+
+				mainRigidbody.AddForce (totalForce, flyForceMode);
+			}
+		}
+	}
+
+	public void enableOrDisableFlyingMode (bool state)
+	{
+		if (!flyModeEnabled) {
+			return;
+		}
+
+		if (mainPlayerController.isUseExternalControllerBehaviorPaused ()) {
+			return;
+		}
+
+		if (flyModeActive == state) {
+			return;
+		}
+
+		if (state) {
+			externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();
+
+			if (currentExternalControllerBehavior != null && currentExternalControllerBehavior != this) {
+				if (canBeActivatedIfOthersBehaviorsActive && checkIfCanEnableBehavior (currentExternalControllerBehavior.behaviorName)) {
+					currentExternalControllerBehavior.disableExternalControllerState ();
+				} else {
+					return;
+				}
+			}
+		}
+
+		bool flyModeActivePrevioulsy = flyModeActive;
+
+		flyModeActive = state;
+
+		mainPlayerController.enableOrDisableFlyingMode (state);
+
+		setBehaviorCurrentlyActiveState (state);
+
+		setCurrentPlayerActionSystemCustomActionCategoryID ();
+
+		if (flyModeActive) {
+			mainPlayerController.setExternalControllerBehavior (this);
+		} else {
+			if (flyModeActivePrevioulsy) {
+				externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();
+
+				if (currentExternalControllerBehavior == null || currentExternalControllerBehavior == this) {
+					mainPlayerController.setExternalControllerBehavior (null);
+				}
+			}
+		}
+
+		if (useIKFlying) {
+			IKManager.setIKBodyState (state, flyingModeName);
+		}
+
+		if (!state) {
+			mainPlayerController.setLastTimeFalling ();
+		}
+
+		if (state) {
+			mainPlayerController.setCurrentAirIDValue (flyingID);
+		} else {
+			mainPlayerController.setCurrentAirIDValue (regularAirID);
+
+			mainPlayerController.setCurrentAirSpeedValue (1);
+		}
+
+		if (setNewDashID) {
+			if (mainDashSystem != null) {
+				if (state) {
+					if (previousDashID == -1) {
+						previousDashID = mainDashSystem.getCurrentDashID ();
+					}
+
+					mainDashSystem.setCheckGroundPausedState (true);
+
+					mainDashSystem.setOverrideStrafeModeActiveStateResult (true);
+
+					mainDashSystem.setCurrentDashID (newDashID);
+				} else {
+					if (previousDashID != -1) {
+
+						mainDashSystem.setCurrentDashID (previousDashID);
+
+						previousDashID = -1;
+
+						mainDashSystem.setCheckGroundPausedState (false);
+
+						mainDashSystem.setOverrideStrafeModeActiveStateResult (false);
+					}
+				}
+			}
+		}
+
+		if (flyModeActive) {
+			eventOnStateEnabled.Invoke ();
+		} else {
+			eventOnStateDisabled.Invoke ();
+
+			resetCOMRotation ();
+
+			if (turboActive) {
+				enableOrDisableTurbo (false);
+			}
+
+			enableOrDisableVerticalMovementUp (false);
+
+			enableOrDisableVerticalMovementDown (false);
+		}
+
+		mainPlayerCamera.stopShakeCamera ();
+
+		if (flyModeActive) {
+			mainPlayerController.setPlayerOnGroundState (false);
+
+			mainPlayerController.setOnGroundAnimatorIDValue (false);
+
+			mainPlayerController.setPreviousValueOnGroundAnimatorStateValue (false);
+		}
+
+		movingUp = false;
+
+		movingDown = false;
+	}
+
+	public void enableOrDisableTurbo (bool state)
+	{
+		turboActive = state;
+
+		mainPlayerController.enableOrDisableFlyModeTurbo (turboActive);
+
+		mainPlayerCamera.changeCameraFov (turboActive);
+
+		//when the player accelerates his movement in the air, the camera shakes
+		if (turboActive) {
+			mainPlayerCamera.setShakeCameraState (true, shakeCameraStateName);
+		} else {
+			mainPlayerCamera.setShakeCameraState (false, "");
+
+			mainPlayerCamera.stopShakeCamera ();
+		}
+
+		if (turboActive) {
+			mainPlayerController.setCurrentAirSpeedValue (2);
+		} else {
+			mainPlayerController.setCurrentAirSpeedValue (1);
+		}
+	}
+
+	public void resetCOMRotation ()
+	{
+		if (resetCOMCoroutine != null) {
+			StopCoroutine (resetCOMCoroutine);
+		}
+
+		resetCOMCoroutine = StartCoroutine (resetCOMRotationCoroutine ());
+	}
+
+	public IEnumerator resetCOMRotationCoroutine ()
+	{
+		for (float t = 0; t < 1;) {
+			t += Time.deltaTime * 4;
+
+			COM.localRotation = Quaternion.Slerp (COM.localRotation, Quaternion.identity, t);
+
+			yield return null;
+		}
+	}
+
+	public void inputChangeTurboState (bool state)
+	{
+		if (flyModeActive && turboEnabled) {
+			enableOrDisableTurbo (state);
+		}
+	}
+
+	public void inputMoveUp (bool state)
+	{
+		if (flyModeActive && moveUpAndDownEnabled) {
+			enableOrDisableVerticalMovementUp (state);
+		}
+	}
+
+	public void inputMoveDown (bool state)
+	{
+		if (flyModeActive && moveUpAndDownEnabled) {
+			enableOrDisableVerticalMovementDown (state);
+		}
+	}
+
+	void enableOrDisableVerticalMovementUp (bool state)
+	{
+		movingUp = state;
+
+		if (movingUp) {
+			movingDown = false;
+		}
+	}
+
+	void enableOrDisableVerticalMovementDown (bool state)
+	{
+		movingDown = state;
+
+		if (movingDown) {
+			movingUp = false;
+		}
+	}
+
+	public void setFlyModeEnabledState (bool state)
+	{
+		if (flyModeActive) {
+			enableOrDisableFlyingMode (false);
+		}
+
+		flyModeEnabled = state;
+	}
+
+	public void setOriginalFlyModeEnabledState ()
+	{
+		setFlyModeEnabledState (originalFlyModeEnabled);
+	}
+
+	public override void disableExternalControllerState ()
+	{
+		enableOrDisableFlyingMode (false);
+	}
+
+	public override void setCurrentPlayerActionSystemCustomActionCategoryID ()
+	{
+		if (behaviorCurrentlyActive) {
+			if (customActionCategoryID > -1) {
+				mainPlayerController.setCurrentCustomActionCategoryID (customActionCategoryID);
+			}
+		} else {
+			if (regularActionCategoryID > -1) {
+				mainPlayerController.setCurrentCustomActionCategoryID (regularActionCategoryID);
+			}
+		}
+	}
+
+	public override void checkPauseStateDuringExternalForceOrBehavior ()
+	{
+		flyForcesPaused = true;
+	}
+
+	public override void checkResumeStateAfterExternalForceOrBehavior ()
+	{
+		if (flyModeActive) {
+			setCurrentPlayerActionSystemCustomActionCategoryID ();
+
+			flyForcesPaused = false;
+		}
+	}
+
+	public void setEnableExternalForceOnFlyModeState (bool state)
+	{
+		if (flyModeActive) {
+			mainPlayerController.setEnableExternalForceOnFlyModeState (state);
+		}
+	}
+
+	public void setFlyModeEnabledStateFromEditor (bool state)
+	{
+		setFlyModeEnabledState (state);
+
+		updateComponent ();
+	}
+
+	void updateComponent ()
+	{
+		GKC_Utils.updateComponent (this);
+
+		GKC_Utils.updateDirtyScene ("Update Fly System", gameObject);
+	}
+}