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

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

    public bool climbEnabled = true;
    public bool climbCheckCanBeUsed = true;

    public float minDistanceToSurfaceToGrabSurfaceOnGround = 0.8f;
    public float minDistanceToSurfaceToGrabSurfaceOnAir = 1;

    public bool activateClimbStateDirectlyOnPressInput;

    public bool canActivateClimbOnPlayerOnGround = true;

    public bool ignoreActivateClimbStateOnNextSurfaceDetectedActive;

    public float surfaceOffset = 0.05f;

    public float minWaitTimeSinceLastTimeActionActiveToClimb = 0.6f;

    [Space]
    [Header ("Climb Method Settings")]
    [Space]

    public bool useRaycastDetectionToClimb = true;

    public climbDetectionCollisionSystem mainClimbDetectionCollisionSystem;

    public Vector3 climbDetectionCollisionPositionOffset;

    public bool updateRigidbodyPositionSmoothlyOnDetectionCollision = true;

    public float minDelayToAdjustDetectionCollision = 1;

    public float adjustToFoundSurfaceSpeed = 4;

    public float adjustToFoundSurfaceOffset = 0.3f;

    [Space]
    [Header ("Reset Rotation Settings")]
    [Space]

    public float resetPlayerRotationSpeed = 5;

    public bool rotateCameraToPlayerRotationOnClimbActiveEnabled = true;

    [Space]

    public bool useCameraOffsetOnClimbActiveEnabled;
    public Vector3 cameraOffsetOnClimbActive;

    public float cameraOffsetOnClimbActiveLerpSpeed;

    [Space]
    [Header ("Stop Climb Settings")]
    [Space]

    public float offsetToCheckIfStopClimbStateOnRaycast = 1;

    public float minTimeToStopClimbIfNotSurfaceFound = 0.3f;

    public float maxRaycastDistanceToStopClimb = 0.75f;

    [Space]
    [Header ("Surface Detection Settings")]
    [Space]

    public LayerMask raycastLayermask;

    public float raycastDistance = 0.6f;

    public float raycastDistanceToCheckToActivateClimbOnGround = 0.9f;
    public float raycastDistanceToCheckToActivateClimbOnAir = 0.9f;

    public float verticalRaycastOffset = 1;

    [Space]

    public bool useClimbZoneDetectionRaycast;

    public float upOffsetToDetectSurfaceOnMovementInput = 0.5f;
    public float downOffsetToDetectSurfaceOnMovementInput = 0.2f;

    public float rightOffsetToDetectSurfaceOnMovementInput = 0.2f;
    public float leftOffsetToDetectSurfaceOnMovementInput = 0.2f;

    [Space]
    [Header ("Surface To Ignore Settings")]
    [Space]

    public bool useSurfacesToIgnoreTags;
    public List<string> surfacesToIgnoreTagsList = new List<string> ();

    [Space]

    public bool useSurfacesToCheckTagsOnClimbByInput;
    public List<string> surfacesToCheckTagsOnClimbByInputList = new List<string> ();

    public bool checkForClimbSurfaceZoneSystemOnClimbInput;

    [Space]

    public bool avoidMovementTowardSurfacesToIgnore;

    public bool stopClimbIfSurfaceToIgnoreDetected;

    public bool avoidMovementTowardNoClimbZones;

    public bool ignoreRigidbodies;

    [Space]
    [Header ("Surface In Front Detection Settings")]
    [Space]

    public bool checkSurfaceForLowerBodyEnabled = true;

    public bool useHangStateOnNoSurfaceOnLowerBody = true;

    public float lowerBodyRaycastOffset = 0.5f;

    public float upperBodyRaycastOffset = 1.5f;

    [Space]
    [Header ("Surface In Top And Bottom Detection Settings")]
    [Space]

    public bool checkSurfaceAbovePlayerEnabled = true;

    public float abovePlayerRaycastOffset = 0.5f;

    public bool checkSurfaceBelowPlayerEnabled = true;

    public float belowPlayerRaycastOffset = -0.2f;

    [Space]
    [Header ("Surface Sides Detection Settings")]
    [Space]

    public bool checkSidesEnabled = true;
    public float raycastDistanceToCheckSides = 0.8f;

    public bool checkCloseSidesEnabled = true;

    public float raycastDistanceToCheckCloseSides = 0.7f;

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

    public bool slideDownEnabled = true;
    public float slideDownSpeedThirdPerson = 10;
    public float SlideDownSpeedFirstPerson = 10;

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

    public bool useMovementCurve = true;

    public AnimationCurve mainMovementCurve;

    public bool useVelocityCurve = true;

    public AnimationCurve mainVelocityCurve;

    public bool stopClimbAtMinAngleOnSurface = true;
    public float minAngleToStopClimb = -50;

    public bool stopClimbAtMaxAngleOnSurface = true;
    public float maxAngleToStopClimb = 50;

    public float minTimeAngleLimitReachedToStopClimb = 1;

    public bool disableClimbStateOnDamageReceivedEnabled;

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

    public float climbMovementSpeedThirdPerson = 5;
    public float climbMovementSpeedFirstPerson = 5;

    public float climbVelocityThirdPerson = 5;
    public float climbVelocityFirstPerson = 5;

    public float climbRotationSpeedThirdPerson = 200;
    public float climbRotationSpeedFirstPerson = 100;

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

    public float climbTurboSpeed = 2;

    public Vector3 impulseOnJump;

    public float maxVelocityChangeSlide;

    public float jumpRotationSpeedThirdPerson = 1;
    public float jumpRotationSpeedFirstPerson = 0.5f;

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

    public bool keepWeapons;
    public bool drawWeaponsIfCarriedPreviously;

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

    public int actionID = 5654231;

    public string freeClimbAnimatorName = "Free Climb";

    public bool checkIfClimbHangOnAirForAction = true;
    public int freeClimbHangFromAirActionID = 5654232;

    public bool checkIfClimbHangOnGroundForAction = true;
    public int freeClimbHangFromGroundActionID = 5654233;

    public float minDelayToUseMovementInputOnClimbStart = 0.5f;

    public string externalControlleBehaviorActiveAnimatorName = "External Behavior Active";
    public string actionIDAnimatorName = "Action ID";

    public string horizontalAnimatorName = "Horizontal Action";
    public string verticalAnimatorName = "Vertical Action";

    public float inputLerpSpeed = 3;

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

    public bool setNewCameraStateOnThirdPerson;

    public string newCameraStateOnThirdPerson;

    [Space]
    [Header ("Climb Top Part Settings")]
    [Space]

    public Transform climbSurfaceActionSystemTransform;

    public float maxAngleDifferenceOnSurfaceToClimb = 20;

    public float checkTopSurfaceRaycastOffset = 1.3f;

    public float climbSurfaceTopSpeed = 2;

    [Space]
    [Space]

    public eventParameters.eventToCallWithGameObject eventToActivateClimbSurfaceActionSystem;

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

    public bool showDebugPrint;

    public bool checkIfDetectClimbActive;

    public bool climbActive;

    public bool isFirstPersonActive;

    public bool carryingWeaponsPreviously;

    public bool climbPaused;

    public bool activateClimbStateOnNextSurfaceDetectedActive;

    public bool slidingDownActive;

    public bool activateAutoSlideDownOnSurface;

    public bool slidingDownResult;

    public bool playerParentAssigned;

    public bool adjustingPlayerToSurfaceCollisionDetection;

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

    public float surfaceAngle;

    public bool surfaceFoundOnSide;

    public bool surfaceFoundOnCloseSide;

    public bool surfaceFoundOnRegularRaycast;

    public bool upperBodySurfaceDetected;

    public bool lowerBodySurfaceDetected;

    public bool surfaceDetectedAbovePlayer;

    public bool surfafeDetectedBelowPlayer;

    public int climbContactCount;

    public Vector3 contactNormal;

    public Vector3 lastClimbNormal;

    public float angleDifferenceWithSurface;

    public bool surfaceDetectedOnMovementInputRaycast;

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

    public float currentVerticalMovement;

    public float currentHorizontalMovement;

    public Vector2 rawAxisValues;

    public bool moving;

    public bool movementInputPressed;

    public bool climbStateActivatedByInput;

    public bool movementInputPausedActive;

    public bool movementInputDisabledOnSurface;

    public bool cancelMovementInputActive;

    public bool turboActive;

    public bool pauseTurboActive;

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

    public bool showGizmo;

    [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 ("Other Events")]
    [Space]

    public UnityEvent eventOnCheckForClimbStateActive;
    public UnityEvent eventOnStopCheckForClimbStateActive;

    [Space]
    [Space]

    public UnityEvent eventOnClimbStateActive;
    public UnityEvent eventOnStopClimbStateActive;

    [Space]

    public UnityEvent eventBeforeCheckingForClimbStateActive;

    [Space]
    [Header ("Turbo Events")]
    [Space]

    public bool useEventOnTurbo;
    public UnityEvent eventOnStartTurbo;
    public UnityEvent eventOnEndTurbo;
    public UnityEvent eventOnRegularClimbSpeed;

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

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

    public Animator mainAnimator;

    public headTrack mainHeadTrack;


    Coroutine resetPlayerCoroutine;

    Coroutine resetCameraCoroutine;

    bool originalClimbEnabled;

    Vector3 playerTransformUp;
    Vector3 playerTransformForward;

    RaycastHit hit;

    Vector3 velocityChange;

    int externalControlleBehaviorActiveAnimatorID;

    int actionIDAnimatorID;

    int horizontalAnimatorID;

    int verticalAnimatorID;

    int freeClimbAnimatorID;

    bool jumpInputUsed;

    Coroutine jumpCoroutine;

    float currentClimbRotationSpeed;

    float currentClimbMovementSpeed;

    float currentClimbVelocity;

    float currentClimbTurboSpeed;

    string previousCameraState = "";

    bool cameraOnThirdPersonOnLastClimbActiveState;


    float lastTimeMinAngleOnSurfaceReached;
    float lastTimeMaxAngleOnSurfaceReached;

    Vector3 lastSideDirection;
    Vector3 lastSideNormal;


    bool resetAnimatorIDValue;

    float lastTimeClimbActive;

    RaycastHit currentSurfaceHit;

    GameObject currentSurfaceDetected;
    GameObject previousSurfaceDetected;

    bool checkTagsToIgnoreOnManualClimbInputActive;

    int currentIDValue = -1;

    bool firstPersonChecked;

    bool thirdPersonChecked;

    float lastTimeActivateClimbStateOnNextSurfaceDetectedActive;

    Coroutine checkIfSurfaceDetectedInFrontCoroutine;

    float lastTimeSurfaceNotFound = 0;

    bool climbingOnTopInProcess;

    float lastTimeCollisionDetectionWithSurfaceNotFound = 0;

    Vector3 positionToAdjustPlayerToSurfaceCollision = Vector3.zero;

    bool isPlayerMovingOn3dWorld;

    bool increaseClimbSpeedActive;


    void Start ()
    {
        originalClimbEnabled = climbEnabled;

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

        horizontalAnimatorID = Animator.StringToHash (horizontalAnimatorName);

        verticalAnimatorID = Animator.StringToHash (verticalAnimatorName);

        freeClimbAnimatorID = Animator.StringToHash (freeClimbAnimatorName);
    }

    public override void checkChangeCameraViewStateOnExternalControllerBehavior ()
    {
        if (climbActive) {
            isFirstPersonActive = mainPlayerController.isPlayerOnFirstPerson ();

            bool isFullBodyAwarenessActive = mainPlayerCamera.isFullBodyAwarenessActive ();

            if (isFullBodyAwarenessActive) {
                mainPlayerCamera.setIgnorePlayerRotationToCameraOnFBAState (true);

                mainPlayerCamera.setPivotCameraTransformParentCurrentTransformToFollow ();
            } else {
                if (isFirstPersonActive) {

                } else {
                    if (mainPlayerCamera.isFullBodyAwarenessEnabled ()) {
                        mainPlayerCamera.setIgnorePlayerRotationToCameraOnFBAState (false);

                        mainPlayerCamera.setPivotCameraTransformOriginalParent ();

                        mainPlayerCamera.resetPivotCameraTransformLocalRotation ();

                        setCameraState (true);
                    }
                }
            }
        }
    }

    void setCameraState (bool state)
    {
        if (useCameraOffsetOnClimbActiveEnabled) {
            mainPlayerCamera.setCameraPositionOffsetActiveState (state, cameraOffsetOnClimbActive, cameraOffsetOnClimbActiveLerpSpeed);

            mainPlayerCamera.setUpdatePlayerCameraPositionOnFixedUpdateActiveState (state);
        }

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

                    cameraOnThirdPersonOnLastClimbActiveState = !mainPlayerCamera.isFullBodyAwarenessActive ();
                }

                mainPlayerCamera.setCameraStateOnlyOnThirdPerson (newCameraStateOnThirdPerson);
            } else {

                if (previousCameraState != "") {
                    if (previousCameraState != newCameraStateOnThirdPerson) {
                        if (cameraOnThirdPersonOnLastClimbActiveState) {
                            if (mainPlayerCamera.isFullBodyAwarenessActive ()) {
                                previousCameraState = "";
                            }
                        } else {
                            if (!mainPlayerCamera.isFullBodyAwarenessActive ()) {
                                previousCameraState = mainPlayerCamera.getDefaultThirdPersonStateName ();
                            }
                        }

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

                    previousCameraState = "";
                }
            }
        }
    }

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

                    resetAnimatorIDValue = false;
                }
            }

            if (movementInputPausedActive) {
                if (Time.time > lastTimeClimbActive + minDelayToUseMovementInputOnClimbStart) {

                    movementInputPausedActive = false;
                }
            }

            float currentFixedUpdateDeltaTime = Time.fixedDeltaTime;

            playerTransformUp = playerTransform.up;

            playerTransformForward = playerTransform.forward;

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

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

            isPlayerMovingOn3dWorld = mainPlayerController.isPlayerMovingOn3dWorld ();

            if (movementInputPausedActive || movementInputDisabledOnSurface || adjustingPlayerToSurfaceCollisionDetection) {
                currentVerticalMovement = 0;
                currentHorizontalMovement = 0;
            }

            if (!isPlayerMovingOn3dWorld) {
                currentHorizontalMovement = 0;
            }

            rawAxisValues = mainPlayerController.getRawAxisValues ();

            if (rawAxisValues.x == 0) {
                if (Mathf.Abs (currentHorizontalMovement) > 0.001f) {

                    currentHorizontalMovement = 0;
                }
            }

            if (rawAxisValues.y == 0) {
                if (Mathf.Abs (currentVerticalMovement) > 0.001f) {

                    currentVerticalMovement = 0;
                }
            }

            if (useRaycastDetectionToClimb) {
                if (!updateRaycastDetectionState (currentRaycastPosition, currentRaycastDirection, currentFixedUpdateDeltaTime)) {
                    return;
                }
            }

            //##################################################################################################
            //Update climb state by collision detection

            else {
                if (!updateCollisionDetectionState (currentRaycastDirection, currentFixedUpdateDeltaTime)) {
                    return;
                }
            }

            checkSurfaceAngleToStopClimb ();

            if (!surfaceFoundOnSide && !adjustingPlayerToSurfaceCollisionDetection) {
                checkIfTopSurfaceReached ();
            }

            checkTopBottomAndFrontSurfaces ();
        }
    }

    //COLLISION DETECTION METHOD
    bool updateCollisionDetectionState (Vector3 currentRaycastDirection, float currentFixedUpdateDeltaTime)
    {
        updateCheckCameraViewState ();


        currentClimbMovementSpeed = climbMovementSpeedThirdPerson;

        if (isFirstPersonActive) {
            currentClimbMovementSpeed = climbMovementSpeedFirstPerson;
        }

        currentClimbRotationSpeed = climbRotationSpeedThirdPerson;

        if (isFirstPersonActive) {
            currentClimbRotationSpeed = climbRotationSpeedFirstPerson;
        }

        currentClimbVelocity = climbVelocityThirdPerson;

        if (isFirstPersonActive) {
            currentClimbVelocity = climbVelocityFirstPerson;
        }

        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            currentClimbVelocity = slideDownSpeedThirdPerson;

            if (isFirstPersonActive) {
                currentClimbVelocity = SlideDownSpeedFirstPerson;
            }
        }

        if (movementInputPausedActive || movementInputDisabledOnSurface || adjustingPlayerToSurfaceCollisionDetection) {
            rawAxisValues = Vector2.zero;
        }

        checkCurrentSurfaceDetected ();

        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            if (!movementInputPausedActive && !cancelMovementInputActive && surfaceDetectedOnMovementInputRaycast) {
                currentVerticalMovement = -1;

                rawAxisValues.y = currentVerticalMovement;

                if (currentHorizontalMovement != 0) {
                    currentHorizontalMovement /= 2;
                }
            }
        }

        if (cancelMovementInputActive) {
            currentVerticalMovement = 0;

            currentHorizontalMovement = 0;

            rawAxisValues = Vector2.zero;
        }

        if (surfaceDetectedAbovePlayer) {
            currentVerticalMovement = Mathf.Clamp (currentVerticalMovement, -1, 0);

            rawAxisValues.y = Mathf.Clamp (rawAxisValues.y, -1, 0);
        }

        if (surfafeDetectedBelowPlayer) {
            currentVerticalMovement = Mathf.Clamp (currentVerticalMovement, 0, 1);

            rawAxisValues.y = Mathf.Clamp (rawAxisValues.y, 0, 1);
        }

        slidingDownResult = false;

        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            if (currentVerticalMovement != 0) {
                if (currentIDValue != 1) {
                    currentIDValue = 1;

                    mainPlayerController.setCurrentIdleIDValue (currentIDValue);

                    mainPlayerController.updateIdleIDOnAnimator ();
                }

                slidingDownResult = true;
            } else {
                if (currentIDValue != 0) {
                    currentIDValue = 0;

                    mainPlayerController.setCurrentIdleIDValue (currentIDValue);

                    mainPlayerController.updateIdleIDOnAnimator ();
                }
            }
        } else {
            if (currentIDValue != 0) {
                currentIDValue = 0;

                mainPlayerController.setCurrentIdleIDValue (currentIDValue);

                mainPlayerController.updateIdleIDOnAnimator ();
            }
        }


        moving = (Mathf.Abs (currentVerticalMovement) > 0.01f || Mathf.Abs (currentHorizontalMovement) > 0.01f);

        movementInputPressed = rawAxisValues != Vector2.zero;

        currentClimbTurboSpeed = 1;

        pauseTurboActive = false;

        bool enougMovementInput = (Mathf.Abs (currentVerticalMovement) > 0.7f || Mathf.Abs (currentHorizontalMovement) > 0.7f);

        if (increaseClimbSpeedActive && movementInputPressed && enougMovementInput && !slidingDownActive && !activateAutoSlideDownOnSurface) {

            if (surfaceDetectedOnMovementInputRaycast && angleDifferenceWithSurface < 3) {
                currentClimbTurboSpeed = climbTurboSpeed;
            } else {
                pauseTurboActive = true;
            }

            if (!turboActive) {
                mainPlayerController.setCurrentAirSpeedValue (2);

                turboActive = true;

                checkEventsOnTurbo (true);
            }
        } else {
            if (turboActive) {
                mainPlayerController.setCurrentAirSpeedValue (1);

                turboActive = false;

                mainPlayerController.stopShakeCamera ();

                checkEventsOnTurbo (false);

                eventOnRegularClimbSpeed.Invoke ();
            }
        }




        if (adjustingPlayerToSurfaceCollisionDetection) {
            //adjust player to surface before moving
            if (positionToAdjustPlayerToSurfaceCollision == Vector3.zero) {
                Vector3 mainRaycastPosition = playerTransform.position + playerTransform.up - playerTransform.forward * 0.3f;

                if (Physics.Raycast (mainRaycastPosition, currentRaycastDirection, out hit, 2, raycastLayermask)) {

                    Vector3 targetPosition = hit.point + adjustToFoundSurfaceOffset * hit.normal;



                    float currentPlayerAngleWithSurface = Vector3.SignedAngle (playerTransform.forward, -hit.normal, playerTransform.right);

                    float currentPlayerAngleWithSurfaceABS = Mathf.Abs (currentPlayerAngleWithSurface);

                    //					print (currentPlayerAngleWithSurface);

                    if (currentPlayerAngleWithSurfaceABS > 8) {
                        Vector3 playerTransformDown = -playerTransform.up;

                        playerTransformDown = Quaternion.AngleAxis (currentPlayerAngleWithSurface, playerTransform.right) * playerTransformDown;

                        playerTransformDown.Normalize ();

                        //						print (playerTransformDown);

                        targetPosition += playerTransformDown;

                        Debug.DrawRay (hit.point + adjustToFoundSurfaceOffset * hit.normal, playerTransformDown * 10000, Color.black, 5);

                        //			print (currentPlayerAngleWithSurface);
                    } else {
                        targetPosition -= playerTransform.up;
                    }

                    positionToAdjustPlayerToSurfaceCollision = targetPosition;
                }
            } else {
                mainRigidbody.position =
                    Vector3.MoveTowards (mainRigidbody.position, positionToAdjustPlayerToSurfaceCollision,
                    adjustToFoundSurfaceSpeed * currentFixedUpdateDeltaTime);

                bool closeToSurfaceDetected = GKC_Utils.distance (mainRigidbody.position, positionToAdjustPlayerToSurfaceCollision) < 0.01f;

                if (Time.time > lastTimeClimbActive + minDelayToAdjustDetectionCollision && closeToSurfaceDetected) {
                    adjustingPlayerToSurfaceCollisionDetection = false;

                    positionToAdjustPlayerToSurfaceCollision = Vector3.zero;

                    Vector3 newPosition = mainRigidbody.position;

                    if (climbDetectionCollisionPositionOffset != Vector3.zero) {
                        newPosition += climbDetectionCollisionPositionOffset.x * (-playerTransform.right);
                        newPosition += climbDetectionCollisionPositionOffset.y * (-playerTransform.up);
                        newPosition += climbDetectionCollisionPositionOffset.z * (-playerTransform.forward);
                    }

                    mainClimbDetectionCollisionSystem.updateObjectPosition (newPosition);
                }
            }
        } else {
            Vector3 climbPosition = mainClimbDetectionCollisionSystem.getMainRigidbodyPosition ();

            if (climbDetectionCollisionPositionOffset != Vector3.zero) {
                climbPosition += climbDetectionCollisionPositionOffset.x * playerTransform.right;
                climbPosition += climbDetectionCollisionPositionOffset.y * playerTransform.up;
                climbPosition += climbDetectionCollisionPositionOffset.z * playerTransform.forward;
            }

            if (updateRigidbodyPositionSmoothlyOnDetectionCollision) {
                if (useMovementCurve) {
                    currentClimbMovementSpeed = mainMovementCurve.Evaluate (currentClimbMovementSpeed);
                }

                mainRigidbody.position = Vector3.Lerp (mainRigidbody.position, climbPosition, currentClimbTurboSpeed * currentClimbMovementSpeed * currentFixedUpdateDeltaTime);
            } else {
                mainRigidbody.position = climbPosition;
            }
        }

        //mainRigidbody.velocity = mainClimbDetectionCollisionSystem.getMainRigidbodyVelocity ();

        //mainAnimator.velocity could be used to move it with root motion used as velocity

        if (movementInputPressed) {
            mainPlayerController.setCurrentVelocityValue (mainRigidbody.linearVelocity);
        } else {
            mainPlayerController.setCurrentVelocityValue (Vector3.zero);
        }

        float currentHorizontalMovementAnimatorValue = currentHorizontalMovement;
        float currentVerticalMovementAnimatorValue = currentVerticalMovement;


        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            if (slidingDownResult) {
                currentVerticalMovementAnimatorValue = 0;
            }
        }

        //update player animation states
        mainAnimator.SetFloat (horizontalAnimatorID, currentHorizontalMovementAnimatorValue, inputLerpSpeed, currentFixedUpdateDeltaTime);
        mainAnimator.SetFloat (verticalAnimatorID, currentVerticalMovementAnimatorValue, inputLerpSpeed, currentFixedUpdateDeltaTime);


        RaycastHit currentClimbCollisionHit = new RaycastHit ();

        Vector3 collisionDetectionDirection = -mainClimbDetectionCollisionSystem.getLastClimbNormal ();

        if (lastClimbNormalValue != -Vector3.one) {
            if (!moving) {
                collisionDetectionDirection = lastClimbNormalValue;
            }
        }

        if (moving) {
            lastClimbNormalValue = -mainClimbDetectionCollisionSystem.getLastClimbNormal ();
        }

        if (Physics.Raycast (mainClimbDetectionCollisionSystem.getMainRigidbodyPosition (), collisionDetectionDirection, out currentClimbCollisionHit, 3, raycastLayermask)) {
            collisionDetectionDirection = -currentClimbCollisionHit.normal;
        } else {
            collisionDetectionDirection = playerTransform.forward;

            if (Physics.Raycast (mainClimbDetectionCollisionSystem.getMainRigidbodyPosition (), collisionDetectionDirection, out currentClimbCollisionHit, 3, raycastLayermask)) {
                collisionDetectionDirection = -currentClimbCollisionHit.normal;
            }
        }

        bool setRotationOnPlayerResult = true;

        angleDifferenceWithSurface = Vector3.Angle (playerTransform.forward, collisionDetectionDirection);

        if (angleDifferenceWithSurface < 3) {
            if (!moving) {
                currentClimbRotationSpeed *= 0.8f;
            }
        }

        if (angleDifferenceWithSurface < 1) {
            setRotationOnPlayerResult = false;
        }

        if (setRotationOnPlayerResult) {
            Quaternion targetRotation = Quaternion.LookRotation (collisionDetectionDirection);

            playerTransform.rotation = Quaternion.Lerp (playerTransform.rotation, targetRotation, currentClimbRotationSpeed * currentFixedUpdateDeltaTime);
        }

        if (rotateCameraToPlayerRotationOnClimbActiveEnabled) {
            Vector3 myForwardCamera = Vector3.Cross (playerCameraTransform.right, playerTransform.up);
            Quaternion dstRotCamera = Quaternion.LookRotation (myForwardCamera, playerTransform.up);

            playerCameraTransform.rotation = Quaternion.Lerp (playerCameraTransform.rotation, dstRotCamera, currentClimbRotationSpeed * currentFixedUpdateDeltaTime);
        }

        if (Time.time > lastTimeClimbActive + 0.5f && !adjustingPlayerToSurfaceCollisionDetection) {
            if (climbContactCount > 0) {
                lastTimeCollisionDetectionWithSurfaceNotFound = 0;

                //				print ("DETECTED " + climbContactCount);
            } else {
                //				print ("NO DETECTED " + climbContactCount);

                if (lastTimeCollisionDetectionWithSurfaceNotFound == 0) {
                    lastTimeCollisionDetectionWithSurfaceNotFound = Time.time;

                } else {
                    if (lastTimeCollisionDetectionWithSurfaceNotFound != 0 && Time.time > lastTimeCollisionDetectionWithSurfaceNotFound + 1.2f) {
                        Vector3 lastContactNormal = contactNormal;

                        if (lastContactNormal == Vector3.zero) {
                            lastContactNormal = mainClimbDetectionCollisionSystem.getLastClimbNormal ();
                        }

                        if (lastContactNormal == Vector3.zero) {
                            lastContactNormal = Vector3.up;
                        }

                        Vector3 currentNormal = getCurrentNormal ();

                        float topSurfaceAngle = Vector3.Angle (currentNormal, lastContactNormal);

                        float topSurfaceAngleABS = Mathf.Abs (topSurfaceAngle);

                        if (showDebugPrint) {
                            print ("stop climb due to collision dropped, checking surface on top" + topSurfaceAngleABS + " " + lastContactNormal);
                        }

                        bool groundLocated = false;

                        if (topSurfaceAngleABS < 20) {
                            if (topSurfaceAngleABS > 10) {
                                groundLocated = true;
                            }
                        }

                        if (!groundLocated) {
                            if (Physics.Raycast (mainClimbDetectionCollisionSystem.getMainRigidbodyPosition (), -getCurrentNormal (), out currentClimbCollisionHit, 1, raycastLayermask)) {
                                groundLocated = true;

                                if (showDebugPrint) {
                                    print ("ground detected");
                                }
                            }
                        }

                        if (groundLocated) {
                            stopClimbToWalkOnSurfaceActive = true;

                            mainAnimator.CrossFadeInFixedTime (stopClimbToWalkOnSurfaceActionName, 0.1f);
                        }

                        lastTimeSurfaceNotFound = 0;

                        stopClimbAndDetectState ();

                        return false;
                    }
                }
            }
        }

        return true;
    }

    Vector3 lastClimbNormalValue = -Vector3.one;

    public void updateClimbContactCount (int newValue)
    {
        climbContactCount = newValue;
    }

    public void updateContactNormal (Vector3 newValue)
    {
        contactNormal = newValue;
    }

    public void updateLastClimbNormal (Vector3 newValue)
    {
        lastClimbNormal = newValue;
    }

    void updateCheckCameraViewState ()
    {
        //check change of view state
        bool isPlayerOnFirstPerson = mainPlayerController.isPlayerOnFirstPerson ();

        if (isPlayerOnFirstPerson) {
            if (!firstPersonChecked) {
                if (showDebugPrint) {
                    print ("checking swim state on first person");
                }

                if (thirdPersonChecked) {
                    //						mainPlayerController.resetAnimator ();

                    if (showDebugPrint) {
                        print ("reset animator state for first person");
                    }
                }

                firstPersonChecked = true;

                thirdPersonChecked = false;

                mainPlayerController.setPausePlayerRotateToCameraDirectionOnFirstPersonActiveState (true);
            }
        } else {
            if (!thirdPersonChecked) {
                if (showDebugPrint) {
                    print ("checking swim state on third person");
                }

                if (firstPersonChecked) {
                    //						mainPlayerController.resetAnimator ();

                    if (showDebugPrint) {
                        print ("reset animator state for first person");
                    }

                    mainPlayerController.setOnGroundState (false);

                    mainPlayerController.setOnGroundAnimatorIDValueWithoutCheck (false);

                    mainPlayerController.setFootStepManagerState (true);

                    mainAnimator.Play (freeClimbAnimatorID);

                    //						mainAnimator.SetInteger (actionIDAnimatorID, actionID);

                    mainAnimator.SetBool (externalControlleBehaviorActiveAnimatorID, true);

                    lastTimeClimbActive = Time.time;

                    resetAnimatorIDValue = true;
                }

                thirdPersonChecked = true;

                firstPersonChecked = false;

                mainPlayerController.setPausePlayerRotateToCameraDirectionOnFirstPersonActiveState (false);
            }
        }
    }

    void checkSurfaceAngleToStopClimb ()
    {
        if (useRaycastDetectionToClimb) {
            //check surface angle to stop the climb
            surfaceAngle = 0;

            Vector3 currentRaycastPosition = playerTransform.position + playerTransform.up;
            Vector3 currentRaycastDirection = playerTransform.forward;

            if (Physics.Raycast (currentRaycastPosition, currentRaycastDirection, raycastDistance, raycastLayermask)) {
                surfaceAngle = Vector3.SignedAngle (playerTransform.up, getCurrentNormal (), playerTransform.right);
            }

            if (surfaceAngle != 0 && !surfaceFoundOnSide && !surfaceFoundOnCloseSide) {
                if (stopClimbAtMinAngleOnSurface) {
                    if (surfaceAngle < 0) {
                        if (surfaceAngle < minAngleToStopClimb) {
                            if (lastTimeMinAngleOnSurfaceReached == 0) {
                                lastTimeMinAngleOnSurfaceReached = Time.time;
                            }
                        } else {
                            lastTimeMinAngleOnSurfaceReached = 0;
                        }
                    }
                }

                if (stopClimbAtMaxAngleOnSurface) {
                    if (surfaceAngle > 0) {
                        if (surfaceAngle > maxAngleToStopClimb) {
                            if (lastTimeMaxAngleOnSurfaceReached == 0) {
                                lastTimeMaxAngleOnSurfaceReached = Time.time;
                            }
                        } else {
                            lastTimeMaxAngleOnSurfaceReached = 0;
                        }
                    }
                }

                if (lastTimeMinAngleOnSurfaceReached != 0) {
                    if (Time.time > lastTimeMinAngleOnSurfaceReached + minTimeAngleLimitReachedToStopClimb) {
                        stopClimbAndDetectState ();

                        return;
                    }
                }

                if (lastTimeMaxAngleOnSurfaceReached != 0) {
                    if (Time.time > lastTimeMaxAngleOnSurfaceReached + minTimeAngleLimitReachedToStopClimb) {
                        stopClimbAndDetectState ();

                        return;
                    }
                }
            }
        } else {

        }
    }

    public bool isSlidingDownActive ()
    {
        return slidingDownActive;
    }

    public bool isPlayerMoving ()
    {
        return moving;
    }

    public float getCurrentClimbTurboSpeed ()
    {
        return currentClimbTurboSpeed;
    }

    public bool isTurboActive ()
    {
        return turboActive;
    }

    public bool isPauseTurboActive ()
    {
        return pauseTurboActive;
    }

    public Vector3 getCurrentNormal ()
    {
        return mainPlayerController.getCurrentNormal ();
    }

    void checkTopBottomAndFrontSurfaces ()
    {
        if (useRaycastDetectionToClimb) {
            if (checkSurfaceForLowerBodyEnabled) {
                Vector3 raycastPosition = playerTransform.position + (lowerBodyRaycastOffset * playerTransform.up);
                Vector3 raycastDirection = playerTransform.forward;

                if (useHangStateOnNoSurfaceOnLowerBody) {
                    if (Physics.Raycast (raycastPosition, raycastDirection, 1.1f, raycastLayermask)) {
                        if (!lowerBodySurfaceDetected) {
                            mainPlayerController.setCurrentAirIDValue (-1);

                            lowerBodySurfaceDetected = true;
                        }

                        if (showGizmo) {
                            Debug.DrawRay (raycastPosition, 2 * raycastDirection, Color.green);
                        }
                    } else {
                        if (lowerBodySurfaceDetected) {
                            mainPlayerController.setCurrentAirIDValue (0);

                            lowerBodySurfaceDetected = false;
                        }

                        if (showGizmo) {
                            Debug.DrawRay (raycastPosition, 2 * raycastDirection, Color.black);
                        }
                    }
                } else {
                    if (!lowerBodySurfaceDetected) {
                        mainPlayerController.setCurrentAirIDValue (-1);

                        lowerBodySurfaceDetected = true;
                    }
                }

                raycastPosition = playerTransform.position + (upperBodyRaycastOffset * playerTransform.up);
                raycastDirection = playerTransform.forward;

                upperBodySurfaceDetected = false;

                if (Physics.Raycast (raycastPosition, raycastDirection, 1.1f, raycastLayermask)) {
                    upperBodySurfaceDetected = true;

                    if (showGizmo) {
                        Debug.DrawRay (raycastPosition, 2 * raycastDirection, Color.green);
                    }
                } else {
                    if (showGizmo) {
                        Debug.DrawRay (raycastPosition, 2 * raycastDirection, Color.black);
                    }
                }
            }

            if (checkSurfaceAbovePlayerEnabled) {
                Vector3 raycastPosition = playerTransform.position + (abovePlayerRaycastOffset * playerTransform.up);
                Vector3 raycastDirection = playerTransform.up;

                RaycastHit abovePlayerHit;

                if (Physics.Raycast (raycastPosition, raycastDirection, out abovePlayerHit, 0.9f, raycastLayermask)) {

                    float currentAngle = Vector3.SignedAngle (abovePlayerHit.normal, -playerTransform.up, playerTransform.right);

                    if (Mathf.Abs (currentAngle) < 25) {
                        surfaceDetectedAbovePlayer = true;
                    } else {
                        surfaceDetectedAbovePlayer = false;
                    }

                } else {
                    surfaceDetectedAbovePlayer = false;
                }
            }

            if (checkSurfaceBelowPlayerEnabled) {
                Vector3 raycastPosition = playerTransform.position + (belowPlayerRaycastOffset * playerTransform.up);
                Vector3 raycastDirection = -playerTransform.up;

                RaycastHit belowPlayerHit;

                if (Physics.Raycast (raycastPosition, raycastDirection, out belowPlayerHit, 0.9f, raycastLayermask)) {

                    float currentAngle = Vector3.SignedAngle (belowPlayerHit.normal, playerTransform.up, playerTransform.right);

                    if (Mathf.Abs (currentAngle) < 25) {
                        surfafeDetectedBelowPlayer = true;
                    } else {
                        surfafeDetectedBelowPlayer = false;
                    }

                } else {
                    surfafeDetectedBelowPlayer = false;
                }
            }
        }
    }

    void checkIfTopSurfaceReached ()
    {
        Vector3 currentNormal = getCurrentNormal ();

        Vector3 raycastPosition = playerTransform.position + (checkTopSurfaceRaycastOffset * playerTransform.up);

        Vector3 playerForwardDirection = playerTransform.forward;

        float currentPlayerAngleWithSurface = Vector3.SignedAngle (playerTransform.up, getCurrentNormal (), playerTransform.right);

        float currentPlayerAngleWithSurfaceABS = Mathf.Abs (currentPlayerAngleWithSurface);

        if (currentPlayerAngleWithSurfaceABS > 5) {
            playerForwardDirection = Quaternion.AngleAxis (currentPlayerAngleWithSurface, playerTransform.right) * playerForwardDirection;

            Debug.DrawRay (raycastPosition, playerForwardDirection * 1000, Color.red);

            //			print (currentPlayerAngleWithSurface);
        }


        Vector3 raycastDirection = playerForwardDirection;

        //		print (raycastDirection);

        Vector3 climbSurfaceTargetPosition = Vector3.zero;

        RaycastHit upperHit = new RaycastHit ();
        RaycastHit lowerHit = new RaycastHit ();

        bool surfaceToLedgeDetected = false;

        Debug.DrawRay (raycastPosition, raycastDirection, Color.green);

        if (!Physics.Raycast (raycastPosition, raycastDirection, out upperHit, 2, raycastLayermask) &&
            Physics.Raycast (playerTransform.position, raycastDirection, out lowerHit, 2, raycastLayermask)) {

            //if not surface is found, then
            if (showGizmo) {
                Debug.DrawRay (raycastPosition, raycastDirection, Color.green);
            }

            //search for the closest point surface of that ledge, by lowering the raycast position until a surface is found
            surfaceToLedgeDetected = false;

            RaycastHit newHit = new RaycastHit ();
            RaycastHit previousHit = new RaycastHit ();

            int numberOfLoops = 0;

            Vector3 newRaycastPosition = playerTransform.position + (0.5f * playerTransform.up) - 0.6f * playerTransform.forward;

            //			raycastDirection = Vector3.Cross (playerTransform.right, currentNormal);

            RaycastHit topSurfaceHit = new RaycastHit ();

            float topSurfaceAngle = -1;

            float currentRaycastDistance = 2.6f;

            if (currentPlayerAngleWithSurface < -8) {
                //print ("looking down");

                currentRaycastDistance = 2;
            }

            raycastDirection = playerTransform.forward;

            while (!surfaceToLedgeDetected && numberOfLoops < 80) {
                if (Physics.Raycast (newRaycastPosition, raycastDirection, out newHit, currentRaycastDistance, raycastLayermask)) {
                    previousHit = newHit;

                    newRaycastPosition += 0.04f * playerTransform.up;

                    if (currentPlayerAngleWithSurface < -8) {
                        if (currentRaycastDistance > 1.5f) {
                            currentRaycastDistance -= 0.05f;
                        }
                    } else {
                        if (currentRaycastDistance > 2) {
                            if (newHit.distance > 2) {
                                currentRaycastDistance -= 0.06f;
                            }
                        }
                    }
                } else {
                    if (previousHit.point == Vector3.zero) {
                        print ("NO LOCATED");
                    } else {

                        climbSurfaceTargetPosition = previousHit.point + 0.04f * playerTransform.up;

                        surfaceToLedgeDetected = true;

                        if (Physics.Raycast (climbSurfaceTargetPosition + 0.2f * currentNormal, raycastDirection - playerTransform.up, out topSurfaceHit, 3.3f, raycastLayermask)) {
                            topSurfaceAngle = Vector3.Angle (currentNormal, topSurfaceHit.normal);
                        }
                    }
                }

                numberOfLoops++;
            }

            if (surfaceToLedgeDetected) {

                float angleWithSurface = Vector3.SignedAngle (currentNormal, previousHit.normal, playerTransform.right);

                bool surfaceAngleNotValid = false;

                float angleWithSurfaceAux = Mathf.Abs (Mathf.Abs (angleWithSurface) - 90);

                //				if (showDebugPrint) {
                //					print ("angle with surface " + angleWithSurface + " " + angleWithSurfaceAux);
                //				}

                if (angleWithSurfaceAux > maxAngleDifferenceOnSurfaceToClimb) {
                    surfaceAngleNotValid = true;
                }

                if (topSurfaceAngle != -1) {
                    //					print ("top surface angle " + topSurfaceAngle);

                    if (Mathf.Abs (topSurfaceAngle) > maxAngleDifferenceOnSurfaceToClimb) {
                        surfaceAngleNotValid = true;
                    }
                }

                if (!useRaycastDetectionToClimb) {

                    if (showDebugPrint) {
                        print ("surface valid to climb on top " + topSurfaceAngle + "  " + angleWithSurface + " " + previousHit.normal);
                    }

                    if (topSurfaceAngle != -1) {

                        float topSurfaceAngleABS = Mathf.Abs (topSurfaceAngle);

                        if (showDebugPrint) {
                            print ("Top surface angle is " + topSurfaceAngle);
                        }

                        bool stopClimbToWalkNormallyResult = false;

                        if (topSurfaceAngleABS > 30) {
                            surfaceAngleNotValid = true;
                        } else if (topSurfaceAngleABS < 20 && topSurfaceAngleABS > 10) {
                            stopClimbToWalkNormallyResult = true;
                        }

                        if (currentPlayerAngleWithSurfaceABS < 30) {
                            if (showDebugPrint) {
                                print ("checking if climb on top on low player rotation");
                            }

                            if (climbSurfaceTargetPosition != Vector3.zero) {
                                if (showDebugPrint) {
                                    print ("surface to climb target position by raycast located");
                                }

                                if (Mathf.Abs (topSurfaceAngle) <= maxAngleDifferenceOnSurfaceToClimb) {
                                    if (showDebugPrint) {
                                        print ("climb on top on low rotation checked properly, activating");
                                    }

                                    stopClimbToWalkNormallyResult = false;

                                    surfaceAngleNotValid = false;
                                }
                            }
                        }

                        if (stopClimbToWalkNormallyResult) {
                            if (showDebugPrint) {
                                print ("stop climb to walk normally");
                            }

                            stopClimbToWalkOnSurfaceActive = true;

                            mainAnimator.CrossFadeInFixedTime (stopClimbToWalkOnSurfaceActionName, 0.1f);

                            lastTimeSurfaceNotFound = 0;

                            stopClimbAndDetectState ();

                            surfaceAngleNotValid = true;
                        }
                    } else {
                        surfaceAngleNotValid = true;
                    }
                }

                if (climbSurfaceTargetPosition == Vector3.zero) {
                    surfaceAngleNotValid = true;
                }

                if (!surfaceAngleNotValid) {
                    if (showGizmo) {
                        Debug.DrawRay (newRaycastPosition, 4 * raycastDirection, Color.blue, 4);
                    }

                    isFirstPersonActive = mainPlayerController.isPlayerOnFirstPerson ();

                    Transform climbSurfaceActionSystemTransformParent = null;

                    if (mainPlayerController.isPlayerSetAsChildOfParent ()) {
                        climbSurfaceActionSystemTransformParent = mainPlayerController.getCurrentTemporalPlayerParent ();
                    }

                    climbSurfaceActionSystemTransform.SetParent (climbSurfaceActionSystemTransformParent);


                    actionSystem climbactionSystem = climbSurfaceActionSystemTransform.GetComponent<actionSystem> ();

                    if (climbactionSystem != null) {
                        climbactionSystem.setPlayerParentDuringActionActiveValues (climbSurfaceActionSystemTransformParent != null,
                            climbSurfaceActionSystemTransformParent);

                        if (isFirstPersonActive) {
                            climbactionSystem.setUseMovingPlayerToPositionTargetValues (true, climbSurfaceTopSpeed, 0);
                        } else {
                            //							if (climbSurfaceActionSystemTransformParent != null) {
                            //								climbactionSystem.setUseMovingPlayerToPositionTargetValues (true, climbSurfaceTopSpeed, 1);
                            //							} else {
                            climbactionSystem.setUseMovingPlayerToPositionTargetValues (false, 0, 0);
                            //							}
                        }
                    }

                    climbingOnTopInProcess = true;

                    stopClimbAndDetectState ();

                    climbSurfaceActionSystemTransform.position = climbSurfaceTargetPosition;

                    Quaternion targetRotation = Quaternion.LookRotation (-previousHit.normal);

                    climbSurfaceActionSystemTransform.rotation = targetRotation;

                    float extraAngleX = 0;

                    if (climbSurfaceActionSystemTransform.up != currentNormal) {
                        extraAngleX = Vector3.SignedAngle (climbSurfaceActionSystemTransform.up, currentNormal, climbSurfaceActionSystemTransform.right);
                    }

                    if (extraAngleX != 0) {
                        climbSurfaceActionSystemTransform.Rotate (new Vector3 (extraAngleX, 0, 0));
                    }

                    float extraAngleY = Vector3.SignedAngle (climbSurfaceActionSystemTransform.forward, playerForwardDirection, climbSurfaceActionSystemTransform.up);

                    if (Mathf.Abs (extraAngleY) > 5) {
                        climbSurfaceActionSystemTransform.Rotate (new Vector3 (0, extraAngleY, 0));
                    }

                    climbSurfaceActionSystemTransform.gameObject.SetActive (true);

                    eventToActivateClimbSurfaceActionSystem.Invoke (playerTransform.gameObject);

                    if (showDebugPrint) {
                        print ("surface to climb detected");
                    }

                }
            } else {
                if (showDebugPrint) {
                    print ("surface to climb not detected");
                }
            }
        } else {
            if (!useRaycastDetectionToClimb) {
                Vector3 lastContactNormal = contactNormal;

                if (climbContactCount > 0) {
                    lastContactNormal = mainClimbDetectionCollisionSystem.getLastClimbNormal ();
                }

                float topSurfaceAngle = Vector3.Angle (currentNormal, lastContactNormal);

                float topSurfaceAngleABS = Mathf.Abs (topSurfaceAngle);

                if (topSurfaceAngleABS < 20) {
                    if (topSurfaceAngleABS > 10) {
                        if (showDebugPrint) {
                            print ("surface valid to climb on top by stopping climb" + topSurfaceAngleABS + " " + lastContactNormal);
                        }

                        stopClimbToWalkOnSurfaceActive = true;

                        mainAnimator.CrossFadeInFixedTime (stopClimbToWalkOnSurfaceActionName, 0.1f);

                        lastTimeSurfaceNotFound = 0;

                        stopClimbAndDetectState ();

                        print ("stop climb to walk normally");
                    }
                }
            }
        }
    }

    public string stopClimbToWalkOnSurfaceActionName = "Stop Climb To Walk On Surface";

    bool stopClimbToWalkOnSurfaceActive;

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

    public void setClimbImpulseForce (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);
    }

    void checkCurrentSurfaceDetected ()
    {
        if (!useClimbZoneDetectionRaycast) {
            return;
        }

        Vector3 currentRaycastPosition = playerTransform.position + playerTransform.up - (0.3f * playerTransform.forward);
        Vector3 currentRaycastDirection = playerTransform.forward;

        Vector2 movementInput = rawAxisValues;

        if (slidingDownResult) {
            movementInput.y = -1;
        }

        if (movementInput.x > 0) {
            currentRaycastPosition += movementInput.x * rightOffsetToDetectSurfaceOnMovementInput * playerTransform.right;
        } else if (movementInput.x < 0) {
            currentRaycastPosition += movementInput.x * leftOffsetToDetectSurfaceOnMovementInput * playerTransform.right;
        }

        if (movementInput.y > 0) {
            currentRaycastPosition += movementInput.y * upOffsetToDetectSurfaceOnMovementInput * playerTransform.up;
        } else if (movementInput.y < 0) {
            currentRaycastPosition += movementInput.y * downOffsetToDetectSurfaceOnMovementInput * playerTransform.up;
        }

        if (showGizmo) {
            Debug.DrawRay (currentRaycastPosition, 2 * currentRaycastDirection, Color.white);
        }

        if (Physics.Raycast (currentRaycastPosition, currentRaycastDirection, out currentSurfaceHit, raycastDistance + 0.3f, raycastLayermask)) {
            currentSurfaceDetected = currentSurfaceHit.collider.gameObject;

            surfaceDetectedOnMovementInputRaycast = true;

            if (currentSurfaceDetected != previousSurfaceDetected) {
                previousSurfaceDetected = currentSurfaceDetected;

                if (avoidMovementTowardNoClimbZones) {
                    freeClimbZoneSystem currentFreeClimbZoneSystem = currentSurfaceDetected.GetComponent<freeClimbZoneSystem> ();

                    if (currentFreeClimbZoneSystem != null) {
                        cancelMovementInputActive = false;
                    } else {
                        cancelMovementInputActive = true;
                    }
                }

                if (avoidMovementTowardSurfacesToIgnore) {
                    if (surfacesToIgnoreTagsList.Contains (currentSurfaceDetected.tag)) {
                        if (stopClimbIfSurfaceToIgnoreDetected) {
                            stopClimbAndDetectState ();
                        } else {
                            cancelMovementInputActive = true;
                        }
                    } else {
                        cancelMovementInputActive = false;
                    }
                }
            }
        } else {
            if (currentSurfaceDetected != null) {
                currentSurfaceDetected = null;

                previousSurfaceDetected = null;

                cancelMovementInputActive = false;
            }

            surfaceDetectedOnMovementInputRaycast = false;
        }

        if (avoidMovementTowardSurfacesToIgnore) {
            if (!cancelMovementInputActive) {
                currentRaycastPosition = playerTransform.position + playerTransform.up - (0.3f * playerTransform.forward);

                movementInput = rawAxisValues;

                if (slidingDownResult) {
                    movementInput.y = -1;
                }

                if (movementInput.x > 0) {
                    currentRaycastDirection = movementInput.x * playerTransform.right;
                } else if (movementInput.x < 0) {
                    currentRaycastPosition = movementInput.x * playerTransform.right;
                }

                if (movementInput.y > 0) {
                    currentRaycastPosition = movementInput.y * playerTransform.up;
                } else if (movementInput.y < 0) {
                    currentRaycastPosition = movementInput.y * playerTransform.up;
                }

                if (showGizmo) {
                    Debug.DrawRay (currentRaycastPosition, 2 * currentRaycastDirection, Color.white);
                }

                if (Physics.Raycast (currentRaycastPosition, currentRaycastDirection, out currentSurfaceHit, raycastDistance + 0.3f, raycastLayermask)) {
                    currentSurfaceDetected = currentSurfaceHit.collider.gameObject;

                    surfaceDetectedOnMovementInputRaycast = true;

                    if (currentSurfaceDetected != previousSurfaceDetected) {
                        previousSurfaceDetected = currentSurfaceDetected;

                        if (avoidMovementTowardNoClimbZones) {
                            freeClimbZoneSystem currentFreeClimbZoneSystem = currentSurfaceDetected.GetComponent<freeClimbZoneSystem> ();

                            if (currentFreeClimbZoneSystem == null) {
                                cancelMovementInputActive = true;
                            }
                        }

                        if (surfacesToIgnoreTagsList.Contains (currentSurfaceDetected.tag)) {
                            if (stopClimbIfSurfaceToIgnoreDetected) {
                                stopClimbAndDetectState ();
                            } else {
                                cancelMovementInputActive = true;
                            }
                        }
                    }
                }
            }
        }
    }

    public void stopClimbFromDamageReceived ()
    {
        if (!disableClimbStateOnDamageReceivedEnabled) {
            return;
        }

        if (!climbActive) {
            return;
        }

        stopClimbAndDetectState ();
    }

    void stopClimbAndDetectState ()
    {
        setClimbActiveState (false);

        if (climbStateActivatedByInput) {
            setCheckIfDetectClimbActiveState (false);
        }
    }

    //Traversal movement functions
    public override void setJumpActiveForExternalForce ()
    {
        setJumpActive (impulseOnJump);
    }

    public void setJumpActive (Vector3 newImpulseOnJumpAmount)
    {
        if (climbActive) {
            if (adjustingPlayerToSurfaceCollisionDetection) {
                return;
            }

            jumpInputUsed = true;

            setClimbActiveState (false);

            Vector3 totalForce = newImpulseOnJumpAmount.y * playerTransform.up + newImpulseOnJumpAmount.z * playerTransform.forward;

            mainPlayerController.useJumpPlatform (totalForce, ForceMode.Impulse);

            if (climbStateActivatedByInput) {
                setCheckIfDetectClimbActiveState (false);
            }

            rotateCharacterOnJump ();

            if (rotateCameraToPlayerRotationOnClimbActiveEnabled) {
                resetCameraRotation ();
            }
        }
    }

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

    public void setMovementInputDisabledOnSurfaceState (bool state)
    {
        movementInputDisabledOnSurface = state;
    }

    public void setCheckIfDetectClimbActiveState (bool state)
    {
        if (!climbEnabled) {
            return;
        }

        if (!climbCheckCanBeUsed) {
            return;
        }

        if (checkIfDetectClimbActive == state) {
            return;
        }

        if (mainPlayerController.isUseExternalControllerBehaviorPaused ()) {
            return;
        }

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

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

            eventBeforeCheckingForClimbStateActive.Invoke ();
        }

        bool checkIfDetectClimbActivePrevioulsy = checkIfDetectClimbActive;

        checkIfDetectClimbActive = state;

        if (checkIfDetectClimbActive) {
            //			externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();
            //			
            //			if (currentExternalControllerBehavior != null && currentExternalControllerBehavior != this) {
            //				currentExternalControllerBehavior.disableExternalControllerState ();
            //			}
            //
            mainPlayerController.setExternalControllerBehavior (this);
        } else {
            if (checkIfDetectClimbActivePrevioulsy) {
                externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();

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

        mainPlayerController.setFallDamageCheckPausedState (state);

        if (!checkIfDetectClimbActive) {
            setClimbActiveState (false);
        }

        if (checkIfDetectClimbActive) {
            eventOnCheckForClimbStateActive.Invoke ();
        } else {
            eventOnStopCheckForClimbStateActive.Invoke ();
        }

        if (!checkIfDetectClimbActive) {
            climbStateActivatedByInput = false;
        }

        //		if (checkIfDetectClimbActive) {
        //			if (activateClimbStateOnEnterTriggerClimbZone) {
        //				if (!ignoreActivateClimbStateOnEnterTriggerClimbZone) {
        //					setClimbActiveState (true);
        //
        //					climbStateActivatedByInput = true;
        //				}
        //
        //				activateClimbStateOnEnterTriggerClimbZone = false;
        //			}
        //		}
    }

    public void setClimbActiveState (bool state)
    {
        if (!climbEnabled) {
            return;
        }

        if (climbActive == state) {
            return;
        }


        if (state && climbPaused) {
            return;
        }

        climbActive = state;

        mainPlayerController.setAddExtraRotationPausedState (state);

        mainPlayerController.setExternalControlBehaviorForAirTypeActiveState (state);

        mainPlayerController.setFreeClimbActiveState (state);

        setBehaviorCurrentlyActiveState (state);

        setCurrentPlayerActionSystemCustomActionCategoryID ();

        bool playerOnGround = mainPlayerController.isPlayerOnGround ();

        if (state) {
            mainPlayerController.setCheckOnGroungPausedState (true);

            mainPlayerController.setPlayerOnGroundState (false);

            mainPlayerController.setPlayerOnGroundAnimatorStateOnOverrideOnGroundWithTime (false);

            mainPlayerController.overrideOnGroundAnimatorValue (0);

            mainPlayerController.setPlayerOnGroundAnimatorStateOnOverrideOnGround (false);

            mainPlayerController.setOnGroundAnimatorIDValue (false);

            mainPlayerController.setPlayerVelocityToZero ();

        } 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 || stopClimbToWalkOnSurfaceActive) {

                    mainPlayerController.setPlayerOnGroundState (true);

                    mainPlayerController.setOnGroundAnimatorIDValue (true);
                }
            }

            stopClimbToWalkOnSurfaceActive = false;
        }

        mainPlayerController.setFootStepManagerState (state);

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

        isFirstPersonActive = mainPlayerController.isPlayerOnFirstPerson ();

        if (climbActive) {
            checkEventsOnStateChange (true);

            if (!isFirstPersonActive) {
                bool playMainAction = true;

                if (checkIfClimbHangOnAirForAction) {
                    if (!playerOnGround) {
                        mainAnimator.SetInteger (actionIDAnimatorID, freeClimbHangFromAirActionID);

                        playMainAction = false;
                    }
                }

                if (checkIfClimbHangOnGroundForAction) {
                    if (playerOnGround) {
                        mainAnimator.SetInteger (actionIDAnimatorID, freeClimbHangFromGroundActionID);

                        playMainAction = false;
                    }
                }

                if (playMainAction) {
                    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);
                }
            }
        } else {
            checkEventsOnStateChange (false);

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

                mainAnimator.SetInteger (actionIDAnimatorID, 0);
            }

            //			mainPlayerCamera.setOriginalchangeCameraViewEnabledValue ();

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

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

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

        //		mainPlayerCamera.setPausePlayerCameraViewChangeState (climbActive);

        mainPlayerController.setLastTimeFalling ();

        mainPlayerCamera.stopShakeCamera ();

        mainPlayerController.setPauseCameraShakeFromGravityActiveState (state);

        if (!climbActive) {
            if (!jumpInputUsed) {
                if (playerTransform.up != getCurrentNormal ()) {
                    if (!climbingOnTopInProcess || isFirstPersonActive) {
                        resetPlayerRotation ();
                    }

                    if (rotateCameraToPlayerRotationOnClimbActiveEnabled) {
                        resetCameraRotation ();
                    }
                }
            }
        }

        climbingOnTopInProcess = false;

        setCameraState (state);

        jumpInputUsed = false;

        surfaceFoundOnSide = false;

        surfaceFoundOnCloseSide = false;

        lastClimbNormalValue = -Vector3.one;

        if (state) {
            eventOnClimbStateActive.Invoke ();
        } else {
            eventOnStopClimbStateActive.Invoke ();
        }

        if (state) {
            eventOnRegularClimbSpeed.Invoke ();

        } else {
            if (turboActive || increaseClimbSpeedActive) {
                mainPlayerController.setCurrentAirSpeedValue (1);

                turboActive = false;

                increaseClimbSpeedActive = false;
            }

            mainPlayerController.setOriginalAirIDValue ();
        }

        lowerBodySurfaceDetected = false;

        upperBodySurfaceDetected = false;

        surfaceDetectedAbovePlayer = false;

        surfafeDetectedBelowPlayer = false;

        lastTimeClimbActive = Time.time;

        resetAnimatorIDValue = state;

        if (activateClimbStateOnNextSurfaceDetectedActive) {
            setActivateClimbStateOnNextSurfaceDetectedActiveState (false);
        }

        if (state) {
            movementInputPausedActive = true;

            positionToAdjustPlayerToSurfaceCollision = Vector3.zero;

            if (!useRaycastDetectionToClimb) {
                adjustingPlayerToSurfaceCollisionDetection = true;
            }

            lastTimeCollisionDetectionWithSurfaceNotFound = 0;

            RaycastHit temporalHit;

            if (Physics.Raycast (playerTransform.position + playerTransform.up, playerTransform.forward, out temporalHit, raycastDistance, raycastLayermask)) {

                freeClimbZoneSystem currentFreeClimbZoneSystem = temporalHit.collider.GetComponent<freeClimbZoneSystem> ();

                if (currentFreeClimbZoneSystem != null) {
                    Transform newParent = currentFreeClimbZoneSystem.checkPlayerParentState ();

                    if (newParent != null) {
                        mainPlayerController.setPlayerAndCameraParent (newParent);

                        if (!useRaycastDetectionToClimb) {
                            mainClimbDetectionCollisionSystem.setNewParent (newParent);
                        }

                        playerParentAssigned = true;
                    }
                }
            }
        } else {
            if (playerParentAssigned) {
                mainPlayerController.setPlayerAndCameraParent (null);

                mainClimbDetectionCollisionSystem.setNewParent (null);
            }

            playerParentAssigned = false;

            movementInputDisabledOnSurface = false;

            adjustingPlayerToSurfaceCollisionDetection = false;
        }

        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            slidingDownActive = false;

            activateAutoSlideDownOnSurface = false;

            currentIDValue = -1;

            mainPlayerController.setCurrentIdleIDValue (0);

            mainPlayerController.updateIdleIDOnAnimator ();
        }

        if (state) {
            firstPersonChecked = isFirstPersonActive;

            thirdPersonChecked = !isFirstPersonActive;
        } else {
            firstPersonChecked = false;

            thirdPersonChecked = false;
        }

        mainPlayerController.setPausePlayerRotateToCameraDirectionOnFirstPersonActiveState (firstPersonChecked);

        if (!useRaycastDetectionToClimb) {
            mainClimbDetectionCollisionSystem.enableOrDisableClimbDetection (state);
        }

        bool isFullBodyAwarenessActive = mainPlayerCamera.isFullBodyAwarenessActive ();

        if (isFullBodyAwarenessActive) {
            mainPlayerCamera.setIgnorePlayerRotationToCameraOnFBAState (state);

            if (state) {
                mainPlayerCamera.setPivotCameraTransformParentCurrentTransformToFollow ();
            } else {
                mainPlayerCamera.setPivotCameraTransformOriginalParent ();

                mainPlayerCamera.resetPivotCameraTransformLocalRotation ();
            }
        }
    }

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

    public void setClimbEnabledState (bool state)
    {
        if (!state) {
            stopClimbAndDetectState ();
        }

        climbEnabled = state;
    }

    public void setClimbCheckCanBeUsedState (bool state)
    {
        climbCheckCanBeUsed = state;
    }

    public void setClimbEnabledState ()
    {
        setClimbEnabledState (originalClimbEnabled);
    }

    public void setOriginalClimbEnabledState ()
    {
        if (climbActive) {
            setCheckIfDetectClimbActiveState (false);
        }

        setClimbEnabledState (originalClimbEnabled);
    }

    //	public void setClimbDownSpeedMultiplier (float newValue)
    //	{
    //		slideDownSpeedMultiplier = newValue;
    //	}

    //	public void setForceSlowDownOnSurfaceActiveState (bool state)
    //	{
    //		forceSlowDownOnSurfaceActive = state;
    //	}

    public void enableCheckIfDetectClimbActiveStateExternally ()
    {
        if (checkIfDetectClimbActive) {
            return;
        }

        setCheckIfDetectClimbActiveState (true);
    }

    public void disableCheckIfDetectClimbActiveStateExternally ()
    {
        if (!checkIfDetectClimbActive) {
            return;
        }

        setCheckIfDetectClimbActiveState (false);
    }


    public override void checkIfResumeExternalControllerState ()
    {
        if (checkIfDetectClimbActive) {
            if (showDebugPrint) {
                print ("resuming free climb state");
            }

            externalControllerBehavior currentExternalControllerBehavior = mainPlayerController.getCurrentExternalControllerBehavior ();

            if (currentExternalControllerBehavior != null && currentExternalControllerBehavior != this) {
                currentExternalControllerBehavior.disableExternalControllerState ();
            }

            checkIfDetectClimbActive = false;

            setCheckIfDetectClimbActiveState (true);
        }
    }

    public override void disableExternalControllerState ()
    {
        setCheckIfDetectClimbActiveState (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 setClimbPausedState (bool state)
    {
        if (state) {
            if (climbActive) {
                stopClimbAndDetectState ();
            }
        }

        climbPaused = state;
    }

    public void rotateCharacterOnJump ()
    {
        stopRotateCharacterOnJumpCoroutine ();

        jumpCoroutine = StartCoroutine (rotateCharacterOnJumpCoroutine ());
    }

    void stopRotateCharacterOnJumpCoroutine ()
    {
        if (jumpCoroutine != null) {
            StopCoroutine (jumpCoroutine);
        }
    }

    public IEnumerator rotateCharacterOnJumpCoroutine ()
    {
        bool targetReached = false;

        float movementTimer = 0;

        float t = 0;

        float duration = 0;

        if (isFirstPersonActive) {
            duration = 0.5f / jumpRotationSpeedFirstPerson;
        } else {
            duration = 0.5f / jumpRotationSpeedThirdPerson;
        }

        float angleDifference = 0;

        Transform objectToRotate = playerTransform;

        if (isFirstPersonActive) {
            objectToRotate = playerCameraTransform;
        }

        Quaternion targetRotation = Quaternion.identity;

        if (playerTransform.up != getCurrentNormal ()) {
            Vector3 currentNormal = getCurrentNormal ();

            Quaternion currentPlayerRotation = playerTransform.rotation;
            Vector3 currentPlayerForward = Vector3.Cross (-playerTransform.right, currentNormal);
            Quaternion playerTargetRotation = Quaternion.LookRotation (currentPlayerForward, currentNormal);

            targetRotation = playerTargetRotation;
        } else {
            targetRotation = Quaternion.LookRotation (-objectToRotate.forward, objectToRotate.up);
        }

        while (!targetReached) {
            t += Time.deltaTime / duration;

            objectToRotate.rotation = Quaternion.Lerp (objectToRotate.rotation, targetRotation, t);

            angleDifference = Quaternion.Angle (objectToRotate.rotation, targetRotation);

            movementTimer += Time.deltaTime;

            if (angleDifference < 0.2f || 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);
            }
        }
    }

    public void resetPlayerRotation ()
    {
        stopResetPlayerRotationCoroutine ();

        resetPlayerCoroutine = StartCoroutine (resetPlayerRotationCoroutine ());
    }

    void stopResetPlayerRotationCoroutine ()
    {
        if (resetPlayerCoroutine != null) {
            StopCoroutine (resetPlayerCoroutine);
        }
    }

    IEnumerator resetPlayerRotationCoroutine ()
    {
        if (showDebugPrint) {
            print ("reset player rotation");
        }

        float movementTimer = 0;

        float t = 0;

        float duration = 1.5f;

        float angleDifference = 0;

        Vector3 currentNormal = getCurrentNormal ();

        Quaternion currentPlayerRotation = playerTransform.rotation;
        Vector3 currentPlayerForward = Vector3.Cross (playerTransform.right, currentNormal);
        Quaternion playerTargetRotation = Quaternion.LookRotation (currentPlayerForward, currentNormal);

        bool targetReached = false;

        while (!targetReached) {
            t += (Time.deltaTime / duration) * resetPlayerRotationSpeed;

            playerTransform.rotation = Quaternion.Slerp (playerTransform.rotation, playerTargetRotation, t);

            angleDifference = Quaternion.Angle (playerTransform.rotation, playerTargetRotation);

            movementTimer += Time.deltaTime;

            if (angleDifference < 0.01f || movementTimer > (duration + 1)) {
                targetReached = true;
            }

            yield return null;
        }
    }

    public void resetCameraRotation ()
    {
        stopResetCameraRotationCoroutine ();

        resetCameraCoroutine = StartCoroutine (resetCameraRotationCoroutine ());
    }

    void stopResetCameraRotationCoroutine ()
    {
        if (resetCameraCoroutine != null) {
            StopCoroutine (resetCameraCoroutine);
        }
    }

    IEnumerator resetCameraRotationCoroutine ()
    {
        if (showDebugPrint) {
            print ("reset camera rotation");
        }

        float movementTimer = 0;

        float t = 0;

        float duration = 1;

        float angleDifference = 0;

        Vector3 currentNormal = getCurrentNormal ();

        Quaternion currentCameraRotation = playerCameraTransform.rotation;
        Vector3 currentCameraForward = Vector3.Cross (playerCameraTransform.right, currentNormal);
        Quaternion cameraTargetRotation = Quaternion.LookRotation (currentCameraForward, currentNormal);

        bool targetReached = false;

        while (!targetReached) {
            t += (Time.deltaTime / duration) * resetPlayerRotationSpeed;

            playerCameraTransform.rotation = Quaternion.Slerp (playerCameraTransform.rotation, cameraTargetRotation, t);

            angleDifference = Quaternion.Angle (playerCameraTransform.rotation, cameraTargetRotation);

            movementTimer += Time.deltaTime;

            if (angleDifference < 0.01f || movementTimer > (duration + 1)) {
                targetReached = true;
            }

            yield return null;
        }
    }


    bool checkIfCanActivateClimbState ()
    {
        activateAutoSlideDownOnSurface = false;

        bool isPlayerOnGround = mainPlayerController.isPlayerOnGround ();

        if (!canActivateClimbOnPlayerOnGround) {
            if (isPlayerOnGround) {
                return false;
            }
        }

        float currentRaycastDistance = raycastDistanceToCheckToActivateClimbOnGround;

        if (!isPlayerOnGround) {
            currentRaycastDistance = raycastDistanceToCheckToActivateClimbOnAir;
        }

        Vector3 currentRaycastPosition = playerTransform.position + playerTransform.up;

        RaycastHit temporalHit;

        if (Physics.Raycast (currentRaycastPosition, playerTransform.forward, out temporalHit, currentRaycastDistance, raycastLayermask)) {
            bool surfaceDistanceTooFar = false;

            if (isPlayerOnGround) {
                if (temporalHit.distance > minDistanceToSurfaceToGrabSurfaceOnGround) {
                    surfaceDistanceTooFar = true;
                }
            } else {
                if (temporalHit.distance > minDistanceToSurfaceToGrabSurfaceOnAir) {
                    surfaceDistanceTooFar = true;
                }
            }

            if (surfaceDistanceTooFar) {

                if (showDebugPrint) {
                    print ("surface to climb too far");
                }

                return false;
            } else {
                if (useSurfacesToIgnoreTags) {
                    if (surfacesToIgnoreTagsList.Contains (temporalHit.collider.gameObject.tag)) {
                        if (showDebugPrint) {
                            print ("surface to ignore by tag found");
                        }

                        return false;
                    }
                }

                freeClimbZoneSystem currentFreeClimbZoneSystem = temporalHit.collider.GetComponent<freeClimbZoneSystem> ();

                if (checkTagsToIgnoreOnManualClimbInputActive) {
                    checkTagsToIgnoreOnManualClimbInputActive = false;

                    if (useSurfacesToCheckTagsOnClimbByInput) {
                        if (!surfacesToCheckTagsOnClimbByInputList.Contains (temporalHit.collider.gameObject.tag)) {
                            if (showDebugPrint) {
                                print ("surface to check by tag not found " + temporalHit.collider.gameObject.tag);
                            }

                            if (checkForClimbSurfaceZoneSystemOnClimbInput) {
                                if (currentFreeClimbZoneSystem != null) {
                                    if (!currentFreeClimbZoneSystem.isAllowClimbSurfaceOnInputEnabled ()) {
                                        return false;
                                    }
                                } else {
                                    return false;
                                }

                            } else {
                                return false;
                            }
                        }
                    }
                }

                if (ignoreRigidbodies) {
                    if (temporalHit.collider.attachedRigidbody != null) {
                        return false;
                    }
                }

                if (currentFreeClimbZoneSystem != null) {
                    if (currentFreeClimbZoneSystem.isIgnoreSurfaceToClimbEnabled ()) {
                        return false;
                    }

                    if (currentFreeClimbZoneSystem.activateAutoSlideDownOnSurface) {
                        activateAutoSlideDownOnSurface = true;
                    }
                }

                if (currentFreeClimbZoneSystem != null) {
                    movementInputDisabledOnSurface = currentFreeClimbZoneSystem.movementInputDisabledOnSurface;
                }
            }
        } else {
            if (showDebugPrint) {
                print ("surface to climb not found");
            }

            return false;
        }

        if (Physics.Raycast (currentRaycastPosition, playerTransform.forward, out temporalHit, currentRaycastDistance, raycastLayermask)) {
            surfaceAngle = Vector3.SignedAngle (temporalHit.normal, -playerTransform.forward, playerTransform.right);
        }

        if (showDebugPrint) {
            print ("surface angle to check before activate climb " + surfaceAngle);
        }

        if (surfaceAngle != 0) {
            if (stopClimbAtMinAngleOnSurface) {
                if (surfaceAngle < 0) {
                    if (surfaceAngle < minAngleToStopClimb) {
                        return false;
                    }
                }
            }

            if (stopClimbAtMaxAngleOnSurface) {
                if (surfaceAngle > 0) {
                    if (surfaceAngle > maxAngleToStopClimb) {
                        return false;
                    }
                }
            }
        }

        return true;
    }


    public void setActivateClimbStateOnNextSurfaceDetectedActiveState (bool state)
    {
        if (ignoreActivateClimbStateOnNextSurfaceDetectedActive) {
            return;
        }

        activateClimbStateOnNextSurfaceDetectedActive = state;

        if (showDebugPrint) {
            print ("setting activateClimbStateOnNextSurfaceDetectedActive " + activateClimbStateOnNextSurfaceDetectedActive);
        }

        stopCheckIfSurfaceDetectedInFrontCoroutine ();

        if (activateClimbStateOnNextSurfaceDetectedActive) {
            lastTimeActivateClimbStateOnNextSurfaceDetectedActive = Time.time;

            checkIfSurfaceDetectedInFrontCoroutine = StartCoroutine (updateCheckIfSurfaceDetectedInFrontCoroutine ());
        }
    }

    public void stopCheckIfSurfaceDetectedInFrontCoroutine ()
    {
        if (checkIfSurfaceDetectedInFrontCoroutine != null) {
            StopCoroutine (checkIfSurfaceDetectedInFrontCoroutine);
        }
    }

    IEnumerator updateCheckIfSurfaceDetectedInFrontCoroutine ()
    {
        var waitTime = new WaitForSeconds (0.00001f);

        while (true) {
            if (Time.time > lastTimeActivateClimbStateOnNextSurfaceDetectedActive + 0.5f) {
                if (mainPlayerController.isPlayerOnGround ()) {
                    stopCheckIfSurfaceDetectedInFrontCoroutine ();

                    activateClimbStateOnNextSurfaceDetectedActive = false;

                    if (showDebugPrint) {
                        print ("disabling activateClimbStateOnNextSurfaceDetectedActive");
                    }
                }

                if (climbActive) {
                    stopCheckIfSurfaceDetectedInFrontCoroutine ();

                    activateClimbStateOnNextSurfaceDetectedActive = false;

                    if (showDebugPrint) {
                        print ("disabling activateClimbStateOnNextSurfaceDetectedActive");
                    }
                }
            }

            if (Time.time > lastTimeActivateClimbStateOnNextSurfaceDetectedActive + 5) {
                if (showDebugPrint) {
                    print ("disabling activateClimbStateOnNextSurfaceDetectedActive from too much time on air");
                }

                stopCheckIfSurfaceDetectedInFrontCoroutine ();

                activateClimbStateOnNextSurfaceDetectedActive = false;
            }

            if (Physics.Raycast (playerTransform.position + (verticalRaycastOffset * playerTransformUp),
                    playerTransform.forward, minDistanceToSurfaceToGrabSurfaceOnAir, raycastLayermask)) {

                inputGrabSurface ();

                stopCheckIfSurfaceDetectedInFrontCoroutine ();

                activateClimbStateOnNextSurfaceDetectedActive = false;

                if (showDebugPrint) {
                    print ("activating climb from detecting next surface");
                }
            }

            yield return waitTime;
        }
    }


    public void activateGrabSurface ()
    {
        if (checkIfDetectClimbActive) {
            if (!climbActive) {
                if (!checkIfCanActivateClimbState ()) {
                    return;
                }
            }

            if (activateClimbStateOnNextSurfaceDetectedActive) {
                setActivateClimbStateOnNextSurfaceDetectedActiveState (false);
            }

            setClimbActiveState (!climbActive);
        }
    }

    void checkEventsOnTurbo (bool state)
    {
        if (useEventOnTurbo) {
            if (state) {
                eventOnStartTurbo.Invoke ();
            } else {
                eventOnEndTurbo.Invoke ();
            }
        }
    }

    #region UpdateRaycastDetection

    //REGULAR RAYCAST DETECTION METHOD
    bool updateRaycastDetectionState (Vector3 currentRaycastPosition, Vector3 currentRaycastDirection, float currentFixedUpdateDeltaTime)
    {
        surfaceFoundOnRegularRaycast = false;

        float currentRaycastDistance = raycastDistance;

        if (surfaceFoundOnSide || surfaceFoundOnCloseSide) {
            Vector3 heading = lastSideDirection - (playerTransform.position + playerTransformUp);

            float distance = heading.magnitude;

            currentRaycastDirection = heading / distance;

            currentRaycastDistance = raycastDistance * 2;
        }

        float regularRaycastDistance = currentRaycastDistance;

        if (movementInputPausedActive) {
            regularRaycastDistance += 1;
        }

        if (Physics.Raycast (playerTransform.position + (verticalRaycastOffset * playerTransformUp),
                currentRaycastDirection, regularRaycastDistance, raycastLayermask)) {

            surfaceFoundOnRegularRaycast = true;
        }

        Vector3 mainRaycastPosition = playerTransform.position + playerTransformUp;

        Physics.Raycast (mainRaycastPosition, currentRaycastDirection, out hit, regularRaycastDistance, raycastLayermask);


        //check sides with raycast
        if (checkSidesEnabled) {
            RaycastHit temporalHit;

            if (!surfaceFoundOnCloseSide && !upperBodySurfaceDetected) {
                if (!surfaceFoundOnSide) {
                    if (!Physics.Raycast (currentRaycastPosition, currentRaycastDirection, out temporalHit,
                            raycastDistanceToCheckSides, raycastLayermask)) {

                        bool movingRight = currentHorizontalMovement > 0;

                        bool movingLeft = currentHorizontalMovement < 0;

                        Vector3 newRaycastDirection = playerTransform.forward;

                        if (movingRight || movingLeft) {
                            if (movingRight) {
                                newRaycastDirection = Quaternion.AngleAxis (-45, Vector3.up) * newRaycastDirection;

                                currentRaycastPosition = playerTransform.position + playerTransform.right + playerTransformUp;

                            } else {
                                newRaycastDirection = Quaternion.AngleAxis (45, Vector3.up) * newRaycastDirection;

                                currentRaycastPosition = playerTransform.position - playerTransform.right + playerTransformUp;
                            }
                        }

                        if (showGizmo) {
                            Debug.DrawRay (currentRaycastPosition, 4 * newRaycastDirection, Color.red, 5);
                        }

                        if (Physics.Raycast (currentRaycastPosition, newRaycastDirection, out hit, raycastDistance * 3, raycastLayermask)) {
                            surfaceFoundOnRegularRaycast = true;

                            surfaceFoundOnSide = true;

                            lastSideDirection = hit.point;

                            lastSideNormal = hit.normal;

                            if (showGizmo) {
                                Debug.DrawRay (currentRaycastPosition, 20 * newRaycastDirection, Color.black, 5);
                            }
                        }
                    }
                }
            }
        }


        //check close sides with raycast
        if (checkCloseSidesEnabled) {
            if (!surfaceFoundOnCloseSide) {
                bool movingRight = currentHorizontalMovement > 0;

                bool movingLeft = currentHorizontalMovement < 0;

                if (movingRight) {
                    currentRaycastDirection = playerTransform.right;
                } else {
                    currentRaycastDirection = -playerTransform.right;
                }

                if (movingLeft || movingRight) {
                    currentRaycastPosition = playerTransform.position + playerTransformUp;

                    RaycastHit temporalHit;

                    if (Physics.Raycast (currentRaycastPosition, currentRaycastDirection, out temporalHit, raycastDistanceToCheckCloseSides, raycastLayermask)) {

                        surfaceFoundOnRegularRaycast = true;

                        surfaceFoundOnCloseSide = true;

                        lastSideDirection = temporalHit.point;

                        lastSideNormal = temporalHit.normal;

                        hit = temporalHit;

                        surfaceFoundOnSide = false;
                    }
                }
            }
        }

        //check change of view state
        updateCheckCameraViewState ();

        currentClimbMovementSpeed = climbMovementSpeedThirdPerson;

        if (isFirstPersonActive) {
            currentClimbMovementSpeed = climbMovementSpeedFirstPerson;
        }

        currentClimbRotationSpeed = climbRotationSpeedThirdPerson;

        if (isFirstPersonActive) {
            currentClimbRotationSpeed = climbRotationSpeedFirstPerson;
        }

        currentClimbVelocity = climbVelocityThirdPerson;

        if (isFirstPersonActive) {
            currentClimbVelocity = climbVelocityFirstPerson;
        }

        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            currentClimbVelocity = slideDownSpeedThirdPerson;

            if (isFirstPersonActive) {
                currentClimbVelocity = SlideDownSpeedFirstPerson;
            }
        }

        if (movementInputPausedActive || movementInputDisabledOnSurface) {
            rawAxisValues = Vector2.zero;
        }

        checkCurrentSurfaceDetected ();

        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            if (!movementInputPausedActive && !cancelMovementInputActive && lowerBodySurfaceDetected && surfaceDetectedOnMovementInputRaycast) {
                currentVerticalMovement = -1;

                rawAxisValues.y = currentVerticalMovement;

                if (currentHorizontalMovement != 0) {
                    currentHorizontalMovement /= 2;
                }
            }
        }

        if (cancelMovementInputActive) {
            currentVerticalMovement = 0;

            currentHorizontalMovement = 0;

            rawAxisValues = Vector2.zero;
        }

        if (!lowerBodySurfaceDetected) {
            if (!surfaceDetectedOnMovementInputRaycast) {
                currentVerticalMovement = 0;

                rawAxisValues.y = 0;
            }
        }

        if (surfaceDetectedAbovePlayer) {
            currentVerticalMovement = Mathf.Clamp (currentVerticalMovement, -1, 0);

            rawAxisValues.y = Mathf.Clamp (rawAxisValues.y, -1, 0);
        }

        if (surfafeDetectedBelowPlayer) {
            currentVerticalMovement = Mathf.Clamp (currentVerticalMovement, 0, 1);

            rawAxisValues.y = Mathf.Clamp (rawAxisValues.y, 0, 1);
        }

        slidingDownResult = false;

        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            if (currentVerticalMovement != 0) {
                if (currentIDValue != 1) {
                    currentIDValue = 1;

                    mainPlayerController.setCurrentIdleIDValue (currentIDValue);

                    mainPlayerController.updateIdleIDOnAnimator ();
                }

                slidingDownResult = true;
            } else {
                if (currentIDValue != 0) {
                    currentIDValue = 0;

                    mainPlayerController.setCurrentIdleIDValue (currentIDValue);

                    mainPlayerController.updateIdleIDOnAnimator ();
                }
            }
        } else {
            if (currentIDValue != 0) {
                currentIDValue = 0;

                mainPlayerController.setCurrentIdleIDValue (currentIDValue);

                mainPlayerController.updateIdleIDOnAnimator ();
            }
        }


        moving = (Mathf.Abs (currentVerticalMovement) > 0.01f || Mathf.Abs (currentHorizontalMovement) > 0.01f);

        movementInputPressed = rawAxisValues != Vector2.zero;

        currentClimbTurboSpeed = 1;

        bool enougMovementInput = (Mathf.Abs (currentVerticalMovement) > 0.7f || Mathf.Abs (currentHorizontalMovement) > 0.7f);

        if (increaseClimbSpeedActive && movementInputPressed && enougMovementInput && !slidingDownActive && !activateAutoSlideDownOnSurface) {
            currentClimbTurboSpeed = climbTurboSpeed;

            if (!turboActive) {
                mainPlayerController.setCurrentAirSpeedValue (2);

                turboActive = true;

                checkEventsOnTurbo (true);
            }
        } else {
            if (turboActive) {
                mainPlayerController.setCurrentAirSpeedValue (1);

                turboActive = false;

                mainPlayerController.stopShakeCamera ();

                checkEventsOnTurbo (false);

                eventOnRegularClimbSpeed.Invoke ();
            }
        }


        //update player velocity
        if (surfaceFoundOnRegularRaycast) {
            Vector3 targetPosition = hit.point + surfaceOffset * hit.normal;

            targetPosition -= playerTransformUp;

            if (useMovementCurve) {
                currentClimbMovementSpeed = mainMovementCurve.Evaluate (currentClimbMovementSpeed);
            }

            bool closeToSurfaceDetected = GKC_Utils.distance (mainRigidbody.position, targetPosition) > 0.01f;

            if (movementInputPressed || closeToSurfaceDetected || movementInputPausedActive) {
                mainRigidbody.position = Vector3.Lerp (mainRigidbody.position, targetPosition, currentClimbTurboSpeed * currentClimbMovementSpeed * currentFixedUpdateDeltaTime);
            }
        }

        if (surfaceFoundOnRegularRaycast || surfaceFoundOnSide || surfaceFoundOnCloseSide) {

            Vector2 axisValues = new Vector2 (currentHorizontalMovement, currentVerticalMovement);

            if (useVelocityCurve) {
                currentClimbVelocity = mainVelocityCurve.Evaluate (currentClimbVelocity);
            }

            if (movementInputPressed) {
                mainRigidbody.linearVelocity = currentClimbVelocity * currentClimbTurboSpeed * playerTransform.TransformDirection (axisValues);
            }
        }

        if (movementInputPressed || surfaceFoundOnSide || surfaceFoundOnCloseSide) {
            mainPlayerController.setCurrentVelocityValue (mainRigidbody.linearVelocity);
        } else {
            mainPlayerController.setCurrentVelocityValue (Vector3.zero);
        }


        if (slidingDownActive || activateAutoSlideDownOnSurface) {
            if (slidingDownResult) {
                currentVerticalMovement = 0;
            }
        }

        //update player animation states
        mainAnimator.SetFloat (horizontalAnimatorID, currentHorizontalMovement, inputLerpSpeed, currentFixedUpdateDeltaTime);
        mainAnimator.SetFloat (verticalAnimatorID, currentVerticalMovement, inputLerpSpeed, currentFixedUpdateDeltaTime);



        //update player rotation
        currentRaycastPosition = playerTransform.position + playerTransformUp;

        currentRaycastDirection = playerTransform.forward;

        currentRaycastDistance = raycastDistance;

        if (surfaceFoundOnSide || surfaceFoundOnCloseSide) {

            currentRaycastDirection = lastSideDirection - (playerTransform.position + playerTransformUp);

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

            float currentClimbAngle = Vector3.SignedAngle (playerTransform.up, getCurrentNormal (), playerTransform.right);

            if (Mathf.Abs (currentClimbAngle) > 3) {
                currentRaycastDistance += 4;
            } else {
                currentRaycastDistance += 2;
            }
        }

        if (Physics.Raycast (currentRaycastPosition, currentRaycastDirection, out hit, currentRaycastDistance, raycastLayermask)) {
            Quaternion targetRotation = Quaternion.LookRotation (-hit.normal);

            playerTransform.rotation = Quaternion.Lerp (playerTransform.rotation, targetRotation, currentClimbRotationSpeed * currentFixedUpdateDeltaTime);

            if (rotateCameraToPlayerRotationOnClimbActiveEnabled) {
                Vector3 myForwardCamera = Vector3.Cross (playerCameraTransform.right, playerTransform.up);
                Quaternion dstRotCamera = Quaternion.LookRotation (myForwardCamera, playerTransform.up);

                playerCameraTransform.rotation = Quaternion.Lerp (playerCameraTransform.rotation, dstRotCamera, currentClimbRotationSpeed * currentFixedUpdateDeltaTime);
            }

            if (surfaceFoundOnSide) {
                float temporalAngle = Vector3.SignedAngle (lastSideNormal, -playerTransform.forward, playerTransform.up);

                if (Mathf.Abs (temporalAngle) < 2) {
                    surfaceFoundOnSide = false;
                }
            }

            if (surfaceFoundOnCloseSide) {
                float temporalAngle = Vector3.SignedAngle (lastSideNormal, -playerTransform.forward, playerTransform.up);

                if (Mathf.Abs (temporalAngle) < 2) {
                    surfaceFoundOnCloseSide = false;
                }
            }

            if (showGizmo) {
                Debug.DrawRay (currentRaycastPosition, currentRaycastDistance * currentRaycastDirection, Color.gray, 5);
            }
        } else {
            if (showGizmo) {
                Debug.DrawRay (currentRaycastPosition, currentRaycastDistance * currentRaycastDirection, Color.magenta, 5);
            }
        }


        //check if surface not found, to stop the climb action
        if (!surfaceFoundOnSide && !surfaceFoundOnCloseSide && !movementInputPausedActive) {

            currentRaycastPosition = playerTransform.position + offsetToCheckIfStopClimbStateOnRaycast * playerTransformUp;

            if (!Physics.Raycast (currentRaycastPosition, playerTransform.forward, maxRaycastDistanceToStopClimb, raycastLayermask)) {
                if (lastTimeSurfaceNotFound == 0) {

                    lastTimeSurfaceNotFound = Time.time;
                }
            } else {
                if (showGizmo) {
                    Debug.DrawRay (currentRaycastPosition, 2 * playerTransform.forward, Color.yellow);
                }

                lastTimeSurfaceNotFound = 0;
            }

            if (lastTimeSurfaceNotFound > 0) {
                if (Time.time > lastTimeSurfaceNotFound + minTimeToStopClimbIfNotSurfaceFound) {
                    lastTimeSurfaceNotFound = 0;

                    stopClimbAndDetectState ();

                    return false;
                }
            }
        }

        return true;
    }

    #endregion

    //Input functions
    public void inputSetSlideDownState (bool state)
    {
        if (!climbActive) {
            return;
        }

        if (!slideDownEnabled) {
            return;
        }

        if (!canUseInput ()) {
            return;
        }

        if (activateAutoSlideDownOnSurface) {
            return;
        }

        if (adjustingPlayerToSurfaceCollisionDetection) {
            return;
        }

        if (slidingDownActive == state) {
            return;
        }

        slidingDownActive = state;

        currentIDValue = -1;
    }

    public void inputGrabSurface ()
    {
        if (!canUseInput ()) {

            if (showDebugPrint) {
                print ("can't use input grab surface");
            }

            return;
        }

        if (climbPaused) {
            return;
        }

        if (!climbActive) {
            if (Time.time < mainPlayerController.getLastTimeActionActive () + minWaitTimeSinceLastTimeActionActiveToClimb) {
                return;
            }
        }

        if (adjustingPlayerToSurfaceCollisionDetection) {
            return;
        }

        if (activateClimbStateDirectlyOnPressInput) {
            if (checkIfDetectClimbActive) {
                setCheckIfDetectClimbActiveState (false);

                climbStateActivatedByInput = false;
            } else {
                checkTagsToIgnoreOnManualClimbInputActive = true;

                if (checkIfCanActivateClimbState ()) {
                    setCheckIfDetectClimbActiveState (true);

                    activateGrabSurface ();

                    climbStateActivatedByInput = true;
                }

                checkTagsToIgnoreOnManualClimbInputActive = false;
            }
        } else {
            activateGrabSurface ();
        }
    }

    public void inpuSetIncreaseClimbSpeedState (bool state)
    {
        if (!climbActive) {
            return;
        }

        if (!slideDownEnabled) {
            return;
        }

        if (!canUseInput ()) {
            return;
        }

        if (adjustingPlayerToSurfaceCollisionDetection) {
            return;
        }

        if (activateAutoSlideDownOnSurface) {
            return;
        }

        if (increaseClimbSpeedActive == state) {
            return;
        }

        increaseClimbSpeedActive = state;
    }

    bool canUseInput ()
    {
        if (mainPlayerController.isGravityPowerActive ()) {
            return false;
        }

        if (mainPlayerController.isPlayerUsingPowers ()) {
            return false;
        }

        if (mainPlayerController.isUsingDevice ()) {
            return false;
        }

        if (mainPlayerController.isPlayerDead ()) {
            return false;
        }

        if (mainPlayerController.isPlayerMenuActive ()) {
            return false;
        }

        if (mainPlayerController.isUsingSubMenu ()) {
            return false;
        }

        if (mainPlayerController.isActionActive ()) {
            return false;
        }

        if (mainPlayerController.isPlayerDriving ()) {
            return false;
        }

        return true;
    }

    public void setClimbEnabledStateFromEditor (bool state)
    {
        setClimbEnabledState (state);

        updateComponent ();
    }

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

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