add ckg

plantilla base para movimiento básico

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

@@ -0,0 +1,891 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class railSystem : externalControllerBehavior
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool railSystemEnabled = true;
+
+	public float lookDirectionSpeed;
+
+	public float resetPlayerRotationSpeed = 5;
+
+	public float adjustPlayerToRailSpeed = 5;
+
+	[Space]
+	[Header ("Reverse Direction Settings")]
+	[Space]
+
+	public bool canChangeDirectionEnabled;
+
+	public float minWaitToChangeDirection = 0.8f;
+
+	public float delayToReverseDirection = 1;
+
+	public float delayToResumeMovementOnReverseDirection = 0.5f;
+
+	public bool reduceSlideSpeedOnReversingDirection;
+
+	public float reduceSlideSpeedOnReversingDirectionMultiplier = 0.2f;
+
+	[Space]
+	[Header ("Physics Settings")]
+	[Space]
+
+	public bool useForceMode;
+
+	public ForceMode railForceMode;
+
+	public bool turboEnabled;
+
+	public float turboSpeed;
+
+	public float speedOnAimMultiplier;
+
+	[Space]
+	[Header ("Speed Settings")]
+	[Space]
+
+	public bool adjustSpeedBasedOnInclination;
+	public float speedMultiplierOnInclinationUp;
+	public float speedMultiplierOnInclinationDown;
+	public float minInclinationDifferenceToAffectSpeed;
+
+	public float speedMultiplierOnInclinationLerp;
+
+	[Space]
+	[Header ("Jump Settings")]
+	[Space]
+
+	public bool canJumpEnabled;
+
+	public Vector3 impulseOnJump;
+	public Vector3 endOfSurfaceImpulse;
+
+	public float maxVelocityChangeOnJump;
+
+	[Space]
+	[Header ("Third Person Settings")]
+	[Space]
+
+	public int actionID = 08632946;
+
+	public string externalControlleBehaviorActiveAnimatorName = "External Behavior Active";
+	public string actionIDAnimatorName = "Action ID";
+
+	public string horizontalAnimatorName = "Horizontal Action";
+
+	public float inputLerpSpeed = 3;
+
+	[Space]
+	[Header ("Third Person Camera State Settings")]
+	[Space]
+
+	public bool setNewCameraStateOnThirdPerson;
+
+	public string newCameraStateOnThirdPerson;
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public bool showDebugPrint;
+
+	public bool movementOnRailPausedDebug;
+
+	public bool railSystemActive;
+
+	public float bezierDuration;
+
+	public bool turboActive;
+
+	public Vector3 targetDirection;
+
+	public BezierSpline currentSpline;
+
+	public bool movingForward;
+
+	public bool adjustingPlayerToRail;
+
+	public float progress = 0;
+	public float progressTarget = 0;
+
+	public bool playerAiming;
+
+
+	[Space]
+	[Header ("Events Settings")]
+	[Space]
+
+	public UnityEvent eventOnStateEnabled;
+	public UnityEvent eventOnStateDisabled;
+
+	public UnityEvent eventBeforeActivatingState;
+	public UnityEvent eventBeforeDeactivatingState;
+
+	public bool useEventUseTurbo;
+	public UnityEvent eventOnStarTurbo;
+	public UnityEvent eventOnEndTurbo;
+
+	[Space]
+	[Header ("Components")]
+	[Space]
+
+	public playerController mainPlayerController;
+
+	public Animator mainAnimator;
+
+	public playerCamera mainPlayerCamera;
+
+	public Transform playerTransform;
+	public Transform playerCameraTransform;
+
+	public Rigidbody mainRigidbody;
+
+	public headTrack mainHeadTrack;
+
+	float currentAimSpeedMultipler;
+
+	bool canUseTurboPausedState;
+
+	int externalControlleBehaviorActiveAnimatorID;
+
+	int actionIDAnimatorID;
+
+	int horizontalAnimatorID;
+
+	bool isFirstPersonActive;
+
+	string previousCameraState = "";
+
+	bool turnAndForwardAnimatorValuesPaused;
+
+	Coroutine adjustPlayerToRailCoroutine;
+
+	Coroutine resetPlayerCoroutine;
+
+	Vector3 lookDirection;
+
+	float currentInclinationSpeed;
+
+	bool resetCameraShakeActive;
+
+	float lastTimeDirectionChanged;
+
+	float lastTimeReverseMovementDirectionInput;
+
+	bool originalCanChangeDirectionEnabled;
+
+	bool activateReverseDirectionActive;
+
+	float reverseDirectionValue;
+
+
+	void Start ()
+	{
+		externalControlleBehaviorActiveAnimatorID = Animator.StringToHash (externalControlleBehaviorActiveAnimatorName);
+
+		actionIDAnimatorID = Animator.StringToHash (actionIDAnimatorName);
+
+		horizontalAnimatorID = Animator.StringToHash (horizontalAnimatorName);
+
+		originalCanChangeDirectionEnabled = canChangeDirectionEnabled;
+
+		if (playerCameraTransform == null) {
+			playerCameraTransform = mainPlayerCamera.transform;
+		}
+	}
+
+	public override void updateControllerBehavior ()
+	{
+		if (railSystemActive && !movementOnRailPausedDebug) {
+			if (!adjustingPlayerToRail) {
+				bool targetReached = false;
+
+				if (mainPlayerController.isPlayerRunning ()) {
+					if (!turboActive) {
+						enableOrDisableTurbo (true);
+					}
+				} else {
+					if (turboActive) {
+						enableOrDisableTurbo (false);
+					}
+				}
+
+				int slidingAnimatorValue = 0;
+
+				float currentSpeed = bezierDuration;
+
+				if (turboActive) {
+					slidingAnimatorValue = 1;
+
+					currentSpeed /= turboSpeed;
+				}
+
+				if (adjustSpeedBasedOnInclination) {
+
+					lookDirection = currentSpline.GetDirection (progress);
+
+					Vector3 currentNormal = mainPlayerController.getCurrentNormal ();
+
+					float angle = Vector3.SignedAngle (playerTransform.up, currentNormal, playerTransform.right);
+
+					if (Mathf.Abs (angle) > minInclinationDifferenceToAffectSpeed) {
+						if (angle < 0) {
+							currentInclinationSpeed = Mathf.Lerp (currentInclinationSpeed, speedMultiplierOnInclinationDown, Time.deltaTime * speedMultiplierOnInclinationLerp);
+						} else {
+							currentInclinationSpeed = Mathf.Lerp (currentInclinationSpeed, speedMultiplierOnInclinationUp, Time.deltaTime * speedMultiplierOnInclinationLerp);
+						}
+					} else {
+						currentInclinationSpeed = Mathf.Lerp (currentInclinationSpeed, 1, Time.deltaTime * speedMultiplierOnInclinationLerp);
+					}
+
+					currentSpeed *= currentInclinationSpeed;
+				}
+
+
+				bool canRotatePlayerResult = true;
+
+				currentAimSpeedMultipler = 1;
+
+
+				if (!mainPlayerController.isPlayerOnFirstPerson () &&
+				    (mainPlayerController.isPlayerAiming () || mainPlayerController.isUsingFreeFireMode ()) &&
+				    !mainPlayerController.isCheckToKeepWeaponAfterAimingWeaponFromShooting ()) {
+
+					currentAimSpeedMultipler = speedOnAimMultiplier;
+			
+					if (!turnAndForwardAnimatorValuesPaused) {
+						mainPlayerController.setTurnAndForwardAnimatorValuesPausedState (true);
+			
+						mainPlayerController.setRotateInCameraDirectionOnAirOnExternalActionActiveState (true);
+
+						turnAndForwardAnimatorValuesPaused = true;
+					}
+
+					canRotatePlayerResult = false;
+
+					if (Time.time > mainPlayerController.getLastTimeFiring () + 0.2f) {
+						if (resetCameraShakeActive) {
+							mainPlayerCamera.stopAllHeadbobMovements ();
+						
+							resetCameraShakeActive = false;
+						}
+					} else {
+						resetCameraShakeActive = true;
+					}
+	
+				} else {
+					if (turnAndForwardAnimatorValuesPaused) {
+						mainPlayerController.setTurnAndForwardAnimatorValuesPausedState (false);
+
+						mainPlayerController.setRotateInCameraDirectionOnAirOnExternalActionActiveState (false);
+			
+						turnAndForwardAnimatorValuesPaused = false;
+
+						mainPlayerCamera.stopAllHeadbobMovements ();
+					}
+				}
+
+				if (canChangeDirectionEnabled && canRotatePlayerResult) {
+					Vector2 rawMovementAxis = mainPlayerController.getRawAxisValues ();
+
+					if (rawMovementAxis != Vector2.zero) {
+
+						Vector3 movementDirection = rawMovementAxis.y * mainPlayerController.getCurrentForwardDirection () +
+						                            rawMovementAxis.x * mainPlayerController.getCurrentRightDirection ();
+
+						float directionAngle = Vector3.SignedAngle (movementDirection, playerTransform.forward, playerTransform.up);
+
+						if (Mathf.Abs (directionAngle) > 90) {
+							if (movingForward) {
+								if (Time.time > minWaitToChangeDirection + lastTimeDirectionChanged) {
+									reverseDirectionValue = -1;
+//									calculateMovementDirection (-1);
+
+									lastTimeReverseMovementDirectionInput = Time.time;
+
+									activateReverseDirectionActive = true;
+								}
+							} else {
+								if (Time.time > minWaitToChangeDirection + lastTimeDirectionChanged) {
+									reverseDirectionValue = 1;
+
+//									calculateMovementDirection (1);
+
+									lastTimeReverseMovementDirectionInput = Time.time;
+
+									activateReverseDirectionActive = true;
+								}
+							}
+						}
+					}
+				}
+
+				if (activateReverseDirectionActive) {
+					if (Time.time > delayToReverseDirection + lastTimeReverseMovementDirectionInput) {
+						activateReverseDirectionActive = false;
+
+						calculateMovementDirection (reverseDirectionValue);
+					}
+				}
+
+				bool canMove = true;
+
+				if (lastTimeReverseMovementDirectionInput > 0) {
+					if (Time.time < lastTimeReverseMovementDirectionInput + delayToResumeMovementOnReverseDirection) {
+						canMove = false;
+
+						slidingAnimatorValue = 0;
+
+						if (reduceSlideSpeedOnReversingDirection) {
+							currentSpeed *= reduceSlideSpeedOnReversingDirectionMultiplier;
+
+							canMove = true;
+						}
+					} else {
+						lastTimeReverseMovementDirectionInput = 0;
+					}
+				}
+
+				mainAnimator.SetFloat (horizontalAnimatorID, slidingAnimatorValue, inputLerpSpeed, Time.fixedDeltaTime);
+
+
+				float currentProgress = 0;
+
+				if (canMove) {
+					currentProgress = Time.deltaTime / (currentSpeed * currentAimSpeedMultipler);
+				}
+
+				if (movingForward) {
+					progress += currentProgress;
+				} else {
+					progress -= currentProgress;
+				}
+
+				Vector3 position = currentSpline.GetPoint (progress);
+
+				playerTransform.position = position;
+
+				if (mainPlayerCamera.isFullBodyAwarenessActive ()) {
+					playerCameraTransform.position = position;
+				}
+
+				lookDirection = currentSpline.GetDirection (progress);
+
+				if (!movingForward) {
+					lookDirection = -lookDirection;
+				}
+
+
+				if (canRotatePlayerResult) {
+					Quaternion targetRotation = Quaternion.LookRotation (lookDirection);
+
+					if (mainPlayerCamera.isFullBodyAwarenessActive ()) {
+						playerCameraTransform.rotation = Quaternion.Lerp (playerCameraTransform.rotation, targetRotation, Time.fixedDeltaTime * lookDirectionSpeed);
+					} else {
+						playerTransform.rotation = Quaternion.Lerp (playerTransform.rotation, targetRotation, Time.fixedDeltaTime * lookDirectionSpeed);
+					}
+				}
+
+				if (movingForward) {
+					if (progress > progressTarget) {
+						targetReached = true;
+					}
+				} else {
+					if (progress < progressTarget) {
+						targetReached = true;
+					}
+				}
+
+				if (targetReached) {
+					stopRail ();
+				}
+			}
+		}
+	}
+
+	public override void setExtraImpulseForce (Vector3 forceAmount, bool useCameraDirection)
+	{
+		setImpulseForce (forceAmount, useCameraDirection);
+	}
+
+	public void setImpulseForce (Vector3 forceAmount, bool useCameraDirection)
+	{
+		Vector3 impulseForce = forceAmount;
+
+		Vector3 velocityChange = Vector3.zero;
+
+		if (maxVelocityChangeOnJump > 0) {
+			velocityChange = impulseForce - mainRigidbody.linearVelocity;
+
+			velocityChange = Vector3.ClampMagnitude (velocityChange, maxVelocityChangeOnJump);
+
+		} else {
+			velocityChange = impulseForce;
+		}
+
+		mainPlayerController.setVelocityChangeValue (impulseForce);
+
+		mainRigidbody.AddForce (impulseForce, ForceMode.VelocityChange);
+	}
+
+	public override void setJumpActiveForExternalForce ()
+	{
+		setJumpActive (impulseOnJump);
+	}
+
+	public void setJumpActive (Vector3 newImpulseOnJumpAmount)
+	{
+		if (railSystemActive) {
+			setRailSystemActivestate (false);
+
+			Vector3 totalForce = newImpulseOnJumpAmount.y * playerTransform.up + newImpulseOnJumpAmount.z * playerTransform.forward;
+
+			mainPlayerController.useJumpPlatform (totalForce, ForceMode.Impulse);
+		}
+	}
+
+	public override void setExternalForceActiveState (bool state)
+	{
+		setRailSystemActivestate (state);
+	}
+
+	public void setRailSystemActivestate (bool state)
+	{
+		if (!railSystemEnabled) {
+			return;
+		}
+			
+		if (railSystemActive == state) {
+			return;
+		}
+
+		if (mainPlayerController.isUseExternalControllerBehaviorPaused ()) {
+			return;
+		}
+
+		if (state && mainPlayerController.isPlayerDead ()) {
+			return;
+		}
+
+		if (state) {
+			externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();
+
+			if (currentExternalControllerBehavior != null && currentExternalControllerBehavior != this) {
+				if (canBeActivatedIfOthersBehaviorsActive && checkIfCanEnableBehavior (currentExternalControllerBehavior.behaviorName)) {
+					currentExternalControllerBehavior.disableExternalControllerState ();
+				} else {
+					return;
+				}
+			}
+		}
+
+		bool modeActivePrevioulsy = railSystemActive;
+
+		railSystemActive = state;
+
+		setBehaviorCurrentlyActiveState (state);
+
+		setCurrentPlayerActionSystemCustomActionCategoryID ();
+
+		if (showDebugPrint) {
+			print ("Setting state as " + railSystemActive);
+		}
+
+		mainPlayerController.setExternalControlBehaviorForAirTypeActiveState (state);
+
+		if (state) {
+			mainPlayerController.setCheckOnGroungPausedState (true);
+
+			mainPlayerController.setPlayerOnGroundState (false);
+
+			mainPlayerController.setPlayerOnGroundAnimatorStateOnOverrideOnGroundWithTime (false);
+
+			mainPlayerController.overrideOnGroundAnimatorValue (0);
+
+			mainPlayerController.setPlayerOnGroundAnimatorStateOnOverrideOnGround (false);
+
+			mainPlayerController.setOnGroundAnimatorIDValue (false);
+
+		} else {
+			mainPlayerController.setCheckOnGroungPausedState (false);
+
+			mainPlayerController.setPlayerOnGroundState (false);
+
+			mainPlayerController.setPlayerOnGroundAnimatorStateOnOverrideOnGroundWithTime (true);
+
+			mainPlayerController.disableOverrideOnGroundAnimatorValue ();
+
+			mainPlayerController.setPauseResetAnimatorStateFOrGroundAnimatorState (true);
+
+			mainPlayerController.setOnGroundAnimatorIDValue (false);
+		}
+
+		mainPlayerController.setUpdate2_5dClampedPositionPausedState (state);
+
+		mainPlayerController.setFootStepManagerState (state);
+
+		mainPlayerController.setAddExtraRotationPausedState (state);
+
+		mainPlayerController.setIgnoreExternalActionsActiveState (state);
+
+		if (railSystemActive) {
+			mainPlayerController.setExternalControllerBehavior (this);
+		} else {
+			if (modeActivePrevioulsy) {
+				externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();
+
+				if (currentExternalControllerBehavior == null || currentExternalControllerBehavior == this) {
+					mainPlayerController.setExternalControllerBehavior (null);
+				}
+
+				if (playerTransform.up != mainPlayerController.getCurrentNormal ()) {
+					resetPlayerRotation ();
+				}
+			}
+		}
+
+		if (state) {
+			eventBeforeActivatingState.Invoke ();
+		} else {
+			eventBeforeDeactivatingState.Invoke ();
+		}
+
+		mainPlayerController.setFallDamageCheckPausedState (state);
+
+		if (railSystemActive) {
+			eventOnStateEnabled.Invoke ();
+		} else {
+			eventOnStateDisabled.Invoke ();
+
+			if (turboActive) {
+				enableOrDisableTurbo (false);
+			}
+		}
+
+		mainHeadTrack.setExternalHeadTrackPauseActiveState (state);
+
+		mainPlayerController.stopShakeCamera ();
+
+		mainPlayerCamera.setPausePlayerCameraViewChangeState (state);
+
+		mainPlayerController.setLastTimeFalling ();
+
+		if (state) {
+			calculateMovementDirection (0);
+		} else {
+			stopAdjustPlayerToRailOnStartCoroutine ();
+		}
+
+		if (state) {
+			mainAnimator.SetInteger (actionIDAnimatorID, actionID);
+
+			mainAnimator.SetBool (externalControlleBehaviorActiveAnimatorID, state);
+		} else {
+			mainAnimator.SetBool (externalControlleBehaviorActiveAnimatorID, state);
+
+			mainAnimator.SetInteger (actionIDAnimatorID, 0);
+		}
+
+		isFirstPersonActive = mainPlayerController.isPlayerOnFirstPerson ();
+
+		if (setNewCameraStateOnThirdPerson && !isFirstPersonActive) {
+			if (state) {
+				previousCameraState = mainPlayerCamera.getCurrentStateName ();
+
+				mainPlayerCamera.setCameraStateOnlyOnThirdPerson (newCameraStateOnThirdPerson);
+			} else {
+
+				if (previousCameraState != "") {
+					if (previousCameraState != newCameraStateOnThirdPerson) {
+						mainPlayerCamera.setCameraStateOnlyOnThirdPerson (previousCameraState);
+					}
+
+					previousCameraState = "";
+				}
+			}
+		}
+
+		if (turnAndForwardAnimatorValuesPaused) {
+			mainPlayerController.setTurnAndForwardAnimatorValuesPausedState (false);
+
+			mainPlayerController.setRotateInCameraDirectionOnAirOnExternalActionActiveState (false);
+
+			turnAndForwardAnimatorValuesPaused = false;
+		}
+
+		currentInclinationSpeed = 1;
+
+		playerAiming = false;
+
+		resetCameraShakeActive = false;
+	}
+
+	void calculateMovementDirection (float inputDirection)
+	{
+		progress = 0;
+
+		progressTarget = 1;
+
+		Vector3 playerPosition = currentSpline.FindNearestPointTo (playerTransform.position, 100, 30);
+
+		adjustPlayerToRailOnStart (playerPosition);
+
+		float step = currentSpline.AccuracyToStepSize (100);
+
+		float minDistance = Mathf.Infinity;
+
+		for (float i = 0f; i < 1f; i += step) {
+			Vector3 thisPoint = currentSpline.GetPoint (i);
+			float thisDistance = (playerPosition - thisPoint).sqrMagnitude;
+
+			if (thisDistance < minDistance) {
+				minDistance = thisDistance;
+				progress = i;
+			}
+		}
+
+		lookDirection = currentSpline.GetDirection (progress);
+
+		float angle = Vector3.SignedAngle (playerTransform.forward, lookDirection, playerTransform.up);
+
+		movingForward = false;
+
+		if (Mathf.Abs (angle) < 90) {
+			movingForward = true;
+		} 
+
+		if (showDebugPrint) {
+			print (movingForward + " " + progress + "  " + angle);
+		}
+
+		if (inputDirection != 0) {
+			if (inputDirection > 0) {
+				movingForward = true;
+			} else {
+				movingForward = false;
+			}
+		}
+
+		if (!movingForward) {
+			progressTarget = 0;
+		}
+
+		lastTimeDirectionChanged = Time.time;
+
+		lastTimeReverseMovementDirectionInput = 0;
+
+		activateReverseDirectionActive = false;
+	}
+
+	public override void setExternalForceEnabledState (bool state)
+	{
+		setRailEnabledState (state);
+	}
+
+	public void setRailEnabledState (bool state)
+	{
+		if (!state) {
+			setRailSystemActivestate (false);
+		}
+
+		railSystemEnabled = state;
+	}
+
+	public void enableOrDisableTurbo (bool state)
+	{
+		if (turboActive == state) {
+			return;
+		}
+
+		if (state && canUseTurboPausedState) {
+			return;
+		}
+
+		turboActive = state;
+
+		if (useEventUseTurbo) {
+			if (state) {
+				eventOnStarTurbo.Invoke ();
+			} else {
+				eventOnEndTurbo.Invoke ();
+			}
+		}
+	}
+
+	public void setCanUseTurboPausedState (bool state)
+	{
+		if (!state && turboActive) {
+			enableOrDisableTurbo (false);
+		}
+
+		canUseTurboPausedState = state;
+	}
+
+	public override void disableExternalControllerState ()
+	{
+		setRailSystemActivestate (false);
+	}
+
+	public void inputChangeTurboState (bool state)
+	{
+		if (railSystemActive && turboEnabled) {
+			enableOrDisableTurbo (state);
+		}
+	}
+
+	public void setCanChangeDirectionEnabledState (bool state)
+	{
+		canChangeDirectionEnabled = state;
+	}
+
+	public void setOriginalCanChangeDirectionEnabled ()
+	{
+		setCanChangeDirectionEnabledState (originalCanChangeDirectionEnabled);
+	}
+
+	public void setCurrentSpline (BezierSpline newSpline)
+	{
+		currentSpline = newSpline;
+	}
+
+	public void setCurrentBezierDuration (float newValue)
+	{
+		bezierDuration = newValue;
+	}
+
+	void stopRail ()
+	{
+		Vector3 totalForce = Vector3.zero;
+
+		totalForce = playerTransform.forward * endOfSurfaceImpulse.z + playerTransform.up * endOfSurfaceImpulse.y;
+
+		setRailSystemActivestate (false);
+
+		setImpulseForce (totalForce, false);
+	}
+
+	public void adjustPlayerToRailOnStart (Vector3 initialPosition)
+	{
+		stopResetPlayerRotationCoroutine ();
+
+		adjustPlayerToRailCoroutine = StartCoroutine (adjustPlayerToRailOnStartCoroutine (initialPosition));
+	}
+
+	void stopAdjustPlayerToRailOnStartCoroutine ()
+	{
+		if (adjustPlayerToRailCoroutine != null) {
+			StopCoroutine (adjustPlayerToRailCoroutine);
+		}
+
+		adjustingPlayerToRail = false;
+	}
+
+	IEnumerator adjustPlayerToRailOnStartCoroutine (Vector3 initialPosition)
+	{
+		adjustingPlayerToRail = true;
+
+		float dist = GKC_Utils.distance (playerTransform.position, initialPosition);
+
+		float duration = dist / adjustPlayerToRailSpeed;
+
+		float t = 0;
+
+		Vector3 pos = initialPosition;
+
+		float movementTimer = 0;
+
+		bool targetReached = false;
+
+		while (!targetReached) {
+			t += Time.deltaTime / duration;
+
+			playerTransform.position = Vector3.Slerp (playerTransform.position, pos, t);
+
+			movementTimer += Time.deltaTime;
+
+			if (GKC_Utils.distance (playerTransform.position, pos) < 0.01f || movementTimer > (duration + 1)) {
+				targetReached = true;
+			}
+
+			yield return null;
+		}
+
+		adjustingPlayerToRail = false;
+	}
+
+	public void resetPlayerRotation ()
+	{
+		stopResetPlayerRotationCoroutine ();
+	
+		resetPlayerCoroutine = StartCoroutine (resetPlayerRotationCoroutine ());
+	}
+
+	void stopResetPlayerRotationCoroutine ()
+	{
+		if (resetPlayerCoroutine != null) {
+			StopCoroutine (resetPlayerCoroutine);
+		}
+	}
+
+	IEnumerator resetPlayerRotationCoroutine ()
+	{
+		float movementTimer = 0;
+	
+		float t = 0;
+	
+		float duration = 1;
+	
+		float angleDifference = 0;
+
+		Vector3 currentNormal = mainPlayerController.getCurrentNormal ();
+	
+		bool isFullBodyAwarenessActive = mainPlayerCamera.isFullBodyAwarenessActive ();
+
+		Transform objectToRotate = playerTransform;
+
+		if (isFullBodyAwarenessActive) {
+			objectToRotate = playerCameraTransform;
+		}
+
+		Quaternion currentPlayerRotation = objectToRotate.rotation;
+		Vector3 currentPlayerForward = Vector3.Cross (objectToRotate.right, currentNormal);
+		Quaternion playerTargetRotation = Quaternion.LookRotation (currentPlayerForward, currentNormal);
+	
+		bool targetReached = false;
+
+		while (!targetReached) {
+			t += (Time.deltaTime / duration) * resetPlayerRotationSpeed;
+	
+			objectToRotate.rotation = Quaternion.Slerp (objectToRotate.rotation, playerTargetRotation, t);
+
+			angleDifference = Quaternion.Angle (objectToRotate.rotation, playerTargetRotation);
+	
+			movementTimer += Time.deltaTime;
+	
+			if (angleDifference < 0.01f || movementTimer > (duration + 1)) {
+				targetReached = true;
+			}
+
+			yield return null;
+		}
+	}
+
+	public override void setCurrentPlayerActionSystemCustomActionCategoryID ()
+	{
+		if (behaviorCurrentlyActive) {
+			if (customActionCategoryID > -1) {
+				mainPlayerController.setCurrentCustomActionCategoryID (customActionCategoryID);
+			}
+		} else {
+			if (regularActionCategoryID > -1) {
+				mainPlayerController.setCurrentCustomActionCategoryID (regularActionCategoryID);
+			}
+		}
+	}
+}