FueraDeEscala/Assets/Game Kit Controller/Scripts/Player/Extra Movements/slideSystem.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class slideSystem : externalControllerBehavior
{
	[Header ("Main Settings")]
	[Space]

	public bool slideEnabled = true;

	public LayerMask raycastLayermask;

	public float raycastDistance = 0.6f;

	public float slideActiveRaycastDistance = 3;

	[Space]
	[Header ("Speed Settings")]
	[Space]

	public float slideSpeed;
	public float slideHorizontalSpeed;
	public float slideSprintSpeed;
	public float slideSlowDownSped;
	public float slideVerticalSpeed;

	public float slideRotationSpeed;
	public bool sliderCanBeUsed = true;

	public Vector3 impulseOnJump;
	public Vector3 endOfSurfaceImpulse;

	public float horizontalInputAmount = 1;

	public float regularSlideMovementAmount = 0.4f;

	public float minWaitTimeToSlideCheckSlideActive = 1;

	[Space]
	[Header ("Surface Angle Speed Multiplier Settings")]
	[Space]

	public bool changeSpeedBasedOnSurfaceAngle;
	public float minAngleToIncreaseSpeed;
	public float speedOnSurfaceAngleMultiplier;

	public bool stopSlideIfSurfaceAngleTooLow;
	public float minAngleToStopSlide;

	[Space]
	[Header ("Other Settings")]
	[Space]

	public float maxVelocityChangeSlide;

	public bool keepWeapons;
	public bool drawWeaponsIfCarriedPreviously;

	public bool setNewAimWeaponCameraState;

	public string customDefaultThirdPersonAimRightStateName = "Aim Right On Slide";
	public string customDefaultThirdPersonAimLeftStateName = "Aim Left On Slide";

	public string newCameraState = "Slide View";

	public bool stopSlideIfObstacleDetected;

	public LayerMask obstacleLayermask;

	[Space]
	[Header ("Manual Slide Settings")]
	[Space]

	public bool manualSlideCanBeEnabled = true;

	public bool stopManualSlideAfterTimeDelay;
	public float timeDelayToStopManualSlide;

	[Space]
	[Header ("Gravity Settings")]
	[Space]

	public bool adhereToSurfacesEnabled;

	public float adhereToSurfacesRotationSpeed;

	public bool disableSlideWhenDisablingAdhereState = true;

	public bool resetGravityDirectionOnSlideExitEnabled = true;

	[Space]
	[Header ("Third Person Settings")]
	[Space]

	public int actionID = 08632946;

	public int slideStandingActionID = 08632945;

	public bool useSlideStandingActionIDOnManualSlide;
	public bool useSlideStandingActionIDOnTriggerSlide;

	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;

	public bool setNewCameraStateOnFBA;

	public string newCameraStateOnFBA;

	[Space]
	[Header ("Debug")]
	[Space]

	public bool showDebugPrint;

	public bool checkIfDetectSlideActive;

	public bool slideActive;

	public bool isFirstPersonActive;

	public float currentHorizontalMovement;
	public float currentVerticalMovement;

	public float slideSpeedMultiplier = 1;

	public bool carryingWeaponsPreviously;

	public Transform currentSlideTransform;

	public float currentSlideSpeed;

	public Vector3 moveInput;

	public Vector3 localMove;

	public int currentSlideZonesAmountDetected;

	public bool slideActivatedBySlideZone;

	public bool adhereToSurfacesActive;
	public Vector3 originalNormal;

	public bool runningActive;

	public bool manualSlideActive;

	public float targetRotation;

	[Space]
	[Header ("First Person Events Settings")]
	[Space]

	public bool useEventsOnFirstPerson;

	public UnityEvent eventOnStartFirstPerson;
	public UnityEvent eventOnEndFirstPerson;
	
	[Space]
	[Header ("Third Person Events Settings")]
	[Space]

	public bool useEventsOnThirdPerson;
	
	public UnityEvent eventOnStartThirdPerson;
	public UnityEvent eventOnEndThirdPerson;

	[Space]
	[Header ("Run On Slide Events Settings")]
	[Space]

	public bool useEventtsOnRunSlideStateChange;
	public UnityEvent eventOnStartRunOnSlide;
	public UnityEvent eventOnStopRunOnSlide;

	[Space]
	[Header ("Components")]
	[Space]

	public playerController mainPlayerController;
	public Transform playerTransform;
	public Rigidbody mainRigidbody;
	public Transform playerCameraTransform;
	public playerCamera mainPlayerCamera;
	public playerWeaponsManager mainPlayerWeaponsManager;
	public gravitySystem mainGravitySystem;

	public headTrack mainHeadTrack;

	public Animator mainAnimator;

	Vector3 currentMovementDirection;

	float lastSlideRunningActive;

	RaycastHit slideHit;

	bool originalSlideEnabled;

	Vector3 playerTransformUp;
	Vector3 playerTransformForward;

	RaycastHit hit;

	Vector3 velocityChange;

	int externalControlleBehaviorActiveAnimatorID;

	int actionIDAnimatorID;

	string previousCameraState = "";

	float lastTimeSlideActive;

	bool resetAnimatorIDValue;

	int horizontalAnimatorID;

	bool jumpInputUsed;

	Transform mainSlideTransform;

	string defaultThirdPersonStateName = "";

	Vector3 currentSurfaceNormal;

	bool runStartEventActive;
	bool runStopEventActive;

	bool canUseRunPaused;

	bool originalResetGravityDirectionOnSlideExitEnabled;
	bool animationStandingResult;

	Transform currentLockedCameraTransform;

	bool isPlayerMovingOn3dWorld;

	float lastTimeGroundDetected;

	float lastTimeObstacleDetected;


	void Start ()
	{
		originalSlideEnabled = slideEnabled;

		externalControlleBehaviorActiveAnimatorID = Animator.StringToHash (externalControlleBehaviorActiveAnimatorName);
		actionIDAnimatorID = Animator.StringToHash (actionIDAnimatorName);

		horizontalAnimatorID = Animator.StringToHash (horizontalAnimatorName);

		originalResetGravityDirectionOnSlideExitEnabled = resetGravityDirectionOnSlideExitEnabled;
	}

	public override void updateControllerBehavior ()
	{
		if (slideActive) {
			if (resetAnimatorIDValue) {
				if (Time.time > lastTimeSlideActive + 0.3f) {
					mainAnimator.SetInteger (actionIDAnimatorID, 0);

					resetAnimatorIDValue = false;
				}
			}

			float currentFixedUpdateDeltaTime = Time.fixedDeltaTime;

			playerTransformUp = playerTransform.up;

			playerTransformForward = playerTransform.forward;

			Vector3 currentRaycastPosition = playerTransform.position + playerTransformUp * 2 + playerTransform.forward * regularSlideMovementAmount;
			Vector3 currentRaycastDirection = -playerTransformUp;

			currentVerticalMovement = mainPlayerController.getVerticalInput ();
			currentHorizontalMovement = mainPlayerController.getHorizontalInput ();

			if (isPlayerMovingOn3dWorld) {
				moveInput = playerCameraTransform.forward * (currentVerticalMovement) + playerCameraTransform.right * (currentHorizontalMovement);

				if (moveInput.magnitude > 1) {
					moveInput.Normalize ();
				}

				localMove = playerTransform.InverseTransformDirection (moveInput);
			
				mainAnimator.SetFloat (horizontalAnimatorID, localMove.x, inputLerpSpeed, Time.fixedDeltaTime);
			} else {
				currentLockedCameraTransform = mainPlayerCamera.getLockedCameraTransform ();

				localMove = currentLockedCameraTransform.right * (currentHorizontalMovement);

				mainAnimator.SetFloat (horizontalAnimatorID, 0, inputLerpSpeed, Time.fixedDeltaTime);
			}

			if (slideActivatedBySlideZone) {
				mainSlideTransform = currentSlideTransform;
			} else {
				mainSlideTransform = playerTransform;
			}

			if (isPlayerMovingOn3dWorld) {
				currentRaycastPosition += mainSlideTransform.right * localMove.x * horizontalInputAmount;
			}

			runningActive = mainPlayerController.isPlayerRunning ();

			if (canUseRunPaused) {
				runningActive = false;
			}

			if (runningActive) {
				if (!runStartEventActive) {
					checkEventsOnRunOnSlideStateChange (true);

					runStartEventActive = true;
				}

				runStopEventActive = false;
			} else {
				if (!runStopEventActive) {
					checkEventsOnRunOnSlideStateChange (false);

					runStopEventActive = true;
				}

				runStartEventActive = false;
			}
				
			float angle = 0;

			if (slideActivatedBySlideZone) {
				angle = Vector3.SignedAngle (playerTransformForward, mainSlideTransform.forward, playerTransformUp);
			} else {
				angle = Vector3.SignedAngle (playerTransformForward, playerCameraTransform.forward, playerTransformUp);
			}

			currentSlideSpeed = slideSpeed;

			if (runningActive) {
				currentSlideSpeed = slideSprintSpeed;
			}
		
			if (isPlayerMovingOn3dWorld) {
				if (localMove.z > 0) {
					currentSlideSpeed += localMove.z * slideVerticalSpeed;
				}

				currentSlideSpeed += Mathf.Abs (localMove.x) * slideHorizontalSpeed;

				if (!runningActive) {
					if (localMove.z < 0) {
						currentSlideSpeed += slideSlowDownSped * localMove.z;
					}
				}
			} else {
				float currentLocalMoveX = localMove.x;

				bool isPlayerLookingAtRightOn2_5d = mainPlayerController.isPlayerLookingAtRightOn2_5d ();

				if (!isPlayerLookingAtRightOn2_5d) {
					currentLocalMoveX *= (-1);
				}

				if (currentLocalMoveX > 0) {
					currentSlideSpeed += currentLocalMoveX * slideVerticalSpeed;
				}

				if (!runningActive) {
					if (currentLocalMoveX < 0) {
						currentSlideSpeed += slideSlowDownSped * currentLocalMoveX;
					}
				}
			}

			currentSlideSpeed *= slideSpeedMultiplier;

			if (!adhereToSurfacesActive) {
				if (changeSpeedBasedOnSurfaceAngle) {
					float surfaceAngle = Vector3.SignedAngle (playerTransformUp, currentSurfaceNormal, playerTransform.right);

					float surfaceAngleABS = Mathf.Abs (surfaceAngle);

					if (surfaceAngleABS > minAngleToIncreaseSpeed) {
						currentSlideSpeed += speedOnSurfaceAngleMultiplier * surfaceAngleABS;
					}
				}
					
				if (stopSlideIfSurfaceAngleTooLow) {
					if (Mathf.Abs (angle) < minAngleToStopSlide) {
						currentSlideSpeed = mainRigidbody.linearVelocity.magnitude / 2;

						if (currentSlideSpeed < 0.5f) {
							setCheckIfDetectSlideActiveState (false, false);

							return;
						}
					}
				}
			}

			Debug.DrawRay (currentRaycastPosition, currentRaycastDirection * 3, Color.yellow);

			if (Physics.Raycast (currentRaycastPosition, currentRaycastDirection, out hit, slideActiveRaycastDistance, raycastLayermask)) {
				slideHit = hit;

				currentMovementDirection = slideHit.point;

				mainRigidbody.position = Vector3.MoveTowards (mainRigidbody.position, currentMovementDirection, currentFixedUpdateDeltaTime * currentSlideSpeed);
			
				currentSurfaceNormal = hit.normal;
			} else {
				stopSlide ();
			}

			if (stopSlideIfObstacleDetected && manualSlideActive) {
				currentRaycastPosition = playerTransform.position + playerTransformUp;
				currentRaycastDirection = playerTransformForward;

				if (Physics.Raycast (currentRaycastPosition, currentRaycastDirection, out hit,
					    slideActiveRaycastDistance, obstacleLayermask)) {
					if (hit.rigidbody == null) {
						if (lastTimeObstacleDetected == 0) {
							lastTimeObstacleDetected = Time.time;
						}
					}
				} else {
					lastTimeObstacleDetected = 0;
				}

				if (lastTimeObstacleDetected > 0) {
					if (Time.time > lastTimeObstacleDetected + 1) {
						setCheckIfDetectSlideActiveState (false, false);

						return;
					}
				}
			}

			mainPlayerController.setCurrentVelocityValue (mainRigidbody.linearVelocity);

			targetRotation = angle;

			if (!mainPlayerCamera.isFullBodyAwarenessActive () && isPlayerMovingOn3dWorld) {
				if (Mathf.Abs (targetRotation) > 0.001f) {
					playerTransform.Rotate (0, targetRotation * slideRotationSpeed * currentFixedUpdateDeltaTime, 0);
				}
			}

			if (mainPlayerController.updateHeadbobState) {
				mainPlayerController.setCurrentHeadBobState ();
			}

			if (adhereToSurfacesActive) {
				updateGravityValues ();
			} 

			if (manualSlideActive) {
				if (stopManualSlideAfterTimeDelay) {
					if (Time.time > timeDelayToStopManualSlide + lastTimeSlideActive) {
						setCheckIfDetectSlideActiveState (false, false);

						manualSlideActive = false;
					}
				}
			}
		} else {
			if (checkIfDetectSlideActive) {
				if (slideEnabled && sliderCanBeUsed && !mainPlayerController.useFirstPersonPhysicsInThirdPersonActive) {
					if (!slideActive && !mainPlayerController.pauseAllPlayerDownForces && !mainPlayerController.ignoreExternalActionsActiveState) {

						if (Time.time > lastTimeSlideActive + 1) {
							playerTransformUp = playerTransform.up;

							Vector3 currentRaycastPosition = playerTransform.position + playerTransformUp;
							Vector3 currentRaycastDirection = -playerTransformUp;

							if (Physics.Raycast (currentRaycastPosition, currentRaycastDirection, out hit, raycastDistance, raycastLayermask)) {
								setSlideActiveState (true);
							} else {
								
								if (lastTimeGroundDetected == 0) {
									lastTimeGroundDetected = Time.time;
								}
							}

							if (lastTimeGroundDetected > 0) {
								if (Time.time > lastTimeGroundDetected + minWaitTimeToSlideCheckSlideActive) {
									if (showDebugPrint) {
										print ("Stop check if detect slide due to being on air enough time");
									}

									setCheckIfDetectSlideActiveState (false, false);

									return;
								}
							}
						}
					}
				}
			}
		}
	}

	void updateGravityValues ()
	{
		Vector3 currentNormal = mainGravitySystem.getCurrentNormal ();

		//recalculate the rotation of the player and the camera according to the normal of the surface under the player
		currentNormal = Vector3.Lerp (currentNormal, currentSurfaceNormal, adhereToSurfacesRotationSpeed * Time.deltaTime);
		Vector3 myForward = Vector3.Cross (playerTransform.right, currentNormal);
		Quaternion dstRot = Quaternion.LookRotation (myForward, currentNormal); 

		playerTransform.rotation = Quaternion.Lerp (playerTransform.rotation, dstRot, adhereToSurfacesRotationSpeed * Time.deltaTime);

		Vector3 myForwardCamera = Vector3.Cross (playerCameraTransform.right, currentNormal);
		Quaternion dstRotCamera = Quaternion.LookRotation (myForwardCamera, currentNormal);

		playerCameraTransform.rotation = Quaternion.Lerp (playerCameraTransform.rotation, dstRotCamera, adhereToSurfacesRotationSpeed * Time.deltaTime);

		mainGravitySystem.setCurrentNormal (currentNormal);

		mainGravitySystem.updateCurrentRotatingNormal (currentNormal);

		//set the normal in the playerController component
		mainPlayerController.setCurrentNormalCharacter (currentNormal);
	}

	public override void setExtraImpulseForce (Vector3 forceAmount, bool useCameraDirection)
	{
		setSlideImpulseForce (forceAmount, useCameraDirection);
	}

	public void setSlideImpulseForce (Vector3 forceAmount, bool useCameraDirection)
	{
		Vector3 impulseForce = forceAmount;

		if (maxVelocityChangeSlide > 0) {
			velocityChange = impulseForce - mainRigidbody.linearVelocity;

			velocityChange = Vector3.ClampMagnitude (velocityChange, maxVelocityChangeSlide);

		} else {
			velocityChange = impulseForce;
		}

		mainPlayerController.setVelocityChangeValue (velocityChange);

		mainRigidbody.AddForce (velocityChange, ForceMode.VelocityChange);
	}

	public override void setJumpActiveForExternalForce ()
	{
		setJumpActive (impulseOnJump);
	}

	public void setJumpActive (Vector3 newImpulseOnJumpAmount)
	{
		if (slideActive) {
			jumpInputUsed = true;

			setSlideActiveState (false);

			Vector3 totalForce = newImpulseOnJumpAmount.y * playerTransform.up + newImpulseOnJumpAmount.z * playerTransform.forward;
		
			mainPlayerController.useJumpPlatform (totalForce, ForceMode.Impulse);

			if (!slideActivatedBySlideZone) {
				setCheckIfDetectSlideActiveState (false, false);
			}
		}
	}

	public override void setExternalForceActiveState (bool state)
	{
		setSlideActiveState (state);
	}

	public void setCheckIfDetectSlideActiveState (bool state, bool slideActivatedBySlideZoneValue)
	{
		if (mainPlayerController.isUseExternalControllerBehaviorPaused ()) {
			return;
		}

		if (state) {
			currentSlideZonesAmountDetected++;
		} else {
			currentSlideZonesAmountDetected--;

			if (currentSlideZonesAmountDetected < 0) {
				currentSlideZonesAmountDetected = 0;
			}

			if (currentSlideZonesAmountDetected > 0) {
				if (showDebugPrint) {
					print ("more slide zones detected, cancelling the change to regular state");
				}

				return;
			}
		}

		if (checkIfDetectSlideActive == state) {
			return;
		}

		if (state) {
			externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();

			if (currentExternalControllerBehavior != null && currentExternalControllerBehavior != this) {
				if (canBeActivatedIfOthersBehaviorsActive && checkIfCanEnableBehavior (currentExternalControllerBehavior.behaviorName)) {
					currentExternalControllerBehavior.disableExternalControllerState ();
				} else {
					currentSlideZonesAmountDetected = 0;

					return;
				}
			}
		}

		slideActivatedBySlideZone = slideActivatedBySlideZoneValue;

		bool checkIfDetectSlideActivePrevioulsy = checkIfDetectSlideActive;

		checkIfDetectSlideActive = state;

		if (checkIfDetectSlideActive) {
			mainPlayerController.setExternalControllerBehavior (this);
		} else {
			if (checkIfDetectSlideActivePrevioulsy) {
				externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();

				if (currentExternalControllerBehavior == null || currentExternalControllerBehavior == this) {
					mainPlayerController.setExternalControllerBehavior (null);
				}
			}
		}

		mainPlayerController.setFallDamageCheckPausedState (state);
			
		if (!checkIfDetectSlideActive) {
			setSlideActiveState (false);
		}
	}

	public void setSlideActiveState (bool state)
	{
		if (!slideEnabled) {
			return;
		}

		if (slideActive == state) {
			return;
		}

		slideActive = state;

		setBehaviorCurrentlyActiveState (state);

		setCurrentPlayerActionSystemCustomActionCategoryID ();

		mainPlayerController.setAddExtraRotationPausedState (state);

		mainPlayerController.setExternalControlBehaviorForAirTypeActiveState (state);
	
		isPlayerMovingOn3dWorld = mainPlayerController.isPlayerMovingOn3dWorld ();

		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);

			if (jumpInputUsed) {
				mainPlayerController.setOnGroundAnimatorIDValue (false);
			} else {
				if (mainPlayerController.getCurrentSurfaceBelowPlayer () != null) {
					mainPlayerController.setPlayerOnGroundState (true);

					mainPlayerController.setOnGroundAnimatorIDValue (true);
				}
			}
		}

		mainPlayerController.setFootStepManagerState (state);

		if (showDebugPrint) {
			print ("Slide active state " + state);
		}

		isFirstPersonActive = mainPlayerController.isPlayerOnFirstPerson ();

		if (slideActive) {
			checkEventsOnStateChange (true);

			if (!isFirstPersonActive) {
				animationStandingResult = true;

				if (manualSlideActive) {
					animationStandingResult = useSlideStandingActionIDOnManualSlide;
				} else {
					animationStandingResult = useSlideStandingActionIDOnTriggerSlide;
				}

				if (animationStandingResult) {
					mainAnimator.SetInteger (actionIDAnimatorID, slideStandingActionID);
				} else {
					mainAnimator.SetInteger (actionIDAnimatorID, actionID);
				}

				mainAnimator.SetBool (externalControlleBehaviorActiveAnimatorID, state);
			}

			mainPlayerController.setJumpsAmountValue (0);

			mainPlayerCamera.enableOrDisableChangeCameraView (false);

			if (!isFirstPersonActive) {
				if (keepWeapons) {
					carryingWeaponsPreviously = mainPlayerWeaponsManager.isPlayerCarringWeapon ();

					if (carryingWeaponsPreviously) {
						mainPlayerWeaponsManager.checkIfDisableCurrentWeapon ();
					}

					mainPlayerWeaponsManager.setGeneralWeaponsInputActiveState (false);
				}

				if (setNewAimWeaponCameraState && !mainPlayerCamera.isFullBodyAwarenessActive ()) {
					if (defaultThirdPersonStateName == "") {
						defaultThirdPersonStateName = mainPlayerCamera.getDefaultThirdPersonStateName ();

						mainPlayerCamera.setDefaultThirdPersonStateName (newCameraState);
					}

					if (!animationStandingResult) {
						mainPlayerCamera.setUseCustomThirdPersonAimActivePausedState (true);

						mainPlayerCamera.setUseCustomThirdPersonAimActiveState (true, 
							customDefaultThirdPersonAimRightStateName, customDefaultThirdPersonAimLeftStateName);
					}
				}
			}

			resetAnimatorIDValue = true;
		} else {
			checkEventsOnStateChange (false);

			if (!isFirstPersonActive) {
				mainAnimator.SetBool (externalControlleBehaviorActiveAnimatorID, state);

				mainAnimator.SetInteger (actionIDAnimatorID, 0);
			}

			mainPlayerCamera.setOriginalchangeCameraViewEnabledValue ();


			if (keepWeapons) {
				mainPlayerWeaponsManager.setGeneralWeaponsInputActiveState (true);
			}

			if (setNewAimWeaponCameraState) {
				if (defaultThirdPersonStateName != "") {
					mainPlayerCamera.setDefaultThirdPersonStateName (defaultThirdPersonStateName);

					defaultThirdPersonStateName = "";
				}

				if (!animationStandingResult) {
					mainPlayerCamera.setUseCustomThirdPersonAimActivePausedState (false);

					mainPlayerCamera.setUseCustomThirdPersonAimActiveState (false, "", "");
				}
			}

			if (carryingWeaponsPreviously) {
				if (!drawWeaponsIfCarriedPreviously) {
					carryingWeaponsPreviously = false;
				}
			}

			resetAnimatorIDValue = false;
		}

		mainPlayerCamera.setPausePlayerCameraViewChangeState (slideActive);

		mainPlayerController.setLastTimeFalling ();

		if (!animationStandingResult) {
			if (mainHeadTrack != null) {
				mainHeadTrack.setHeadTrackSmoothPauseState (slideActive);
			}
		}

		if (mainPlayerCamera.isFullBodyAwarenessActive ()) {
			if (setNewCameraStateOnFBA) {
				if (state) {
					previousCameraState = mainPlayerCamera.getCurrentStateName ();

					mainPlayerCamera.setCameraState (newCameraStateOnFBA);
				} else {
					if (previousCameraState != "") {
						if (previousCameraState != newCameraStateOnFBA) {
							mainPlayerCamera.setCameraStateOnlyOnThirdPerson (previousCameraState);
						}

						previousCameraState = "";
					}
				}
			}
		} else {
			if (setNewCameraStateOnThirdPerson && !isFirstPersonActive) {
				if (state) {
					previousCameraState = mainPlayerCamera.getCurrentStateName ();

					mainPlayerCamera.setCameraStateOnlyOnThirdPerson (newCameraStateOnThirdPerson);
				} else {

					if (previousCameraState != "") {
						if (previousCameraState != newCameraStateOnThirdPerson) {
							mainPlayerCamera.setCameraStateOnlyOnThirdPerson (previousCameraState);
						}
				
						previousCameraState = "";
					}
				}
			}
		}

		if (state) {
			originalNormal = mainGravitySystem.getCurrentNormal ();
		} else {
			checkResetGravityState ();
		}

		mainPlayerCamera.stopShakeCamera ();

		lastTimeSlideActive = Time.time;

		targetRotation = 0;

		if (runStartEventActive) {
			checkEventsOnRunOnSlideStateChange (false);
		}

		runStartEventActive = false;
		runStopEventActive = false;

		canUseRunPaused = false;

		if (!slideActive) {
			if (manualSlideActive) {
				if (mainPlayerController.isPlayerRunning () && jumpInputUsed) {
					mainPlayerController.forceStopRun ();
				}
			}
		}

		jumpInputUsed = false;

		lastTimeGroundDetected = 0;

		lastTimeObstacleDetected = 0;
	}

	public override void setExternalForceEnabledState (bool state)
	{
		setSlideEnabledState (state);
	}

	public void setSlideEnabledState (bool state)
	{
		if (!state) {
			setSlideActiveState (false);
		}

		slideEnabled = state;
	}

	public void setSlideCanBeUsedState (bool state)
	{
		sliderCanBeUsed = state;
	}

	public void setSliderEnabledState ()
	{
		setSlideEnabledState (originalSlideEnabled);
	}

	public void setOriginalSliderEnabledState ()
	{
		if (slideActive) {
			setCheckIfDetectSlideActiveState (false, false);
		}

		setSlideEnabledState (originalSlideEnabled);
	}

	public void setCurrentSlideTransform (Transform newTransform)
	{
		if (newTransform == null) {
			if (currentSlideZonesAmountDetected > 0) {
				return;
			}
		}

		currentSlideTransform = newTransform;
	}

	public void setSlideSpeedMultiplier (float newValue)
	{
		slideSpeedMultiplier = newValue;
	}

	public void setManualSlideCanBeEnabledState (bool state)
	{
		manualSlideCanBeEnabled = state;
	}

	public void enableCheckIfDetectSlideActiveStateExternally ()
	{
		if (!manualSlideCanBeEnabled) {
			return;
		}

		if (checkIfDetectSlideActive || slideActivatedBySlideZone) {
			return;
		}

		setCheckIfDetectSlideActiveState (true, false);

		manualSlideActive = true;
	}

	public void disableCheckIfDetectSlideActiveStateExternally ()
	{
		if (!checkIfDetectSlideActive || slideActivatedBySlideZone) {
			return;
		}

		setCheckIfDetectSlideActiveState (false, false);

		manualSlideActive = false;
	}

	public override void disableExternalControllerState ()
	{
		setCheckIfDetectSlideActiveState (false, false);
	}

	public void checkEventsOnStateChange (bool state)
	{
		if (isFirstPersonActive) {
			if (useEventsOnFirstPerson) {
				if (state) {
					eventOnStartFirstPerson.Invoke ();
				} else {
					eventOnEndFirstPerson.Invoke ();
				}
			} 
		} else {
			if (useEventsOnThirdPerson) {
				if (state) {
					eventOnStartThirdPerson.Invoke ();
				} else {
					eventOnEndThirdPerson.Invoke ();
				}
			}
		}
	}

	public void checkEventsOnRunOnSlideStateChange (bool state)
	{
		if (useEventtsOnRunSlideStateChange) {
			if (state) {
				eventOnStartRunOnSlide.Invoke ();
			} else {
				eventOnStopRunOnSlide.Invoke ();
			}
		}
	}

	public void setAdhereToSurfacesActiveState (bool state)
	{
		if (!adhereToSurfacesEnabled) {
			return;
		}

		if (!state) {
			if (disableSlideWhenDisablingAdhereState) {
				stopSlide ();
			}
		} else {
			if (!adhereToSurfacesActive) {
				originalNormal = mainGravitySystem.getCurrentNormal ();
			}
		}

		adhereToSurfacesActive = state;
	}

	public void setResetGravityDirectionOnSlideExitEnabledState (bool state)
	{
		resetGravityDirectionOnSlideExitEnabled = state;
	}

	public void setOriginalResetGravityDirectionOnSlideExitEnabled ()
	{
		setResetGravityDirectionOnSlideExitEnabledState (originalResetGravityDirectionOnSlideExitEnabled);
	}

	void checkResetGravityState ()
	{
		if (adhereToSurfacesActive) {
			if (resetGravityDirectionOnSlideExitEnabled) {
				if (mainGravitySystem.getCurrentRotatingNormal () != originalNormal && originalNormal != Vector3.zero) {

					mainGravitySystem.checkRotateToSurface (originalNormal, 2);
				}
			}

			originalNormal = Vector3.zero;
		}
	}

	void stopSlide ()
	{
		Vector3 totalForce = Vector3.zero;

		if (mainSlideTransform != null) {
			totalForce = mainSlideTransform.forward * endOfSurfaceImpulse.z + mainSlideTransform.up * endOfSurfaceImpulse.y;
		} else {
			totalForce = playerTransform.forward * endOfSurfaceImpulse.z + playerTransform.up * endOfSurfaceImpulse.y;
		}

		setSlideActiveState (false);

		setSlideImpulseForce (totalForce, false);

		currentSurfaceNormal = Vector3.zero;
	}

	public void setCanUseRunPausedState (bool state)
	{
		canUseRunPaused = state;
	}

	public override void setCurrentPlayerActionSystemCustomActionCategoryID ()
	{
		if (behaviorCurrentlyActive) {
			if (customActionCategoryID > -1) {
				mainPlayerController.setCurrentCustomActionCategoryID (customActionCategoryID);
			}
		} else {
			if (regularActionCategoryID > -1) {
				mainPlayerController.setCurrentCustomActionCategoryID (regularActionCategoryID);
			}
		}
	}

	public void setSlideEnabledStateFromEditor (bool state)
	{
		setSlideEnabledState (state);

		updateComponent ();
	}

	public void setManualSlideCanBeEnabledStateFromEditor (bool state)
	{
		setManualSlideCanBeEnabledState (state);

		updateComponent ();
	}

	void updateComponent ()
	{
		GKC_Utils.updateComponent (this);

		GKC_Utils.updateDirtyScene ("Update Slide System", gameObject);
	}
}