FueraDeEscala/Assets/Game Kit Controller/Scripts/Weapons/IKWeaponSystem.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.IO;

public class IKWeaponSystem : weaponObjectInfo
{
    public IKWeaponInfo thirdPersonWeaponInfo;
    public IKWeaponInfo firstPersonWeaponInfo;

    public weaponSwayInfo firstPersonSwayInfo;
    public weaponSwayInfo runFirstPersonSwayInfo;
    public weaponSwayInfo thirdPersonSwayInfo;
    public weaponSwayInfo runThirdPersonSwayInfo;

    public bool useShotShakeInFirstPerson;
    public bool useShotShakeInThirdPerson;
    public bool sameValueBothViews;
    public weaponShotShakeInfo thirdPersonshotShakeInfo;
    public weaponShotShakeInfo firstPersonshotShakeInfo;

    public weaponShotShakeInfo thirdPersonMeleeAttackShakeInfo;
    public weaponShotShakeInfo firstPersonMeleeAttackShakeInfo;

    public GameObject weaponPrefabModel;
    public GameObject inventoryWeaponPrefabObject;

    public GameObject weaponGameObject;

    public GameObject firstPersonArms;

    public bool disableOnlyFirstPersonArmsMesh;

    public SkinnedMeshRenderer firstPersonArmsMesh;

    public List<SkinnedMeshRenderer> extraFirstPersonArmsMeshes = new List<SkinnedMeshRenderer> ();

    public bool useWeaponAnimatorFirstPerson;
    public weaponAnimatorSystem mainWeaponAnimatorSystem;

    public bool headLookWhenAiming;
    public float headLookSpeed;
    public Transform headLookTarget;

    public bool canAimInFirstPerson;
    public bool currentWeapon;
    public bool aiming;
    public bool carrying;
    public float extraRotation;
    public float aimFovValue;
    public float aimFovSpeed;
    public bool weaponEnabled;

    public bool useWeaponIdle;
    public float timeToActiveWeaponIdle = 3;
    public bool playerMoving;
    float lastTimePlayerMoving;

    float horizontalABS;
    float verticalABS;
    float mouseXABS;
    float mouseYABS;

    public Vector3 idlePositionAmount;
    public Vector3 idleRotationAmount;
    public Vector3 idleSpeed;
    public bool idleActive;
    public bool showIdleSettings;

    public bool useLowerRotationSpeedAimed;
    public float verticalRotationSpeedAimedInFirstPerson = 4;
    public float horizontalRotationSpeedAimedInFirstPerson = 4;

    public bool useLowerRotationSpeedAimedThirdPerson;
    public float verticalRotationSpeedAimedInThirdPerson = 4;
    public float horizontalRotationSpeedAimedInThirdPerson = 4;

    public GameObject player;
    public bool moving;
    public playerWeaponSystem weaponSystemManager;
    public playerWeaponsManager weaponsManager;
    public Transform weaponTransform;

    public string relativePathWeaponsPickups = "";
    public GameObject emtpyWeaponPrefab;

    public string relativePathWeaponsMesh = "";
    public string relativePathWeaponsAmmoMesh = "";

    public LayerMask layer;
    public bool surfaceDetected;

    public bool useShotCameraNoise;
    public Vector2 verticalShotCameraNoiseAmountFirstPerson;
    public Vector2 horizontalShotCameraNoiseAmountFirstPerson;
    public Vector2 verticalShotCameraNoiseAmountThirdPerson;
    public Vector2 horizontalShotCameraNoiseAmountThirdPerson;

    public bool useShotCameraNoiseDuration;

    public float shotCameraNoiseDuration;

    public bool hideWeaponIfKeptInThirdPerson;

    public bool canBeDropped = true;

    public bool canUnlockCursor;
    public bool canUnlockCursorOnThirdPerson;
    public bool disableHUDWhenCursorUnlocked;

    public bool weaponInRunPosition;
    bool useRunPositionThirdPerson;
    bool useRunPositionFirstPerson;

    bool useRunPositionFBA;

    public bool playerRunning;
    bool useNewFovOnRunThirdPerson;
    bool useNewFovOnRunFirstPerson;

    public bool weaponConfiguredAsDualWeapon;
    public string linkedDualWeaponName;
    bool weaponConfiguredAsDualWeaponPreviously;

    public Transform rightHandMountPoint;
    public Transform leftHandMountPoint;

    public Vector3 extraColliderCenterOnFireWeaponOnFBA;
    public Vector3 extraColliderScaleOnFireWeaponOnFBA;

    Transform newWeaponParent;

    bool cursorHidden;

    Coroutine weaponMovement;

    Vector3 weaponPositionTarget;
    Quaternion weaponRotationTarget;
    List<Transform> inverseKeepPath = new List<Transform> ();
    List<Transform> currentKeepPath = new List<Transform> ();

    Transform weaponSwayTransform;
    Vector3 swayPosition;
    Vector3 swayExtraPosition;
    Quaternion swayTargetRotation;
    Vector3 mainSwayTargetPosition;
    Vector3 currentSwayPosition;

    Vector3 swayRotation;
    Vector3 swayTilt;
    float swayPositionRunningMultiplier = 1;
    float swayRotationRunningMultiplier = 1;
    float bobPositionRunningMultiplier = 1;
    float bobRotationRunningMultiplier = 1;

    float currentSwayRotationSmooth;
    float currentSwayPositionSmooth;

    bool usingPositionSway;
    bool usingRotationSway;
    Coroutine swayValueCoroutine;
    bool resetingWeaponSwayValue;

    bool weaponSwayPaused;

    float lastTimeMoved = 0;
    RaycastHit hit;

    bool carryingWeapon;
    float currentRecoilSpeed;

    bool editingAttachments;

    bool weaponOnRecoil;
    public weaponAttachmentSystem mainWeaponAttachmentSystem;
    public bool weaponUsesAttachment;

    public bool ignoreUseAttachmentSystem;

    public bool jumpingOnProcess;
    bool weaponInJumpStart;
    bool weaponInJumpEnd;

    bool drawingWeaponInProcess;
    bool holsteringWeaponInProcess;

    bool canRunWhileCarrying;
    bool canRunWhileAiming;

    bool useNewCarrySpeed;
    float newCarrySpeed;
    bool useNewAimSpeed;
    float newAimSpeed;

    float timeToCheckSurfaceCollision = 0.4f;

    Transform currentAimPositionTransform;
    Transform currentDrawPositionTransform;
    Transform currentCollisionPositionTransform;
    Transform currentCollisionRayPositionTransform;
    Transform currentWalkOrRunPositionTransform;
    Transform currentJumpPositionTransform;
    Transform currentCrouchPositionTransform;
    Transform currentMeleeAttackPositionTransform;
    Transform currentEditAttachmentPositionTransform;
    Transform currentReloadPosition;

    bool currentlyUsingSway;

    bool meleeAtacking;

    Transform currentAimRecoilPositionTransform;

    Vector3 recoilExtraPosition;
    Vector3 recoilRandomPosition;
    Vector3 recoilExtraRotatation;
    Vector3 recoilRandomRotation;

    Coroutine handAttachmentCoroutine;

    public bool usingWeaponRotationPoint;
    public Transform currentHeadLookTarget;

    bool startInitialized;

    float timeToCheckRunPosition = 0.4f;

    public bool usingDualWeapon;

    public bool disablingDualWeapon;

    public bool usingRightHandDualWeapon;

    public bool playerOnJumpStart;
    public bool playerOnJumpEnd;

    IKWeaponsPosition currentIKWeaponsPosition;

    IKWeaponsPosition currentGizmoIKWeaponPosition;

    Transform mainWeaponMeshTransform;

    float currentCollisionRayDistance;

    public bool crouchingActive;

    bool useBezierCurve;
    BezierSpline spline;
    float bezierDuration;
    float lookDirectionSpeed;

    bool aimingWeaponInProcess;

    public bool reloadingWeapon;

    public bool actionActive;

    weaponSwayInfo currentSwayInfo;

    bool currentSwayInfoAssigned;

    Transform previousParentBeforeActivateAction;

    Coroutine actionCoroutine;

    public bool weaponObjectActive = true;

    public bool IKPausedOnHandsActive;

    //Gizmo variables
    public bool showThirdPersonGizmo;
    public bool showFirstPersonGizmo;

    public bool showMainWeaponPositionsGizmo;

    public bool showCollisionDetectionGizmo;

    public bool showEditAttachmentGizmo;

    public bool showFBAGizmo;
    public bool showFBAWalkGizmo;
    public bool showFBAAimGizmo;
    public bool showFBACrouchGizmo;
    public bool showFBAJumpGizmo;

    public bool showFBARunGizmo;
    public bool showFBAObstacleGizmo;

    public Color gizmoLabelColor;

    public bool showHandsWaypointGizmo = true;
    public bool showWeaponWaypointGizmo = true;
    public bool showPositionGizmo = true;

    public bool showThirdPersonSettings;
    public bool showFirstPersonSettings;
    public bool showShotShakeSettings;
    public bool showSettings;
    public bool showElementSettings;

    public bool showSwaySettings;
    public bool showWalkSwaySettings;
    public bool showRunSwaySettings;

    public bool showFullBodyAwarernessSettings;

    public bool showPrefabSettings;

    public bool showShotCameraNoiseSettings;

    bool componentsInitialized;

    bool weaponRotationPointHolderInitialized;

    public GameObject weaponAmmoMesh;
    public Texture weaponAmmoIconTexture;
    public string inventoryAmmoCategoryName = "Ammo";
    public int ammoAmountPerPickup = 10;
    public string inventoryWeaponCategoryName = "Weapons";
    public string weaponName = "New Weapon Name";

    string customAmmoDescription;

    Texture weaponIconTexture;

    string weaponDescription;

    float objectWeight;

    bool canBeSold = true;

    float vendorPrice = 1000;

    float sellPrice = 500;

    public bool useDurability;
    public float durabilityAmount;
    public float maxDurabilityAmount;

    public bool setNewAnimatorWeaponID;
    public int newAnimatorWeaponID;

    public bool setNewAnimatorDualWeaponID = true;
    public int newAnimatorDualWeaponID = 0;

    public bool setUpperBodyBendingMultiplier;
    public float horizontalBendingMultiplier = 1;
    public float verticalBendingMultiplier = 1;


    public bool followFullRotationPointDirection;

    public Vector2 followFullRotationClampX = new Vector2 (80, 80);
    public Vector2 followFullRotationClampY = new Vector2 (40, 1);
    public Vector2 followFullRotationClampZ = new Vector2 (80, 80);


    public bool setNewAnimatorCrouchID;
    public int newAnimatorCrouchID;

    public bool ignoreCrouchWhileWeaponActive = true;

    public bool pivotPointRotationActive = true;

    public bool useNewMaxAngleDifference;
    public float horizontalMaxAngleDifference = 90;
    public float verticalMaxAngleDifference = 90;


    Vector3 currentFBAWalkPositionOffset;
    Vector3 currentFBAWalkRotationOffset;

    Vector3 currentFBAWalkRecoilPositionOffset;
    Vector3 currentFBAWalkRecoilRotationOffset;

    Vector3 currentFBARunPositionOffset;
    Vector3 currentFBARunRotationOffset;

    Vector3 currentFBAAimPositionOffset;
    Vector3 currentFBAAimRotationOffset;

    Vector3 currentFBAAimRecoilPositionOffset;
    Vector3 currentFBAAimRecoilRotationOffset;

    Vector3 currentFBACrouchPositionOffset;
    Vector3 currentFBACrouchRotationOffset;

    Vector3 currentFBACrouchRecoilPositionOffset;
    Vector3 currentFBACrouchRecoilRotationOffset;

    Vector3 currentFBAJumpStartPositionOffset;
    Vector3 currentFBAJumpStartRotationOffset;

    Vector3 currentFBAJumpEndPositionOffset;
    Vector3 currentFBAJumpEndRotationOffset;

    Vector3 currentFBAObstaclePositionOffset;
    Vector3 currentFBAObstacleRotationOffset;


    bool overrideFBAValuesForOffset;

    void Start ()
    {
        initializeComponents ();
    }

    public void initializeComponents ()
    {
        if (componentsInitialized) {
            return;
        }

        mainWeaponMeshTransform = weaponSystemManager.weaponSettings.weaponMesh.transform;

        if (thirdPersonWeaponInfo.useWeaponRotationPoint) {
            checkWeaponRotationPointHolderInitialized ();
        }

        weaponsManagerLocated = weaponsManager != null;

        setCurrentSwayInfo (true);

        thirdPersonWeaponInfo.InitializeAudioElements ();
        firstPersonWeaponInfo.InitializeAudioElements ();

        weaponTransform = weaponGameObject.transform;
        thirdPersonWeaponInfo.weapon = weaponGameObject;
        firstPersonWeaponInfo.weapon = weaponGameObject;

        useRunPositionThirdPerson = thirdPersonWeaponInfo.useRunPosition;
        useRunPositionFirstPerson = firstPersonWeaponInfo.useRunPosition;

        useRunPositionFBA = thirdPersonWeaponInfo.useFBARunPosition;

        useNewFovOnRunThirdPerson = thirdPersonWeaponInfo.useNewFovOnRun;
        useNewFovOnRunFirstPerson = firstPersonWeaponInfo.useNewFovOnRun;

        usingWeaponRotationPoint = thirdPersonWeaponInfo.useWeaponRotationPoint;
        if (usingWeaponRotationPoint) {
            currentHeadLookTarget = thirdPersonWeaponInfo.weaponRotationPointHeadLookTarget;
        } else {
            currentHeadLookTarget = headLookTarget;
        }

        activateWeaponUpdate ();

        componentsInitialized = true;
    }

    void OnEnable ()
    {
        weaponObjectActive = true;
    }

    void OnDisable ()
    {
        weaponObjectActive = false;

        weaponUpdateActive = false;
    }

    public bool weaponUpdateActive;

    float lastTimeWeaponActive;

    Coroutine updateWeaponCoroutine;

    public bool isWeaponUpdateActive ()
    {
        return weaponUpdateActive;
    }

    public void activateWeaponUpdate ()
    {
        if (!weaponObjectActive) {
            return;
        }

        stopActivateWeaponUpdate ();

        updateWeaponCoroutine = StartCoroutine (updateWeaponStateCoroutine ());

        weaponUpdateActive = true;
    }

    public void stopActivateWeaponUpdate ()
    {
        if (updateWeaponCoroutine != null) {
            StopCoroutine (updateWeaponCoroutine);
        }

        weaponUpdateActive = false;
    }

    IEnumerator updateWeaponStateCoroutine ()
    {
        var waitTime = new WaitForFixedUpdate ();

        while (true) {
            yield return waitTime;

            if (!startInitialized) {
                setInitialWeaponState ();

                startInitialized = true;

                lastTimeWeaponActive = Time.time;

                if (!carrying) {
                    setWeaponParent (carrying);
                }
            }

            updateWeaponState ();

            if (!currentWeapon) {
                if (Time.time > lastTimeWeaponActive + 5) {
                    stopActivateWeaponUpdate ();
                }
            }
        }
    }

    void updateWeaponState ()
    {
        if (currentWeapon) {

            if (!weaponSystemManager.isWeaponUpdateActive ()) {
                weaponSystemManager.activateWeaponUpdate ();
            }

            if (!weaponsManager.weaponsAreMoving ()) {

                bool checkCollisionResult = thirdPersonWeaponInfo.checkSurfaceCollision;

                if (checkCollisionResult) {
                    checkCollisionResult = weaponSystemManager.isAimingInThirdPerson ();
                }

                if (isFullBodyAwarenessActive ()) {
                    checkCollisionResult = firstPersonWeaponInfo.checkSurfaceCollision;

                    if (checkCollisionResult) {
                        checkCollisionResult = weaponSystemManager.carryingWeaponInThirdPerson;
                    }

                    if (checkCollisionResult) {
                        if (firstPersonWeaponInfo.checkSurfaceOnlyOnAiming) {
                            checkCollisionResult = aiming;
                        }
                    }
                }

                //check collision on third person
                if (checkCollisionResult &&
                    !weaponsManager.ignoreCheckSurfaceCollisionThirdPerson &&
                    !meleeAtacking &&
                    !aimingWeaponInProcess &&
                    !actionActive &&
                    !weaponsManager.isReloadingWithAnimationActive ()) {
                    //if the raycast detects a surface, get the distance to it

                    bool canCheckCollisionDetectionResult = true;

                    //if (isFullBodyAwarenessActive ()) {
                    //if (!aiming || Time.time < weaponsManager.getLastTimeFired () + timeToCheckSurfaceCollision) {

                    if (Time.time < weaponsManager.getLastTimeFired () + timeToCheckSurfaceCollision) {
                        canCheckCollisionDetectionResult = false;
                    }
                    // }

                    if (canCheckCollisionDetectionResult) {
                        if (isUsingDualWeapon ()) {
                            if (usingRightHandDualWeapon) {
                                currentCollisionRayPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.surfaceCollisionRayPosition;

                                currentCollisionRayDistance = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.collisionRayDistance;
                            } else {
                                currentCollisionRayPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.surfaceCollisionRayPosition;

                                currentCollisionRayDistance = thirdPersonWeaponInfo.leftHandDualWeaponInfo.collisionRayDistance;
                            }
                        } else {
                            currentCollisionRayPositionTransform = thirdPersonWeaponInfo.surfaceCollisionRayPosition;

                            currentCollisionRayDistance = thirdPersonWeaponInfo.collisionRayDistance;
                        }

                        if (Physics.Raycast (currentCollisionRayPositionTransform.position, currentCollisionRayPositionTransform.forward, out hit, currentCollisionRayDistance, layer)) {
                            if (!hit.collider.isTrigger) {
                                Debug.DrawRay (currentCollisionRayPositionTransform.position, currentCollisionRayDistance * currentCollisionRayPositionTransform.forward, Color.red);

                                if (!surfaceDetected) {
                                    walkOrSurfaceCollision (!surfaceDetected);
                                }
                            }
                        } else {
                            Debug.DrawRay (currentCollisionRayPositionTransform.position, currentCollisionRayDistance * currentCollisionRayPositionTransform.forward, Color.green);

                            if (surfaceDetected) {
                                walkOrSurfaceCollision (!surfaceDetected);
                            }
                        }
                    }
                }

                bool checkRunPositionResult = true;

                if (isFullBodyAwarenessActive ()) {
                    checkRunPositionResult = useRunPositionOnFBA ();
                } else {
                    checkRunPositionResult = useRunPositionOnThirdPerson ();
                }

                if (checkRunPositionResult) {
                    if (weaponSystemManager.carryingWeaponInThirdPerson &&
                        !moving &&
                        !aiming &&
                        !actionActive &&
                        !weaponsManager.isReloadingWithAnimationActive () &&
                        !checkIfDeactivateIKIfNotAimingActive () &&
                        !meleeAtacking) {

                        if (Time.time > weaponsManager.getLastTimeFired () + timeToCheckRunPosition) {
                            if (weaponsManager.isPlayerMoving () &&
                                !weaponsManager.isObstacleToAvoidMovementFound () &&
                                (weaponsManager.isPlayerRunning () || !isFullBodyAwarenessActive ())) {

                                if (!weaponInRunPosition) {
                                    walkOrRunWeaponPosition (true);
                                }
                            } else {
                                if (weaponInRunPosition) {
                                    walkOrRunWeaponPosition (false);
                                }
                            }
                        }
                    }
                }

                if (isFullBodyAwarenessActive ()) {
                    if (weaponSystemManager.carryingWeaponInThirdPerson && !moving && !meleeAtacking && !aiming && !actionActive && !IKPausedOnHandsActive) {
                        if (firstPersonWeaponInfo.useCrouchPosition) {
                            if (!crouchingActive && isPlayerCrouching ()) {
                                setCrouchStatetWeaponPosition (true);
                            }

                            if (crouchingActive && !isPlayerCrouching ()) {
                                setCrouchStatetWeaponPosition (false);
                            }
                        }

                        if (firstPersonWeaponInfo.useJumpPositions) {
                            if (playerOnJumpStart && !weaponsManager.isPlayerOnGroundForWeapons ()) {
                                if (!weaponInJumpStart) {
                                    setJumpStatetWeaponPosition (true, false);

                                    playerOnJumpStart = false;
                                }
                            }

                            if (playerOnJumpEnd && weaponsManager.isPlayerOnGroundForWeapons ()) {
                                if (!weaponInJumpEnd) {
                                    setJumpStatetWeaponPosition (false, true);

                                    playerOnJumpEnd = false;
                                }
                            }
                        }
                    }
                } else {
                    //check collision on first person
                    if (weaponSystemManager.carryingWeaponInFirstPerson && !moving && !meleeAtacking && !aiming) {
                        if (!weaponInRunPosition && firstPersonWeaponInfo.checkSurfaceCollision && !weaponsManager.ignoreCheckSurfaceCollisionFirstPerson) {
                            if (Time.time > weaponsManager.getLastTimeFired () + timeToCheckSurfaceCollision) {
                                if (weaponsManager.isCarryWeaponInLowerPositionActive ()) {
                                    if (!surfaceDetected) {
                                        walkOrSurfaceCollision (!surfaceDetected);
                                    }
                                } else {
                                    //if the raycast detects a surface, get the distance to it

                                    if (isUsingDualWeapon ()) {
                                        if (usingRightHandDualWeapon) {
                                            currentCollisionRayPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.surfaceCollisionRayPosition;

                                            currentCollisionRayDistance = firstPersonWeaponInfo.rightHandDualWeaopnInfo.collisionRayDistance;
                                        } else {
                                            currentCollisionRayPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.surfaceCollisionRayPosition;

                                            currentCollisionRayDistance = firstPersonWeaponInfo.leftHandDualWeaponInfo.collisionRayDistance;
                                        }
                                    } else {
                                        currentCollisionRayPositionTransform = firstPersonWeaponInfo.surfaceCollisionRayPosition;

                                        currentCollisionRayDistance = firstPersonWeaponInfo.collisionRayDistance;
                                    }

                                    if (Physics.Raycast (currentCollisionRayPositionTransform.position, currentCollisionRayPositionTransform.forward, out hit, currentCollisionRayDistance, layer)) {
                                        if (!hit.collider.isTrigger) {
                                            Debug.DrawRay (currentCollisionRayPositionTransform.position, currentCollisionRayDistance * currentCollisionRayPositionTransform.forward, Color.red);

                                            if (!surfaceDetected) {
                                                walkOrSurfaceCollision (!surfaceDetected);
                                            }
                                        }
                                    } else {
                                        Debug.DrawRay (currentCollisionRayPositionTransform.position, currentCollisionRayDistance * currentCollisionRayPositionTransform.forward, Color.green);

                                        if (surfaceDetected) {
                                            walkOrSurfaceCollision (!surfaceDetected);
                                        }
                                    }
                                }
                            }
                        }

                        if (!weaponsManager.weaponsAreMoving ()) {
                            //manage the weapon position when the player is running in first person
                            if (useRunPositionFirstPerson) {
                                if (Time.time > weaponsManager.getLastTimeFired () + timeToCheckRunPosition && !jumpingOnProcess && !meleeAtacking) {
                                    if (weaponsManager.isPlayerMoving () && weaponsManager.isPlayerRunning () && weaponsManager.isPlayerOnGroundForWeapons ()) {
                                        if (!weaponInRunPosition) {
                                            walkOrRunWeaponPosition (true);
                                        }
                                    } else {
                                        if (weaponInRunPosition) {
                                            walkOrRunWeaponPosition (false);
                                        }
                                    }
                                }
                            }

                            //manage if the camera fov is modified when the player is running on first person
                            if (useNewFovOnRunFirstPerson) {
                                if (Time.time > weaponsManager.getLastTimeFired () + timeToCheckRunPosition) {
                                    if (weaponsManager.isPlayerMoving () && weaponsManager.isPlayerRunning ()) {
                                        if (!playerRunning) {
                                            weaponsManager.setPlayerRunningState (true, this);
                                        }
                                    } else {
                                        if (playerRunning) {
                                            weaponsManager.setPlayerRunningState (false, this);
                                        }
                                    }
                                }
                            }

                            if (firstPersonWeaponInfo.useJumpPositions) {
                                if (playerOnJumpStart && !weaponsManager.isPlayerOnGroundForWeapons ()) {
                                    if (!weaponInJumpStart) {
                                        setJumpStatetWeaponPosition (true, false);

                                        playerOnJumpStart = false;
                                    }
                                }

                                if (playerOnJumpEnd && weaponsManager.isPlayerOnGroundForWeapons ()) {
                                    if (!weaponInJumpEnd) {
                                        setJumpStatetWeaponPosition (false, true);

                                        playerOnJumpEnd = false;
                                    }
                                }
                            }

                            if (firstPersonWeaponInfo.useCrouchPosition) {
                                if (!crouchingActive && isPlayerCrouching ()) {
                                    setCrouchStatetWeaponPosition (true);
                                }

                                if (crouchingActive && !isPlayerCrouching ()) {
                                    setCrouchStatetWeaponPosition (false);
                                }
                            }
                        }
                    }
                }
            }
        }

        if (disablingDualWeapon && !moving) {
            disablingDualWeapon = false;
        }
    }

    public void setInitialWeaponState ()
    {
        if (!weaponEnabled) {
            enableOrDisableWeaponMesh (false);
        }

        if (weaponsManager.checkIfHideWeaponMeshWhenNotUsed (hideWeaponIfKeptInThirdPerson)) {
            enableOrDisableWeaponMesh (false);

            if (checkIfWeaponUsesAttachment ()) {
                mainWeaponAttachmentSystem.checkInitializeAttachmentElements ();
            }
        }
    }

    public bool checkIfWeaponUsesAttachment ()
    {
        return weaponUsesAttachment && !ignoreUseAttachmentSystem;
    }

    public void setPlayerOnJumpStartState (bool state)
    {
        playerOnJumpStart = state;
    }

    public void setPlayerOnJumpEndState (bool state)
    {
        playerOnJumpEnd = state;
    }

    public bool isWeaponMoving ()
    {
        return moving;
    }

    public bool isDrawingWeaponInProcess ()
    {
        return drawingWeaponInProcess;
    }

    public bool isHolsteringWeaponInProcess ()
    {
        return holsteringWeaponInProcess;
    }

    public bool isAimingWeaponInProcess ()
    {
        return aimingWeaponInProcess;
    }

    public bool weaponCanFire ()
    {
        //return !surfaceDetected ||
        //(!weaponSystemManager.aimingInThirdPerson && surfaceDetected) ||
        //isFullBodyAwarenessActive ();

        if (isFullBodyAwarenessActive ()) {
            if (surfaceDetected) {
                if (firstPersonWeaponInfo.avoidShootOnSurfaceDetected) {
                    return false;
                }
            }
        } else {
            if (surfaceDetected) {
                if (weaponSystemManager.isAimingInThirdPerson ()) {
                    if (thirdPersonWeaponInfo.avoidShootOnSurfaceDetected) {
                        return false;
                    }
                }
            }
        }

        return true;
    }

    public bool weaponCanAim ()
    {
        if (isFullBodyAwarenessActive ()) {
            if (surfaceDetected) {
                if (firstPersonWeaponInfo.avoidAimingIfSurfaceDetected) {
                    return false;
                }
            }
        }

        return true;
    }

    public bool isWeaponSurfaceDetected ()
    {
        return surfaceDetected;
    }

    public void setWeaponSystemManager ()
    {
        weaponSystemManager = weaponGameObject.GetComponent<playerWeaponSystem> ();

        weaponsManager = weaponSystemManager.playerControllerGameObject.GetComponent<playerWeaponsManager> ();

        updateComponent ();
    }

    public void checkWeaponBuilder ()
    {
        weaponBuilder currentWeaponBuilder = GetComponent<weaponBuilder> ();

        if (currentWeaponBuilder != null) {
            currentWeaponBuilder.checkWeaponBuilder (weaponsManager);
        }
    }

    public playerWeaponSystem getWeaponSystemManager ()
    {
        return weaponSystemManager;
    }

    public playerWeaponsManager getPlayerWeaponsManager ()
    {
        return weaponsManager;
    }

    public int getWeaponSystemKeyNumber ()
    {
        return weaponSystemManager.getWeaponNumberKey ();
    }

    public bool isUseRemainAmmoFromInventoryActive ()
    {
        return weaponSystemManager.isUseRemainAmmoFromInventoryActive ();
    }

    public bool isWeaponEnabled ()
    {
        return weaponEnabled;
    }

    public void setWeaponEnabledState (bool state)
    {
        weaponEnabled = state;

        weaponSystemManager.checkEventsOnWeaponActivatedOrDeactivated (weaponEnabled);
    }

    public string getWeaponSystemName ()
    {
        return weaponSystemManager.getWeaponSystemName ();
    }

    public void renameWeapon (string newWeaponName)
    {
        weaponSystemManager.setWeaponSystemName (newWeaponName);
    }

    public void renameWeaponAmmo (string currentAmmoName, string newAmmoName)
    {
        weaponSystemManager.renameWeaponAmmo (currentAmmoName, newAmmoName);
    }

    public string getWeaponSystemAmmoName ()
    {
        return weaponSystemManager.getWeaponSystemAmmoName ();
    }

    public int getWeaponOriginalClipSize ()
    {
        return weaponSystemManager.getWeaponOriginalClipSize ();
    }

    public void setRemainAmmoAmount (int newRemainAmmoAmount)
    {
        weaponSystemManager.setRemainAmmoAmount (newRemainAmmoAmount);
    }

    public void setInitialProjectilesInMagazine (int newProjectilesInMagazine)
    {
        weaponSystemManager.setInitialProjectilesInMagazine (newProjectilesInMagazine);
    }

    public int getProjectilesInMagazine ()
    {
        return weaponSystemManager.getProjectilesInMagazine ();
    }

    public bool isCurrentMagazineEmpty ()
    {
        return weaponSystemManager.isCurrentMagazineEmpty ();
    }

    public bool isRemainAmmoEmpty ()
    {
        return weaponSystemManager.isRemainAmmoEmpty ();
    }

    public void checkWeaponSidePosition ()
    {
        bool changeWeaponPositionSide = false;

        if (usingDualWeapon) {
            if (usingRightHandDualWeapon) {
                if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.placeWeaponOnKeepPositionSideBeforeDraw) {
                    currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.keepPosition;

                    changeWeaponPositionSide = true;
                }
            } else {
                if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.placeWeaponOnKeepPositionSideBeforeDraw) {
                    currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.keepPosition;

                    changeWeaponPositionSide = true;
                }
            }
        } else {
            if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.placeWeaponOnKeepPositionSideBeforeDraw || thirdPersonWeaponInfo.leftHandDualWeaponInfo.placeWeaponOnKeepPositionSideBeforeDraw) {
                currentDrawPositionTransform = thirdPersonWeaponInfo.keepPosition;

                changeWeaponPositionSide = true;
            }
        }

        if (changeWeaponPositionSide) {
            weaponTransform.position = currentDrawPositionTransform.position;
            weaponTransform.rotation = currentDrawPositionTransform.rotation;
        }
    }

    //third person
    public void drawOrKeepWeaponThirdPerson (bool state)
    {
        bool moveWeapon = false;

        carrying = state;

        if (carrying) {
            checkIfSetNewAnimatorWeaponID ();
        }

        if (carrying) {
            setWeaponParent (carrying);
        }

        if (carrying) {
            //draw the weapon
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentKeepPath = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.keepPath;
                } else {
                    currentKeepPath = thirdPersonWeaponInfo.leftHandDualWeaponInfo.keepPath;
                }
            } else {
                currentKeepPath = thirdPersonWeaponInfo.keepPath;
            }

            moveWeapon = true;
        } else {
            //if the weapon is in its carrying position or if the weapon was moving towards its carrying position, stop it, reverse the path and start the movement
            if (carryingWeapon || moving) {
                inverseKeepPath.Clear ();

                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        inverseKeepPath = new List<Transform> (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.keepPath);
                    } else {
                        inverseKeepPath = new List<Transform> (thirdPersonWeaponInfo.leftHandDualWeaponInfo.keepPath);
                    }
                } else {
                    inverseKeepPath = new List<Transform> (thirdPersonWeaponInfo.keepPath);
                }

                inverseKeepPath.Reverse ();

                currentKeepPath = inverseKeepPath;

                aiming = false;
                moveWeapon = true;
            }
        }

        //stop the coroutine to translate the camera and call it again
        stopWeaponMovement ();

        if (moveWeapon) {
            weaponMovement = StartCoroutine (drawOrKeepWeaponThirdPersonCoroutine ());
        }

        resetOtherWeaponsStates ();

        disableOtherWeaponsStates ();

        setPlayerControllerMovementValues ();

        setLastTimeMoved ();

        if (!carrying && !isFullBodyAwarenessActive ()) {
            checkIfSetNewAnimatorWeaponID ();
        }
    }

    public bool isUseDrawKeepWeaponAnimationActive ()
    {
        return isUseDrawKeepWeaponAnimationActiveOnThisWeapon () &&
        !weaponsManager.isIgnoreUseDrawKeepWeaponAnimationActive () &&
        !weaponsManager.isUsingDualWeapons ();
    }

    public bool isUseDrawKeepWeaponAnimationActiveOnThisWeapon ()
    {
        if (isFullBodyAwarenessActive ()) {
            if (weaponsManager.isUseDrawKeepWeaponAnimationOnAllWeaponsOnFBAActive ()) {
                return true;
            }

            return firstPersonWeaponInfo.useDrawKeepWeaponAnimation;
        }

        return thirdPersonWeaponInfo.useDrawKeepWeaponAnimation;
    }

    void checkIfAddFBAWalkPositionOffset ()
    {
        currentFBAWalkPositionOffset = Vector3.zero;
        currentFBAWalkRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            currentFBAWalkPositionOffset = thirdPersonWeaponInfo.FBAWalkPositionOffset;
            currentFBAWalkRotationOffset = thirdPersonWeaponInfo.FBAWalkRotationOffset;

            if (usingDualWeapon) {
                if (!usingRightHandDualWeapon) {
                    currentFBAWalkPositionOffset.x *= (-1) * currentFBAWalkPositionOffset.x;
                }
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBARunPositionOffset ()
    {
        currentFBARunPositionOffset = Vector3.zero;
        currentFBARunRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            currentFBARunPositionOffset = thirdPersonWeaponInfo.FBARunPositionOffset;
            currentFBARunRotationOffset = thirdPersonWeaponInfo.FBARunRotationOffset;

            if (usingDualWeapon) {
                if (!usingRightHandDualWeapon) {
                    currentFBARunPositionOffset.x *= (-1) * currentFBARunPositionOffset.x;
                }
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBAWalkRecoilPositionOffset ()
    {
        currentFBAWalkRecoilPositionOffset = Vector3.zero;
        currentFBAWalkRecoilRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            currentFBAWalkRecoilPositionOffset = thirdPersonWeaponInfo.FBAWalkRecoilPositionOffset;
            currentFBAWalkRecoilRotationOffset = thirdPersonWeaponInfo.FBAWalkRecoilRotationOffset;

            if (usingDualWeapon) {
                if (!usingRightHandDualWeapon) {
                    currentFBAWalkRecoilPositionOffset.x *= (-1) * currentFBAWalkRecoilPositionOffset.x;
                }
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBAAimPositionOffset ()
    {
        currentFBAAimPositionOffset = Vector3.zero;
        currentFBAAimRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            if (newFBAAimInfoActive) {
                currentFBAAimPositionOffset = currentFBAAimInfo.FBAAimPositionOffset;
                currentFBAAimRotationOffset = currentFBAAimInfo.FBAAimRotationOffset;
            } else {
                currentFBAAimPositionOffset = thirdPersonWeaponInfo.FBAAimPositionOffset;
                currentFBAAimRotationOffset = thirdPersonWeaponInfo.FBAAimRotationOffset;
            }

            if (usingDualWeapon) {
                currentFBAAimPositionOffset = thirdPersonWeaponInfo.FBAWalkPositionOffset;
                currentFBAAimRotationOffset = thirdPersonWeaponInfo.FBAWalkRotationOffset;

                if (!usingRightHandDualWeapon) {
                    currentFBAAimPositionOffset.x *= (-1) * currentFBAAimPositionOffset.x;
                }
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBAAimRecoilPositionOffset ()
    {
        currentFBAAimRecoilPositionOffset = Vector3.zero;
        currentFBAAimRecoilRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            if (newFBAAimInfoActive) {
                currentFBAAimRecoilPositionOffset = currentFBAAimInfo.FBAAimRecoilPositionOffset;
                currentFBAAimRecoilRotationOffset = currentFBAAimInfo.FBAAimRecoilRotationOffset;
            } else {
                currentFBAAimRecoilPositionOffset = thirdPersonWeaponInfo.FBAAimRecoilPositionOffset;
                currentFBAAimRecoilRotationOffset = thirdPersonWeaponInfo.FBAAimRecoilRotationOffset;
            }

            if (usingDualWeapon) {
                currentFBAAimRecoilPositionOffset = thirdPersonWeaponInfo.FBAWalkRecoilPositionOffset;
                currentFBAAimRecoilRotationOffset = thirdPersonWeaponInfo.FBAWalkRecoilRotationOffset;

                if (!usingRightHandDualWeapon) {
                    currentFBAAimRecoilPositionOffset.x *= (-1) * currentFBAAimRecoilPositionOffset.x;
                }
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBACrouchPositionOffset ()
    {
        currentFBACrouchPositionOffset = Vector3.zero;
        currentFBACrouchRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            currentFBACrouchPositionOffset = thirdPersonWeaponInfo.FBACrouchPositionOffset;
            currentFBACrouchRotationOffset = thirdPersonWeaponInfo.FBACrouchRotationOffset;

            if (usingDualWeapon) {
                if (!usingRightHandDualWeapon) {
                    currentFBACrouchPositionOffset.x *= (-1) * currentFBACrouchPositionOffset.x;
                }
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBACrouchRecoilPositionOffset ()
    {
        currentFBACrouchRecoilPositionOffset = Vector3.zero;
        currentFBACrouchRecoilRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            currentFBACrouchRecoilPositionOffset = thirdPersonWeaponInfo.FBACrouchRecoilPositionOffset;
            currentFBACrouchRecoilRotationOffset = thirdPersonWeaponInfo.FBACrouchRecoilRotationOffset;

            if (usingDualWeapon) {
                if (!usingRightHandDualWeapon) {
                    currentFBACrouchRecoilPositionOffset.x *= (-1) * currentFBACrouchRecoilPositionOffset.x;
                }
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBAJumpStartPositionOffset ()
    {
        currentFBAJumpStartPositionOffset = Vector3.zero;
        currentFBAJumpStartRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            currentFBAJumpStartPositionOffset = thirdPersonWeaponInfo.FBAJumpStartPositionOffset;
            currentFBAJumpStartRotationOffset = thirdPersonWeaponInfo.FBAJumpStartRotationOffset;

            if (usingDualWeapon) {
                currentFBAJumpStartPositionOffset =
                    new Vector3 (weaponTransform.localPosition.x, currentFBAJumpStartPositionOffset.y, weaponTransform.localPosition.z);

                currentFBAJumpStartRotationOffset = new Vector3 (currentFBAJumpStartRotationOffset.x, 0, 0);
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBAJumpEndPositionOffset ()
    {
        currentFBAJumpEndPositionOffset = Vector3.zero;
        currentFBAJumpEndRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            currentFBAJumpEndPositionOffset = thirdPersonWeaponInfo.FBAJumpEndPositionOffset;
            currentFBAJumpEndRotationOffset = thirdPersonWeaponInfo.FBAJumpEndRotationOffset;

            if (usingDualWeapon) {
                currentFBAJumpEndPositionOffset =
                    new Vector3 (weaponTransform.localPosition.x, currentFBAJumpEndPositionOffset.y, weaponTransform.localPosition.z);

                currentFBAJumpEndRotationOffset = new Vector3 (currentFBAJumpEndRotationOffset.x, 0, 0);
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    void checkIfAddFBAObstaclePositionOffset ()
    {
        currentFBAObstaclePositionOffset = Vector3.zero;
        currentFBAObstacleRotationOffset = Vector3.zero;

        overrideFBAValuesForOffset = false;

        if (isFullBodyAwarenessActive ()) {
            currentFBAObstaclePositionOffset = thirdPersonWeaponInfo.FBAObstaclePositionOffset;
            currentFBAObstacleRotationOffset = thirdPersonWeaponInfo.FBAObstacleRotationOffset;

            if (usingDualWeapon) {
                currentFBAObstaclePositionOffset =
                    new Vector3 (weaponTransform.localPosition.x, currentFBAObstaclePositionOffset.y, weaponTransform.localPosition.z);

                currentFBAObstacleRotationOffset = new Vector3 (currentFBAObstacleRotationOffset.x, 0, 0);
            }

            overrideFBAValuesForOffset = thirdPersonWeaponInfo.overrideFBAValuesForOffset;
        }
    }

    public void updateFBAValues (bool useRifleValues)
    {
        if (useRifleValues) {
            thirdPersonWeaponInfo.FBAWalkPositionOffset = new Vector3 (0.22f, 1.499f, 0.255f);
            thirdPersonWeaponInfo.FBAWalkRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBAWalkRecoilPositionOffset = new Vector3 (0.22f, 1.499f, 0.23f);
            thirdPersonWeaponInfo.FBAWalkRecoilRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.useFBARunPosition = false;

            thirdPersonWeaponInfo.FBARunPositionOffset = new Vector3 (0.22f, 1.499f, 0.255f);
            thirdPersonWeaponInfo.FBARunRotationOffset = new Vector3 (0, -25, 0);

            thirdPersonWeaponInfo.FBAAimPositionOffset = new Vector3 (0.153f, 1.5f, 0.252f);
            thirdPersonWeaponInfo.FBAAimRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBAAimRecoilPositionOffset = new Vector3 (0.153f, 1.505f, 0.24f);
            thirdPersonWeaponInfo.FBAAimRecoilRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBACrouchPositionOffset = new Vector3 (0.22f, 1.46f, 0.255f);
            thirdPersonWeaponInfo.FBACrouchRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBACrouchRecoilPositionOffset = new Vector3 (0.22f, 1.46f, 0.2f);
            thirdPersonWeaponInfo.FBACrouchRecoilRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBAJumpStartPositionOffset = new Vector3 (0.19f, 1.55f, 0.245f);
            thirdPersonWeaponInfo.FBAJumpStartRotationOffset = new Vector3 (-9.5f, -20, 0);

            thirdPersonWeaponInfo.FBAJumpEndPositionOffset = new Vector3 (0.15f, 1.4f, 0.225f);
            thirdPersonWeaponInfo.FBAJumpEndRotationOffset = new Vector3 (0, -10, 0);

            extraColliderCenterOnFireWeaponOnFBA = new Vector3 (0, 0, 0.1f);
            extraColliderScaleOnFireWeaponOnFBA = new Vector3 (0.1f, 0.24f, 0.7f);
        } else {
            thirdPersonWeaponInfo.FBAWalkPositionOffset = new Vector3 (0.25f, 1.56f, 0.3f);
            thirdPersonWeaponInfo.FBAWalkRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBAWalkRecoilPositionOffset = new Vector3 (0.25f, 1.55f, 0.29f);
            thirdPersonWeaponInfo.FBAWalkRecoilRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.useFBARunPosition = false;

            thirdPersonWeaponInfo.FBARunPositionOffset = new Vector3 (0.25f, 1.5f, 0.29f);
            thirdPersonWeaponInfo.FBARunRotationOffset = new Vector3 (0, -25, 0);

            thirdPersonWeaponInfo.FBAAimPositionOffset = new Vector3 (0.154f, 1.515f, 0.252f);
            thirdPersonWeaponInfo.FBAAimRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBAAimRecoilPositionOffset = new Vector3 (0.154f, 1.505f, 0.24f);
            thirdPersonWeaponInfo.FBAAimRecoilRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBACrouchPositionOffset = new Vector3 (0.22f, 1.53f, 0.255f);
            thirdPersonWeaponInfo.FBACrouchRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBACrouchRecoilPositionOffset = new Vector3 (0.22f, 1.53f, 0.24f);
            thirdPersonWeaponInfo.FBACrouchRecoilRotationOffset = Vector3.zero;

            thirdPersonWeaponInfo.FBAJumpStartPositionOffset = new Vector3 (0.19f, 1.55f, 0.245f);
            thirdPersonWeaponInfo.FBAJumpStartRotationOffset = new Vector3 (-9.5f, -20, 0);

            thirdPersonWeaponInfo.FBAJumpEndPositionOffset = new Vector3 (0.15f, 1.4f, 0.225f);
            thirdPersonWeaponInfo.FBAJumpEndRotationOffset = new Vector3 (0, -10, 0);

            extraColliderCenterOnFireWeaponOnFBA = new Vector3 (0, 0, 0.06f);
            extraColliderScaleOnFireWeaponOnFBA = new Vector3 (0.1f, 0.24f, 0.31f);
        }

        thirdPersonWeaponInfo.FBAObstaclePositionOffset = new Vector3 (0.16f, 1.5f, 0.17f);
        thirdPersonWeaponInfo.FBAObstacleRotationOffset = new Vector3 (0, -60, 0);

        thirdPersonWeaponInfo.overrideFBAValuesForOffset = true;

        thirdPersonWeaponInfo.FBARandomRecoilWalkPositionMultiplier = 0.4f;

        thirdPersonWeaponInfo.FBARandomRecoilAimPositionMultiplier = 0.2f;

        updateComponent ();
    }

    public void resetFBAValues ()
    {
        thirdPersonWeaponInfo.FBAWalkPositionOffset = Vector3.zero;
        thirdPersonWeaponInfo.FBAWalkRotationOffset = Vector3.zero;

        thirdPersonWeaponInfo.FBAAimPositionOffset = Vector3.zero;
        thirdPersonWeaponInfo.FBAAimRotationOffset = Vector3.zero;

        thirdPersonWeaponInfo.FBAWalkRecoilPositionOffset = Vector3.zero;
        thirdPersonWeaponInfo.FBAWalkRecoilRotationOffset = Vector3.zero;

        thirdPersonWeaponInfo.FBAAimRecoilPositionOffset = Vector3.zero;
        thirdPersonWeaponInfo.FBAAimRecoilRotationOffset = Vector3.zero;

        thirdPersonWeaponInfo.FBACrouchPositionOffset = Vector3.zero;
        thirdPersonWeaponInfo.FBACrouchRotationOffset = Vector3.zero;

        thirdPersonWeaponInfo.FBACrouchRecoilPositionOffset = Vector3.zero;
        thirdPersonWeaponInfo.FBACrouchRecoilRotationOffset = Vector3.zero;

        thirdPersonWeaponInfo.FBAJumpStartPositionOffset = Vector3.zero;
        thirdPersonWeaponInfo.FBAJumpStartRotationOffset = Vector3.zero;

        thirdPersonWeaponInfo.FBAJumpEndPositionOffset = Vector3.zero;
        thirdPersonWeaponInfo.FBAJumpEndRotationOffset = Vector3.zero;

        updateComponent ();
    }

    bool newFBAAimInfoActive;

    FBAAimInfo currentFBAAimInfo;

    public void setNewFBAAimInfo (string infoName)
    {
        int infoIndex = thirdPersonWeaponInfo.FBAAimInfoList.FindIndex (s => s.Name == infoName);

        if (infoIndex > -1) {
            newFBAAimInfoActive = true;

            currentFBAAimInfo = thirdPersonWeaponInfo.FBAAimInfoList [infoIndex];
        }
    }

    public void setRegularFBAAimInfo ()
    {
        newFBAAimInfoActive = false;
    }

    public void setNewExtraColliderOnFireWeaponOnFBAValues (Vector3 newScaleValues, Vector3 newCenterValues)
    {
        extraColliderCenterOnFireWeaponOnFBA = newCenterValues;
        extraColliderScaleOnFireWeaponOnFBA = newScaleValues;

        updateComponent ();
    }

    bool drawKeepWeaponAnimationInProcess;

    public bool isdrawKeepWeaponAnimationInProcess ()
    {
        return drawKeepWeaponAnimationInProcess;
    }

    IEnumerator drawOrKeepWeaponThirdPersonCoroutine ()
    {
        drawingWeaponInProcess = carrying;
        holsteringWeaponInProcess = !carrying;

        setWeaponMovingState (true);

        bool useDrawKeepWeaponAnimation = isUseDrawKeepWeaponAnimationActive ();

        bool deactivateIKIfNotAimingActive = isDeactivateIKIfNotAimingActive ();

        drawKeepWeaponAnimationInProcess = useDrawKeepWeaponAnimation;

        if (carrying) {
            if (!useDrawKeepWeaponAnimation) {
                setWeaponTransformParent (weaponSystemManager.getWeaponParent ());
            }

            enableOrDisableWeaponMesh (true);

            weaponSystemManager.changeHUDPosition (true);
        }

        if (checkIfDeactivateIKIfNotAimingActive () || IKPausedOnHandsActive) {
            if (carrying) {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentKeepPath = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.deactivateIKDrawPath;
                    } else {
                        currentKeepPath = thirdPersonWeaponInfo.leftHandDualWeaponInfo.deactivateIKDrawPath;
                    }
                } else {
                    currentKeepPath = thirdPersonWeaponInfo.deactivateIKDrawPath;
                }
            } else {
                inverseKeepPath.Clear ();

                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        inverseKeepPath = new List<Transform> (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.deactivateIKDrawPath);
                    } else {
                        inverseKeepPath = new List<Transform> (thirdPersonWeaponInfo.leftHandDualWeaponInfo.deactivateIKDrawPath);
                    }
                } else {
                    inverseKeepPath = new List<Transform> (thirdPersonWeaponInfo.deactivateIKDrawPath);
                }

                inverseKeepPath.Reverse ();

                currentKeepPath = inverseKeepPath;

                if (isUsingDualWeapon () && !usingWeaponAsOneHandWield) {
                    if (usingRightHandDualWeapon) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                    } else {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                    }

                    setHandDeactivateIKStateToDisable ();

                } else {
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {
                            setHandDeactivateIKStateToDisable ();
                        }
                    }
                }

                setWeaponTransformParent (transform);
            }
        }

        if (carrying) {
            resetElbowIKPositions ();
        } else {
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                setElbowTargetValue (currentIKWeaponsPosition, 0);
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    setElbowTargetValue (currentIKWeaponsPosition, 0);

                    if (!currentIKWeaponsPosition.usedToDrawWeapon) {
                        currentIKWeaponsPosition.elbowInfo.position.SetParent (transform);
                    }
                }
            }
        }

        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                useBezierCurve = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.useBezierCurve;

                if (useBezierCurve) {
                    spline = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.spline;
                    bezierDuration = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.bezierDuration;
                    lookDirectionSpeed = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.lookDirectionSpeed;
                }

            } else {
                useBezierCurve = thirdPersonWeaponInfo.leftHandDualWeaponInfo.useBezierCurve;

                if (useBezierCurve) {
                    spline = thirdPersonWeaponInfo.leftHandDualWeaponInfo.spline;
                    bezierDuration = thirdPersonWeaponInfo.leftHandDualWeaponInfo.bezierDuration;
                    lookDirectionSpeed = thirdPersonWeaponInfo.leftHandDualWeaponInfo.lookDirectionSpeed;
                }
            }
        } else {
            useBezierCurve = thirdPersonWeaponInfo.useBezierCurve;

            if (useBezierCurve) {
                spline = thirdPersonWeaponInfo.spline;
                bezierDuration = thirdPersonWeaponInfo.bezierDuration;
                lookDirectionSpeed = thirdPersonWeaponInfo.lookDirectionSpeed;
            }
        }

        bool targetReached = false;

        if (useDrawKeepWeaponAnimation) {
            if (carrying) {
                if (isFullBodyAwarenessActive ()) {
                    activateCustomAction (firstPersonWeaponInfo.drawWeaponActionName);
                } else {
                    activateCustomAction (thirdPersonWeaponInfo.drawWeaponActionName);
                }
            } else {
                //when the character is holstering the weapon, please, disable the IK on the hand not used to draw the weapon

                //testing an improvement to draw/holster the weapon in a better way
                if (isFullBodyAwarenessActive ()) {
                    checkIfAddFBAWalkPositionOffset ();

                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBAWalkPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBAWalkPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                    }

                    weaponPositionTarget -= new Vector3 (0, 0.1f, 0);

                    weaponRotationTarget *= Quaternion.Euler (new Vector3 (0, -20, 0));

                    Vector3 currentWeaponPosition = weaponTransform.localPosition;
                    Quaternion currentWeaponRotation = weaponTransform.localRotation;

                    float dist = GKC_Utils.distance (currentWeaponPosition, weaponPositionTarget);

                    float duration = dist / 1;
                    float t = 0;

                    targetReached = false;

                    float angleDifference = 0;

                    float positionDifference = 0;

                    float movementTimer = 0;

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

                        weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
                        weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

                        angleDifference = Quaternion.Angle (weaponTransform.localRotation, weaponRotationTarget);

                        positionDifference = GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget);

                        movementTimer += Time.deltaTime;

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

                        yield return null;
                    }

                    activateCustomAction (firstPersonWeaponInfo.keepWeaponActionName);
                }

                if (!deactivateIKIfNotAimingActive && !thirdPersonWeaponInfo.useQuickDrawKeepWeapon && !weaponsManager.isForceWeaponToUseQuickDrawKeepWeaponActive ()) {
                    setWeaponTransformParent (weaponSystemManager.getWeaponParent ());
                }

                weaponsManager.getIKSystem ().setDisableWeaponsState (true);

                if (!deactivateIKIfNotAimingActive && !thirdPersonWeaponInfo.useQuickDrawKeepWeapon && !weaponsManager.isForceWeaponToUseQuickDrawKeepWeaponActive ()) {
                    bool rightHandUsed = false;

                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {

                            if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                                rightHandUsed = true;
                            }
                        }
                    }

                    if (rightHandUsed) {
                        setHandsIKTargetValue (0, 1);
                        setElbowsIKTargetValue (0, 1);
                    } else {
                        setHandsIKTargetValue (1, 0);
                        setElbowsIKTargetValue (1, 0);
                    }
                }
            }

            targetReached = false;

            float lastTimeDrawKeepAnimationActive = Time.time;

            float delayTime = 0;

            if (!carrying) {
                delayTime = 0.5f;

                if (deactivateIKIfNotAimingActive || thirdPersonWeaponInfo.useQuickDrawKeepWeapon || weaponsManager.isForceWeaponToUseQuickDrawKeepWeaponActive ()) {
                    delayTime = 0;
                }

                if (isFullBodyAwarenessActive ()) {
                    delayTime = 0;
                }

                while (!targetReached) {

                    if (Time.time > lastTimeDrawKeepAnimationActive + delayTime) {
                        targetReached = true;
                    }

                    yield return null;
                }

                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        newWeaponParent = leftHandMountPoint;

                        if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                            newWeaponParent = rightHandMountPoint;
                        }

                        if (newWeaponParent == null) {
                            newWeaponParent = currentIKWeaponsPosition.handTransform;
                        }

                        setWeaponTransformParent (newWeaponParent);

                        currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.transformFollowByHand.position;
                        currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.transformFollowByHand.rotation;
                        currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;
                    }
                }

                setHandsIKTargetValue (0, 0);
                setElbowsIKTargetValue (0, 0);

                if (!isFullBodyAwarenessActive ()) {
                    activateCustomAction (thirdPersonWeaponInfo.keepWeaponActionName);
                }
            }

            targetReached = false;

            lastTimeDrawKeepAnimationActive = Time.time;

            delayTime = 0;

            if (carrying) {
                if (isFullBodyAwarenessActive ()) {
                    delayTime = firstPersonWeaponInfo.delayToPlaceWeaponOnHandOnDrawAnimation;
                } else {
                    delayTime = thirdPersonWeaponInfo.delayToPlaceWeaponOnHandOnDrawAnimation;
                }
            } else {
                if (isFullBodyAwarenessActive ()) {
                    delayTime = firstPersonWeaponInfo.delayToPlaceWeaponOnKeepAnimation;
                } else {
                    delayTime = thirdPersonWeaponInfo.delayToPlaceWeaponOnKeepAnimation;
                }
            }

            while (!targetReached) {

                if (Time.time > lastTimeDrawKeepAnimationActive + delayTime) {
                    targetReached = true;
                }

                yield return null;
            }

            if (carrying) {

                weaponsManager.stopFreeFireOnDrawWeaponWithAnimation ();

                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        newWeaponParent = leftHandMountPoint;

                        if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                            newWeaponParent = rightHandMountPoint;
                        }

                        if (newWeaponParent == null) {
                            newWeaponParent = currentIKWeaponsPosition.handTransform;
                        }

                        setWeaponTransformParent (newWeaponParent);
                    }
                }

                adjustWeaponPositionToDeactivateIKOnHands ();
            } else {
                setWeaponTransformParent (weaponSystemManager.weaponSettings.weaponParent);

                weaponTransform.localPosition = thirdPersonWeaponInfo.keepPosition.localPosition;
                weaponTransform.localRotation = thirdPersonWeaponInfo.keepPosition.localRotation;
            }

            targetReached = false;

            while (!targetReached) {
                if (!weaponsManager.isActionActiveInPlayer ()) {
                    targetReached = true;
                }

                yield return null;
            }

            if (carrying) {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    currentIKWeaponsPosition.handInPositionToAim = true;

                    currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                    currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                    currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;
                }

                if (deactivateIKIfNotAimingActive) {
                    weaponsManager.getIKSystem ().quickDrawWeaponState (thirdPersonWeaponInfo);

                } else {
                    setWeaponTransformParent (weaponSystemManager.getWeaponParent ());

                    weaponsManager.getIKSystem ().setUsingWeaponsState (true);

                    setElbowsIKTargetValue (1, 1);
                    setHandsIKTargetValue (1, 1);

                    weaponInRunPosition = true;

                    walkOrRunWeaponPosition (false);
                }

                weaponsManager.getIKSystem ().checkHandsInPosition (true);
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    currentIKWeaponsPosition.handInPositionToAim = false;
                }

                weaponsManager.getIKSystem ().checkHandsInPosition (false);
            }
        } else {
            if (useBezierCurve) {

                //If the weapon is being kept, move it from its keep position to the end of the spline, to start the movement there
                targetReached = false;

                float angleDifference = 0;

                if (!carrying) {
                    Transform targetTransform = spline.GetLookTransform (1);

                    float dist = GKC_Utils.distance (weaponTransform.position, targetTransform.position);

                    float duration = dist / thirdPersonWeaponInfo.drawWeaponMovementSpeed;

                    float t = 0;

                    Vector3 pos = targetTransform.localPosition;
                    Quaternion rot = targetTransform.localRotation;

                    float movementTimer = 0;

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

                        weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, pos, t);
                        weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, rot, t);

                        angleDifference = Quaternion.Angle (weaponTransform.localRotation, rot);

                        movementTimer += Time.deltaTime;

                        if ((GKC_Utils.distance (weaponTransform.localPosition, pos) < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 1)) {
                            targetReached = true;
                        }

                        yield return null;
                    }
                }

                //Move the weapon through the spline
                float progress = 0;
                float progressTarget = 1;

                if (!carrying) {
                    progress = 1;
                    progressTarget = 0;
                }

                targetReached = false;

                angleDifference = 0;

                while (!targetReached) {
                    if (carrying) {
                        progress += Time.deltaTime / bezierDuration;
                    } else {
                        progress -= Time.deltaTime / bezierDuration;
                    }

                    Vector3 position = spline.GetPoint (progress);
                    weaponTransform.position = position;

                    Quaternion targetRotation = Quaternion.Euler (spline.GetLookDirection (progress));
                    weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, targetRotation, Time.deltaTime * lookDirectionSpeed);

                    if ((carrying && progress > progressTarget) || (!carrying && progress < progressTarget)) {
                        targetReached = true;
                    }

                    yield return null;
                }


                //Adjust the weapon position toward the walk position, once it has been moved through the spline
                if (carrying) {
                    if (isUsingDualWeapon () || weaponConfiguredAsDualWeaponPreviously) {
                        if (usingRightHandDualWeapon) {
                            currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                        } else {
                            currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                        }

                    } else {
                        currentDrawPositionTransform = thirdPersonWeaponInfo.walkPosition;
                    }

                    checkIfAddFBAWalkPositionOffset ();

                    float dist = GKC_Utils.distance (weaponTransform.position, currentDrawPositionTransform.position);

                    float duration = dist / thirdPersonWeaponInfo.drawWeaponMovementSpeed;

                    Vector3 pos = currentDrawPositionTransform.localPosition;
                    Quaternion rot = currentDrawPositionTransform.localRotation;

                    if (isFullBodyAwarenessActive ()) {
                        if (overrideFBAValuesForOffset) {
                            pos = currentFBAWalkPositionOffset;

                            rot = Quaternion.Euler (currentFBAWalkRotationOffset);
                        } else {
                            pos += currentFBAWalkPositionOffset;

                            rot *= Quaternion.Euler (currentFBAWalkRotationOffset);
                        }
                    }

                    float movementTimer = 0;

                    angleDifference = 0;

                    targetReached = false;

                    float t = 0;

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

                        weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, pos, t);
                        weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, rot, t);

                        angleDifference = Quaternion.Angle (weaponTransform.localRotation, rot);

                        movementTimer += Time.deltaTime;

                        if ((GKC_Utils.distance (weaponTransform.localPosition, pos) < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 1)) {
                            targetReached = true;
                        }

                        yield return null;
                    }
                }
            } else {
                targetReached = false;

                float angleDifference = 0;

                float movementTimer = 0;

                foreach (Transform transformPath in currentKeepPath) {
                    float dist = GKC_Utils.distance (weaponTransform.position, transformPath.position);

                    float duration = dist / thirdPersonWeaponInfo.drawWeaponMovementSpeed;

                    float t = 0;

                    Vector3 pos = transformPath.localPosition;
                    Quaternion rot = transformPath.localRotation;

                    targetReached = false;

                    angleDifference = 0;

                    movementTimer = 0;

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

                        weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, pos, t);
                        weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, rot, t);

                        angleDifference = Quaternion.Angle (weaponTransform.localRotation, rot);

                        movementTimer += Time.deltaTime;

                        if ((GKC_Utils.distance (weaponTransform.localPosition, pos) < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 1)) {
                            targetReached = true;
                        }

                        yield return null;
                    }
                }

                if (carrying) {
                    if (isFullBodyAwarenessActive ()) {
                        checkIfAddFBAWalkPositionOffset ();

                        checkIfAddFBACrouchPositionOffset ();

                        Vector3 weaponPositionTarget = Vector3.zero;
                        Quaternion weaponRotationTarget = Quaternion.identity;

                        if (isPlayerCrouching ()) {
                            if (overrideFBAValuesForOffset) {
                                weaponPositionTarget = currentFBACrouchPositionOffset;

                                weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                            } else {
                                weaponPositionTarget += currentFBACrouchPositionOffset;

                                weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                            }
                        } else {
                            if (overrideFBAValuesForOffset) {
                                weaponPositionTarget = currentFBAWalkPositionOffset;

                                weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                            } else {
                                weaponPositionTarget += currentFBAWalkPositionOffset;

                                weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                            }
                        }

                        float dist = GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget);

                        float duration = dist / thirdPersonWeaponInfo.drawWeaponMovementSpeed;

                        movementTimer = 0;

                        angleDifference = 0;

                        targetReached = false;

                        float t = 0;

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

                            weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, weaponPositionTarget, t);
                            weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, weaponRotationTarget, t);

                            angleDifference = Quaternion.Angle (weaponTransform.localRotation, weaponRotationTarget);

                            movementTimer += Time.deltaTime;

                            if ((GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget) < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 1)) {
                                targetReached = true;
                            }

                            yield return null;
                        }
                    }
                }
            }
        }

        if (carrying) {
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                setElbowTargetValue (currentIKWeaponsPosition, 1);
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        setElbowTargetValue (currentIKWeaponsPosition, 1);
                    }
                }
            }
        }

        if (!aiming && !carrying && !useDrawKeepWeaponAnimation) {
            setWeaponTransformParent (weaponSystemManager.weaponSettings.weaponParent);

            if (isUsingDualWeapon () || weaponConfiguredAsDualWeaponPreviously) {
                if (usingRightHandDualWeapon) {
                    currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.keepPosition;
                } else {
                    currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.keepPosition;
                }

            } else {
                currentDrawPositionTransform = thirdPersonWeaponInfo.keepPosition;
            }

            float dist = GKC_Utils.distance (weaponTransform.position, currentDrawPositionTransform.position);

            float duration = dist / thirdPersonWeaponInfo.drawWeaponMovementSpeed;

            Vector3 pos = currentDrawPositionTransform.localPosition;
            Quaternion rot = currentDrawPositionTransform.localRotation;

            float t = 0;

            targetReached = false;

            float angleDifference = 0;

            float movementDifference = 0;

            float movementTimer = 0;

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

                weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, pos, t);
                weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, rot, t);

                angleDifference = Quaternion.Angle (weaponTransform.localRotation, rot);

                movementDifference = GKC_Utils.distance (weaponTransform.localPosition, pos);

                movementTimer += Time.deltaTime;

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

                yield return null;
            }

            setHandsIKTargetValue (0, 0);
            setElbowsIKTargetValue (0, 0);

            if (isUsingDualWeapon () || weaponConfiguredAsDualWeaponPreviously) {
                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                currentIKWeaponsPosition.handInPositionToAim = false;

                currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                weaponConfiguredAsDualWeaponPreviously = false;
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        currentIKWeaponsPosition.handInPositionToAim = false;

                        currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                        currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                        currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;
                    }
                }
            }

            checkWeaponSidePosition ();
        }

        setWeaponMovingState (false);

        carryingWeapon = carrying;

        if (carryingWeapon && !isUsingDualWeapon () && !useDrawKeepWeaponAnimation) {
            weaponsManager.grabWeaponWithNoDrawHand ();
        }

        if (carryingWeapon && usingWeaponAsOneHandWield) {
            if (usingWeaponAsOneHandWield) {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    currentIKWeaponsPosition.handInPositionToAim = true;
                }

                weaponsManager.getIKSystem ().checkHandsInPosition (true);
            }
        }

        if (!carrying) {
            if (weaponsManager.checkIfHideWeaponMeshWhenNotUsed (hideWeaponIfKeptInThirdPerson)) {
                enableOrDisableWeaponMesh (false);
            }
        }

        if (checkIfDeactivateIKIfNotAimingActive () || IKPausedOnHandsActive) {
            if (carryingWeapon) {
                if (isUsingDualWeapon ()) {
                    newWeaponParent = leftHandMountPoint;

                    if (usingRightHandDualWeapon) {
                        newWeaponParent = rightHandMountPoint;
                    }

                    if (usingRightHandDualWeapon) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                    } else {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                    }

                    currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                    currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                    currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                    if (newWeaponParent == null) {
                        newWeaponParent = currentIKWeaponsPosition.handTransform;
                    }

                    setWeaponTransformParent (newWeaponParent);
                } else {
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {
                            newWeaponParent = leftHandMountPoint;

                            if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                                newWeaponParent = rightHandMountPoint;
                            }

                            currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                            currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                            currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                            if (newWeaponParent == null) {
                                newWeaponParent = currentIKWeaponsPosition.handTransform;
                            }

                            setWeaponTransformParent (newWeaponParent);
                        }
                    }
                }

                setHandsIKTargetValue (0, 0);
                setElbowsIKTargetValue (0, 0);
            }
        }

        if (!carrying) {
            setWeaponParent (carrying);

            IKPausedOnHandsActive = false;

            if (isFullBodyAwarenessActive ()) {
                checkIfSetNewAnimatorWeaponID ();
            }
        }

        setLastTimeMoved ();

        drawingWeaponInProcess = false;
        holsteringWeaponInProcess = false;

        drawKeepWeaponAnimationInProcess = false;
    }

    public void setHandDeactivateIKStateToDisable ()
    {
        currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
        currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
        currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;

        setHandIKWeightValue (currentIKWeaponsPosition, 1);

        setHandTargetValue (currentIKWeaponsPosition, 1);
    }
    void setHandIKWeightValue (IKWeaponsPosition handInfo, float newValue)
    {
        handInfo.HandIKWeight = newValue;
    }

    public void setHandTargetValue (IKWeaponsPosition handInfo, float newValue)
    {
        handInfo.targetValue = newValue;
    }

    public void setElbowTargetValue (IKWeaponsPosition handInfo, float newValue)
    {
        handInfo.elbowInfo.targetValue = newValue;
    }

    public void placeWeaponDirectlyOnDrawHand (bool state)
    {
        bool moveWeapon = false;

        carrying = state;

        drawingWeaponInProcess = false;
        holsteringWeaponInProcess = false;

        drawKeepWeaponAnimationInProcess = false;

        if (carrying) {
            checkIfSetNewAnimatorWeaponID ();
        }

        if (carrying) {
            setWeaponParent (carrying);
        }

        if (carrying) {
            //draw the weapon
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                } else {
                    currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                }
            } else {
                currentDrawPositionTransform = thirdPersonWeaponInfo.walkPosition;
            }

            checkIfAddFBAWalkPositionOffset ();

            checkIfAddFBACrouchPositionOffset ();

            moveWeapon = true;
        } else {
            //if the weapon is in its carrying position or if the weapon was moving towards its carrying position, stop it, reverse the path and start the movement
            if (carryingWeapon || moving) {

                aiming = false;
                moveWeapon = true;
            }
        }

        //stop the coroutine to translate the camera and call it again
        stopWeaponMovement ();

        if (moveWeapon) {
            weaponMovement = StartCoroutine (placeWeaponDirectlyOnDrawHandCoroutine ());
        }

        resetOtherWeaponsStates ();

        disableOtherWeaponsStates ();

        setPlayerControllerMovementValues ();

        if (!carrying) {
            checkIfSetNewAnimatorWeaponID ();
        }
    }

    IEnumerator placeWeaponDirectlyOnDrawHandCoroutine ()
    {
        //print ("drawOrKeepWeaponThirdPersonCoroutine "+ carrying);
        setWeaponMovingState (true);

        bool originallyDeactivateIKIfNotAiming = false;

        if (carrying) {

            setWeaponTransformParent (weaponSystemManager.getWeaponParent ());

            enableOrDisableWeaponMesh (true);

            if (checkIfDeactivateIKIfNotAimingActive ()) {
                if (carrying) {
                    originallyDeactivateIKIfNotAiming = true;

                    quickDrawWeaponThirdPerson ();

                    if (usingDualWeapon) {
                        if (usingRightHandDualWeapon) {
                            weaponsManager.getIKSystem ().quickDrawWeaponStateDualWeapon (thirdPersonWeaponInfo, true);
                        } else {
                            weaponsManager.getIKSystem ().quickDrawWeaponStateDualWeapon (thirdPersonWeaponInfo, false);
                        }
                    } else {
                        weaponsManager.getIKSystem ().quickDrawWeaponState (thirdPersonWeaponInfo);
                    }
                }
            } else {
                if (carrying) {
                    setDeactivateIKIfNotAimingState (true);

                    quickDrawWeaponThirdPerson ();

                    setDeactivateIKIfNotAimingState (false);
                }
            }

            if (!originallyDeactivateIKIfNotAiming) {

                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                    } else {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                    }

                    setHandDeactivateIKStateToDisable ();
                } else {
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {
                            setHandDeactivateIKStateToDisable ();
                        }
                    }
                }

                if (thirdPersonWeaponInfo.useWeaponRotationPoint) {
                    bool useRegularWeaponRotationPointHolder = true;

                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.useDualRotationPoint) {
                                setWeaponTransformParent (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponRotationPointHolder);

                                useRegularWeaponRotationPointHolder = false;
                            }
                        } else {
                            if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.useDualRotationPoint) {
                                setWeaponTransformParent (thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponRotationPointHolder);

                                useRegularWeaponRotationPointHolder = false;
                            }
                        }
                    }

                    if (useRegularWeaponRotationPointHolder) {
                        setWeaponTransformParent (thirdPersonWeaponInfo.weaponRotationPointHolder);
                    }
                } else {
                    setWeaponTransformParent (transform);
                }

                resetElbowIKPositions ();

                bool targetReached = false;

                float angleDifference = 0;

                float movementTimer = 0;

                float dist = GKC_Utils.distance (weaponTransform.position, currentDrawPositionTransform.position);

                float duration = dist / thirdPersonWeaponInfo.drawWeaponMovementSpeed;

                float t = 0;

                Vector3 pos = currentDrawPositionTransform.localPosition;
                Quaternion rot = currentDrawPositionTransform.localRotation;

                if (isFullBodyAwarenessActive ()) {
                    if (aiming) {
                        if (overrideFBAValuesForOffset) {
                            pos = currentFBAAimPositionOffset;

                            rot = Quaternion.Euler (currentFBAAimRotationOffset);
                        } else {
                            pos += currentFBAAimPositionOffset;

                            rot *= Quaternion.Euler (currentFBAAimRotationOffset);
                        }
                    } else {
                        if (overrideFBAValuesForOffset) {
                            pos = currentFBAWalkPositionOffset;

                            rot = Quaternion.Euler (currentFBAWalkRotationOffset);
                        } else {
                            pos += currentFBAWalkPositionOffset;

                            rot *= Quaternion.Euler (currentFBAWalkRotationOffset);
                        }
                    }
                }

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

                    weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, pos, t);
                    weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, rot, t);

                    angleDifference = Quaternion.Angle (weaponTransform.localRotation, rot);

                    movementTimer += Time.deltaTime;

                    if ((GKC_Utils.distance (weaponTransform.localPosition, pos) < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 1)) {
                        targetReached = true;
                    }

                    yield return null;
                }

                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                    } else {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                    }

                    setElbowTargetValue (currentIKWeaponsPosition, 1);
                } else {
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {
                            setElbowTargetValue (currentIKWeaponsPosition, 1);
                        }
                    }
                }

                if (!isUsingDualWeapon ()) {
                    weaponsManager.grabWeaponWithNoDrawHand ();
                }
            }
        } else {
            if (isUsingDualWeapon ()) {
                newWeaponParent = leftHandMountPoint;

                if (usingRightHandDualWeapon) {
                    newWeaponParent = rightHandMountPoint;
                }

                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                if (newWeaponParent == null) {
                    newWeaponParent = currentIKWeaponsPosition.handTransform;
                }

                setWeaponTransformParent (newWeaponParent);
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        newWeaponParent = leftHandMountPoint;

                        if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                            newWeaponParent = rightHandMountPoint;
                        }

                        currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                        currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                        currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                        if (newWeaponParent == null) {
                            newWeaponParent = currentIKWeaponsPosition.handTransform;
                        }

                        setWeaponTransformParent (newWeaponParent);
                    }
                }
            }

            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                setElbowTargetValue (currentIKWeaponsPosition, 0);
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    setElbowTargetValue (currentIKWeaponsPosition, 0);

                    if (!currentIKWeaponsPosition.usedToDrawWeapon) {
                        currentIKWeaponsPosition.elbowInfo.position.SetParent (transform);
                    }
                }
            }

            setHandsIKTargetValue (0, 0);
            setElbowsIKTargetValue (0, 0);

            bool targetReached = false;

            while (!targetReached) {
                if (disablingDualWeapon) {
                    if (usingRightHandDualWeapon) {
                        if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0].HandIKWeight <= 0) {
                            targetReached = true;
                        }
                    } else {
                        if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0].HandIKWeight <= 0) {
                            targetReached = true;
                        }
                    }
                } else {
                    int c = 0;
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        if (thirdPersonWeaponInfo.handsInfo [i].HandIKWeight == 0) {
                            c++;
                        }
                    }

                    if (c == 2) {
                        targetReached = true;
                    }
                }

                yield return null;
            }

            quickKeepWeaponThirdPerson ();
        }

        setWeaponMovingState (false);

        carryingWeapon = carrying;

        if (!carrying) {
            setWeaponParent (carrying);

            IKPausedOnHandsActive = false;
        }
    }

    void checkWeaponRotationPointHolderInitialized ()
    {
        if (!weaponRotationPointHolderInitialized) {
            thirdPersonWeaponInfo.weaponRotationPointHolder.position = transform.position;
            thirdPersonWeaponInfo.weaponRotationPointHolder.rotation = transform.rotation;

            if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.useDualRotationPoint) {
                if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponRotationPointHolder != null) {
                    thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponRotationPointHolder.position = transform.position;
                    thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponRotationPointHolder.rotation = transform.rotation;
                }
            }

            if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.useDualRotationPoint) {
                if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponRotationPointHolder != null) {
                    thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponRotationPointHolder.position = transform.position;
                    thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponRotationPointHolder.rotation = transform.rotation;
                }
            }

            weaponRotationPointHolderInitialized = true;


            Vector3 lastPosition = thirdPersonWeaponInfo.aimPosition.localPosition;
            Vector3 lastRotation = thirdPersonWeaponInfo.aimPosition.localEulerAngles;

            thirdPersonWeaponInfo.aimPosition.SetParent (thirdPersonWeaponInfo.weaponRotationPointHolder);

            thirdPersonWeaponInfo.aimPosition.localPosition = lastPosition;
            thirdPersonWeaponInfo.aimPosition.localEulerAngles = lastRotation;


            lastPosition = thirdPersonWeaponInfo.walkPosition.localPosition;
            lastRotation = thirdPersonWeaponInfo.walkPosition.localEulerAngles;

            thirdPersonWeaponInfo.walkPosition.SetParent (thirdPersonWeaponInfo.weaponRotationPointHolder);

            thirdPersonWeaponInfo.walkPosition.localPosition = lastPosition;
            thirdPersonWeaponInfo.walkPosition.localEulerAngles = lastRotation;


            lastPosition = thirdPersonWeaponInfo.aimRecoilPosition.localPosition;
            lastRotation = thirdPersonWeaponInfo.aimRecoilPosition.localEulerAngles;

            thirdPersonWeaponInfo.aimRecoilPosition.SetParent (thirdPersonWeaponInfo.weaponRotationPointHolder);

            thirdPersonWeaponInfo.aimRecoilPosition.localPosition = lastPosition;
            thirdPersonWeaponInfo.aimRecoilPosition.localEulerAngles = lastRotation;
        }
    }

    public void aimOrDrawWeaponThirdPerson (bool state)
    {
        if (currentWeapon) {
            aiming = state;

            if (carrying) {
                checkIfSetNewAnimatorWeaponID ();
            }

            aimingWeaponInProcess = true;

            if (surfaceDetected) {
                surfaceDetected = false;

                bool firstPersonActive = isPlayerCameraFirstPersonActive ();

                setWeaponRegularCursorState (firstPersonActive);
            }

            if (aiming) {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentAimPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.aimPosition;
                    } else {
                        currentAimPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.aimPosition;
                    }
                } else {
                    currentAimPositionTransform = thirdPersonWeaponInfo.aimPosition;
                }

                checkIfAddFBAAimPositionOffset ();

                checkIfAddFBAWalkPositionOffset ();
            } else {

                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentAimPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                    } else {
                        currentAimPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                    }
                } else {
                    currentAimPositionTransform = thirdPersonWeaponInfo.walkPosition;
                }

                checkIfAddFBAWalkPositionOffset ();

                checkIfAddFBACrouchPositionOffset ();
            }

            weaponPositionTarget = currentAimPositionTransform.localPosition;
            weaponRotationTarget = currentAimPositionTransform.localRotation;

            if (isFullBodyAwarenessActive ()) {
                if (aiming) {
                    if (isAimModeInputPressed ()) {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBAAimPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBAAimRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBAAimPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBAAimRotationOffset);
                        }
                    } else {
                        if (isPlayerCrouching ()) {
                            if (overrideFBAValuesForOffset) {
                                weaponPositionTarget = currentFBACrouchPositionOffset;

                                weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                            } else {
                                weaponPositionTarget += currentFBACrouchPositionOffset;

                                weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                            }
                        } else {
                            if (overrideFBAValuesForOffset) {
                                weaponPositionTarget = currentFBAWalkPositionOffset;

                                weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                            } else {
                                weaponPositionTarget += currentFBAWalkPositionOffset;

                                weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                            }
                        }
                    }
                } else {
                    if (isPlayerCrouching ()) {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBACrouchPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBACrouchPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                        }
                    } else {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBAWalkPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBAWalkPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                        }
                    }
                }
            }

            //stop the coroutine to translate the camera and call it again
            stopWeaponMovement ();

            if (!weaponsManager.isPauseWeaponAimMovementActive ()) {
                weaponMovement = StartCoroutine (aimOrDrawWeaponThirdPersonCoroutine ());
            }

            disableOtherWeaponsStates ();

            setPlayerControllerMovementValues ();

            setLastTimeMoved ();

            if (thirdPersonWeaponInfo.useSwayInfo) {

                setCurrentSwayInfo (!weaponInRunPosition);

                if (aiming) {
                    resetSwayValue ();
                }
            }
        }
    }

    IEnumerator aimOrDrawWeaponThirdPersonCoroutine ()
    {
        if (checkIfDeactivateIKIfNotAimingActive () || IKPausedOnHandsActive) {

            if (IKPausedOnHandsActive) {
                actionActive = false;

                IKPausedOnHandsActive = false;
            }

            bool rightHandUsedToDrawWeapon = false;

            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                    rightHandUsedToDrawWeapon = true;
                }

                if (aiming) {
                    currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                    currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                    currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;

                    setHandIKWeightValue (currentIKWeaponsPosition, 1);
                }
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                            rightHandUsedToDrawWeapon = true;
                        }

                        if (aiming) {
                            currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                            currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                            currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;

                            setHandIKWeightValue (currentIKWeaponsPosition, 1);
                        }
                    }
                }
            }

            if (aiming) {
                if (thirdPersonWeaponInfo.useWeaponRotationPoint) {
                    bool useRegularWeaponRotationPointHolder = true;

                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.useDualRotationPoint) {
                                setWeaponTransformParent (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponRotationPointHolder);

                                useRegularWeaponRotationPointHolder = false;
                            }
                        } else {
                            if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.useDualRotationPoint) {
                                setWeaponTransformParent (thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponRotationPointHolder);

                                useRegularWeaponRotationPointHolder = false;
                            }
                        }
                    }

                    if (useRegularWeaponRotationPointHolder) {
                        setWeaponTransformParent (thirdPersonWeaponInfo.weaponRotationPointHolder);
                    }
                } else {
                    setWeaponTransformParent (transform);
                }
            }

            if (rightHandUsedToDrawWeapon) {
                setHandsIKTargetValue (0, 1);
                setElbowsIKTargetValue (0, 1);
            } else {
                setHandsIKTargetValue (1, 0);
                setElbowsIKTargetValue (1, 0);
            }
        } else {
            if (thirdPersonWeaponInfo.useWeaponRotationPoint) {
                if (aiming) {
                    bool useRegularWeaponRotationPointHolder = true;

                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.useDualRotationPoint) {
                                setWeaponTransformParent (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponRotationPointHolder);

                                useRegularWeaponRotationPointHolder = false;
                            }
                        } else {
                            if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.useDualRotationPoint) {
                                setWeaponTransformParent (thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponRotationPointHolder);

                                useRegularWeaponRotationPointHolder = false;
                            }
                        }
                    }

                    if (useRegularWeaponRotationPointHolder) {
                        setWeaponTransformParent (thirdPersonWeaponInfo.weaponRotationPointHolder);
                    }
                } else {
                    setWeaponTransformParent (transform);
                }
            }
        }

        bool placeWeaponOnWalkPositionBeforeDeactivateIK = false;

        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                placeWeaponOnWalkPositionBeforeDeactivateIK = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.placeWeaponOnWalkPositionBeforeDeactivateIK;
            } else {
                placeWeaponOnWalkPositionBeforeDeactivateIK = thirdPersonWeaponInfo.leftHandDualWeaponInfo.placeWeaponOnWalkPositionBeforeDeactivateIK;
            }
        } else {
            placeWeaponOnWalkPositionBeforeDeactivateIK = thirdPersonWeaponInfo.placeWeaponOnWalkPositionBeforeDeactivateIK;
        }

        if (!actionActive && !weaponSystemManager.isReloadingWithAnimationActive ()) {
            if (aiming || !checkIfDeactivateIKIfNotAimingActive () || placeWeaponOnWalkPositionBeforeDeactivateIK) {
                bool moveWeaponResult = true;

                if (isFullBodyAwarenessActive () && !isAimModeInputPressed ()) {
                    //if (aiming) {
                    float weaponDistance = GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget);

                    if (weaponDistance < 0.04f) {
                        moveWeaponResult = false;
                    }
                    //}
                }

                if (!aiming && checkIfDeactivateIKIfNotAimingActive () && !isFullBodyAwarenessActive ()) {
                    moveWeaponResult = false;
                }

                if (moveWeaponResult) {
                    setWeaponMovingState (true);

                    //float dist = GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget);

                    //float duration = dist / thirdPersonWeaponInfo.aimMovementSpeed;

                    //float t = 0;

                    //float movementTimer = 0;

                    //bool targetReached = false;

                    //float angleDifference = 0;

                    //float positionDifference = 0;

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

                    //    weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, weaponPositionTarget, t);
                    //    weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, weaponRotationTarget, t);

                    //    angleDifference = Quaternion.Angle (weaponTransform.localRotation, weaponRotationTarget);

                    //    positionDifference = GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget);

                    //    movementTimer += Time.deltaTime;

                    //    if ((positionDifference < 0.001f && angleDifference < 0.1f) || movementTimer > (duration + 1)) {
                    //        targetReached = true;
                    //    }

                    //    yield return null;
                    //}

                    Vector3 currentWeaponPosition = weaponTransform.localPosition;
                    Quaternion currentWeaponRotation = weaponTransform.localRotation;

                    for (float t = 0; t < 1;) {
                        t += Time.smoothDeltaTime * thirdPersonWeaponInfo.aimMovementSpeed;

                        weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
                        weaponTransform.localRotation = Quaternion.Lerp (weaponTransform.localRotation, weaponRotationTarget, t);

                        yield return null;
                    }

                    setWeaponMovingState (false);
                }
            }
        }

        if (checkIfDeactivateIKIfNotAimingActive ()) {
            if (aiming) {
                setHandsIKTargetValue (1, 1);
                setElbowsIKTargetValue (1, 1);

                setGrabbingHandStateOnSingleHand (true, true);
            } else {
                if (isUsingDualWeapon ()) {
                    newWeaponParent = leftHandMountPoint;

                    if (usingRightHandDualWeapon) {
                        newWeaponParent = rightHandMountPoint;
                    }

                    if (usingRightHandDualWeapon) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                    } else {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                    }

                    currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                    currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                    currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                    if (newWeaponParent == null) {
                        newWeaponParent = currentIKWeaponsPosition.handTransform;
                    }

                    setWeaponTransformParent (newWeaponParent);
                } else {
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {
                            newWeaponParent = leftHandMountPoint;

                            if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                                newWeaponParent = rightHandMountPoint;
                            }

                            currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                            currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                            currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                            if (newWeaponParent == null) {
                                newWeaponParent = currentIKWeaponsPosition.handTransform;
                            }

                            setWeaponTransformParent (newWeaponParent);
                        }
                    }
                }

                setHandsIKTargetValue (0, 0);

                setElbowsIKTargetValue (0, 0);

                setGrabbingHandStateOnSingleHand (true, false);
            }
        }

        aimingWeaponInProcess = false;

        if (carrying && !aiming) {
            if (!ignoreCrouchWhileWeaponActive && isPlayerCrouching () && !isFullBodyAwarenessActive ()) {
                enableOrDisableIKOnHands (false);
            }
        }
    }

    void setGrabbingHandStateOnSingleHand (bool carryingWeapon, bool handInPosition)
    {
        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            if (currentIKWeaponsPosition.handUsedInWeapon && !currentIKWeaponsPosition.usedToDrawWeapon) {
                bool isRightHand = (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand);

                weaponsManager.setGrabbingHandStateOnSingleHand (carryingWeapon, isRightHand, handInPosition);
            }
        }
    }

    public void walkOrSurfaceCollision (bool state)
    {
        if (currentWeapon) {
            surfaceDetected = state;

            bool firstPersonActive = isPlayerCameraFirstPersonActive ();

            float movementSpeed = thirdPersonWeaponInfo.collisionMovementSpeed;

            if (firstPersonActive) {
                movementSpeed = firstPersonWeaponInfo.collisionMovementSpeed;
            }

            if (surfaceDetected) {
                if (firstPersonActive) {
                    if (firstPersonWeaponInfo.lowerWeaponPosition && weaponsManager.isCarryWeaponInLowerPositionActive ()) {
                        if (isUsingDualWeapon ()) {
                            if (usingRightHandDualWeapon) {
                                currentCollisionPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.lowerWeaponPosition;
                            } else {
                                currentCollisionPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.lowerWeaponPosition;
                            }
                        } else {
                            currentCollisionPositionTransform = firstPersonWeaponInfo.lowerWeaponPosition;
                        }

                    } else {
                        if (isUsingDualWeapon ()) {
                            if (usingRightHandDualWeapon) {
                                currentCollisionPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.surfaceCollisionPosition;
                            } else {
                                currentCollisionPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.surfaceCollisionPosition;
                            }
                        } else {
                            currentCollisionPositionTransform = firstPersonWeaponInfo.surfaceCollisionPosition;
                        }

                    }
                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentCollisionPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.surfaceCollisionPosition;
                        } else {
                            currentCollisionPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.surfaceCollisionPosition;
                        }
                    } else {
                        currentCollisionPositionTransform = thirdPersonWeaponInfo.surfaceCollisionPosition;
                    }

                    checkIfAddFBAObstaclePositionOffset ();
                }
            } else {
                if (firstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            if (crouchingActive) {
                                currentCollisionPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                            } else {
                                currentCollisionPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                            }
                        } else {
                            if (crouchingActive) {
                                currentCollisionPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                            } else {
                                currentCollisionPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                            }
                        }
                    } else {
                        if (crouchingActive) {
                            currentCollisionPositionTransform = firstPersonWeaponInfo.crouchPosition;
                        } else {
                            currentCollisionPositionTransform = firstPersonWeaponInfo.walkPosition;
                        }
                    }

                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentCollisionPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.aimPosition;
                        } else {
                            currentCollisionPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.aimPosition;
                        }
                    } else {
                        currentCollisionPositionTransform = thirdPersonWeaponInfo.aimPosition;
                    }

                    checkIfAddFBAAimPositionOffset ();
                }
            }

            weaponPositionTarget = currentCollisionPositionTransform.localPosition;
            weaponRotationTarget = currentCollisionPositionTransform.localRotation;

            if (isFullBodyAwarenessActive ()) {
                if (surfaceDetected) {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBAObstaclePositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBAObstacleRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBAObstaclePositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBAObstacleRotationOffset);
                    }
                } else {
                    if (isPlayerCrouching ()) {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBACrouchPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBACrouchPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                        }
                    } else {
                        if (aiming) {
                            if (overrideFBAValuesForOffset) {
                                weaponPositionTarget = currentFBAAimPositionOffset;

                                weaponRotationTarget = Quaternion.Euler (currentFBAAimRotationOffset);
                            } else {
                                weaponPositionTarget += currentFBAAimPositionOffset;

                                weaponRotationTarget *= Quaternion.Euler (currentFBAAimRotationOffset);
                            }
                        } else {
                            if (overrideFBAValuesForOffset) {
                                weaponPositionTarget = currentFBAWalkPositionOffset;

                                weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                            } else {
                                weaponPositionTarget += currentFBAWalkPositionOffset;

                                weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                            }
                        }
                    }
                }
            }

            setWeaponRegularCursorState (firstPersonActive);

            if (!firstPersonActive) {
                if (!isUsingDualWeapon ()) {
                    weaponsManager.checkSetExtraRotationCoroutine (!state);
                }
            }

            stopWeaponMovement ();

            activateMoveWeaponToPositionCoroutine (movementSpeed);
        }
    }

    public void setWeaponRegularCursorState (bool firstPersonActive)
    {
        if (firstPersonActive) {
            if (isUsingDualWeapon ()) {
                if (surfaceDetected) {
                    if (!weaponsManager.currentRightIKWeapon.isWeaponSurfaceDetected () || !weaponsManager.currentLeftIkWeapon.isWeaponSurfaceDetected ()) {
                        return;
                    }
                }
            }

            if (firstPersonWeaponInfo.hideCursorOnCollision) {
                weaponsManager.enableOrDisableGeneralWeaponCursor (!surfaceDetected);
                cursorHidden = surfaceDetected;
            } else {
                weaponsManager.enableOrDisableGeneralWeaponCursor (true);
            }
        } else {
            if (thirdPersonWeaponInfo.hideCursorOnCollision) {
                weaponsManager.enableOrDisableGeneralWeaponCursor (!surfaceDetected);
                cursorHidden = surfaceDetected;
            } else {
                weaponsManager.enableOrDisableGeneralWeaponCursor (true);
            }
        }

        weaponsManager.enableOrDisableWeaponCursorUnableToShoot (surfaceDetected);

        weaponsManager.checkIfAnyReticleActive ();
    }

    public void walkOrRunWeaponPosition (bool state)
    {
        if (currentWeapon && weaponInRunPosition != state) {
            weaponInRunPosition = state;

            surfaceDetected = false;
            meleeAtacking = false;

            bool firstPersonActive = isPlayerCameraFirstPersonActive ();

            float movementSpeed = thirdPersonWeaponInfo.runMovementSpeed;

            if (firstPersonActive) {
                movementSpeed = firstPersonWeaponInfo.runMovementSpeed;
            }

            if (weaponInRunPosition) {
                if (firstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentWalkOrRunPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.runPosition;
                        } else {
                            currentWalkOrRunPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.runPosition;
                        }
                    } else {
                        currentWalkOrRunPositionTransform = firstPersonWeaponInfo.runPosition;
                    }
                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentWalkOrRunPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.runPosition;
                        } else {
                            currentWalkOrRunPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.runPosition;
                        }
                    } else {
                        currentWalkOrRunPositionTransform = thirdPersonWeaponInfo.runPosition;
                    }

                    checkIfAddFBARunPositionOffset ();
                }
            } else {
                if (firstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            if (crouchingActive) {
                                currentWalkOrRunPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                            } else {
                                currentWalkOrRunPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                            }
                        } else {
                            if (crouchingActive) {
                                currentWalkOrRunPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                            } else {
                                currentWalkOrRunPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                            }
                        }
                    } else {
                        if (crouchingActive) {
                            currentWalkOrRunPositionTransform = firstPersonWeaponInfo.crouchPosition;
                        } else {
                            currentWalkOrRunPositionTransform = firstPersonWeaponInfo.walkPosition;
                        }
                    }
                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentWalkOrRunPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                        } else {
                            currentWalkOrRunPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                        }
                    } else {
                        currentWalkOrRunPositionTransform = thirdPersonWeaponInfo.walkPosition;
                    }

                    checkIfAddFBAWalkPositionOffset ();

                    checkIfAddFBACrouchPositionOffset ();
                }
            }

            if (currentWalkOrRunPositionTransform != null) {
                weaponPositionTarget = currentWalkOrRunPositionTransform.localPosition;
                weaponRotationTarget = currentWalkOrRunPositionTransform.localRotation;
            } else {
                weaponPositionTarget = Vector3.zero;
                weaponRotationTarget = Quaternion.identity;
            }

            if (isFullBodyAwarenessActive ()) {
                if (weaponInRunPosition) {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBARunPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBARunRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBARunPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBARunRotationOffset);
                    }
                } else {
                    if (isPlayerCrouching ()) {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBACrouchPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBACrouchPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                        }
                    } else {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBAWalkPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBAWalkPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                        }
                    }
                }
            }

            checkCursorState (firstPersonActive);

            stopWeaponMovement ();

            if (firstPersonActive && useWeaponAnimatorFirstPerson) {
                if (state) {
                    mainWeaponAnimatorSystem.setRunState (true);
                } else {
                    mainWeaponAnimatorSystem.setWalkState (true);
                }

                if (!mainWeaponAnimatorSystem.useWalkRunExtraMovement) {
                    return;
                }
            }

            bool activateMoveWeaponResult = true;

            if (!ignoreCrouchWhileWeaponActive && isPlayerCrouching ()) {
                activateMoveWeaponResult = false;
            }

            crouchingActive = false;

            if (activateMoveWeaponResult) {
                activateMoveWeaponToPositionCoroutine (movementSpeed);
            }
        }
    }

    public void checkCursorState (bool firstPersonActive)
    {
        if (firstPersonActive) {
            if (firstPersonWeaponInfo.hideCursorOnRun) {
                weaponsManager.enableOrDisableGeneralWeaponCursor (!weaponInRunPosition);
                cursorHidden = weaponInRunPosition;
            }

            if (firstPersonWeaponInfo.useSwayInfo || thirdPersonWeaponInfo.useSwayInfo) {
                setCurrentSwayInfo (!weaponInRunPosition);
            }
        } else {
            if (thirdPersonWeaponInfo.hideCursorOnRun) {
                weaponsManager.enableOrDisableGeneralWeaponCursor (!weaponInRunPosition);
                cursorHidden = weaponInRunPosition;
            }

            if (firstPersonWeaponInfo.useSwayInfo || thirdPersonWeaponInfo.useSwayInfo) {
                setCurrentSwayInfo (!weaponInRunPosition);
            }
        }

        weaponsManager.checkIfAnyReticleActive ();
    }

    public void setJumpStatetWeaponPosition (bool isJumpStart, bool isJumpEnd)
    {
        if (currentWeapon) {
            bool firstPersonActive = isPlayerCameraFirstPersonActive ();

            meleeAtacking = false;

            weaponInRunPosition = false;

            float movementSpeed = 0;

            if (firstPersonActive) {
                if (isJumpStart) {
                    movementSpeed = firstPersonWeaponInfo.jumpStartMovementSpeed;
                } else {
                    movementSpeed = firstPersonWeaponInfo.jumpEndtMovementSpeed;
                }
            } else {
                if (isJumpStart) {
                    movementSpeed = thirdPersonWeaponInfo.jumpStartMovementSpeed;
                } else {
                    movementSpeed = thirdPersonWeaponInfo.jumpEndtMovementSpeed;
                }
            }

            float delayAtJumpEnd = thirdPersonWeaponInfo.delayAtJumpEnd;

            if (firstPersonActive) {
                delayAtJumpEnd = firstPersonWeaponInfo.delayAtJumpEnd;
            }

            weaponInJumpStart = isJumpStart;
            weaponInJumpEnd = isJumpEnd;

            if (!jumpingOnProcess) {
                jumpingOnProcess = true;
            }

            if (weaponInJumpStart) {
                if (firstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentJumpPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.jumpStartPosition;
                        } else {
                            currentJumpPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.jumpStartPosition;
                        }
                    } else {
                        currentJumpPositionTransform = firstPersonWeaponInfo.jumpStartPosition;
                    }

                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentJumpPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.jumpStartPosition;
                        } else {
                            currentJumpPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.jumpStartPosition;
                        }
                    } else {
                        currentJumpPositionTransform = thirdPersonWeaponInfo.jumpStartPosition;
                    }

                    checkIfAddFBAJumpStartPositionOffset ();

                }
            } else {
                if (firstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentJumpPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.jumpEndPosition;
                        } else {
                            currentJumpPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.jumpEndPosition;
                        }
                    } else {
                        currentJumpPositionTransform = firstPersonWeaponInfo.jumpEndPosition;
                    }

                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentJumpPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.jumpEndPosition;
                        } else {
                            currentJumpPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.jumpEndPosition;
                        }
                    } else {
                        currentJumpPositionTransform = thirdPersonWeaponInfo.jumpEndPosition;
                    }

                    checkIfAddFBAJumpEndPositionOffset ();

                }
            }

            if (currentJumpPositionTransform != null) {
                weaponPositionTarget = currentJumpPositionTransform.localPosition;
                weaponRotationTarget = currentJumpPositionTransform.localRotation;
            }

            if (isFullBodyAwarenessActive ()) {
                if (weaponInJumpStart) {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBAJumpStartPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBAJumpStartRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBAJumpStartPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBAJumpStartRotationOffset);
                    }
                } else {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBAJumpEndPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBAJumpEndRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBAJumpEndPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBAJumpEndRotationOffset);
                    }
                }
            }

            stopWeaponMovement ();

            if (isJumpStart) {
                activateMoveWeaponToPositionCoroutine (movementSpeed);
            } else {
                weaponMovement = StartCoroutine (weaponEndJumpCoroutine (movementSpeed, delayAtJumpEnd));
            }
        }
    }

    void activateMoveWeaponToPositionCoroutine (float movementSpeed)
    {
        weaponMovement = StartCoroutine (moveWeaponToPositionCoroutine (movementSpeed));
    }

    IEnumerator moveWeaponToPositionCoroutine (float movementSpeed)
    {
        Vector3 currentWeaponPosition = weaponTransform.localPosition;
        Quaternion currentWeaponRotation = weaponTransform.localRotation;

        for (float t = 0; t < 1;) {
            t += Time.deltaTime * movementSpeed;

            weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
            weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

            yield return null;
        }
    }

    public void updateWeaponWalkPositionToFullBodyAwarenessState (bool state)
    {
        if (moving) {
            return;
        }

        if (isDeactivateIKIfNotAimingActive ()) {
            return;
        }

        if (aiming) {
            return;
        }

        if (IKPausedOnHandsActive) {
            return;
        }

        weaponInRunPosition = false;

        //if (state && aimingWeaponInProcess && !aiming) {
        //    print ("stop aiming in process");
        //}

        float movementSpeed = thirdPersonWeaponInfo.FBAMoveWalkPositionSpeed;

        if (isUsingDualWeapon () || weaponConfiguredAsDualWeaponPreviously) {
            if (usingRightHandDualWeapon) {
                currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
            } else {
                currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
            }

        } else {
            currentDrawPositionTransform = thirdPersonWeaponInfo.walkPosition;
        }

        weaponPositionTarget = currentDrawPositionTransform.localPosition;
        weaponRotationTarget = currentDrawPositionTransform.localRotation;

        if (state) {
            checkIfAddFBAWalkPositionOffset ();

            checkIfAddFBACrouchPositionOffset ();

            if (isPlayerCrouching ()) {
                if (overrideFBAValuesForOffset) {
                    weaponPositionTarget = currentFBACrouchPositionOffset;

                    weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                } else {
                    weaponPositionTarget += currentFBACrouchPositionOffset;

                    weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                }
            } else {
                if (overrideFBAValuesForOffset) {
                    weaponPositionTarget = currentFBAWalkPositionOffset;

                    weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                } else {
                    weaponPositionTarget += currentFBAWalkPositionOffset;

                    weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                }
            }
        }

        stopWeaponMovement ();

        activateMoveWeaponToPositionCoroutine (movementSpeed);
    }

    IEnumerator weaponEndJumpCoroutine (float movementSpeed, float delayAtJumpEnd)
    {
        Vector3 currentWeaponPosition = weaponTransform.localPosition;
        Quaternion currentWeaponRotation = weaponTransform.localRotation;

        for (float t = 0; t < 1;) {
            t += Time.deltaTime * movementSpeed;

            weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
            weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

            yield return null;
        }

        WaitForSeconds delay = new WaitForSeconds (delayAtJumpEnd);

        yield return delay;

        bool firstPersonActive = isPlayerCameraFirstPersonActive ();

        if (firstPersonActive) {
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    if (crouchingActive) {
                        currentJumpPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                    } else {
                        currentJumpPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                    }
                } else {
                    if (crouchingActive) {
                        currentJumpPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                    } else {
                        currentJumpPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                    }
                }
            } else {
                if (crouchingActive) {
                    currentJumpPositionTransform = firstPersonWeaponInfo.crouchPosition;
                } else {
                    currentJumpPositionTransform = firstPersonWeaponInfo.walkPosition;
                }
            }
        } else {
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentJumpPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                } else {
                    currentJumpPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                }
            } else {
                currentJumpPositionTransform = thirdPersonWeaponInfo.walkPosition;
            }

            if (crouchingActive) {
                checkIfAddFBACrouchPositionOffset ();
            } else {
                checkIfAddFBAWalkPositionOffset ();
            }

            checkIfAddFBAJumpEndPositionOffset ();
        }

        if (currentJumpPositionTransform != null) {
            weaponPositionTarget = currentJumpPositionTransform.localPosition;
            weaponRotationTarget = currentJumpPositionTransform.localRotation;
        }

        if (isFullBodyAwarenessActive ()) {
            if (crouchingActive) {
                if (overrideFBAValuesForOffset) {
                    weaponPositionTarget = currentFBACrouchPositionOffset;

                    weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                } else {
                    weaponPositionTarget += currentFBACrouchPositionOffset;

                    weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                }
            } else {
                if (overrideFBAValuesForOffset) {
                    weaponPositionTarget = currentFBAWalkPositionOffset;

                    weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                } else {
                    weaponPositionTarget += currentFBAWalkPositionOffset;

                    weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                }
            }
        }

        if (firstPersonActive) {
            movementSpeed = firstPersonWeaponInfo.resetJumpMovementSped;
        } else {
            movementSpeed = thirdPersonWeaponInfo.resetJumpMovementSped;
        }

        stopWeaponMovement ();

        activateMoveWeaponToPositionCoroutine (movementSpeed);

        weaponInJumpEnd = false;
        jumpingOnProcess = false;
    }

    public void setCrouchStatetWeaponPosition (bool state)
    {
        if (currentWeapon) {
            bool firstPersonActive = isPlayerCameraFirstPersonActive ();

            setLastTimeMoved ();

            crouchingActive = state;

            meleeAtacking = false;

            weaponInRunPosition = false;

            float movementSpeed = 0;

            if (firstPersonActive) {
                movementSpeed = firstPersonWeaponInfo.crouchMovementSpeed;
            } else {
                movementSpeed = thirdPersonWeaponInfo.crouchMovementSpeed;
            }

            if (crouchingActive) {
                if (firstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentCrouchPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                        } else {
                            currentCrouchPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                        }
                    } else {
                        currentCrouchPositionTransform = firstPersonWeaponInfo.crouchPosition;
                    }

                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentCrouchPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                        } else {
                            currentCrouchPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                        }
                    } else {
                        currentCrouchPositionTransform = thirdPersonWeaponInfo.crouchPosition;
                    }

                }
            } else {
                if (firstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentCrouchPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                        } else {
                            currentCrouchPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                        }
                    } else {
                        currentCrouchPositionTransform = firstPersonWeaponInfo.walkPosition;
                    }

                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentCrouchPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                        } else {
                            currentCrouchPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                        }
                    } else {
                        currentCrouchPositionTransform = thirdPersonWeaponInfo.walkPosition;
                    }

                    checkIfAddFBAWalkPositionOffset ();
                }
            }

            if (surfaceDetected) {
                return;
            }

            if (currentCrouchPositionTransform != null) {
                weaponPositionTarget = currentCrouchPositionTransform.localPosition;
                weaponRotationTarget = currentCrouchPositionTransform.localRotation;
            }

            if (isFullBodyAwarenessActive ()) {
                checkIfAddFBACrouchPositionOffset ();

                checkIfAddFBAWalkPositionOffset ();

                if (crouchingActive) {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBACrouchPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBACrouchPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                    }
                } else {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBAWalkPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBAWalkPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                    }
                }
            }

            stopWeaponMovement ();

            activateMoveWeaponToPositionCoroutine (movementSpeed);
        }
    }

    public bool isWeaponInRunPosition ()
    {
        return weaponInRunPosition;
    }

    public bool useRunPositionOnFirstPerson ()
    {
        return useRunPositionFirstPerson;
    }

    public bool useRunPositionOnThirdPerson ()
    {
        return useRunPositionThirdPerson;
    }

    public bool useRunPositionOnFBA ()
    {
        return useRunPositionFBA;
    }

    public bool isPlayerRunning ()
    {
        return playerRunning;
    }

    public void setPlayerRunningState (bool state)
    {
        playerRunning = state;
    }

    public bool isWeaponItJumpStart ()
    {
        return weaponInJumpStart;
    }

    public bool isWeaponItJumpEnd ()
    {
        return weaponInJumpEnd;
    }

    public bool isjumpingOnProcess ()
    {
        return jumpingOnProcess;
    }

    public bool weaponUseJumpPositions ()
    {
        return (firstPersonWeaponInfo.useJumpPositions && isPlayerCameraFirstPersonActive ()) ||
        (thirdPersonWeaponInfo.useJumpPositions && !isPlayerCameraFirstPersonActive ()) ||
        isFullBodyAwarenessActive ();
    }

    public bool useNewFovOnRunOnThirdPerson ()
    {
        return useNewFovOnRunThirdPerson;
    }

    public bool useNewFovOnRunOnFirstPerson ()
    {
        return useNewFovOnRunFirstPerson;
    }

    public bool isCursorHidden ()
    {
        return cursorHidden;
    }

    public void setCursorHiddenState (bool state)
    {
        cursorHidden = state;
    }

    bool weaponsManagerLocated;

    public void setCurrentSwayInfo (bool state)
    {
        if (weaponsManagerLocated && (isPlayerCameraFirstPersonActive () || isFullBodyAwarenessActive ())) {
            if (state) {
                //print ("regular first person");
                currentlyUsingSway = firstPersonSwayInfo.useSway;

                if (currentlyUsingSway) {
                    currentSwayInfo = firstPersonSwayInfo;

                    currentSwayInfoAssigned = true;
                }
            } else {
                //print ("run first person");
                currentlyUsingSway = runFirstPersonSwayInfo.useSway;

                if (currentlyUsingSway) {
                    currentSwayInfo = runFirstPersonSwayInfo;

                    currentSwayInfoAssigned = true;
                }
            }
        } else {
            if (state) {
                //print ("regular third person");
                currentlyUsingSway = thirdPersonSwayInfo.useSway;

                if (currentlyUsingSway) {
                    currentSwayInfo = thirdPersonSwayInfo;

                    currentSwayInfoAssigned = true;
                }
            } else {
                //print ("run third person");
                currentlyUsingSway = runThirdPersonSwayInfo.useSway;

                if (currentlyUsingSway) {
                    currentSwayInfo = runThirdPersonSwayInfo;

                    currentSwayInfoAssigned = true;
                }
            }
        }
    }

    public bool isUseReticleOnAimingEnabled ()
    {
        return
            (weaponSystemManager.weaponSettings.useAimReticleFirstPerson && (isPlayerCameraFirstPersonActive () || isFullBodyAwarenessActive ())) ||
        (weaponSystemManager.weaponSettings.useAimReticleThirdPerson && !isPlayerCameraFirstPersonActive () && !isFullBodyAwarenessActive ());
    }

    public bool isUseReticleEnabled ()
    {
        return
            (weaponSystemManager.weaponSettings.useReticleFirstPerson && (isPlayerCameraFirstPersonActive () || isFullBodyAwarenessActive ())) ||
        (weaponSystemManager.weaponSettings.useReticleThirdPerson && !isPlayerCameraFirstPersonActive () && !isFullBodyAwarenessActive ());
    }

    public void walkOrMeleeAttackWeaponPosition ()
    {
        if (meleeAtacking) {
            return;
        }

        if (weaponsManager.weaponsAreMoving () || isWeaponMoving ()) {
            return;
        }

        bool firstPersonActive = isPlayerCameraFirstPersonActive ();

        if (currentWeapon && (thirdPersonWeaponInfo.useMeleeAttack || firstPersonWeaponInfo.useMeleeAttack) &&
            ((!weaponsManager.isAimingWeapons () && firstPersonActive) || (!firstPersonActive && !surfaceDetected))) {

            if ((firstPersonActive && !firstPersonWeaponInfo.useMeleeAttack) || (!firstPersonActive && !thirdPersonWeaponInfo.useMeleeAttack)) {
                return;
            }

            if (!firstPersonActive) {
                if (thirdPersonWeaponInfo.useActionSystemForMeleeAttack) {
                    activateCustomAction (thirdPersonWeaponInfo.meleeAttackActionName);
                }

                return;
            }

            if (!firstPersonActive && checkIfDeactivateIKIfNotAimingActive ()) {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                    } else {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                    }

                    setHandDeactivateIKStateToDisable ();

                    setWeaponTransformParent (transform);
                } else {
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {
                            setHandDeactivateIKStateToDisable ();

                            setWeaponTransformParent (transform);
                        }
                    }
                }
            }

            meleeAtacking = true;

            surfaceDetected = false;

            checkCursorState (firstPersonActive);

            weaponInRunPosition = false;

            float movementSpeed = thirdPersonWeaponInfo.meleeAttackStartMovementSpeed;
            if (firstPersonActive) {
                movementSpeed = firstPersonWeaponInfo.meleeAttackStartMovementSpeed;
            }

            if (firstPersonActive) {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentMeleeAttackPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.meleeAttackPosition;
                    } else {
                        currentMeleeAttackPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.meleeAttackPosition;
                    }
                } else {
                    currentMeleeAttackPositionTransform = firstPersonWeaponInfo.meleeAttackPosition;
                }

            } else {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.meleeAttackPosition;
                    } else {
                        currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.meleeAttackPosition;
                    }
                } else {
                    currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.meleeAttackPosition;
                }
            }

            weaponPositionTarget = currentMeleeAttackPositionTransform.localPosition;
            weaponRotationTarget = currentMeleeAttackPositionTransform.localRotation;

            float delayEndMeleeAttack = thirdPersonWeaponInfo.meleeAttackEndDelay;
            if (firstPersonActive) {
                delayEndMeleeAttack = firstPersonWeaponInfo.meleeAttackEndDelay;
            }

            stopWeaponMovement ();

            weaponMovement = StartCoroutine (weaponStartMeleeAttack (movementSpeed, delayEndMeleeAttack));
        }
    }

    IEnumerator weaponStartMeleeAttack (float movementSpeed, float delayEndMeleeAttack)
    {
        Vector3 currentWeaponPosition = weaponTransform.localPosition;
        Quaternion currentWeaponRotation = weaponTransform.localRotation;

        bool firstPersonActive = isPlayerCameraFirstPersonActive ();

        bool useMeleeAnimation = false;

        if (firstPersonActive && useWeaponAnimatorFirstPerson) {
            useMeleeAnimation = true;
        }

        bool canActivateMeleeAttack = true;

        if (useMeleeAnimation) {
            mainWeaponAnimatorSystem.setMeleeAttackInfo ();

            canActivateMeleeAttack = mainWeaponAnimatorSystem.setMeleeAttackState (true);

            if (canActivateMeleeAttack) {
                WaitForSeconds delay = new WaitForSeconds (mainWeaponAnimatorSystem.getMeleeAttackStartDuration ());

                yield return delay;
            }
        } else {
            for (float t = 0; t < 1;) {
                t += Time.deltaTime * movementSpeed;

                weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
                weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

                yield return null;
            }
        }

        if (canActivateMeleeAttack) {
            weaponSystemManager.checkMeleeAttackShakeInfo ();

            checkMeleeAttackDamage ();

            if (useMeleeAnimation) {
                WaitForSeconds delay = new WaitForSeconds (mainWeaponAnimatorSystem.getMeleeAttackMiddleDuration ());

                yield return delay;
            } else {
                WaitForSeconds delay = new WaitForSeconds (delayEndMeleeAttack);

                yield return delay;
            }

            if (firstPersonActive || !checkIfDeactivateIKIfNotAimingActive () || (checkIfDeactivateIKIfNotAimingActive () && aiming)) {

                if (firstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            if (crouchingActive) {
                                currentMeleeAttackPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                            } else {
                                currentMeleeAttackPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                            }
                        } else {
                            if (crouchingActive) {
                                currentMeleeAttackPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                            } else {
                                currentMeleeAttackPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                            }
                        }
                    } else {
                        if (crouchingActive) {
                            currentMeleeAttackPositionTransform = firstPersonWeaponInfo.crouchPosition;
                        } else {
                            currentMeleeAttackPositionTransform = firstPersonWeaponInfo.walkPosition;
                        }
                    }
                } else {
                    if (weaponsManager.isAimingInThirdPerson ()) {
                        if (isUsingDualWeapon ()) {
                            if (usingRightHandDualWeapon) {
                                currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.aimPosition;
                            } else {
                                currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.aimPosition;
                            }
                        } else {
                            currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.aimPosition;
                        }

                        checkIfAddFBAAimPositionOffset ();

                    } else {
                        if (isUsingDualWeapon ()) {
                            if (usingRightHandDualWeapon) {
                                currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                            } else {
                                currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                            }
                        } else {
                            currentMeleeAttackPositionTransform = thirdPersonWeaponInfo.walkPosition;
                        }

                        checkIfAddFBAWalkPositionOffset ();

                        checkIfAddFBACrouchPositionOffset ();
                    }
                }

                weaponPositionTarget = currentMeleeAttackPositionTransform.localPosition;
                weaponRotationTarget = currentMeleeAttackPositionTransform.localRotation;

                if (isFullBodyAwarenessActive ()) {
                    if (aiming) {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBAAimPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBAAimRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBAAimPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBAAimRotationOffset);
                        }
                    } else {
                        if (isPlayerCrouching ()) {
                            if (overrideFBAValuesForOffset) {
                                weaponPositionTarget = currentFBACrouchPositionOffset;

                                weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                            } else {
                                weaponPositionTarget += currentFBACrouchPositionOffset;

                                weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                            }
                        } else {
                            if (overrideFBAValuesForOffset) {
                                weaponPositionTarget = currentFBAWalkPositionOffset;

                                weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                            } else {
                                weaponPositionTarget += currentFBAWalkPositionOffset;

                                weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                            }
                        }
                    }
                }

                if (firstPersonActive) {
                    movementSpeed = firstPersonWeaponInfo.meleeAttackEndMovementSpeed;
                } else {
                    movementSpeed = thirdPersonWeaponInfo.meleeAttackEndMovementSpeed;
                }

                currentWeaponPosition = weaponTransform.localPosition;
                currentWeaponRotation = weaponTransform.localRotation;

                if (useMeleeAnimation) {
                    WaitForSeconds delay = new WaitForSeconds (mainWeaponAnimatorSystem.getMeleeAttackEndDuration ());

                    yield return delay;
                } else {
                    for (float t = 0; t < 1;) {
                        t += Time.deltaTime * movementSpeed;

                        weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
                        weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

                        yield return null;
                    }
                }

            } else {
                if (isUsingDualWeapon ()) {
                    newWeaponParent = leftHandMountPoint;

                    if (usingRightHandDualWeapon) {
                        newWeaponParent = rightHandMountPoint;
                    }

                    if (usingRightHandDualWeapon) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                    } else {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                    }

                    currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                    currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                    currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                    if (newWeaponParent == null) {
                        newWeaponParent = currentIKWeaponsPosition.handTransform;
                    }

                    setWeaponTransformParent (newWeaponParent);
                } else {
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {
                            newWeaponParent = leftHandMountPoint;

                            if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                                newWeaponParent = rightHandMountPoint;
                            }

                            currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                            currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                            currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                            if (newWeaponParent == null) {
                                newWeaponParent = currentIKWeaponsPosition.handTransform;
                            }

                            setWeaponTransformParent (newWeaponParent);
                        }
                    }
                }

                setHandsIKTargetValue (0, 0);
                setElbowsIKTargetValue (0, 0);
            }
        }

        meleeAtacking = false;
    }

    public void checkWeaponCameraShake ()
    {
        weaponSystemManager.checkWeaponCameraShake ();
    }

    public void setUseShotShakeState (bool state)
    {
        useShotShakeInFirstPerson = state;
        useShotShakeInThirdPerson = state;
    }

    public void checkMeleeAttackExternally ()
    {
        checkMeleeAttackShakeInfo ();

        checkMeleeAttackDamage ();
    }

    public void checkMeleeAttackShakeInfo ()
    {
        weaponSystemManager.checkMeleeAttackShakeInfo ();
    }

    public void checkMeleeAttackDamage ()
    {
        Vector3 raycastPosition = thirdPersonWeaponInfo.meleeAttackRaycastPosition.position;

        Vector3 raycastForward = player.transform.forward;

        LayerMask meleeAttackLayer = layer;

        if (thirdPersonWeaponInfo.useCustomMeleeAttackLayer) {
            meleeAttackLayer = thirdPersonWeaponInfo.customMeleeAttackLayer;
        }

        bool useCapsuleRaycast = thirdPersonWeaponInfo.useCapsuleRaycast;

        float raycastDistance = thirdPersonWeaponInfo.meleeAttackRaycastDistance;
        float meleeAttackCapsuleDistance = thirdPersonWeaponInfo.meleeAttackCapsuleDistance;
        float raycastRadius = thirdPersonWeaponInfo.meleeAttackRaycastRadius;
        float damageAmount = thirdPersonWeaponInfo.meleeAttackDamageAmount;
        bool applyMeleeAtackForce = thirdPersonWeaponInfo.applyMeleeAtackForce;
        float meleeAttackForceAmount = thirdPersonWeaponInfo.meleeAttackForceAmount;
        ForceMode meleeAttackForceMode = thirdPersonWeaponInfo.meleeAttackForceMode;
        bool useMeleeAttackSound = thirdPersonWeaponInfo.useMeleeAttackSound;
        var meleeAttackSurfaceSound = thirdPersonWeaponInfo.meleeAttackSurfaceAudioElement;
        var meleeAttackAirSound = thirdPersonWeaponInfo.meleeAttackAirAudioElement;
        bool useMeleeAttackParticles = thirdPersonWeaponInfo.useMeleeAttackParticles;
        GameObject meleeAttackParticles = thirdPersonWeaponInfo.meleeAttackParticles;
        bool meleeAttackApplyForceToVehicles = thirdPersonWeaponInfo.meleeAttackApplyForceToVehicles;
        float meleAttackForceToVehicles = thirdPersonWeaponInfo.meleAttackForceToVehicles;
        bool ignoreShield = thirdPersonWeaponInfo.meleeAttackIgnoreShield;
        bool canActivateReactionSystemTemporally = thirdPersonWeaponInfo.canActivateReactionSystemTemporally;
        int damageReactionID = thirdPersonWeaponInfo.damageReactionID;
        int damageTypeID = thirdPersonWeaponInfo.damageTypeID;
        bool damageCanBeBlocked = thirdPersonWeaponInfo.damageCanBeBlocked;

        bool useRemoteEvent = thirdPersonWeaponInfo.useRemoteEvent;
        List<string> remoteEventNameList = thirdPersonWeaponInfo.remoteEventNameList;

        bool useRemoteEventToEnableParryInteraction = thirdPersonWeaponInfo.useRemoteEventToEnableParryInteraction;
        List<string> remoteEventToEnableParryInteractionNameList = thirdPersonWeaponInfo.remoteEventToEnableParryInteractionNameList;

        bool checkObjectsToUseRemoteEventsOnDamage = thirdPersonWeaponInfo.checkObjectsToUseRemoteEventsOnDamage;
        LayerMask layerToUseRemoteEventsOnDamage = thirdPersonWeaponInfo.layerToUseRemoteEventsOnDamage;

        bool ignoreDamageValueOnLayer = thirdPersonWeaponInfo.ignoreDamageValueOnLayer;
        LayerMask layerToIgnoreDamage = thirdPersonWeaponInfo.layerToIgnoreDamage;

        bool firstPersonActive = isPlayerCameraFirstPersonActive ();

        if (firstPersonActive) {
            Transform mainCameraTransform = weaponsManager.getMainCameraTransform ();

            raycastPosition = mainCameraTransform.position;

            raycastForward = mainCameraTransform.forward;

            if (firstPersonWeaponInfo.useCustomMeleeAttackLayer) {
                meleeAttackLayer = firstPersonWeaponInfo.customMeleeAttackLayer;
            }

            useCapsuleRaycast = firstPersonWeaponInfo.useCapsuleRaycast;

            raycastDistance = firstPersonWeaponInfo.meleeAttackRaycastDistance;
            meleeAttackCapsuleDistance = firstPersonWeaponInfo.meleeAttackCapsuleDistance;

            raycastRadius = firstPersonWeaponInfo.meleeAttackRaycastRadius;
            damageAmount = firstPersonWeaponInfo.meleeAttackDamageAmount;
            applyMeleeAtackForce = firstPersonWeaponInfo.applyMeleeAtackForce;
            meleeAttackForceAmount = firstPersonWeaponInfo.meleeAttackForceAmount;
            meleeAttackForceMode = firstPersonWeaponInfo.meleeAttackForceMode;
            useMeleeAttackSound = firstPersonWeaponInfo.useMeleeAttackSound;
            meleeAttackSurfaceSound = firstPersonWeaponInfo.meleeAttackSurfaceAudioElement;
            meleeAttackAirSound = firstPersonWeaponInfo.meleeAttackAirAudioElement;
            useMeleeAttackParticles = firstPersonWeaponInfo.useMeleeAttackParticles;
            meleeAttackParticles = firstPersonWeaponInfo.meleeAttackParticles;
            meleeAttackApplyForceToVehicles = firstPersonWeaponInfo.meleeAttackApplyForceToVehicles;
            meleAttackForceToVehicles = firstPersonWeaponInfo.meleAttackForceToVehicles;
            ignoreShield = firstPersonWeaponInfo.meleeAttackIgnoreShield;
            canActivateReactionSystemTemporally = firstPersonWeaponInfo.canActivateReactionSystemTemporally;
            damageReactionID = firstPersonWeaponInfo.damageReactionID;
            damageTypeID = firstPersonWeaponInfo.damageTypeID;
            damageCanBeBlocked = firstPersonWeaponInfo.damageCanBeBlocked;

            useRemoteEvent = firstPersonWeaponInfo.useRemoteEvent;
            remoteEventNameList = firstPersonWeaponInfo.remoteEventNameList;

            useRemoteEventToEnableParryInteraction = firstPersonWeaponInfo.useRemoteEventToEnableParryInteraction;
            remoteEventToEnableParryInteractionNameList = firstPersonWeaponInfo.remoteEventToEnableParryInteractionNameList;

            checkObjectsToUseRemoteEventsOnDamage = firstPersonWeaponInfo.checkObjectsToUseRemoteEventsOnDamage;
            layerToUseRemoteEventsOnDamage = firstPersonWeaponInfo.layerToUseRemoteEventsOnDamage;

            ignoreDamageValueOnLayer = firstPersonWeaponInfo.ignoreDamageValueOnLayer;
            layerToIgnoreDamage = firstPersonWeaponInfo.layerToIgnoreDamage;
        }

        bool surfaceDetectedOnMelee = false;

        if (useCapsuleRaycast) {
            Vector3 point1 = raycastPosition;
            Vector3 point2 = raycastPosition + meleeAttackCapsuleDistance * raycastForward;

            Vector3 rayDirection = point1 - point2;
            rayDirection = rayDirection / rayDirection.magnitude;

            point1 = point1 - raycastDistance * rayDirection;
            point2 = point2 + raycastDistance * rayDirection;

            RaycastHit [] hits = Physics.CapsuleCastAll (point1, point2, raycastDistance, rayDirection, 0, layer);

            Collider detectedSurface = null;

            if (hits.Length > 0) {
                detectedSurface = hits [0].collider;

                if (hits [0].collider.gameObject == player) {
                    if (hits.Length >= 2) {
                        detectedSurface = hits [1].collider;
                    }
                }

                //				foreach (RaycastHit col in hits) {
                //					print (col.collider.name);
                //				}
            }

            if (detectedSurface != null) {
                float distanceToTarget = GKC_Utils.distance (detectedSurface.transform.position, raycastPosition) + 0.1f;

                rayDirection = detectedSurface.transform.position - raycastPosition;
                rayDirection = rayDirection / rayDirection.magnitude;

                surfaceDetectedOnMelee = Physics.Raycast (raycastPosition, rayDirection, out hit, distanceToTarget, meleeAttackLayer);
            }
        } else {
            surfaceDetectedOnMelee = Physics.Raycast (raycastPosition, raycastForward, out hit, raycastDistance, meleeAttackLayer);
        }

        if (surfaceDetectedOnMelee) {
            List<Collider> colliders = new List<Collider> ();

            colliders.AddRange (Physics.OverlapSphere (hit.point, raycastRadius, meleeAttackLayer));

            bool canApplyDamage = true;

            //			print ("ACTIVATING OVERLAP SPHERE");

            foreach (Collider col in colliders) {
                GameObject objectToDamage = col.gameObject;

                if (objectToDamage != player) {
                    //					print (objectToDamage.name);

                    if (damageAmount != 0) {
                        canApplyDamage = true;

                        if (ignoreDamageValueOnLayer) {
                            if ((1 << objectToDamage.layer & layerToIgnoreDamage.value) == 1 << objectToDamage.layer) {
                                canApplyDamage = false;
                            }
                        }

                        if (canApplyDamage) {
                            applyDamage.checkHealth (gameObject, objectToDamage, damageAmount, raycastForward, hit.point,
                                player, false, true, ignoreShield, false, damageCanBeBlocked,
                                canActivateReactionSystemTemporally, damageReactionID, damageTypeID);
                        }
                    }

                    if (applyMeleeAtackForce) {
                        Rigidbody objectToDamageMainRigidbody = applyDamage.applyForce (objectToDamage);

                        if (objectToDamageMainRigidbody != null) {
                            bool isVehicle = false;
                            bool canApplyForce = false;

                            if (applyDamage.isVehicle (objectToDamage)) {
                                isVehicle = true;
                            }

                            if (isVehicle) {
                                if (meleeAttackApplyForceToVehicles) {
                                    canApplyForce = true;
                                }
                            } else {
                                canApplyForce = true;
                            }

                            if (canApplyForce) {
                                Vector3 force = (meleeAttackForceAmount * objectToDamageMainRigidbody.mass) * raycastForward;

                                if (isVehicle) {
                                    force = (meleAttackForceToVehicles * (objectToDamageMainRigidbody.mass / 4)) * raycastForward;
                                }

                                objectToDamageMainRigidbody.AddForce (force, meleeAttackForceMode);
                            }
                        }
                    }

                    if (useRemoteEvent) {
                        bool useRemoteEvents = false;

                        //						print (objectToDamage.name);

                        if (objectToDamage != null) {
                            if (checkObjectsToUseRemoteEventsOnDamage) {
                                if ((1 << objectToDamage.layer & layerToUseRemoteEventsOnDamage.value) == 1 << objectToDamage.layer) {
                                    useRemoteEvents = true;
                                }
                            } else {
                                useRemoteEvents = true;
                            }

                            if (useRemoteEvents) {
                                remoteEventSystem currentRemoteEventSystem = objectToDamage.GetComponent<remoteEventSystem> ();

                                if (currentRemoteEventSystem != null) {
                                    int remoteEventNameListCount = remoteEventNameList.Count;

                                    for (int j = 0; j < remoteEventNameListCount; j++) {
                                        currentRemoteEventSystem.callRemoteEvent (remoteEventNameList [j]);
                                    }

                                    //									if (!ignoreParryActive) {
                                    if (useRemoteEventToEnableParryInteraction) {
                                        for (int j = 0; j < remoteEventToEnableParryInteractionNameList.Count; j++) {
                                            currentRemoteEventSystem.callRemoteEvent (remoteEventToEnableParryInteractionNameList [j]);
                                        }
                                    }
                                    //									}
                                }
                            }
                        }
                    }
                }
            }

            if (useMeleeAttackSound) {
                weaponSystemManager.playSound (meleeAttackSurfaceSound);
            }

            if (useMeleeAttackParticles) {
                GameObject newMeleeAttackParticles = (GameObject)Instantiate (meleeAttackParticles, hit.point + 0.1f * hit.normal, Quaternion.LookRotation (hit.normal));

                newMeleeAttackParticles.transform.position = hit.point + 0.1f * hit.normal;
            }
        } else {
            if (useMeleeAttackSound) {
                weaponSystemManager.playSound (meleeAttackAirSound);
            }
        }
    }

    public bool isMeleeAtacking ()
    {
        return meleeAtacking;
    }

    public void setHandsIKTargetValue (float leftValue, float rightValue)
    {
        if (usingRightHandDualWeapon) {
            if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo.Count > 0) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];

                setHandTargetValue (currentIKWeaponsPosition, rightValue);
            }
        } else {
            if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo.Count > 0) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];

                setHandTargetValue (currentIKWeaponsPosition, leftValue);
            }
        }

        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            if (currentIKWeaponsPosition.limb == AvatarIKGoal.LeftHand) {
                setHandTargetValue (currentIKWeaponsPosition, leftValue);
            }

            if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                setHandTargetValue (currentIKWeaponsPosition, rightValue);
            }
        }
    }

    public void setElbowsIKTargetValue (float leftValue, float rightValue)
    {
        if (usingRightHandDualWeapon) {
            if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo.Count > 0) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];

                setElbowTargetValue (currentIKWeaponsPosition, rightValue);
            }
        } else {
            if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo.Count > 0) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];

                setElbowTargetValue (currentIKWeaponsPosition, leftValue);
            }
        }

        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            if (currentIKWeaponsPosition.limb == AvatarIKGoal.LeftHand) {
                setElbowTargetValue (currentIKWeaponsPosition, leftValue);
            }

            if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                setElbowTargetValue (currentIKWeaponsPosition, rightValue);
            }
        }
    }

    public void setIKWeight (float leftValue, float rightValue)
    {
        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];

                setHandIKWeightValue (currentIKWeaponsPosition, rightValue);
            } else {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];

                setHandIKWeightValue (currentIKWeaponsPosition, leftValue);
            }
        } else {
            for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                if (currentIKWeaponsPosition.limb == AvatarIKGoal.LeftHand) {
                    setHandIKWeightValue (currentIKWeaponsPosition, leftValue);
                }

                if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                    setHandIKWeightValue (currentIKWeaponsPosition, rightValue);
                }
            }
        }
    }

    public void resetElbowIKPositions ()
    {
        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            currentIKWeaponsPosition.elbowInfo.position.SetParent (currentIKWeaponsPosition.elbowInfo.elbowOriginalPosition);
            currentIKWeaponsPosition.elbowInfo.position.localPosition = Vector3.zero;
            currentIKWeaponsPosition.elbowInfo.position.localRotation = Quaternion.identity;
        }
    }

    public void quickDrawWeaponThirdPerson ()
    {
        carrying = true;

        drawingWeaponInProcess = false;
        holsteringWeaponInProcess = false;

        drawKeepWeaponAnimationInProcess = false;

        checkIfSetNewAnimatorWeaponID ();

        if (carrying) {
            setWeaponParent (carrying);
        }

        currentKeepPath = thirdPersonWeaponInfo.keepPath;

        setWeaponTransformParent (weaponSystemManager.getWeaponParent ());

        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
            } else {
                currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
            }
        } else {
            currentDrawPositionTransform = thirdPersonWeaponInfo.walkPosition;
        }

        checkIfAddFBAWalkPositionOffset ();

        checkIfAddFBACrouchPositionOffset ();


        weaponTransform.localPosition = currentDrawPositionTransform.localPosition;
        weaponTransform.localRotation = currentDrawPositionTransform.localRotation;

        if (isFullBodyAwarenessActive ()) {
            if (aiming) {
                if (overrideFBAValuesForOffset) {
                    weaponTransform.localPosition = currentFBAAimPositionOffset;

                    weaponTransform.localRotation = Quaternion.Euler (currentFBAAimRotationOffset);
                } else {
                    weaponTransform.localPosition += currentFBAAimPositionOffset;

                    weaponTransform.localRotation *= Quaternion.Euler (currentFBAAimRotationOffset);
                }
            } else {
                if (isPlayerCrouching ()) {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBACrouchPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBACrouchPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                    }
                } else {
                    if (overrideFBAValuesForOffset) {
                        weaponTransform.localPosition = currentFBAWalkPositionOffset;

                        weaponTransform.localRotation = Quaternion.Euler (currentFBAWalkRotationOffset);
                    } else {
                        weaponTransform.localPosition += currentFBAWalkPositionOffset;

                        weaponTransform.localRotation *= Quaternion.Euler (currentFBAWalkRotationOffset);
                    }
                }
            }
        }

        carryingWeapon = carrying;

        enableOrDisableWeaponMesh (true);

        resetOtherWeaponsStates ();

        disableOtherWeaponsStates ();

        setPlayerControllerMovementValues ();

        checkDeactivateIKIfNotAiming ();

        resetElbowIKPositions ();
    }

    public void checkDeactivateIKIfNotAiming ()
    {
        if (checkIfDeactivateIKIfNotAimingActive ()) {
            if (isUsingDualWeapon ()) {
                newWeaponParent = leftHandMountPoint;

                if (usingRightHandDualWeapon) {
                    newWeaponParent = rightHandMountPoint;
                }

                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                setHandIKWeightValue (currentIKWeaponsPosition, 0);

                setHandTargetValue (currentIKWeaponsPosition, 0);

                setElbowTargetValue (currentIKWeaponsPosition, 0);

                currentIKWeaponsPosition.elbowInfo.elbowIKWeight = 0;

                if (currentIKWeaponsPosition.usedToDrawWeapon) {
                    if (newWeaponParent == null) {
                        newWeaponParent = currentIKWeaponsPosition.handTransform;
                    }

                    setWeaponTransformParent (newWeaponParent);

                    if (usingRightHandDualWeapon) {
                        weaponTransform.localPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponPositionInHandForDeactivateIK.localPosition;
                        weaponTransform.localRotation = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponPositionInHandForDeactivateIK.localRotation;
                    } else {
                        weaponTransform.localPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponPositionInHandForDeactivateIK.localPosition;
                        weaponTransform.localRotation = thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponPositionInHandForDeactivateIK.localRotation;
                    }
                }
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    setHandIKWeightValue (currentIKWeaponsPosition, 0);

                    setHandTargetValue (currentIKWeaponsPosition, 0);

                    setElbowTargetValue (currentIKWeaponsPosition, 0);

                    currentIKWeaponsPosition.elbowInfo.elbowIKWeight = 0;

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        newWeaponParent = leftHandMountPoint;

                        if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                            newWeaponParent = rightHandMountPoint;
                        }

                        if (newWeaponParent == null) {
                            newWeaponParent = currentIKWeaponsPosition.handTransform;
                        }

                        setWeaponTransformParent (newWeaponParent);

                        weaponTransform.localPosition = thirdPersonWeaponInfo.weaponPositionInHandForDeactivateIK.localPosition;
                        weaponTransform.localRotation = thirdPersonWeaponInfo.weaponPositionInHandForDeactivateIK.localRotation;
                    }
                }
            }
        }
    }

    public void adjustWeaponPositionToDeactivateIKOnHands ()
    {
        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
            } else {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
            }

            if (currentIKWeaponsPosition.usedToDrawWeapon) {

                if (usingRightHandDualWeapon) {
                    weaponTransform.localPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponPositionInHandForDeactivateIK.localPosition;
                    weaponTransform.localRotation = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.weaponPositionInHandForDeactivateIK.localRotation;
                } else {
                    weaponTransform.localPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponPositionInHandForDeactivateIK.localPosition;
                    weaponTransform.localRotation = thirdPersonWeaponInfo.leftHandDualWeaponInfo.weaponPositionInHandForDeactivateIK.localRotation;
                }
            }
        } else {
            for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                if (currentIKWeaponsPosition.usedToDrawWeapon) {
                    weaponTransform.localPosition = thirdPersonWeaponInfo.weaponPositionInHandForDeactivateIK.localPosition;
                    weaponTransform.localRotation = thirdPersonWeaponInfo.weaponPositionInHandForDeactivateIK.localRotation;
                }
            }
        }
    }

    public void quickKeepWeaponThirdPerson ()
    {
        stopWeaponMovement ();

        aiming = false;

        carrying = false;

        drawingWeaponInProcess = false;
        holsteringWeaponInProcess = false;

        drawKeepWeaponAnimationInProcess = false;

        setWeaponMovingState (false);

        if (reloadingWeapon) {
            cancelReloadIfActive ();

            reloadingWeapon = false;
        }

        aimingWeaponInProcess = false;

        setWeaponTransformParent (weaponSystemManager.weaponSettings.weaponParent);

        weaponTransform.localPosition = thirdPersonWeaponInfo.keepPosition.localPosition;
        weaponTransform.localRotation = thirdPersonWeaponInfo.keepPosition.localRotation;

        setHandsIKTargetValue (0, 0);
        setElbowsIKTargetValue (0, 0);

        if (isUsingDualWeapon ()) {
            newWeaponParent = leftHandMountPoint;

            if (usingRightHandDualWeapon) {
                newWeaponParent = rightHandMountPoint;
            }

            if (usingRightHandDualWeapon) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
            } else {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
            }

            currentIKWeaponsPosition.handInPositionToAim = false;
            currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

            if (newWeaponParent == null) {
                newWeaponParent = currentIKWeaponsPosition.handTransform;
            }

            currentIKWeaponsPosition.transformFollowByHand.position = newWeaponParent.position;
        } else {
            for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                newWeaponParent = leftHandMountPoint;

                if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                    newWeaponParent = rightHandMountPoint;
                }

                currentIKWeaponsPosition.handInPositionToAim = false;
                currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                if (newWeaponParent == null) {
                    newWeaponParent = currentIKWeaponsPosition.handTransform;
                }

                currentIKWeaponsPosition.transformFollowByHand.position = newWeaponParent.position;
            }
        }

        carryingWeapon = carrying;

        if (!carrying) {
            if (weaponsManager.checkIfHideWeaponMeshWhenNotUsed (hideWeaponIfKeptInThirdPerson)) {
                enableOrDisableWeaponMesh (false);
            }
        }

        resetOtherWeaponsStates ();

        disableOtherWeaponsStates ();

        setPlayerControllerMovementValues ();

        if (!carrying) {
            setWeaponParent (carrying);
        }

        checkIfSetNewAnimatorWeaponID ();
    }

    public void quickDrawWeaponThirdPersonAction ()
    {
        quickDrawWeaponThirdPerson ();
    }

    public void quickKeepWeaponThirdPersonAction ()
    {
        stopWeaponMovement ();

        aiming = false;

        carrying = false;

        drawingWeaponInProcess = false;
        holsteringWeaponInProcess = false;

        drawKeepWeaponAnimationInProcess = false;

        setWeaponMovingState (false);

        if (reloadingWeapon) {
            cancelReloadIfActive ();

            reloadingWeapon = false;
        }

        aimingWeaponInProcess = false;

        setWeaponTransformParent (weaponSystemManager.weaponSettings.weaponParent);

        weaponTransform.localPosition = thirdPersonWeaponInfo.keepPosition.localPosition;
        weaponTransform.localRotation = thirdPersonWeaponInfo.keepPosition.localRotation;

        setHandsIKTargetValue (0, 0);
        setElbowsIKTargetValue (0, 0);

        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
            } else {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
            }

            currentIKWeaponsPosition.handInPositionToAim = false;

            setHandIKWeightValue (currentIKWeaponsPosition, 0);
        } else {
            for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {

                currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                currentIKWeaponsPosition.handInPositionToAim = false;

                setHandIKWeightValue (currentIKWeaponsPosition, 0);
            }
        }

        carryingWeapon = carrying;

        if (!carrying) {
            if (weaponsManager.checkIfHideWeaponMeshWhenNotUsed (hideWeaponIfKeptInThirdPerson)) {
                enableOrDisableWeaponMesh (false);
            }
        }

        resetOtherWeaponsStates ();

        disableOtherWeaponsStates ();

        setPlayerControllerMovementValues ();

        if (!carrying) {
            setWeaponParent (carrying);
        }

        IKPausedOnHandsActive = false;

        checkIfSetNewAnimatorWeaponID ();
    }

    public bool isWeaponHandsOnPositionToAim ()
    {
        int handInPositionToAimAmount = 0;
        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            if (thirdPersonWeaponInfo.handsInfo [i].handInPositionToAim) {
                handInPositionToAimAmount++;
            }
        }

        return handInPositionToAimAmount == 2;
    }

    public bool isRightWeaponHandOnPositionToAim ()
    {
        return thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0].handInPositionToAim;
    }

    public bool isLeftWeaponHandOnPositionToAim ()
    {
        return thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0].handInPositionToAim;
    }

    //first person
    public void aimOrDrawWeaponFirstPerson (bool state)
    {
        if (currentWeapon) {
            aiming = state;

            if (aiming) {
                setWeaponMovingState (false);

                carryingWeapon = true;
            }

            if (aiming) {
                if (weaponSystemManager.isUsingSight () && firstPersonWeaponInfo.useSightPosition) {
                    currentAimPositionTransform = firstPersonWeaponInfo.sightPosition;
                } else {
                    currentAimPositionTransform = firstPersonWeaponInfo.aimPosition;
                }
            } else {
                if (crouchingActive) {
                    currentAimPositionTransform = firstPersonWeaponInfo.crouchPosition;
                } else {
                    currentAimPositionTransform = firstPersonWeaponInfo.walkPosition;
                }
            }

            weaponPositionTarget = currentAimPositionTransform.localPosition;
            weaponRotationTarget = currentAimPositionTransform.localRotation;

            //stop the coroutine to translate the camera and call it again
            stopWeaponMovement ();

            weaponMovement = StartCoroutine (aimOrDrawWeaponFirstPersonCoroutine ());

            setLastTimeMoved ();

            disableOtherWeaponsStates ();

            setPlayerControllerMovementValues ();

            if (aiming) {
                resetSwayValue ();
            }
        }
    }

    IEnumerator aimOrDrawWeaponFirstPersonCoroutine ()
    {
        bool activateWeaponMovement = true;

        if (useWeaponAnimatorFirstPerson) {
            mainWeaponAnimatorSystem.setAimState (aiming);

            if (!mainWeaponAnimatorSystem.useAimExtraMovement) {
                activateWeaponMovement = false;
            }
        }

        if (activateWeaponMovement) {
            //print ("aimOrDrawWeaponFirstPersonCoroutine "+aiming);
            Vector3 currentWeaponPosition = weaponTransform.localPosition;
            Quaternion currentWeaponRotation = weaponTransform.localRotation;

            for (float t = 0; t < 1;) {
                t += Time.deltaTime * firstPersonWeaponInfo.aimMovementSpeed;

                weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
                weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

                yield return null;
            }
        }
    }

    public void drawOrKeepWeaponFirstPerson (bool state)
    {
        if (!carrying && state && !moving) {
            resetWeaponPositionInFirstPerson ();
        }

        carrying = state;

        if (carrying) {
            checkIfSetNewAnimatorWeaponID ();
        }

        if (!carrying) {
            aiming = false;
        }

        if (carrying) {
            setWeaponParent (carrying);
        }

        if (carrying) {
            crouchingActive = isPlayerCrouching ();
        }

        //stop the coroutine to translate the camera and call it again
        stopWeaponMovement ();

        weaponMovement = StartCoroutine (drawOrKeepWeaponFirstPersonCoroutine ());

        setLastTimeMoved ();

        resetOtherWeaponsStates ();

        disableOtherWeaponsStates ();

        setPlayerControllerMovementValues ();

        if (!carrying) {
            checkIfSetNewAnimatorWeaponID ();
        }
    }

    IEnumerator drawOrKeepWeaponFirstPersonCoroutine ()
    {

        //print ("drawOrKeepWeaponFirstPersonCoroutine "+carrying);
        Vector3 targetPosition = Vector3.zero;
        Quaternion targetRotation = Quaternion.identity;
        Vector3 worldTargetPosition = Vector3.zero;

        drawingWeaponInProcess = carrying;
        holsteringWeaponInProcess = !carrying;

        drawKeepWeaponAnimationInProcess = false;

        setWeaponMovingState (true);

        if (carrying) {
            enableOrDisableWeaponMesh (true);

            enableOrDisableFirstPersonArms (true);

            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    if (crouchingActive) {
                        currentDrawPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                    } else {
                        currentDrawPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                    }
                } else {
                    if (crouchingActive) {
                        currentDrawPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                    } else {
                        currentDrawPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                    }
                }
            } else {
                if (crouchingActive) {
                    currentDrawPositionTransform = firstPersonWeaponInfo.crouchPosition;
                } else {
                    currentDrawPositionTransform = firstPersonWeaponInfo.walkPosition;
                }
            }

            weaponSystemManager.changeHUDPosition (false);

        } else {
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentDrawPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.keepPosition;
                } else {
                    currentDrawPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.keepPosition;
                }
            } else {
                currentDrawPositionTransform = firstPersonWeaponInfo.keepPosition;
            }
        }

        targetPosition = currentDrawPositionTransform.localPosition;
        targetRotation = currentDrawPositionTransform.localRotation;
        worldTargetPosition = currentDrawPositionTransform.position;

        if (useWeaponAnimatorFirstPerson) {
            if (carrying) {
                mainWeaponAnimatorSystem.setDrawState (true);

                weaponTransform.localPosition = targetPosition;
                weaponTransform.localRotation = targetRotation;

                WaitForSeconds delay = new WaitForSeconds (mainWeaponAnimatorSystem.getDrawDuration ());

                yield return delay;
            } else {
                mainWeaponAnimatorSystem.setHolsterState (true);

                WaitForSeconds delay = new WaitForSeconds (mainWeaponAnimatorSystem.getHolsterDuration ());

                yield return delay;

                weaponTransform.localPosition = targetPosition;
                weaponTransform.localRotation = targetRotation;

                mainWeaponAnimatorSystem.setWeaponInFirstPersonStateActiveState (false);
            }

        } else {

            float dist = GKC_Utils.distance (weaponTransform.position, worldTargetPosition);

            float currentDrawWeaponMovementSpeed = firstPersonWeaponInfo.drawWeaponMovementSpeed;

            if (!carrying) {
                currentDrawWeaponMovementSpeed *= 0.5f;
            }

            float duration = dist / currentDrawWeaponMovementSpeed;
            float t = 0;

            bool targetReached = false;

            float angleDifference = 0;

            float positionDifference = 0;

            float movementTimer = 0;

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

                weaponTransform.localPosition = Vector3.Lerp (weaponTransform.localPosition, targetPosition, t);
                weaponTransform.localRotation = Quaternion.Lerp (weaponTransform.localRotation, targetRotation, t);

                angleDifference = Quaternion.Angle (weaponTransform.localRotation, targetRotation);

                positionDifference = GKC_Utils.distance (weaponTransform.localPosition, targetPosition);

                movementTimer += Time.deltaTime;

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

                yield return null;
            }
        }

        if (!aiming && !carrying) {
            setWeaponTransformParent (weaponSystemManager.getWeaponParent ());

            resetWeaponPositionInFirstPerson ();

            enableOrDisableWeaponMesh (false);

            enableOrDisableFirstPersonArms (false);
        }

        setWeaponMovingState (false);

        carryingWeapon = carrying;

        if (!carryingWeapon) {
            weaponsManager.enableOrDisableWeaponsCamera (false);
        }

        if (!carrying) {
            setWeaponParent (carrying);
        }

        drawingWeaponInProcess = false;
        holsteringWeaponInProcess = false;

        drawKeepWeaponAnimationInProcess = false;
    }

    public void setNewSightPosition (Transform newTransform)
    {
        firstPersonWeaponInfo.sightPosition = newTransform;
    }

    public void setNewSightRecoilPosition (Transform newTransform)
    {
        firstPersonWeaponInfo.sightRecoilPosition = newTransform;
    }

    public void reloadWeaponFirstPerson ()
    {
        //		print (firstPersonWeaponInfo.useReloadMovement);

        if (!firstPersonWeaponInfo.useReloadMovement) {
            return;
        }

        if (aiming) {
            weaponsManager.aimCurrentWeapon (false);
            weaponsManager.disableAimModeInputPressedState ();
        }

        //stop the coroutine to translate the camera and call it again
        stopWeaponMovement ();

        weaponMovement = StartCoroutine (reloadWeaponFirstPersonCoroutine ());

        resetOtherWeaponsStates ();

        disableOtherWeaponsStates ();

        setPlayerControllerMovementValues ();
    }

    IEnumerator reloadWeaponFirstPersonCoroutine ()
    {
        setWeaponMovingState (true);

        reloadingWeapon = true;

        if (useWeaponAnimatorFirstPerson) {
            checkReloadAnimatorState (true);
        }

        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                spline = firstPersonWeaponInfo.rightHandDualWeaopnInfo.reloadSpline;
                bezierDuration = firstPersonWeaponInfo.rightHandDualWeaopnInfo.reloadDuration;
                lookDirectionSpeed = firstPersonWeaponInfo.rightHandDualWeaopnInfo.reloadLookDirectionSpeed;
            } else {
                spline = firstPersonWeaponInfo.leftHandDualWeaponInfo.reloadSpline;
                bezierDuration = firstPersonWeaponInfo.leftHandDualWeaponInfo.reloadDuration;
                lookDirectionSpeed = firstPersonWeaponInfo.leftHandDualWeaponInfo.reloadLookDirectionSpeed;
            }
        } else {
            spline = firstPersonWeaponInfo.reloadSpline;
            bezierDuration = firstPersonWeaponInfo.reloadDuration;
            lookDirectionSpeed = firstPersonWeaponInfo.reloadLookDirectionSpeed;
        }

        bool targetReached = false;

        float angleDifference = 0;

        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                currentReloadPosition = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
            } else {
                currentReloadPosition = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
            }
        } else {
            currentReloadPosition = firstPersonWeaponInfo.walkPosition;
        }

        float dist = GKC_Utils.distance (weaponTransform.position, currentReloadPosition.position);

        float duration = dist;

        float t = 0;

        Vector3 pos = currentReloadPosition.localPosition;
        Quaternion rot = currentReloadPosition.localRotation;

        float movementTimer = 0;

        if (reloadAnimatorActive && mainWeaponAnimatorSystem.useReloadPosition) {

            currentReloadPosition = mainWeaponAnimatorSystem.reloadPosition;

            dist = GKC_Utils.distance (weaponTransform.position, currentReloadPosition.position);

            duration = dist;

            pos = currentReloadPosition.localPosition;
            rot = currentReloadPosition.localRotation;

            if (dist > 0.01f) {
                while (!targetReached) {
                    t += Time.deltaTime / duration;

                    weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, pos, t);
                    weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, rot, t);

                    angleDifference = Quaternion.Angle (weaponTransform.localRotation, rot);

                    movementTimer += Time.deltaTime;

                    if ((GKC_Utils.distance (weaponTransform.localPosition, pos) < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 1)) {
                        targetReached = true;
                    }

                    yield return null;
                }
            }
        } else {

            if (dist > 0.01f) {
                while (!targetReached) {
                    t += Time.deltaTime / duration;

                    weaponTransform.localPosition = Vector3.Slerp (weaponTransform.localPosition, pos, t);
                    weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, rot, t);

                    angleDifference = Quaternion.Angle (weaponTransform.localRotation, rot);

                    movementTimer += Time.deltaTime;

                    if ((GKC_Utils.distance (weaponTransform.localPosition, pos) < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 1)) {
                        targetReached = true;
                    }

                    yield return null;
                }
            }
        }

        if (!reloadAnimatorActive) {
            float progress = 0;
            float progressTarget = 1;

            targetReached = false;

            while (!targetReached) {
                progress += Time.deltaTime / bezierDuration;

                Vector3 position = spline.GetPoint (progress);
                weaponTransform.position = position;

                Quaternion targetRotation = Quaternion.Euler (spline.GetLookDirection (progress));

                weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, targetRotation, Time.deltaTime * lookDirectionSpeed);

                if (progress > progressTarget) {
                    targetReached = true;
                }

                yield return null;
            }

            movementTimer = 0;

            duration = 0.2f;

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

                weaponTransform.localRotation = Quaternion.Slerp (weaponTransform.localRotation, rot, t);

                angleDifference = Quaternion.Angle (weaponTransform.localRotation, rot);

                movementTimer += Time.deltaTime;

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

                yield return null;
            }

            setWeaponMovingState (false);

            reloadingWeapon = false;
        }
    }

    public bool isReloadingWeapon ()
    {
        return reloadingWeapon || weaponSystemManager.isReloadingWithAnimationActive ();
    }

    public void cancelReloadIfActive ()
    {
        if (isReloadingWeapon ()) {

            if (weaponSystemManager.isReloadingWithAnimationActive ()) {

            } else {

            }

            reloadAnimatorActive = false;

            setWeaponMovingState (false);

            reloadingWeapon = false;

            weaponSystemManager.cancelReloadIfActive ();

            setActionActiveState (false);
        }
    }

    public void quickKeepWeaponFirstPerson ()
    {
        carrying = false;

        drawingWeaponInProcess = false;
        holsteringWeaponInProcess = false;

        drawKeepWeaponAnimationInProcess = false;

        aiming = false;

        setWeaponMovingState (false);

        if (reloadingWeapon) {
            cancelReloadIfActive ();

            reloadingWeapon = false;
        }

        aimingWeaponInProcess = false;

        resetWeaponPositionInFirstPerson ();

        enableOrDisableWeaponMesh (false);
        carryingWeapon = carrying;

        stopWeaponMovement ();

        setPlayerControllerMovementValues ();

        if (useWeaponAnimatorFirstPerson) {
            mainWeaponAnimatorSystem.setWeaponInFirstPersonStateActiveState (false);
        }

        checkIfSetNewAnimatorWeaponID ();
    }

    public void resetWeaponPositionInFirstPerson ()
    {
        if (isUsingDualWeapon () || weaponConfiguredAsDualWeapon) {
            if (usingRightHandDualWeapon) {
                currentDrawPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.keepPosition;
            } else {
                currentDrawPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.keepPosition;
            }
        } else {
            currentDrawPositionTransform = firstPersonWeaponInfo.keepPosition;
        }

        if (currentDrawPositionTransform != null) {
            weaponTransform.localPosition = currentDrawPositionTransform.localPosition;
            weaponTransform.localRotation = currentDrawPositionTransform.localRotation;
        }
    }

    public void resetWeaponPositionInAnyView ()
    {
        bool firstPersonActive = isPlayerCameraFirstPersonActive ();

        Transform newParent = weaponsManager.getWeaponsParent ();

        if (newParent == null) {
            newParent = weaponsManager.getPlayerManagersParentGameObject ();
        }

        Transform newParentWeaponMesh = newParent;

        if (usingDualWeapon) {
            if (usingRightHandDualWeapon) {
                if (firstPersonActive) {
                    newParentWeaponMesh = firstPersonWeaponInfo.rightHandDualWeaopnInfo.keepPosition;
                } else {
                    newParentWeaponMesh = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.keepPosition;
                }
            } else {
                if (firstPersonActive) {
                    newParentWeaponMesh = firstPersonWeaponInfo.leftHandDualWeaponInfo.keepPosition;
                } else {
                    newParentWeaponMesh = thirdPersonWeaponInfo.leftHandDualWeaponInfo.keepPosition;
                }
            }
        } else {
            if (firstPersonActive) {
                newParentWeaponMesh = firstPersonWeaponInfo.keepPosition;
            } else {
                newParentWeaponMesh = thirdPersonWeaponInfo.keepPosition;
            }
        }

        weaponTransform.localPosition = newParentWeaponMesh.localPosition;
        weaponTransform.localRotation = newParentWeaponMesh.localRotation;
    }

    public void setWeaponHasRecoilState (bool state)
    {
        thirdPersonWeaponInfo.weaponHasRecoil = state;
        firstPersonWeaponInfo.weaponHasRecoil = state;
    }

    public void startRecoilFromExternalFunction ()
    {
        if (!aiming || aimingWeaponInProcess) {
            //			print ("avoid recoil externally " + aiming + " " + aimingWeaponInProcess);

            return;
        }

        //		print ("AIMING STATE " + aiming + "moving " + moving);

        startRecoil (!isPlayerCameraFirstPersonActive ());
    }

    //Recoil functions
    public void startRecoil (bool isThirdPersonView)
    {
        if (weaponsManager.isPauseRecoilOnWeaponActive ()) {
            return;
        }

        if ((isThirdPersonView && thirdPersonWeaponInfo.weaponHasRecoil) || (!isThirdPersonView && firstPersonWeaponInfo.weaponHasRecoil)) {

            disableOtherWeaponsStates ();

            if (!isThirdPersonView && useWeaponAnimatorFirstPerson) {
                if (aiming) {
                    if (mainWeaponAnimatorSystem.useAnimationForRecoilWithAim) {
                        checkShootAnimatorState (true);
                    }
                } else {
                    if (mainWeaponAnimatorSystem.useAnimationForRecoilWithoutAim) {
                        checkShootAnimatorState (true);
                    }
                }
            }

            if (shootAnimatorActive) {
                return;
            }

            stopWeaponMovement ();

            weaponMovement = StartCoroutine (recoilMovementBack (isThirdPersonView));
        }
    }

    IEnumerator recoilMovementBack (bool isThirdPersonView)
    {
        weaponOnRecoil = true;

        recoilExtraPosition = Vector3.zero;
        recoilRandomPosition = Vector3.zero;
        recoilExtraRotatation = Vector3.zero;
        recoilRandomRotation = Vector3.zero;

        if (isThirdPersonView) {
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentAimRecoilPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.aimRecoilPosition;
                } else {
                    currentAimRecoilPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.aimRecoilPosition;
                }
            } else {
                currentAimRecoilPositionTransform = thirdPersonWeaponInfo.aimRecoilPosition;
            }

            checkIfAddFBAAimRecoilPositionOffset ();

            checkIfAddFBAWalkRecoilPositionOffset ();

            checkIfAddFBACrouchRecoilPositionOffset ();

            weaponPositionTarget = currentAimRecoilPositionTransform.localPosition;
            weaponRotationTarget = currentAimRecoilPositionTransform.localRotation;

            if (isFullBodyAwarenessActive ()) {
                if (isAimModeInputPressed ()) {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBAAimRecoilPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBAAimRecoilRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBAAimRecoilPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBAAimRecoilRotationOffset);
                    }
                } else {
                    if (isPlayerCrouching ()) {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBACrouchRecoilPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBACrouchRecoilRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBACrouchRecoilPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRecoilRotationOffset);
                        }
                    } else {
                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBAWalkRecoilPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBAWalkRecoilRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBAWalkRecoilPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRecoilRotationOffset);
                        }
                    }
                }
            }

            if (thirdPersonWeaponInfo.useExtraRandomRecoil) {
                if (thirdPersonWeaponInfo.useExtraRandomRecoilPosition) {
                    recoilExtraPosition = thirdPersonWeaponInfo.extraRandomRecoilPosition;

                    recoilRandomPosition = new Vector3 (Random.Range (-recoilExtraPosition.x, recoilExtraPosition.x),
                        Random.Range (0, recoilExtraPosition.y), Random.Range (-recoilExtraPosition.z, 0));
                }

                if (thirdPersonWeaponInfo.useExtraRandomRecoilRotation) {
                    recoilExtraRotatation = thirdPersonWeaponInfo.extraRandomRecoilRotation;

                    recoilRandomRotation = new Vector3 (Random.Range (-recoilExtraRotatation.x, 0),
                        Random.Range (-recoilExtraRotatation.y, recoilExtraRotatation.y), Random.Range (-recoilExtraRotatation.z, recoilExtraRotatation.z));
                }

                if (isFullBodyAwarenessActive ()) {
                    if (isAimModeInputPressed ()) {
                        recoilRandomPosition *= thirdPersonWeaponInfo.FBARandomRecoilAimPositionMultiplier;

                        recoilRandomRotation *= thirdPersonWeaponInfo.FBARandomRecoilAimPositionMultiplier;
                    } else {
                        recoilRandomPosition *= thirdPersonWeaponInfo.FBARandomRecoilWalkPositionMultiplier;

                        recoilRandomRotation *= thirdPersonWeaponInfo.FBARandomRecoilWalkPositionMultiplier;
                    }
                }

                if (recoilRandomPosition != Vector3.zero) {
                    weaponPositionTarget += recoilRandomPosition;
                }

                if (recoilRandomRotation != Vector3.zero) {
                    weaponRotationTarget = Quaternion.Euler (weaponRotationTarget.eulerAngles + recoilRandomRotation);
                }
            }

            currentRecoilSpeed = thirdPersonWeaponInfo.recoilSpeed;
        } else {
            if (aiming) {
                if (weaponSystemManager.isUsingSight () && firstPersonWeaponInfo.useSightPosition) {
                    currentAimRecoilPositionTransform = firstPersonWeaponInfo.sightRecoilPosition;
                } else {
                    currentAimRecoilPositionTransform = firstPersonWeaponInfo.aimRecoilPosition;
                }
            } else {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        if (crouchingActive) {
                            currentAimRecoilPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchRecoilPosition;
                        } else {
                            currentAimRecoilPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkRecoilPosition;
                        }
                    } else {
                        if (crouchingActive) {
                            currentAimRecoilPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchRecoilPosition;
                        } else {
                            currentAimRecoilPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkRecoilPosition;
                        }
                    }
                } else {
                    if (crouchingActive) {
                        currentAimRecoilPositionTransform = firstPersonWeaponInfo.crouchRecoilPosition;
                    } else {
                        currentAimRecoilPositionTransform = firstPersonWeaponInfo.walkRecoilPosition;
                    }
                }
            }

            weaponPositionTarget = currentAimRecoilPositionTransform.localPosition;
            weaponRotationTarget = currentAimRecoilPositionTransform.localRotation;

            if (firstPersonWeaponInfo.useExtraRandomRecoil) {
                if (firstPersonWeaponInfo.useExtraRandomRecoilPosition) {
                    recoilExtraPosition = firstPersonWeaponInfo.extraRandomRecoilPosition;
                    recoilRandomPosition = new Vector3 (Random.Range (-recoilExtraPosition.x, recoilExtraPosition.x),
                        Random.Range (0, recoilExtraPosition.y), Random.Range (-recoilExtraPosition.z, 0));

                    if (aiming) {
                        recoilRandomPosition *= currentSwayInfo.swayPositionPercentageAiming;
                    }

                    weaponPositionTarget += recoilRandomPosition;
                }

                if (firstPersonWeaponInfo.useExtraRandomRecoilRotation) {
                    recoilExtraRotatation = firstPersonWeaponInfo.extraRandomRecoilRotation;
                    recoilRandomRotation = new Vector3 (Random.Range (-recoilExtraRotatation.x, 0),
                        Random.Range (-recoilExtraRotatation.y, recoilExtraRotatation.y), Random.Range (-recoilExtraRotatation.z, recoilExtraRotatation.z));
                }

                if (aiming) {
                    recoilRandomRotation *= currentSwayInfo.swayRotationPercentageAiming;
                }

                weaponRotationTarget = Quaternion.Euler (weaponRotationTarget.eulerAngles + recoilRandomRotation);
            }
            currentRecoilSpeed = firstPersonWeaponInfo.recoilSpeed;
        }

        Vector3 currentWeaponPosition = weaponTransform.localPosition;
        Quaternion currentWeaponRotation = weaponTransform.localRotation;

        for (float t = 0; t < 1;) {
            t += Time.deltaTime * currentRecoilSpeed * 2;

            weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
            weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

            yield return null;
        }

        endRecoil (isThirdPersonView);
    }

    public void endRecoil (bool isThirdPersonView)
    {
        stopWeaponMovement ();

        weaponMovement = StartCoroutine (recoilMovementForward (isThirdPersonView));
    }

    IEnumerator recoilMovementForward (bool isThirdPersonView)
    {
        weaponOnRecoil = true;

        if (isThirdPersonView) {
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentAimRecoilPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.aimPosition;
                } else {
                    currentAimRecoilPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.aimPosition;
                }
            } else {
                currentAimRecoilPositionTransform = thirdPersonWeaponInfo.aimPosition;
            }

            checkIfAddFBAAimPositionOffset ();

            checkIfAddFBAWalkPositionOffset ();

            checkIfAddFBACrouchPositionOffset ();

            currentRecoilSpeed = thirdPersonWeaponInfo.endRecoilSpeed;
        } else {
            if (aiming) {
                if (weaponSystemManager.isUsingSight () && firstPersonWeaponInfo.useSightPosition) {
                    currentAimRecoilPositionTransform = firstPersonWeaponInfo.sightPosition;
                } else {
                    currentAimRecoilPositionTransform = firstPersonWeaponInfo.aimPosition;
                }
            } else {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        if (crouchingActive) {
                            currentAimRecoilPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                        } else {
                            currentAimRecoilPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                        }
                    } else {
                        if (crouchingActive) {
                            currentAimRecoilPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                        } else {
                            currentAimRecoilPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                        }
                    }
                } else {
                    if (crouchingActive) {
                        currentAimRecoilPositionTransform = firstPersonWeaponInfo.crouchPosition;
                    } else {
                        currentAimRecoilPositionTransform = firstPersonWeaponInfo.walkPosition;
                    }
                }
            }

            currentRecoilSpeed = firstPersonWeaponInfo.endRecoilSpeed;
        }

        weaponPositionTarget = currentAimRecoilPositionTransform.localPosition;
        weaponRotationTarget = currentAimRecoilPositionTransform.localRotation;

        if (isFullBodyAwarenessActive ()) {
            if (isAimModeInputPressed ()) {
                if (overrideFBAValuesForOffset) {
                    weaponPositionTarget = currentFBAAimPositionOffset;

                    weaponRotationTarget = Quaternion.Euler (currentFBAAimRotationOffset);
                } else {
                    weaponPositionTarget += currentFBAAimPositionOffset;

                    weaponRotationTarget *= Quaternion.Euler (currentFBAAimRotationOffset);
                }
            } else {
                if (isPlayerCrouching ()) {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBACrouchPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBACrouchPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                    }
                } else {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBAWalkPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBAWalkPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                    }
                }
            }
        }

        Vector3 currentWeaponPosition = weaponTransform.localPosition;
        Quaternion currentWeaponRotation = weaponTransform.localRotation;

        for (float t = 0; t < 1;) {
            t += Time.deltaTime * currentRecoilSpeed * 2;

            weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
            weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

            yield return null;
        }

        weaponOnRecoil = false;
    }

    public void disableOtherWeaponsStates ()
    {
        surfaceDetected = false;

        weaponInRunPosition = false;

        playerRunning = false;

        setCurrentSwayInfo (true);

        cursorHidden = false;

        meleeAtacking = false;
    }

    public void resetOtherWeaponsStates ()
    {
        if (jumpingOnProcess) {
            weaponsManager.disableWeaponJumpState ();
        }

        if (playerRunning) {
            weaponsManager.resetPlayerRunningState ();
        }

        jumpingOnProcess = false;

        if (cursorHidden) {
            weaponsManager.enableOrDisableGeneralWeaponCursor (true);
        }

        weaponsManager.checkIfAnyReticleActive ();
    }

    public void stopWeaponMovement ()
    {
        if (weaponMovement != null) {
            StopCoroutine (weaponMovement);
        }

        if (resetingWeaponSwayValue) {
            stopResetSwayValue ();
        }

        weaponOnRecoil = false;
    }

    bool movementNotActive;
    bool cameraRotationNotActive;

    public void setWeaponSway (float mouseX, float mouseY, float vertical, float horizontal, bool running, bool shooting,
                               bool onGround, bool externalShakingActive, bool usingDevice, bool isThirdPersonView,
                               bool canMove, bool isFullBodyAwarenessActive)
    {
        if (weaponSwayPaused) {
            return;
        }

        bool deactivateIKIfNotAimingActiveResult = isDeactivateIKIfNotAimingActive ();

        if (currentlyUsingSway &&
            currentSwayInfo.useSway &&
            !resetingWeaponSwayValue &&
            (!isThirdPersonView || isFullBodyAwarenessActive || !deactivateIKIfNotAimingActiveResult) &&
            carrying) {

            float currentTime = Time.fixedDeltaTime;

            if (!isUsingDualWeapon () || !isThirdPersonView || isFullBodyAwarenessActive) {

                horizontalABS = Mathf.Abs (horizontal);
                verticalABS = Mathf.Abs (vertical);
                mouseXABS = Mathf.Abs (mouseX);
                mouseYABS = Mathf.Abs (mouseY);

                if (useWeaponIdle) {
                    movementNotActive = (horizontalABS < 0.01f && verticalABS < 0.01f);
                    cameraRotationNotActive = (mouseXABS < 0.01f && mouseYABS < 0.01f);

                    if (movementNotActive && cameraRotationNotActive && onGround && !actionActive) {
                        playerMoving = false;
                    } else {
                        playerMoving = true;

                        idleActive = false;

                        setLastTimeMoved ();

                        lastTimePlayerMoving = Time.time;
                    }

                    if (!playerMoving) {
                        if (externalShakingActive) {
                            setLastTimeMoved ();
                        }

                        if (Time.time > lastTimeMoved + timeToActiveWeaponIdle && !moving && !usingDevice && canMove) {
                            idleActive = true;

                            if (deactivateIKIfNotAimingActiveResult && crouchingActive) {
                                idleActive = false;
                            }
                        } else {
                            idleActive = false;
                        }
                    }
                }


                if (isThirdPersonView && !isFullBodyAwarenessActive) {
                    mouseX = 0;
                    mouseY = 0;
                    horizontal = 0;

                    horizontalABS = 0;
                    mouseXABS = 0;
                    mouseYABS = 0;
                }

                mouseX = Mathf.Clamp (mouseX, -1, 1);

                mouseY = Mathf.Clamp (mouseY, -1, 1);

                //assign values for walk or running multiplier

                if (running && !aiming) {
                    swayPositionRunningMultiplier = currentSwayInfo.swayPositionRunningMultiplier;
                    swayRotationRunningMultiplier = currentSwayInfo.swayRotationRunningMultiplier;
                    bobPositionRunningMultiplier = currentSwayInfo.bobPositionRunningMultiplier;
                    bobRotationRunningMultiplier = currentSwayInfo.bobRotationRunningMultiplier;
                } else {
                    swayPositionRunningMultiplier = 1;
                    swayRotationRunningMultiplier = 1;
                    bobPositionRunningMultiplier = 1;
                    bobRotationRunningMultiplier = 1;
                }

                usingPositionSway = false;
                usingRotationSway = false;

                //set the current rotation and positioon smooth value
                if (playerMoving || Time.time < lastTimePlayerMoving + 0.6f) {
                    currentSwayRotationSmooth = currentSwayInfo.swayRotationSmooth;
                    currentSwayPositionSmooth = currentSwayInfo.swayPositionSmooth;
                } else {
                    currentSwayRotationSmooth = currentSwayInfo.resetSwayRotationSmooth;
                    currentSwayPositionSmooth = currentSwayInfo.resetSwayPositionSmooth;
                }

                swayPosition = Vector3.zero;
                swayRotation = Vector3.zero;

                //set the position sway
                if (currentSwayInfo.usePositionSway) {

                    usingPositionSway = true;

                    if (mouseXABS > currentSwayInfo.minMouseAmountForSway) {
                        swayPosition.x = -mouseX * currentSwayInfo.swayPositionVertical;
                    } else {
                        swayPosition.x = 0;
                    }

                    if (mouseYABS > currentSwayInfo.minMouseAmountForSway) {
                        swayPosition.y = -mouseY * currentSwayInfo.swayPositionHorizontal;
                    } else {
                        swayPosition.y = 0;
                    }

                    swayPosition *= swayPositionRunningMultiplier;

                    if (swayPosition.x > currentSwayInfo.swayPositionMaxAmount) {
                        swayPosition.x = currentSwayInfo.swayPositionMaxAmount;
                    }

                    if (swayPosition.x < -currentSwayInfo.swayPositionMaxAmount) {
                        swayPosition.x = -currentSwayInfo.swayPositionMaxAmount;
                    }

                    if (swayPosition.y > currentSwayInfo.swayPositionMaxAmount) {
                        swayPosition.y = currentSwayInfo.swayPositionMaxAmount;
                    }

                    if (swayPosition.y < -currentSwayInfo.swayPositionMaxAmount) {
                        swayPosition.y = -currentSwayInfo.swayPositionMaxAmount;
                    }
                }

                //set the position bob
                if (currentSwayInfo.useBobPosition) {
                    usingPositionSway = true;

                    if ((horizontalABS > 0.01f || verticalABS > 0.01f) && onGround) {
                        mainSwayTargetPosition = getSwayPosition (currentSwayInfo.bobPositionSpeed, currentSwayInfo.bobPositionAmount, 1);

                        if (aiming) {
                            mainSwayTargetPosition *= currentSwayInfo.bobPositionPercentageAiming;
                        }

                        mainSwayTargetPosition *= bobPositionRunningMultiplier;

                        if (currentSwayInfo.useInputMultiplierForBobPosition) {
                            float inputAmount = Mathf.Abs (vertical) + Mathf.Abs (horizontal);

                            mainSwayTargetPosition *= Mathf.Clamp (inputAmount, 0, 1);
                        }
                    } else {
                        mainSwayTargetPosition = Vector3.zero;
                    }
                }

                //apply total position sway
                if (usingPositionSway) {
                    swayPosition += mainSwayTargetPosition;

                    if (aiming) {
                        swayPosition *= currentSwayInfo.swayPositionPercentageAiming;
                    } else {
                        swayExtraPosition = currentSwayInfo.movingExtraPosition;

                        if (vertical > 0.01f) {
                            swayPosition += swayExtraPosition.z * Vector3.forward;
                        }

                        if (vertical < -0.01f) {
                            swayPosition -= swayExtraPosition.z * Vector3.forward;
                        }

                        if (horizontal > 0) {
                            swayPosition += swayExtraPosition.x * Vector3.right;
                        }

                        if (horizontal < 0) {
                            swayPosition -= swayExtraPosition.x * Vector3.right;
                        }
                    }

                    if (!moving && idleActive) {
                        swayPosition = getSwayPosition (idleSpeed, idlePositionAmount, 1);
                    }

                    if (currentSwayInfo.useSwayPositionClamp) {
                        swayPosition.x = Mathf.Clamp (swayPosition.x, currentSwayInfo.swayPositionHorizontalClamp.x, currentSwayInfo.swayPositionHorizontalClamp.y);
                        swayPosition.y = Mathf.Clamp (swayPosition.y, currentSwayInfo.swayPositionVerticalClamp.x, currentSwayInfo.swayPositionVerticalClamp.y);
                    }

                    mainWeaponMeshTransform.localPosition =
                        Vector3.Lerp (mainWeaponMeshTransform.localPosition, swayPosition,
                        currentTime * currentSwayPositionSmooth);
                }

                //set the rotation sway
                if (currentSwayInfo.useRotationSway) {

                    usingRotationSway = true;

                    if (mouseXABS > currentSwayInfo.minMouseAmountForSway) {
                        swayRotation.z = mouseX * currentSwayInfo.swayRotationHorizontal;
                    }

                    if (mouseYABS > currentSwayInfo.minMouseAmountForSway) {
                        swayRotation.x = mouseY * currentSwayInfo.swayRotationVertical;
                    }

                    swayRotation *= swayRotationRunningMultiplier;
                }

                //set the rotation bob
                if (currentSwayInfo.useBobRotation) {
                    usingRotationSway = true;
                    if (!shooting) {
                        swayTilt.x = vertical * currentSwayInfo.bobRotationVertical;
                        swayTilt.z = horizontal * currentSwayInfo.bobRotationHorizontal;

                        swayTilt *= bobRotationRunningMultiplier;

                        if (aiming) {
                            swayTilt *= currentSwayInfo.bobRotationPercentageAiming;
                        }

                        if (currentSwayInfo.useInputMultiplierForBobRotation) {
                            float inputAmount = Mathf.Abs (vertical) + Mathf.Abs (horizontal);

                            swayTilt *= Mathf.Clamp (inputAmount, 0, 1);
                        }
                    } else {
                        swayTilt = Vector3.zero;
                    }
                }

                //apply total rotation sway
                if (usingRotationSway) {
                    swayRotation += swayTilt;
                    if (aiming) {
                        swayRotation *= currentSwayInfo.swayRotationPercentageAiming;
                    }

                    if (!moving && idleActive) {
                        swayRotation = getSwayPosition (idleSpeed, idleRotationAmount, 1);
                    }

                    if (currentSwayInfo.useSwayRotationClamp) {
                        swayRotation.x = Mathf.Clamp (swayRotation.x, currentSwayInfo.swayRotationClampX.x, currentSwayInfo.swayRotationClampX.y);
                        swayRotation.z = Mathf.Clamp (swayRotation.z, currentSwayInfo.swayRotationClampZ.x, currentSwayInfo.swayRotationClampZ.y);
                    }

                    swayTargetRotation = Quaternion.Euler (swayRotation);

                    mainWeaponMeshTransform.localRotation =
                        Quaternion.Lerp (mainWeaponMeshTransform.localRotation, swayTargetRotation,
                        currentTime * currentSwayRotationSmooth);
                }
            } else {
                mainWeaponMeshTransform.localPosition =
                    Vector3.Lerp (mainWeaponMeshTransform.localPosition, Vector3.zero, currentTime * currentSwayInfo.resetSwayRotationSmooth);
                mainWeaponMeshTransform.localRotation =
                    Quaternion.Slerp (mainWeaponMeshTransform.localRotation, Quaternion.identity, currentTime * currentSwayInfo.resetSwayRotationSmooth);
            }


            if (!isThirdPersonView && useWeaponAnimatorFirstPerson && !aiming) {
                if (!movementNotActive && onGround) {
                    if (running) {
                        mainWeaponAnimatorSystem.setRunState (true);
                    } else {
                        mainWeaponAnimatorSystem.setWalkState (true);
                    }
                } else {
                    mainWeaponAnimatorSystem.setIdleState (true);
                }
            }
        }
    }

    public Vector3 getSwayPosition (Vector3 speed, Vector3 amount, float multiplier)
    {
        currentSwayPosition = Vector3.zero;

        currentSwayPosition.x = Mathf.Sin (Time.time * speed.x) * amount.x * multiplier;
        currentSwayPosition.y = Mathf.Sin (Time.time * speed.y) * amount.y * multiplier;
        currentSwayPosition.z = Mathf.Sin (Time.time * speed.z) * amount.z * multiplier;

        return currentSwayPosition;
    }

    public void resetSwayValue ()
    {
        stopResetSwayValue ();

        swayValueCoroutine = StartCoroutine (resetSwayValueCoroutine ());
    }

    public void stopResetSwayValue ()
    {
        if (swayValueCoroutine != null) {
            StopCoroutine (swayValueCoroutine);
        }

        resetingWeaponSwayValue = false;
    }

    IEnumerator resetSwayValueCoroutine ()
    {
        weaponSwayTransform = weaponSystemManager.weaponSettings.weaponMesh.transform;

        resetingWeaponSwayValue = true;

        Vector3 targetPosition = Vector3.zero;
        Vector3 worldTargetPosition = weaponGameObject.transform.position;

        Quaternion targetRotation = Quaternion.identity;

        bool isFirstPersonActive = isPlayerCameraFirstPersonActive ();

        float movementSpeed = 0;

        if (fullBodyAwarenessActive && currentSwayInfoAssigned) {
            movementSpeed = currentSwayInfo.resetSwayValueSpeed;
        } else {
            if (isFirstPersonActive) {
                movementSpeed = firstPersonWeaponInfo.aimMovementSpeed;
            } else {
                movementSpeed = thirdPersonWeaponInfo.aimMovementSpeed;
            }
        }

        float dist = GKC_Utils.distance (weaponSwayTransform.position, worldTargetPosition);

        if (dist < 0.01f) {
            dist = 1;
        }

        float duration = dist / movementSpeed;
        float t = 0;

        bool targetReached = false;

        float angleDifference = 0;

        float movementDifference = 0;

        float movementTimer = 0;

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

            weaponSwayTransform.localPosition = Vector3.Slerp (weaponSwayTransform.localPosition, targetPosition, t);
            weaponSwayTransform.localRotation = Quaternion.Slerp (weaponSwayTransform.localRotation, targetRotation, t);

            angleDifference = Quaternion.Angle (weaponTransform.localRotation, targetRotation);

            movementDifference = GKC_Utils.distance (weaponTransform.localPosition, targetPosition);

            movementTimer += Time.deltaTime;

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

            yield return null;
        }

        //print (weaponSwayTransform.localPosition + " " + weaponSwayTransform.localRotation);

        resetingWeaponSwayValue = false;
    }

    //Function used to place the weapon in a better position while held in hand
    public void checkIfResetWeaponSway ()
    {
        if (aiming && !isPlayerCameraFirstPersonActive ()) {
            resetSwayValue ();
        }
    }

    public void checkIfResetWeaponSway (bool ignoreIfAiming)
    {
        if ((ignoreIfAiming || aiming) && !isPlayerCameraFirstPersonActive ()) {
            resetSwayValue ();
        }
    }

    public void setWeaponSwayPausedState (bool state)
    {
        weaponSwayPaused = state;
    }

    public void resetWeaponMeshPositionRotation ()
    {
        setWeaponMeshPositionRotation (null);
    }

    public void setWeaponMeshPositionRotation (Transform referenceTransform)
    {
        stopSetWeaponMeshPositionRotation ();

        swayValueCoroutine = StartCoroutine (setWeaponMeshPositionRotationCoroutine (referenceTransform));
    }

    public void stopSetWeaponMeshPositionRotation ()
    {
        if (swayValueCoroutine != null) {
            StopCoroutine (swayValueCoroutine);
        }
    }

    IEnumerator setWeaponMeshPositionRotationCoroutine (Transform referenceTransform)
    {
        Transform weaponMeshTransform = weaponSystemManager.weaponSettings.weaponMesh.transform;

        bool referenceTransformNotNull = referenceTransform != null;

        Vector3 targetPosition = Vector3.zero;

        if (referenceTransformNotNull) {
            targetPosition = referenceTransform.localPosition;
        }

        Vector3 worldTargetPosition = weaponGameObject.transform.position;

        Quaternion targetRotation = Quaternion.identity;

        if (referenceTransformNotNull) {
            targetRotation = referenceTransform.localRotation;
        }

        bool isFirstPersonActive = isPlayerCameraFirstPersonActive ();

        float movementSpeed = 0;

        if (isFirstPersonActive) {
            movementSpeed = firstPersonWeaponInfo.aimMovementSpeed;
        } else {
            movementSpeed = thirdPersonWeaponInfo.aimMovementSpeed;
        }

        float dist = 0;

        if (referenceTransformNotNull) {
            dist = GKC_Utils.distance (weaponMeshTransform.position, worldTargetPosition);
        } else {
            dist = GKC_Utils.distance (weaponMeshTransform.localPosition, targetPosition);
        }

        if (dist < 0.01f) {
            dist = 1;
        }

        float duration = dist / movementSpeed;
        float t = 0;

        bool targetReached = false;

        float angleDifference = 0;

        float movementDifference = 0;

        float movementTimer = 0;

        while (!targetReached) {

            t += Time.deltaTime / duration;

            weaponMeshTransform.localPosition = Vector3.Lerp (weaponMeshTransform.localPosition, targetPosition, t);
            weaponMeshTransform.localRotation = Quaternion.Lerp (weaponMeshTransform.localRotation, targetRotation, t);

            angleDifference = Quaternion.Angle (weaponTransform.localRotation, targetRotation);

            movementDifference = GKC_Utils.distance (weaponTransform.localPosition, targetPosition);

            movementTimer += Time.deltaTime;

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

            yield return null;
        }
    }

    public void setLastTimeMoved ()
    {
        lastTimeMoved = Time.time;
    }

    public void enableOrDisableFirstPersonArms (bool state)
    {
        if (isUsingDualWeapon ()) {
            enableOrDisableFirstPersonArmsDualWeapons (state);

            if (firstPersonArms != null) {
                if (disableOnlyFirstPersonArmsMesh) {
                    firstPersonArmsMesh.enabled = false;

                    if (extraFirstPersonArmsMeshes.Count > 0) {
                        for (int i = 0; i < extraFirstPersonArmsMeshes.Count; i++) {
                            if (extraFirstPersonArmsMeshes [i] != null) {
                                extraFirstPersonArmsMeshes [i].enabled = false;
                            }
                        }
                    }
                } else {
                    if (firstPersonArms.activeSelf) {
                        firstPersonArms.SetActive (false);
                    }
                }
            }
        } else {
            if (firstPersonArms != null) {
                if (disableOnlyFirstPersonArmsMesh) {
                    firstPersonArmsMesh.enabled = state;

                    if (extraFirstPersonArmsMeshes.Count > 0) {
                        for (int i = 0; i < extraFirstPersonArmsMeshes.Count; i++) {
                            if (extraFirstPersonArmsMeshes [i] != null) {
                                extraFirstPersonArmsMeshes [i].enabled = state;
                            }
                        }
                    }
                } else {
                    if (firstPersonArms.activeSelf != state) {
                        firstPersonArms.SetActive (state);
                    }
                }
            }

            enableOrDisableFirstPersonArmsDualWeapons (false);
        }
    }

    public void enableOrDisableFirstPersonArmsDualWeapons (bool state)
    {
        bool rightArmState = state;
        bool leftArmState = state;

        if (state) {
            if (usingRightHandDualWeapon) {
                leftArmState = false;
            } else {
                rightArmState = false;
            }
        }

        if (firstPersonWeaponInfo.rightHandDualWeaopnInfo.firstPersonHandMesh != null && firstPersonWeaponInfo.rightHandDualWeaopnInfo.firstPersonHandMesh.activeSelf != rightArmState) {
            firstPersonWeaponInfo.rightHandDualWeaopnInfo.firstPersonHandMesh.SetActive (rightArmState);
        }

        if (firstPersonWeaponInfo.leftHandDualWeaponInfo.firstPersonHandMesh != null && firstPersonWeaponInfo.leftHandDualWeaponInfo.firstPersonHandMesh.activeSelf != leftArmState) {
            firstPersonWeaponInfo.leftHandDualWeaponInfo.firstPersonHandMesh.SetActive (leftArmState);
        }
    }

    public void setNewFirstPersonArms (GameObject newArms)
    {
        firstPersonArms = newArms;

        updateComponent ();
    }

    public void enableOrDisableFirstPersonArmsFromEditor (bool state)
    {
        enableOrDisableFirstPersonArms (state);
    }

    public void destroyFirstPersonArmsFromEditor ()
    {
        if (firstPersonArms != null ||
            firstPersonWeaponInfo.rightHandDualWeaopnInfo.firstPersonHandMesh != null ||
            firstPersonWeaponInfo.leftHandDualWeaponInfo.firstPersonHandMesh != null) {

            GKC_Utils.unpackPrefabObjectByCheckingTransformRoot (gameObject);
        }

        if (firstPersonArms != null) {
            DestroyImmediate (firstPersonArms);
        }

        if (firstPersonWeaponInfo.rightHandDualWeaopnInfo.firstPersonHandMesh != null) {
            DestroyImmediate (firstPersonWeaponInfo.rightHandDualWeaopnInfo.firstPersonHandMesh);
        }

        if (firstPersonWeaponInfo.leftHandDualWeaponInfo.firstPersonHandMesh != null) {
            DestroyImmediate (firstPersonWeaponInfo.leftHandDualWeaponInfo.firstPersonHandMesh);
        }
    }

    public void enableOrDisableWeaponMesh (bool state)
    {
        //print ("mesh state "+gameObject.name + " " + state);
        weaponSystemManager.enableOrDisableWeaponMesh (state);
    }

    public void setWeaponMeshScale (float newValue)
    {
        weaponSystemManager.setWeaponMeshScale (newValue);
    }

    public void adjustAllFireWeaponTransformReferencePosition (float newValue)
    {
        thirdPersonWeaponInfo.aimPosition.localPosition *= newValue;
        thirdPersonWeaponInfo.walkPosition.localPosition *= newValue;
        thirdPersonWeaponInfo.aimRecoilPosition.localPosition *= newValue;

        if (thirdPersonWeaponInfo.surfaceCollisionPosition != null) {
            thirdPersonWeaponInfo.surfaceCollisionPosition.localPosition *= newValue;
        }

        if (thirdPersonWeaponInfo.surfaceCollisionRayPosition != null) {
            thirdPersonWeaponInfo.surfaceCollisionRayPosition.localPosition *= newValue;
        }

        if (thirdPersonWeaponInfo.weaponPositionInHandForDeactivateIK != null) {
            thirdPersonWeaponInfo.weaponPositionInHandForDeactivateIK.localPosition *= newValue;
        }

        if (thirdPersonWeaponInfo.weaponPivotPoint != null) {
            thirdPersonWeaponInfo.weaponPivotPoint.localPosition *= newValue;
        }

        if (thirdPersonWeaponInfo.weaponRotationPointHeadLookTarget != null) {
            thirdPersonWeaponInfo.weaponRotationPointHeadLookTarget.localPosition *= newValue;
        }

        currentKeepPath = thirdPersonWeaponInfo.keepPath;

        for (int j = 0; j < currentKeepPath.Count; j++) {
            if (currentKeepPath [j] != null) {
                if (currentKeepPath [j] != thirdPersonWeaponInfo.walkPosition) {
                    currentKeepPath [j].localPosition *= newValue;
                }
            }
        }

        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            for (int j = 0; j < thirdPersonWeaponInfo.handsInfo [i].wayPoints.Count; j++) {
                if (thirdPersonWeaponInfo.handsInfo [i].wayPoints [j] != null &&
                    thirdPersonWeaponInfo.handsInfo [i].wayPoints [j] != thirdPersonWeaponInfo.handsInfo [i].position) {
                    thirdPersonWeaponInfo.handsInfo [i].wayPoints [j].localPosition *= newValue;
                }
            }
        }

        //public Transform aimPosition;
        //public Transform walkPosition;
        //public Transform keepPosition;
        //public Transform aimRecoilPosition;
        //public Transform walkRecoilPosition;


        //public Transform surfaceCollisionPosition;
        //public Transform surfaceCollisionRayPosition;


        //public Transform lowerWeaponPosition;


        //public Transform runPosition;



        //public Transform jumpStartPosition;
        //public Transform jumpEndPosition;


        //public Transform meleeAttackPosition;

        //public Transform meleeAttackRaycastPosition;

        //public Transform editAttachmentPosition;
        //public Transform attachmentCameraPosition;


        //public Transform leftHandEditPosition;

        //public Transform leftHandParent;
        //public Transform extraLeftHandMeshParent;


        //public Transform secondPositionForHand;


        //public Transform sightPosition;
        //public Transform sightRecoilPosition;


        //public List<Transform> deactivateIKDrawPath = new List<Transform> ();
        //public Transform weaponPositionInHandForDeactivateIK;

        //public List<Transform> keepPath = new List<Transform> ();

        //public Transform weaponRotationPoint;
        //public Transform weaponRotationPointHolder;
        //public Transform weaponRotationPointHeadLookTarget;

        //public Transform weaponPivotPoint;


        //public Transform crouchPosition;
        //public Transform crouchRecoilPosition;

    }

    public void setHandTransform (Transform rightHand, Transform leftHand, Transform newRightHandMountPoint, Transform newLeftHandMountPoint)
    {
        for (int j = 0; j < thirdPersonWeaponInfo.handsInfo.Count; j++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [j];

            if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                currentIKWeaponsPosition.handTransform = rightHand;

                if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo.Count > 0) {
                    thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0].handTransform = rightHand;
                }
            }

            if (currentIKWeaponsPosition.limb == AvatarIKGoal.LeftHand) {
                currentIKWeaponsPosition.handTransform = leftHand;

                if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo.Count > 0) {
                    thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0].handTransform = leftHand;
                }
            }
        }

        rightHandMountPoint = newRightHandMountPoint;
        leftHandMountPoint = newLeftHandMountPoint;

        updateComponent ();
    }

    public bool isPlayerCarringWeapon ()
    {
        return carryingWeapon;
    }

    public void setShotCameraNoise ()
    {
        if (useShotCameraNoise) {
            float verticalAmount = 0;
            float horizontalAmount = 0;

            if (isFullBodyAwarenessActive () || isPlayerCameraFirstPersonActive ()) {
                verticalAmount = Random.Range (verticalShotCameraNoiseAmountFirstPerson.x, verticalShotCameraNoiseAmountFirstPerson.y);
                horizontalAmount = Random.Range (horizontalShotCameraNoiseAmountFirstPerson.x, horizontalShotCameraNoiseAmountFirstPerson.y);
            } else {
                verticalAmount = Random.Range (verticalShotCameraNoiseAmountThirdPerson.x, verticalShotCameraNoiseAmountThirdPerson.y);
                horizontalAmount = Random.Range (horizontalShotCameraNoiseAmountThirdPerson.x, horizontalShotCameraNoiseAmountThirdPerson.y);
            }

            if (verticalAmount != 0 || horizontalAmount != 0) {
                if (useShotCameraNoiseDuration) {
                    weaponsManager.setShotCameraNoiseWithDuration (new Vector2 (horizontalAmount, verticalAmount), shotCameraNoiseDuration);
                } else {
                    weaponsManager.setShotCameraNoise (new Vector2 (horizontalAmount, verticalAmount));
                }
            }
        }
    }

    public void setCameraPositionMouseWheelEnabledState (bool state)
    {
        weaponsManager.setCameraPositionMouseWheelEnabledState (state);
    }

    public bool checkIfIKHandsIsActive ()
    {
        bool isFirstPersonActive = isPlayerCameraFirstPersonActive ();

        if (isFirstPersonActive || (!isFirstPersonActive && !checkIfDeactivateIKIfNotAimingActive ()) ||
            (!isFirstPersonActive && checkIfDeactivateIKIfNotAimingActive () && editingAttachments)) {
            return true;
        }

        return false;
    }

    public void enableOrDisableEditAttachment (bool state)
    {
        //stop the coroutines and start them again
        stopWeaponMovement ();

        weaponMovement = StartCoroutine (enableOrDisableEditAttachmentCoroutine (state));

        if (checkIfIKHandsIsActive () && (isPlayerCameraFirstPersonActive () || !checkIfDeactivateIKIfNotAimingActive ())) {
            moveHandForAttachment ();
        }

        setLastTimeMoved ();
    }

    IEnumerator enableOrDisableEditAttachmentCoroutine (bool state)
    {
        disableOtherWeaponsStates ();

        editingAttachments = state;

        bool isFirstPersonActive = isPlayerCameraFirstPersonActive ();

        if (!isFirstPersonActive && checkIfDeactivateIKIfNotAimingActive ()) {
            if (editingAttachments) {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                    } else {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                    }

                    setHandDeactivateIKStateToDisable ();

                    setWeaponTransformParent (transform);
                } else {
                    for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                        currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                        if (currentIKWeaponsPosition.usedToDrawWeapon) {
                            setHandDeactivateIKStateToDisable ();

                            setWeaponTransformParent (transform);
                        }
                    }
                }
            }
        }

        if (checkIfIKHandsIsActive ()) {
            Vector3 worldTargetPosition = Vector3.zero;

            setWeaponMovingState (true);

            float movementSpeed = 0;

            if (isFirstPersonActive) {
                movementSpeed = firstPersonWeaponInfo.editAttachmentMovementSpeed;
            } else {
                movementSpeed = thirdPersonWeaponInfo.editAttachmentMovementSpeed;
            }

            if (editingAttachments) {
                if (isFirstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentEditAttachmentPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.editAttachmentPosition;
                        } else {
                            currentEditAttachmentPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.editAttachmentPosition;
                        }
                    } else {
                        currentEditAttachmentPositionTransform = firstPersonWeaponInfo.editAttachmentPosition;
                    }
                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.editAttachmentPosition;
                        } else {
                            currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.editAttachmentPosition;
                        }
                    } else {
                        currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.editAttachmentPosition;
                    }
                }
            } else {
                if (isFirstPersonActive) {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            if (crouchingActive) {
                                currentEditAttachmentPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                            } else {
                                currentEditAttachmentPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                            }
                        } else {
                            if (crouchingActive) {
                                currentEditAttachmentPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                            } else {
                                currentEditAttachmentPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                            }
                        }
                    } else {
                        if (crouchingActive) {
                            currentEditAttachmentPositionTransform = firstPersonWeaponInfo.crouchPosition;
                        } else {
                            currentEditAttachmentPositionTransform = firstPersonWeaponInfo.walkPosition;
                        }
                    }

                } else {
                    if (isUsingDualWeapon ()) {
                        if (usingRightHandDualWeapon) {
                            currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                        } else {
                            currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                        }
                    } else {
                        currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.walkPosition;
                    }

                    checkIfAddFBAWalkPositionOffset ();

                    checkIfAddFBACrouchPositionOffset ();
                }
            }

            weaponPositionTarget = currentEditAttachmentPositionTransform.localPosition;
            weaponRotationTarget = currentEditAttachmentPositionTransform.localRotation;

            worldTargetPosition = currentEditAttachmentPositionTransform.position;

            if (isFullBodyAwarenessActive ()) {
                if (!editingAttachments) {
                    if (isPlayerCrouching ()) {
                        checkIfAddFBACrouchPositionOffset ();

                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBACrouchPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBACrouchPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                        }
                    } else {
                        checkIfAddFBAWalkPositionOffset ();

                        if (overrideFBAValuesForOffset) {
                            weaponPositionTarget = currentFBAWalkPositionOffset;

                            weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                        } else {
                            weaponPositionTarget += currentFBAWalkPositionOffset;

                            weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                        }
                    }
                }
            }

            float dist = GKC_Utils.distance (weaponTransform.position, worldTargetPosition);
            float duration = dist / movementSpeed;
            float t = 0;

            bool targetReached = false;

            float angleDifference = 0;

            float positionDifference = 0;

            float movementTimer = 0;

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

                weaponTransform.localPosition = Vector3.Lerp (weaponTransform.localPosition, weaponPositionTarget, t);
                weaponTransform.localRotation = Quaternion.Lerp (weaponTransform.localRotation, weaponRotationTarget, t);

                angleDifference = Quaternion.Angle (weaponTransform.localRotation, weaponRotationTarget);

                positionDifference = GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget);

                movementTimer += Time.deltaTime;

                if ((positionDifference < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 0.5f)) {
                    targetReached = true;
                }

                yield return null;
            }



            Transform weaponMeshTransform = weaponSystemManager.weaponSettings.weaponMesh.transform;
            Vector3 weaponMeshTargetPosition = Vector3.zero;
            Quaternion weaponMeshTargetRotation = Quaternion.identity;

            dist = GKC_Utils.distance (weaponMeshTransform.position, worldTargetPosition);
            duration = dist / movementSpeed;
            t = 0;

            targetReached = false;

            angleDifference = 0;

            float movementDifference = 0;

            movementTimer = 0;

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

                weaponMeshTransform.localPosition = Vector3.Lerp (weaponMeshTransform.localPosition, weaponMeshTargetPosition, t);
                weaponMeshTransform.localRotation = Quaternion.Lerp (weaponMeshTransform.localRotation, weaponMeshTargetRotation, t);

                angleDifference = Quaternion.Angle (weaponTransform.localRotation, weaponMeshTargetRotation);

                movementDifference = GKC_Utils.distance (weaponTransform.localPosition, weaponMeshTargetPosition);

                movementTimer += Time.deltaTime;

                if ((movementDifference < 0.01f && angleDifference < 0.2f) || movementTimer > (duration + 0.5f)) {
                    targetReached = true;
                }

                yield return null;
            }

            setWeaponMovingState (false);
        }

        if (!isFirstPersonActive && !editingAttachments && checkIfDeactivateIKIfNotAimingActive ()) {
            if (isUsingDualWeapon ()) {
                newWeaponParent = leftHandMountPoint;

                if (usingRightHandDualWeapon) {
                    newWeaponParent = rightHandMountPoint;
                }

                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                if (newWeaponParent == null) {
                    newWeaponParent = currentIKWeaponsPosition.handTransform;
                }

                setWeaponTransformParent (newWeaponParent);
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        newWeaponParent = leftHandMountPoint;

                        if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                            newWeaponParent = rightHandMountPoint;
                        }

                        currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                        currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                        currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;

                        if (newWeaponParent == null) {
                            newWeaponParent = currentIKWeaponsPosition.handTransform;
                        }

                        setWeaponTransformParent (newWeaponParent);
                    }
                }
            }

            setHandsIKTargetValue (0, 0);
            setElbowsIKTargetValue (0, 0);
        }
    }

    public void moveHandForAttachment ()
    {
        bool isFirstPersonActive = isPlayerCameraFirstPersonActive ();

        if (firstPersonWeaponInfo.leftHandMesh == null && isFirstPersonActive) {
            return;
        }

        if (thirdPersonWeaponInfo.leftHandMesh == null && !isFirstPersonActive) {
            return;
        }

        if (handAttachmentCoroutine != null) {
            StopCoroutine (handAttachmentCoroutine);
        }

        handAttachmentCoroutine = StartCoroutine (moveHandForAttachnmentCoroutine ());
    }

    IEnumerator moveHandForAttachnmentCoroutine ()
    {
        Vector3 handTargetPosition = Vector3.zero;
        Vector3 handWorldTargetPosition = Vector3.zero;
        Transform handToMove = thirdPersonWeaponInfo.leftHandMesh.transform;

        Quaternion handTargetRotation = Quaternion.identity;

        bool isFirstPersonActive = isPlayerCameraFirstPersonActive ();

        float movementSpeed = 0;

        if (isFirstPersonActive) {
            handToMove = firstPersonWeaponInfo.leftHandMesh.transform;
            movementSpeed = firstPersonWeaponInfo.editAttachmentHandSpeed;
        } else {
            movementSpeed = thirdPersonWeaponInfo.editAttachmentHandSpeed;
        }

        if (editingAttachments) {
            if (isFirstPersonActive) {
                handTargetPosition = firstPersonWeaponInfo.leftHandEditPosition.localPosition;
                handWorldTargetPosition = firstPersonWeaponInfo.leftHandEditPosition.position;

                if (firstPersonWeaponInfo.extraLeftHandMesh != null) {
                    firstPersonWeaponInfo.extraLeftHandMesh.transform.SetParent (handToMove);
                }
            } else {
                handWorldTargetPosition = thirdPersonWeaponInfo.leftHandEditPosition.position;

                setElbowsIKTargetValue (0, 0);

                weaponsManager.getIKSystem ().setElbowsIKTargetValue (0, 0);

                handToMove.SetParent (thirdPersonWeaponInfo.leftHandEditPosition);
            }
        } else {
            if (isFirstPersonActive) {
                if (firstPersonWeaponInfo.usingSecondPositionForHand) {
                    handTargetPosition = firstPersonWeaponInfo.secondPositionForHand.localPosition;
                    handWorldTargetPosition = firstPersonWeaponInfo.secondPositionForHand.position;
                } else {
                    handWorldTargetPosition = firstPersonWeaponInfo.leftHandEditPosition.parent.position;
                }
            } else {
                if (thirdPersonWeaponInfo.usingSecondPositionForHand) {
                    handTargetPosition = thirdPersonWeaponInfo.secondPositionForHand.localPosition;
                    handWorldTargetPosition = thirdPersonWeaponInfo.secondPositionForHand.position;
                } else {
                    handWorldTargetPosition = thirdPersonWeaponInfo.leftHandParent.position;
                }

                setElbowsIKTargetValue (1, 1);

                weaponsManager.getIKSystem ().setElbowsIKTargetValue (1, 1);

                handToMove.SetParent (thirdPersonWeaponInfo.leftHandParent);
            }
        }

        float dist = GKC_Utils.distance (handToMove.position, handWorldTargetPosition);
        float duration = dist / movementSpeed;
        float t = 0;

        bool targetReached = false;

        float movementDifference = 0;

        float movementTimer = 0;

        float angleDifference = 0;

        if (isFirstPersonActive) {

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

                handToMove.localPosition = Vector3.Slerp (handToMove.localPosition, handTargetPosition, t);

                movementDifference = GKC_Utils.distance (weaponTransform.localPosition, handTargetPosition);

                movementTimer += Time.deltaTime;

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

                yield return null;
            }

            if (isFirstPersonActive && !editingAttachments) {
                if (firstPersonWeaponInfo.extraLeftHandMesh) {
                    firstPersonWeaponInfo.extraLeftHandMesh.transform.SetParent (firstPersonWeaponInfo.extraLeftHandMeshParent);
                }
            }
        } else {
            while (!targetReached) {
                t += Time.deltaTime / duration;

                handToMove.localPosition = Vector3.Slerp (handToMove.localPosition, handTargetPosition, t);
                handToMove.localRotation = Quaternion.Slerp (handToMove.localRotation, handTargetRotation, t);

                angleDifference = Quaternion.Angle (weaponTransform.localRotation, handTargetRotation);

                movementDifference = GKC_Utils.distance (weaponTransform.localPosition, handTargetPosition);

                movementTimer += Time.deltaTime;

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

                yield return null;
            }
        }
    }

    public void quickEnableOrDisableEditAttachment (bool state)
    {
        editingAttachments = state;

        Vector3 targetPosition = Vector3.zero;
        Quaternion targetRotation = Quaternion.identity;

        bool isFirstPersonActive = isPlayerCameraFirstPersonActive ();

        if (editingAttachments) {
            if (isFirstPersonActive) {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentEditAttachmentPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.editAttachmentPosition;
                    } else {
                        currentEditAttachmentPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.editAttachmentPosition;
                    }
                } else {
                    currentEditAttachmentPositionTransform = firstPersonWeaponInfo.editAttachmentPosition;
                }

            } else {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.editAttachmentPosition;
                    } else {
                        currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.editAttachmentPosition;
                    }
                } else {
                    currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.editAttachmentPosition;
                }
            }
        } else {
            if (isFirstPersonActive) {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        if (crouchingActive) {
                            currentEditAttachmentPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.crouchPosition;
                        } else {
                            currentEditAttachmentPositionTransform = firstPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                        }
                    } else {
                        if (crouchingActive) {
                            currentEditAttachmentPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.crouchPosition;
                        } else {
                            currentEditAttachmentPositionTransform = firstPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                        }
                    }
                } else {
                    if (crouchingActive) {
                        currentEditAttachmentPositionTransform = firstPersonWeaponInfo.crouchPosition;
                    } else {
                        currentEditAttachmentPositionTransform = firstPersonWeaponInfo.walkPosition;
                    }
                }

            } else {
                if (isUsingDualWeapon ()) {
                    if (usingRightHandDualWeapon) {
                        currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                    } else {
                        currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                    }
                } else {
                    currentEditAttachmentPositionTransform = thirdPersonWeaponInfo.walkPosition;
                }

                checkIfAddFBAWalkPositionOffset ();

                checkIfAddFBACrouchPositionOffset ();
            }
        }

        weaponTransform.localPosition = currentEditAttachmentPositionTransform.localPosition;
        weaponTransform.localRotation = currentEditAttachmentPositionTransform.localRotation;

        Transform weaponMeshTransform = weaponSystemManager.weaponSettings.weaponMesh.transform;
        Vector3 weaponMeshTargetPosition = Vector3.zero;
        Quaternion weaponMeshTargetRotation = Quaternion.identity;

        weaponMeshTransform.localPosition = weaponMeshTargetPosition;
        weaponMeshTransform.localRotation = weaponMeshTargetRotation;

        Vector3 handTargetPosition = Vector3.zero;
        Transform handToMove = thirdPersonWeaponInfo.leftHandMesh.transform;

        Quaternion handTargetRotation = Quaternion.identity;

        if (isFirstPersonActive) {
            handToMove = firstPersonWeaponInfo.leftHandMesh.transform;
        }

        if (editingAttachments) {
            if (isFirstPersonActive) {
                handTargetPosition = firstPersonWeaponInfo.leftHandEditPosition.localPosition;
            } else {
                setElbowsIKTargetValue (0, 0);
                weaponsManager.getIKSystem ().setElbowsIKTargetValue (0, 0);
                handToMove.SetParent (thirdPersonWeaponInfo.leftHandEditPosition);
            }
        } else {
            if (!isFirstPersonActive) {
                setElbowsIKTargetValue (1, 1);
                weaponsManager.getIKSystem ().setElbowsIKTargetValue (1, 1);
                handToMove.SetParent (thirdPersonWeaponInfo.leftHandParent);
            }

            if (isFirstPersonActive) {
                if (firstPersonWeaponInfo.usingSecondPositionForHand) {
                    handTargetPosition = firstPersonWeaponInfo.secondPositionForHand.localPosition;
                }
            } else {
                if (thirdPersonWeaponInfo.usingSecondPositionForHand) {
                    handTargetPosition = thirdPersonWeaponInfo.secondPositionForHand.localPosition;
                }
            }
        }

        if (isFirstPersonActive) {
            handToMove.localPosition = handTargetPosition;
        } else {
            handToMove.localPosition = handTargetPosition;
            handToMove.localRotation = handTargetRotation;
        }
    }

    public void setUsingSecondPositionHandState (bool state)
    {
        firstPersonWeaponInfo.usingSecondPositionForHand = state;
        thirdPersonWeaponInfo.usingSecondPositionForHand = state;
    }

    public void setNewSecondPositionHandTransformFirstPerson (Transform newTransform)
    {
        firstPersonWeaponInfo.secondPositionForHand = newTransform;

        if (!editingAttachments) {
            checkHandsPosition ();
        }
    }

    public void setNewSecondPositionHandTransformThirdPerson (Transform newTransform)
    {
        thirdPersonWeaponInfo.secondPositionForHand = newTransform;

        if (!editingAttachments) {
            checkHandsPosition ();
        }
    }

    public void checkHandsPosition ()
    {
        if (thirdPersonWeaponInfo.leftHandMesh == null || firstPersonWeaponInfo.leftHandMesh == null) {
            return;
        }

        bool isFirstPersonActive = isPlayerCameraFirstPersonActive ();

        Vector3 handTargetPosition = Vector3.zero;
        Transform handToMove = thirdPersonWeaponInfo.leftHandMesh.transform;

        Quaternion handTargetRotation = Quaternion.identity;

        if (isFirstPersonActive) {
            handToMove = firstPersonWeaponInfo.leftHandMesh.transform;
        }

        if (isFirstPersonActive) {
            if (firstPersonWeaponInfo.usingSecondPositionForHand) {
                if (firstPersonWeaponInfo.secondPositionForHand) {
                    handTargetPosition = firstPersonWeaponInfo.secondPositionForHand.localPosition;
                }
            }
        } else {
            if (thirdPersonWeaponInfo.usingSecondPositionForHand) {
                if (thirdPersonWeaponInfo.secondPositionForHand) {
                    handTargetPosition = thirdPersonWeaponInfo.secondPositionForHand.localPosition;
                }
            }
        }

        if (isFirstPersonActive) {
            handToMove.localPosition = handTargetPosition;
        } else {
            handToMove.localPosition = handTargetPosition;
            handToMove.localRotation = handTargetRotation;
        }
    }

    public void stopEditAttachment ()
    {
        if (editingAttachments) {
            //stop the coroutines
            stopWeaponMovement ();

            if (handAttachmentCoroutine != null) {
                StopCoroutine (handAttachmentCoroutine);
            }

            setWeaponMovingState (false);

            setLastTimeMoved ();

            editingAttachments = false;

            if (firstPersonWeaponInfo.leftHandMesh != null) {
                firstPersonWeaponInfo.leftHandMesh.transform.localPosition = Vector3.zero;
            }

            if (thirdPersonWeaponInfo.leftHandMesh != null) {
                thirdPersonWeaponInfo.leftHandMesh.transform.localPosition = Vector3.zero;
            }
        }
    }

    public Transform getThirdPersonAttachmentCameraPosition ()
    {
        if (isUsingDualWeapon ()) {
            if (usingRightHandDualWeapon) {
                return thirdPersonWeaponInfo.rightHandDualWeaopnInfo.attachmentCameraPosition;
            } else {
                return thirdPersonWeaponInfo.leftHandDualWeaponInfo.attachmentCameraPosition;
            }
        } else {
            return thirdPersonWeaponInfo.attachmentCameraPosition;
        }
    }

    public bool isWeaponOnRecoil ()
    {
        return weaponOnRecoil;
    }

    public void setCurrentWeaponState (bool state)
    {
        //		print ("set state " + getWeaponSystemName () + " " + state + " " + weaponsManager.name);

        currentWeapon = state;

        weaponSystemManager.setCurrentWeaponState (state);

        if (currentWeapon) {
            if (checkIfWeaponUsesAttachment ()) {
                mainWeaponAttachmentSystem.checkIfAttachmentSystemInitialized ();
            }
        } else {
            lastTimeWeaponActive = Time.time;

            IKPausedOnHandsActive = false;
        }
    }

    public bool isCurrentWeapon ()
    {
        return currentWeapon;
    }

    public bool isAimingWeapon ()
    {
        return aiming;
    }

    public void updateProjectileInfoValues ()
    {
        weaponSystemManager.updateProjectileInfoValues ();
    }

    public bool isPlayerCameraFirstPersonActive ()
    {
        return weaponsManager.checkIfFirstPersonActiveExternally ();
    }

    public bool isAimModeInputPressed ()
    {
        return weaponsManager.isAimModeInputPressed ();
    }

    public bool fullBodyAwarenessActive;

    public void setFullBodyAwarenessActiveState (bool state)
    {
        fullBodyAwarenessActive = state;

        weaponSystemManager.setFullBodyAwarenessActiveState (state);
    }

    public bool isFullBodyAwarenessActive ()
    {
        return fullBodyAwarenessActive;
    }

    public void enableOrDisableIKOnHandsFromFBAStateChange (bool state)
    {
        changingIKOnHandsFromFBAStateChangeActive = true;

        enableOrDisableIKOnHands (state);
    }

    bool changingIKOnHandsFromFBAStateChangeActive;

    public bool isPlayerCrouching ()
    {
        return weaponsManager.isPlayerCrouching ();
    }

    public bool isHideWeaponIfKeptInThirdPersonActive ()
    {
        return hideWeaponIfKeptInThirdPerson;
    }

    public void initializeAttachmentSystem ()
    {
        if (checkIfWeaponUsesAttachment ()) {
            mainWeaponAttachmentSystem.initializeAttachmentSystem ();
        }
    }

    public bool pickupAttachment (string attachmentName)
    {
        if (mainWeaponAttachmentSystem != null) {
            if (isAttachmentAlreadyActiveOnWeapon (attachmentName)) {
                //				print (attachmentName + " attachment already active on weapon");

                return false;
            }

            return mainWeaponAttachmentSystem.pickupAttachment (attachmentName);
        }

        return false;
    }

    public bool isAttachmentAlreadyActiveOnWeapon (string attachmentName)
    {
        if (mainWeaponAttachmentSystem != null) {
            return mainWeaponAttachmentSystem.isAttachmentAlreadyActiveOnWeapon (attachmentName);
        }

        return false;
    }

    public void checkIfWeaponAttachmentAssigned ()
    {
        if (mainWeaponAttachmentSystem == null) {
            mainWeaponAttachmentSystem = weaponGameObject.GetComponentInChildren<weaponAttachmentSystem> ();
        }

        weaponUsesAttachment = mainWeaponAttachmentSystem != null;

        if (weaponUsesAttachment) {
            mainWeaponAttachmentSystem.assignWeaponToAttachment (this);

            print ("Weapon Attachment found on the weapon " + getWeaponSystemName ());
        } else {
            print ("No Weapon Attachment found on the weapon " + getWeaponSystemName ());
        }

        updateComponent ();
    }

    public void selectAttachmentSystemOnEditor ()
    {
        if (mainWeaponAttachmentSystem != null) {
            GKC_Utils.setActiveGameObjectInEditor (mainWeaponAttachmentSystem.gameObject);
        }
    }

    public void setWeaponAttachmentSystem (weaponAttachmentSystem attachmentSystem)
    {
        mainWeaponAttachmentSystem = attachmentSystem;

        weaponUsesAttachment = mainWeaponAttachmentSystem != null;

        if (weaponUsesAttachment) {
            mainWeaponAttachmentSystem.assignWeaponToAttachment (this);
        }

        updateComponent ();
    }

    public void removeAttachmentSystem ()
    {
        setWeaponAttachmentSystem (null);
    }

    public weaponAttachmentSystem getWeaponAttachmentSystem ()
    {
        return mainWeaponAttachmentSystem;
    }

    public bool checkAttachmentsHUD ()
    {
        if (mainWeaponAttachmentSystem != null) {
            mainWeaponAttachmentSystem.checkAttachmentsHUD ();

            return true;
        }

        return false;
    }

    public void enableAllAttachments ()
    {
        if (mainWeaponAttachmentSystem != null) {
            mainWeaponAttachmentSystem.enableAllAttachments ();
        }
    }

    public void checkSniperSightUsedOnWeapon (bool state)
    {
        weaponsManager.checkSniperSightUsedOnWeapon (state);
    }

    public void setPlayerControllerMovementValues ()
    {
        if (aiming || carrying) {
            bool firstPersonActive = isPlayerCameraFirstPersonActive ();

            if (firstPersonActive) {
                useNewCarrySpeed = firstPersonWeaponInfo.useNewCarrySpeed;
                newCarrySpeed = firstPersonWeaponInfo.newCarrySpeed;
                useNewAimSpeed = firstPersonWeaponInfo.useNewAimSpeed;
                newAimSpeed = firstPersonWeaponInfo.newAimSpeed;
                canRunWhileCarrying = firstPersonWeaponInfo.canRunWhileCarrying;
                canRunWhileAiming = firstPersonWeaponInfo.canRunWhileAiming;
            } else {
                useNewCarrySpeed = thirdPersonWeaponInfo.useNewCarrySpeed;
                newCarrySpeed = thirdPersonWeaponInfo.newCarrySpeed;
                useNewAimSpeed = thirdPersonWeaponInfo.useNewAimSpeed;
                newAimSpeed = thirdPersonWeaponInfo.newAimSpeed;
                canRunWhileCarrying = thirdPersonWeaponInfo.canRunWhileCarrying;
                canRunWhileAiming = thirdPersonWeaponInfo.canRunWhileAiming;
            }

            if (aiming) {
                weaponsManager.setPlayerControllerMovementValues (useNewAimSpeed, newAimSpeed);
                weaponsManager.setPlayerControllerCanRunValue (canRunWhileAiming);
            } else {
                weaponsManager.setPlayerControllerMovementValues (useNewCarrySpeed, newCarrySpeed);
                weaponsManager.setPlayerControllerCanRunValue (canRunWhileCarrying);
            }
        } else {
            setPlayerControllerMovementOriginalValues ();
        }
    }

    public void setPlayerControllerMovementOriginalValues ()
    {
        weaponsManager.setPlayerControllerMovementOriginalValues ();
    }

    public void setPlayerControllerCurrentIdleIDValue (int newValue)
    {
        weaponsManager.setPlayerControllerCurrentIdleIDValue (newValue);
    }

    public void setUsingDualWeaponState (bool state)
    {
        usingDualWeapon = state;

        weaponSystemManager.setUsingDualWeaponState (state);
    }

    public void disableUsingDualWeaponState ()
    {
        setDisablingDualWeaponState (true);
    }

    public void setDisablingDualWeaponState (bool state)
    {
        disablingDualWeapon = state;
    }

    public bool isUsingDualWeapon ()
    {
        return usingDualWeapon || disablingDualWeapon;
    }

    public void setUsingRightHandDualWeaponState (bool state)
    {
        usingRightHandDualWeapon = state;

        weaponSystemManager.setUsingRightHandDualWeaponState (state);
    }

    public void resetWeaponMeshTransform ()
    {
        weaponSystemManager.resetWeaponMeshTransform ();
    }

    public bool isQuickDrawKeepDualWeaponActive ()
    {
        return (usingRightHandDualWeapon && thirdPersonWeaponInfo.rightHandDualWeaopnInfo.useQuickDrawKeepWeapon) ||
        (!usingRightHandDualWeapon && thirdPersonWeaponInfo.leftHandDualWeaponInfo.useQuickDrawKeepWeapon) ||
        weaponsManager.isForceWeaponToUseQuickDrawKeepWeaponActive ();
    }

    public void setWeaponConfiguredAsDualWeaponState (bool state, string newWeaponName)
    {
        if (weaponConfiguredAsDualWeaponPreviously != weaponConfiguredAsDualWeapon) {
            weaponConfiguredAsDualWeaponPreviously = weaponConfiguredAsDualWeapon;
        }

        weaponConfiguredAsDualWeapon = state;
        linkedDualWeaponName = newWeaponName;
    }

    public void disableWeaponConfiguredAsDualWeaponPreviously ()
    {
        weaponConfiguredAsDualWeaponPreviously = false;
    }

    public bool isWeaponConfiguredAsDualWeapon ()
    {
        return weaponConfiguredAsDualWeapon;
    }

    public string getLinkedDualWeaponName ()
    {
        return linkedDualWeaponName;
    }

    public bool usingWeaponAsOneHandWield;

    public void setCurrentWeaponAsOneHandWield ()
    {
        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            if (currentIKWeaponsPosition.usedToDrawWeapon) {
                currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;
            } else {
                currentIKWeaponsPosition.ignoreIKWeight = true;
                currentIKWeaponsPosition.handInPositionToAim = true;
            }
        }

        usingWeaponAsOneHandWield = true;

        thirdPersonWeaponInfo.usingWeaponAsOneHandWield = true;

        bool rightHandUsedToDrawWeapon = false;

        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            if (currentIKWeaponsPosition.usedToDrawWeapon) {
                if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                    rightHandUsedToDrawWeapon = true;
                }
            }
        }

        setUsingRightHandDualWeaponState (rightHandUsedToDrawWeapon);

        if (!checkIfDeactivateIKIfNotAimingActive ()) {

            thirdPersonWeaponInfo.usedOnRightHand = rightHandUsedToDrawWeapon;
            thirdPersonWeaponInfo.dualWeaponActive = true;

            stopWeaponMovement ();

            weaponMovement = StartCoroutine (setCurrentWeaponAsOneHandWieldCoroutine (rightHandUsedToDrawWeapon));
        }
    }

    IEnumerator setCurrentWeaponAsOneHandWieldCoroutine (bool rightHandUsedToDrawWeapon)
    {
        setWeaponMovingState (true);

        if (rightHandUsedToDrawWeapon) {
            setHandsIKTargetValue (0, 1);
            setElbowsIKTargetValue (0, 1);
        } else {
            setHandsIKTargetValue (1, 0);
            setElbowsIKTargetValue (1, 0);
        }

        WaitForSeconds delay = new WaitForSeconds (0.2f);

        yield return delay;

        if (rightHandUsedToDrawWeapon) {
            currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
        } else {
            currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
        }

        weaponPositionTarget = currentDrawPositionTransform.localPosition;
        weaponRotationTarget = currentDrawPositionTransform.localRotation;

        if (isFullBodyAwarenessActive ()) {
            if (overrideFBAValuesForOffset) {
                weaponPositionTarget = currentFBAWalkPositionOffset;

                weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
            } else {
                weaponPositionTarget += currentFBAWalkPositionOffset;

                weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
            }
        }

        stopWeaponMovement ();

        activateMoveWeaponToPositionCoroutine (thirdPersonWeaponInfo.changeOneOrTwoHandWieldSpeed);

        setWeaponMovingState (false);
    }

    public void setCurrentWeaponAsTwoHandsWield ()
    {
        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            if (!currentIKWeaponsPosition.usedToDrawWeapon) {
                currentIKWeaponsPosition.ignoreIKWeight = false;

                if (!checkIfDeactivateIKIfNotAimingActive ()) {
                    currentIKWeaponsPosition.handInPositionToAim = false;
                }

                currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;
            }
        }

        setUsingRightHandDualWeaponState (false);

        usingWeaponAsOneHandWield = false;

        thirdPersonWeaponInfo.usingWeaponAsOneHandWield = false;

        thirdPersonWeaponInfo.usedOnRightHand = false;
        thirdPersonWeaponInfo.dualWeaponActive = false;

        if (!checkIfDeactivateIKIfNotAimingActive ()) {
            bool rightHandUsedToDrawWeapon = false;

            for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                if (currentIKWeaponsPosition.usedToDrawWeapon) {
                    if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                        rightHandUsedToDrawWeapon = true;
                    }
                }
            }

            stopWeaponMovement ();

            weaponMovement = StartCoroutine (setCurrentWeaponAsTwoHandWieldCoroutine (rightHandUsedToDrawWeapon));
        }
    }

    IEnumerator setCurrentWeaponAsTwoHandWieldCoroutine (bool rightHandUsedToDrawWeapon)
    {
        setWeaponMovingState (true);

        if (rightHandUsedToDrawWeapon) {
            currentDrawPositionTransform = thirdPersonWeaponInfo.walkPosition;
        } else {
            currentDrawPositionTransform = thirdPersonWeaponInfo.walkPosition;
        }

        checkIfAddFBAWalkPositionOffset ();

        weaponPositionTarget = currentDrawPositionTransform.localPosition;
        weaponRotationTarget = currentDrawPositionTransform.localRotation;

        if (isFullBodyAwarenessActive ()) {
            if (overrideFBAValuesForOffset) {
                weaponPositionTarget = currentFBAWalkPositionOffset;

                weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
            } else {
                weaponPositionTarget += currentFBAWalkPositionOffset;

                weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
            }
        }

        Vector3 currentWeaponPosition = weaponTransform.localPosition;
        Quaternion currentWeaponRotation = weaponTransform.localRotation;

        for (float t = 0; t < 1;) {
            t += Time.deltaTime * thirdPersonWeaponInfo.changeOneOrTwoHandWieldSpeed;

            weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
            weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

            yield return null;
        }

        setHandsIKTargetValue (1, 1);
        setElbowsIKTargetValue (1, 1);

        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            currentIKWeaponsPosition.handInPositionToAim = true;
        }

        setWeaponMovingState (false);
    }

    public bool getUsingWeaponAsOneHandWieldState ()
    {
        return usingWeaponAsOneHandWield;
    }

    public void setPlayer (GameObject newPlayer)
    {
        player = newPlayer;
    }

    public GameObject getPlayerGameObject ()
    {
        return player;
    }

    public bool checkIfDeactivateIKIfNotAimingActive ()
    {
        if (isFullBodyAwarenessActive ()) {
            return false;
        }

        if (isPlayerCrouching ()) {
            return true;
        }

        return isDeactivateIKIfNotAimingActive ();
    }

    bool isDeactivateIKIfNotAimingActive ()
    {
        if (isFullBodyAwarenessActive ()) {
            return false;
        }

        bool deactivateIKActive = false;

        if (isUsingDualWeapon () || weaponConfiguredAsDualWeaponPreviously) {
            if (usingRightHandDualWeapon) {
                if (thirdPersonWeaponInfo.rightHandDualWeaopnInfo.deactivateIKIfNotAiming) {
                    deactivateIKActive = true;
                }
            } else {
                if (thirdPersonWeaponInfo.leftHandDualWeaponInfo.deactivateIKIfNotAiming) {
                    deactivateIKActive = true;
                }
            }
        } else {
            if (thirdPersonWeaponInfo.deactivateIKIfNotAiming) {
                deactivateIKActive = true;
            }
        }

        return deactivateIKActive;
    }

    public void setDeactivateIKIfNotAimingState (bool state)
    {
        thirdPersonWeaponInfo.rightHandDualWeaopnInfo.deactivateIKIfNotAiming = state;

        thirdPersonWeaponInfo.leftHandDualWeaponInfo.deactivateIKIfNotAiming = state;

        thirdPersonWeaponInfo.deactivateIKIfNotAiming = state;
    }

    //Disable the IK on hands when the player is making an action to avoid to look awkward during the play of the animation used on that action
    public void enableOrDisableIKOnWeaponsDuringAction (bool state)
    {
        if (IKPausedOnHandsActive) {
            return;
        }

        if (!carryingWeapon) {
            return;
        }

        if (isDeactivateIKIfNotAimingActive ()) {
            if (!aiming) {
                return;
            }
        }

        if (!gameObject.activeInHierarchy) {
            return;
        }

        actionActive = !state;

        if (surfaceDetected) {
            surfaceDetected = false;

            bool firstPersonActive = isPlayerCameraFirstPersonActive ();

            setWeaponRegularCursorState (firstPersonActive);
        }

        if (state) {
            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    if (aiming) {
                        currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.aimPosition;
                    } else {
                        currentDrawPositionTransform = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.walkPosition;
                    }
                } else {
                    if (aiming) {
                        currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.aimPosition;
                    } else {
                        currentDrawPositionTransform = thirdPersonWeaponInfo.leftHandDualWeaponInfo.walkPosition;
                    }
                }
            } else {
                if (aiming) {
                    currentDrawPositionTransform = thirdPersonWeaponInfo.aimPosition;
                } else {
                    currentDrawPositionTransform = thirdPersonWeaponInfo.walkPosition;
                }
            }

            if (aiming) {
                checkIfAddFBAAimPositionOffset ();
            } else {
                checkIfAddFBAWalkPositionOffset ();

                checkIfAddFBACrouchPositionOffset ();
            }
        }

        if (aiming) {
            weaponsManager.enableOrDisableIKUpperBodyExternally (!actionActive);
        }

        weaponPositionTarget = currentDrawPositionTransform.localPosition;
        weaponRotationTarget = currentDrawPositionTransform.localRotation;

        if (isFullBodyAwarenessActive ()) {
            if (aiming && isAimModeInputPressed ()) {
                if (overrideFBAValuesForOffset) {
                    weaponPositionTarget = currentFBAAimPositionOffset;

                    weaponRotationTarget = Quaternion.Euler (currentFBAAimRotationOffset);
                } else {
                    weaponPositionTarget += currentFBAAimPositionOffset;

                    weaponRotationTarget *= Quaternion.Euler (currentFBAAimRotationOffset);
                }
            } else {
                if (isPlayerCrouching ()) {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBACrouchPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBACrouchRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBACrouchPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBACrouchRotationOffset);
                    }
                } else {
                    if (overrideFBAValuesForOffset) {
                        weaponPositionTarget = currentFBAWalkPositionOffset;

                        weaponRotationTarget = Quaternion.Euler (currentFBAWalkRotationOffset);
                    } else {
                        weaponPositionTarget += currentFBAWalkPositionOffset;

                        weaponRotationTarget *= Quaternion.Euler (currentFBAWalkRotationOffset);
                    }
                }
            }
        }

        //stop the coroutine to translate the camera and call it again
        stopWeaponMovement ();

        stopEnableOrDisableIKOnWeaponsDuringActionCoroutine ();

        actionCoroutine = StartCoroutine (enableOrDisableIKOnWeaponsDuringActionCoroutine (state));

        disableOtherWeaponsStates ();

        setPlayerControllerMovementValues ();

        setLastTimeMoved ();

        if (thirdPersonWeaponInfo.useSwayInfo) {
            setCurrentSwayInfo (!weaponInRunPosition);

            if (aiming) {
                resetSwayValue ();
            }
        }
    }

    public void stopEnableOrDisableIKOnWeaponsDuringActionCoroutine ()
    {
        if (actionCoroutine != null) {
            StopCoroutine (actionCoroutine);
        }

        enableOrDisableIKOnWeaponsInProcess = false;
    }

    bool enableOrDisableIKOnWeaponsInProcess;

    IEnumerator enableOrDisableIKOnWeaponsDuringActionCoroutine (bool state)
    {
        //print (state + " " + reloadingWeapon + " " +
        //     weaponSystemManager.isReloadingWithAnimationActive () + " " +
        //   changingIKOnHandsFromFBAStateChangeActive);

        enableOrDisableIKOnWeaponsInProcess = true;

        if (state) {
            bool rightHandUsedToDrawWeapon = false;

            if (isUsingDualWeapon ()) {
                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                    rightHandUsedToDrawWeapon = true;
                }

                currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;

                setHandIKWeightValue (currentIKWeaponsPosition, 1);
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                            rightHandUsedToDrawWeapon = true;
                        }

                        currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                        currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;
                        currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;

                        setHandIKWeightValue (currentIKWeaponsPosition, 1);
                    }
                }
            }

            Transform previousParentDuringAction = weaponTransform.parent;

            if (previousParentBeforeActivateAction) {
                if (previousParentDuringAction == previousParentBeforeActivateAction) {
                    previousParentBeforeActivateAction = transform;
                }

                setWeaponTransformParent (previousParentBeforeActivateAction);
            } else {
                setWeaponTransformParent (transform);
            }

            if (rightHandUsedToDrawWeapon) {
                setHandsIKTargetValue (0, 1);
                setElbowsIKTargetValue (0, 1);
            } else {
                setHandsIKTargetValue (1, 0);
                setElbowsIKTargetValue (1, 0);
            }

            setWeaponMovingState (true);

            Vector3 currentWeaponPosition = weaponTransform.localPosition;
            Quaternion currentWeaponRotation = weaponTransform.localRotation;

            bool targetReached = false;

            float t = 0;
            float movementTimer = 0;

            float angleDifference = 0;
            float distanceDifference = 0;

            float dist = GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget);

            float weaponMovementSpeed = 0;

            bool isReloadingWithAnimationActive = weaponSystemManager.isReloadingWithAnimationActive ();

            if (isReloadingWithAnimationActive) {
                if (isFullBodyAwarenessActive ()) {
                    weaponMovementSpeed = firstPersonWeaponInfo.resetWeaponPositionAfterReloadSpeed;
                } else {
                    weaponMovementSpeed = thirdPersonWeaponInfo.resetWeaponPositionAfterReloadSpeed;
                }
            } else {
                if (changingIKOnHandsFromFBAStateChangeActive) {
                    if (isFullBodyAwarenessActive ()) {
                        weaponMovementSpeed = firstPersonWeaponInfo.resetWeaponPositionAfterActionSpeed;
                    } else {
                        weaponMovementSpeed = thirdPersonWeaponInfo.resetWeaponPositionAfterActionSpeed;
                    }
                } else {
                    if (isFullBodyAwarenessActive ()) {
                        weaponMovementSpeed = firstPersonWeaponInfo.resumeWeaponIKPositionAfterActionSpeed;
                    } else {
                        weaponMovementSpeed = thirdPersonWeaponInfo.resumeWeaponIKPositionAfterActionSpeed;
                    }
                }
            }

            bool reactivateIKOnHandsBeforeMovingWeaponResult = false;

            if (isReloadingWithAnimationActive) {
                //if (isFullBodyAwarenessActive ()) {
                reactivateIKOnHandsBeforeMovingWeaponResult = true;
                //}
            }

            if (reactivateIKOnHandsBeforeMovingWeaponResult) {
                setHandsIKTargetValue (1, 1);
                setElbowsIKTargetValue (1, 1);

                setGrabbingHandStateOnSingleHand (true, true);
            }

            float duration = dist / weaponMovementSpeed;

            changingIKOnHandsFromFBAStateChangeActive = false;

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

                weaponTransform.localPosition = Vector3.Lerp (currentWeaponPosition, weaponPositionTarget, t);
                weaponTransform.localRotation = Quaternion.Slerp (currentWeaponRotation, weaponRotationTarget, t);

                angleDifference = Quaternion.Angle (weaponTransform.localRotation, weaponRotationTarget);

                distanceDifference = GKC_Utils.distance (weaponTransform.localPosition, weaponPositionTarget);

                movementTimer += Time.deltaTime;

                if (distanceDifference < 0.001f && angleDifference < 0.03f) {
                    targetReached = true;
                }

                if (movementTimer > (duration + 1)) {
                    targetReached = true;
                }

                yield return null;
            }

            setWeaponMovingState (false);

            if (!reactivateIKOnHandsBeforeMovingWeaponResult) {
                setHandsIKTargetValue (1, 1);
                setElbowsIKTargetValue (1, 1);

                setGrabbingHandStateOnSingleHand (true, true);
            }

            if (isFullBodyAwarenessActive ()) {
                if (aiming && !isAimModeInputPressed ()) {
                    weaponsManager.disableFreeFireModeAfterStopFiring ();
                }
            }
        } else {
            previousParentBeforeActivateAction = weaponTransform.parent;

            if (isUsingDualWeapon ()) {
                newWeaponParent = leftHandMountPoint;

                if (usingRightHandDualWeapon) {
                    newWeaponParent = rightHandMountPoint;
                }

                if (usingRightHandDualWeapon) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.handsInfo [0];
                } else {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.leftHandDualWeaponInfo.handsInfo [0];
                }

                currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;

                if (newWeaponParent == null) {
                    newWeaponParent = currentIKWeaponsPosition.handTransform;
                }

                setWeaponTransformParent (newWeaponParent);

                currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;
            } else {
                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.usedToDrawWeapon) {
                        newWeaponParent = leftHandMountPoint;

                        if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                            newWeaponParent = rightHandMountPoint;
                        }

                        currentIKWeaponsPosition.waypointFollower.position = currentIKWeaponsPosition.position.position;
                        currentIKWeaponsPosition.waypointFollower.rotation = currentIKWeaponsPosition.position.rotation;

                        if (newWeaponParent == null) {
                            newWeaponParent = currentIKWeaponsPosition.handTransform;
                        }

                        setWeaponTransformParent (newWeaponParent);

                        currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.waypointFollower;
                    }
                }
            }

            yield return new WaitForEndOfFrame ();

            setHandsIKTargetValue (0, 0);

            setElbowsIKTargetValue (0, 0);

            if (changingIKOnHandsFromFBAStateChangeActive) {
                actionActive = false;

                changingIKOnHandsFromFBAStateChangeActive = false;
            }

            yield return null;

            setGrabbingHandStateOnSingleHand (true, false);
        }

        changingIKOnHandsFromFBAStateChangeActive = false;

        enableOrDisableIKOnWeaponsInProcess = false;
    }

    public void checkIfDisableCurrentWeaponIfEnableOrDisableIKOnWeaponsInProcess ()
    {
        if (enableOrDisableIKOnWeaponsInProcess) {
            //print ("stop deactivate IK coroutine to disable current weapon");

            stopEnableOrDisableIKOnWeaponsDuringActionCoroutine ();
        }
    }

    public void enableOrDisableIKOnHands (bool state)
    {
        if (!carryingWeapon) {
            return;
        }

        if (isDeactivateIKIfNotAimingActive ()) {
            return;
        }

        if (state) {
            IKPausedOnHandsActive = !state;
        }

        enableOrDisableIKOnWeaponsDuringAction (state);

        if (!state) {
            IKPausedOnHandsActive = !state;
        }

        if (IKPausedOnHandsActive && actionActive) {
            if (isPlayerCrouching ()) {
                setWeaponMovingState (false);
            }
        }
    }

    public void setIKPausedOnHandsActiveState (bool state)
    {
        IKPausedOnHandsActive = state;
    }

    public void setActionActiveState (bool state)
    {
        actionActive = state;

        if (!actionActive) {
            setReloadingWithAnimationActiveState (false);
        }

        setLastTimeMoved ();

        //print ("action active state " + actionActive);
    }

    void setCurrentWeaponID (bool state)
    {
        if (setNewAnimatorWeaponID) {
            if (state) {
                if (usingDualWeapon && setNewAnimatorDualWeaponID) {
                    weaponsManager.setCurrentWeaponID (newAnimatorDualWeaponID);
                } else {
                    weaponsManager.setCurrentWeaponID (newAnimatorWeaponID);
                }

                weaponsManager.setUsingNewWeaponID (true);
            } else {
                if (isFullBodyAwarenessActive ()) {
                    weaponsManager.setCurrentWeaponIDSmoothly (0);
                } else {
                    weaponsManager.setCurrentWeaponID (0);
                }

                weaponsManager.setUsingNewWeaponID (false);
            }
        }
    }

    public void checkIfSetNewAnimatorWeaponID ()
    {
        if (weaponsManager.isIgnoreNewAnimatorWeaponIDSettings ()) {
            return;
        }

        bool adjustAnimatorResult = true;

        if (isPlayerCameraFirstPersonActive () || !carrying) {
            adjustAnimatorResult = false;
        }

        if (usingDualWeapon && !usingRightHandDualWeapon) {
            return;
        }

        if (setNewAnimatorWeaponID) {
            setCurrentWeaponID (adjustAnimatorResult);
        }

        if (setNewAnimatorCrouchID) {
            if (adjustAnimatorResult) {
                weaponsManager.setCurrentCrouchID (newAnimatorCrouchID);
            } else {
                weaponsManager.setCurrentCrouchID (0);
            }
        }

        if (useNewMaxAngleDifference) {
            if (adjustAnimatorResult) {
                weaponsManager.setHorizontalMaxAngleDifference (horizontalMaxAngleDifference);
                weaponsManager.setVerticalMaxAngleDifference (verticalMaxAngleDifference);
            } else {
                weaponsManager.setOriginalHorizontalMaxAngleDifference ();
                weaponsManager.setOriginalVerticalMaxAngleDifference ();
            }
        }

        weaponsManager.setIgnoreCrouchWhileWeaponActiveState (ignoreCrouchWhileWeaponActive);

        weaponsManager.setPivotPointRotationActiveOnCurrentWeaponState (pivotPointRotationActive);
    }

    public void setWeaponMovingState (bool state)
    {
        moving = state;
    }

    public void setReloadingWithAnimationActiveState (bool state)
    {
        weaponsManager.setReloadingWithAnimationActiveState (state);

        weaponSystemManager.setReloadingWithAnimationActiveState (state);

        if (state) {
            resetWeaponMeshPositionRotation ();
        }
    }

    public void activateCustomAction (string actionName)
    {
        weaponsManager.activateCustomAction (actionName);
    }

    public void placeMagazineInPlayerHand (Transform magazineTransform, Transform magazineInHandTransform)
    {
        for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
            currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

            if (!currentIKWeaponsPosition.usedToDrawWeapon) {
                newWeaponParent = leftHandMountPoint;

                if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
                    newWeaponParent = rightHandMountPoint;
                }

                if (newWeaponParent == null) {
                    newWeaponParent = currentIKWeaponsPosition.handTransform;
                }

                magazineTransform.SetParent (newWeaponParent);
                magazineTransform.localPosition = magazineInHandTransform.localPosition;
                magazineTransform.localRotation = magazineInHandTransform.localRotation;
            }
        }
    }

    public bool parentWeaponOutsidePlayerBodyWhenNotActive = true;

    Coroutine setParentCoroutine;

    public void setWeaponParent (bool state)
    {
        if (!parentWeaponOutsidePlayerBodyWhenNotActive || weaponsManager.ignoreParentWeaponOutsidePlayerBodyWhenNotActive) {
            return;
        }

        stopSetWeaponParentCoroutine ();

        setParentCoroutine = StartCoroutine (setWeaponParentCoroutine (state));
    }

    public void stopSetWeaponParentCoroutine ()
    {
        if (setParentCoroutine != null) {
            StopCoroutine (setParentCoroutine);
        }
    }

    IEnumerator setWeaponParentCoroutine (bool state)
    {
        bool firstPersonActive = isPlayerCameraFirstPersonActive ();

        Transform newParent = weaponsManager.getWeaponsParent ();

        if (!state) {
            newParent = weaponsManager.getTemporalParentForWeapons ();
        }

        if (newParent == null) {
            newParent = weaponsManager.getPlayerManagersParentGameObject ();
        }

        Transform newParentWeaponMesh = newParent;

        if (usingDualWeapon) {
            if (usingRightHandDualWeapon) {
                if (firstPersonActive) {
                    newParentWeaponMesh = firstPersonWeaponInfo.rightHandDualWeaopnInfo.keepPosition;
                } else {
                    newParentWeaponMesh = thirdPersonWeaponInfo.rightHandDualWeaopnInfo.keepPosition;
                }
            } else {
                if (firstPersonActive) {
                    newParentWeaponMesh = firstPersonWeaponInfo.leftHandDualWeaponInfo.keepPosition;
                } else {
                    newParentWeaponMesh = thirdPersonWeaponInfo.leftHandDualWeaponInfo.keepPosition;
                }
            }
        } else {
            if (firstPersonActive) {
                newParentWeaponMesh = firstPersonWeaponInfo.keepPosition;
            } else {
                newParentWeaponMesh = thirdPersonWeaponInfo.keepPosition;
            }
        }

        if (state || firstPersonActive) {
            transform.SetParent (newParent);

            transform.localPosition = Vector3.zero;
            transform.localRotation = Quaternion.identity;
        }

        if (weaponEnabled) {
            if (firstPersonActive) {
                setWeaponTransformParent (transform);
            } else {
                setWeaponTransformParent (weaponSystemManager.getWeaponsParent ());
            }
            weaponTransform.localPosition = newParentWeaponMesh.localPosition;
            weaponTransform.localRotation = newParentWeaponMesh.localRotation;
        } else {
            setWeaponTransformParent (newParent);
            weaponTransform.localPosition = Vector3.zero;
            weaponTransform.localRotation = Quaternion.identity;
        }

        if (!firstPersonActive) {
            bool targetReached = false;

            while (!targetReached) {

                int handCount = 0;

                for (int i = 0; i < thirdPersonWeaponInfo.handsInfo.Count; i++) {
                    currentIKWeaponsPosition = thirdPersonWeaponInfo.handsInfo [i];

                    if (currentIKWeaponsPosition.HandIKWeight == 0) {
                        handCount++;
                    }
                }

                if (handCount == 2) {
                    targetReached = true;
                }

                yield return null;
            }

            if (!state) {
                transform.SetParent (newParent);

                transform.localPosition = Vector3.zero;
                transform.localRotation = Quaternion.identity;
            }
        }

        yield return null;
    }

    void setWeaponTransformParent (Transform newParent)
    {
        weaponTransform.SetParent (newParent);
    }

    bool shootAnimatorActive;
    bool idleAnimatorActive;
    bool reloadAnimatorActive;

    //ANIMATION FUNCTIONS
    public void checkShootAnimatorState (bool state)
    {
        if (useWeaponAnimatorFirstPerson) {
            weaponOnRecoil = state;

            shootAnimatorActive = state;

            mainWeaponAnimatorSystem.setShootState (state);
        }
    }

    public void shootAnimatorStateComplete ()
    {
        if (useWeaponAnimatorFirstPerson) {
            weaponOnRecoil = false;

            shootAnimatorActive = false;
        }
    }

    public void checkIdleAnimatorState (bool state)
    {
        if (useWeaponAnimatorFirstPerson) {
            mainWeaponAnimatorSystem.setIdleState (state);
        }
    }

    public void checkWalkAnimatorState (bool state)
    {
        if (useWeaponAnimatorFirstPerson) {
            mainWeaponAnimatorSystem.setWalkState (state);
        }
    }

    public void checkRunAnimatorState (bool state)
    {
        if (useWeaponAnimatorFirstPerson) {
            mainWeaponAnimatorSystem.setRunState (state);
        }
    }

    public void checkReloadAnimatorState (bool state)
    {
        if (useWeaponAnimatorFirstPerson) {

            reloadAnimatorActive = state;

            mainWeaponAnimatorSystem.setReloadState (state);
        }
    }

    public void reloadAnimatorStateComplete ()
    {
        if (useWeaponAnimatorFirstPerson) {
            reloadAnimatorActive = false;

            setWeaponMovingState (false);

            reloadingWeapon = false;

            if (mainWeaponAnimatorSystem.useReloadPosition) {
                aimOrDrawWeaponFirstPerson (false);
            }
        }
    }

    public void setNewReloadTimeFirstPerson (float newValue)
    {
        weaponSystemManager.setNewReloadTimeFirstPerson (newValue);
    }

    public void reloadSingleProjectile ()
    {
        weaponSystemManager.reloadSingleProjectile ();
    }

    public void pauseOrResumePlaySoundOnWeapon (bool state)
    {
        weaponSystemManager.pauseOrResumePlaySoundOnWeapon (state);
    }

    public void updateDurabilityAmountState ()
    {
        if (weaponSystemManager.useObjectDurability) {
            weaponSystemManager.updateDurabilityAmountState ();
        }
    }

    public void initializeDurabilityValue (float newAmount, int currentObjectIndex)
    {
        if (weaponSystemManager.useObjectDurability) {
            weaponSystemManager.initializeDurabilityValue (newAmount, currentObjectIndex);
        }
    }

    public void setInventoryObjectIndex (int currentObjectIndex)
    {
        if (weaponSystemManager.useObjectDurability) {
            weaponSystemManager.setInventoryObjectIndex (currentObjectIndex);
        }
    }

    public float getDurabilityAmount ()
    {
        if (weaponSystemManager.useObjectDurability) {
            return weaponSystemManager.getDurabilityAmount ();
        }

        return -1;
    }

    public void repairObjectFully ()
    {
        if (weaponSystemManager.useObjectDurability) {
            weaponSystemManager.repairObjectFully ();
        }
    }

    public void breakFullDurabilityOnCurrentWeapon ()
    {
        if (weaponSystemManager.useObjectDurability) {
            weaponSystemManager.breakFullDurabilityOnCurrentWeapon ();
        }
    }

    public void checkEventOnEmptyDurability ()
    {
        weaponsManager.checkEventOnEmptyDurability ();
    }

    public bool canWeaponMarkTargets ()
    {
        return weaponSystemManager.canMarkTargets;
    }

    public bool canWeaponAutoShootOnTag ()
    {
        return weaponSystemManager.weaponSettings.autoShootOnTag;
    }

    public bool canWeaponAvoidShootAtTag ()
    {
        return weaponSystemManager.weaponSettings.avoidShootAtTag;
    }

    public void setUseLowerRotationSpeedAimed (bool state)
    {
        useLowerRotationSpeedAimed = state;
    }

    public void setUseLowerRotationSpeedAimedThirdPerson (bool state)
    {
        useLowerRotationSpeedAimedThirdPerson = state;
    }

    //EDITOR FUNCTIONS FOR WEAPONS
    public void createWeaponPrefab ()
    {
        GameObject newEmptyWeaponPrefab = Instantiate (emtpyWeaponPrefab);

        playerWeaponSystem currentPlayerWeaponSystem = weaponGameObject.GetComponent<playerWeaponSystem> ();

        if (currentPlayerWeaponSystem != null) {

            GameObject weaponMeshParts = currentPlayerWeaponSystem.weaponSettings.weaponMesh;

            if (weaponMeshParts != null) {
                GameObject newWeaponMesh = Instantiate (weaponMeshParts);
                newWeaponMesh.transform.SetParent (newEmptyWeaponPrefab.transform);
                newWeaponMesh.transform.localPosition = Vector3.zero;
                newWeaponMesh.transform.localRotation = Quaternion.identity;

                string weaponName = currentPlayerWeaponSystem.getWeaponSystemName ();

                deviceStringAction currentDeviceStringAction = newEmptyWeaponPrefab.GetComponentInChildren<deviceStringAction> ();

                currentDeviceStringAction.setNewDeviceName (weaponName);

                weaponPickup currentWeaponPickup = newEmptyWeaponPrefab.GetComponent<weaponPickup> ();
                if (currentWeaponPickup != null) {
                    currentWeaponPickup.weaponName = weaponName;
                }

                relativePathWeaponsPickups = pathInfoValues.getWeaponPickupsPrefabsPath ();

                weaponPrefabModel = GKC_Utils.createPrefab (relativePathWeaponsPickups, (weaponName + " Pickup (No Inventory)"), newEmptyWeaponPrefab);
            } else {
                print ("WARNING: No mesh parts configured in the player weapon system inspector");
            }

        } else {
            print ("WARNING: No player weapon system component found on the weapon");
        }

        DestroyImmediate (newEmptyWeaponPrefab);

        updateComponent ();
    }

    public void removeWeaponRegularPickup ()
    {
        weaponPrefabModel = null;

        updateComponent ();
    }

    public void assignWeaponPrefab ()
    {
        GameObject currentWeaponPrefab = GKC_Utils.getInventoryPrefabByName (getWeaponSystemName ());

        if (currentWeaponPrefab != null) {
            inventoryWeaponPrefabObject = currentWeaponPrefab;

            print ("Weapon inventory prefab " + getWeaponSystemName () + " assigned properly");
        } else {
            print ("WARNING: Weapon inventory prefab " + getWeaponSystemName () + " not found, make sure that object is configured in the Inventory List Manager");
        }

        updateComponent ();
    }

    public void createInventoryWeaponAmmo ()
    {
        GKC_Utils.createInventoryWeaponAmmo (getWeaponSystemName (), getWeaponSystemAmmoName (), weaponAmmoMesh,
            weaponAmmoIconTexture, inventoryAmmoCategoryName, ammoAmountPerPickup, customAmmoDescription);
    }

    public void createInventoryWeapon ()
    {
        weaponSystemManager.setWeaponSystemName (weaponName);

        GameObject weaponMesh = weaponSystemManager.weaponSettings.weaponMesh;

        Texture newWeaponIconTexture = weaponIconTexture;

        if (newWeaponIconTexture == null) {
            newWeaponIconTexture = weaponSystemManager.weaponSettings.weaponInventorySlotIcon;
        }

        relativePathWeaponsMesh = pathInfoValues.getWeaponMeshInventoryPrefabsPath ();

        GKC_Utils.createInventoryWeapon (getWeaponSystemName (), inventoryWeaponCategoryName, weaponMesh,
            weaponDescription, newWeaponIconTexture, relativePathWeaponsMesh, false,
            useDurability, durabilityAmount, maxDurabilityAmount, objectWeight, canBeSold, sellPrice, vendorPrice);

        assignWeaponPrefab ();
    }

    public void createInventoryWeaponExternally (string newWeaponName, string weaponDescriptionValue, Texture newWeaponIconTexture,
                                                 bool useDurabilityValue, float durabilityAmountValue, float maxDurabilityAmountValue,
                                                 float durabilityUsedOnAttackValue, float objectWeightValue,
                                                 bool canBeSoldValue, float sellPriceValue, float vendorPriceValue)
    {
        weaponName = newWeaponName;

        weaponIconTexture = newWeaponIconTexture;

        weaponDescription = weaponDescriptionValue;

        objectWeight = objectWeightValue;

        canBeSold = canBeSoldValue;
        sellPrice = sellPriceValue;
        vendorPrice = vendorPriceValue;

        useDurability = useDurabilityValue;
        durabilityAmount = durabilityAmountValue;
        maxDurabilityAmount = maxDurabilityAmountValue;

        weaponSystemManager.setDurabilityUsedOnAttackValueFromEditor (durabilityUsedOnAttackValue);

        weaponSystemManager.setMaxDurabilityAmountFromEditor (maxDurabilityAmount);

        weaponSystemManager.setDurabilityAmountFromEditor (durabilityAmount);

        weaponSystemManager.setObjectNameFromEditor (weaponName);

        createInventoryWeapon ();
    }

    public void createInventoryWeaponAmmoExternally (string newWeaponAmmoName, int ammoAmount,
                                                     GameObject newCustomAmmoMesh, Texture newCustomAmmoIcon,
                                                     string newCustomAmmoDescription)
    {
        weaponSystemManager.setWeaponSystemAmmoName (newWeaponAmmoName);

        if (weaponAmmoMesh != null) {
            if (newCustomAmmoMesh != null) {
                weaponAmmoMesh = newCustomAmmoMesh;
            }

            if (newCustomAmmoIcon != null) {
                weaponAmmoIconTexture = newCustomAmmoIcon;
            }

            customAmmoDescription = newCustomAmmoDescription;

            relativePathWeaponsAmmoMesh = pathInfoValues.getWeaponAmmoMeshInventoryPrefabsPath ();

            GameObject newWeaponAmmoMesh = GKC_Utils.createPrefab (relativePathWeaponsAmmoMesh, "Ammo Pickup (" + newWeaponAmmoName + ") Mesh", weaponAmmoMesh);

            if (newWeaponAmmoMesh != null) {
                weaponAmmoMesh = newWeaponAmmoMesh;

                if (ammoAmount > 0) {
                    ammoAmountPerPickup = ammoAmount;
                }

                createInventoryWeaponAmmo ();
            }
        } else {
            print ("WARNING: the weapon ammo mesh prefab is not assigned in the ammo settings of IK Weapon System component" +
            " for the weapon " + getWeaponSystemName ());
        }
    }

    public void copyTransformValuesToBuffer (Transform transformToCopyValues)
    {
        objectTransformInfo newObjectTransformInfo = new objectTransformInfo ();

        newObjectTransformInfo.objectPosition = transformToCopyValues.localPosition;
        newObjectTransformInfo.objectRotation = transformToCopyValues.localRotation;

        objectTransformData mainObjectTransformData = weaponsManager.getMainObjectTransformData ();

        mainObjectTransformData.objectTransformInfoList.Clear ();

        mainObjectTransformData.objectTransformInfoList.Add (newObjectTransformInfo);

        print ("Copied transform values of " + transformToCopyValues.name + ": " + transformToCopyValues.localPosition.ToString ("F7") + "_" + transformToCopyValues.localEulerAngles.ToString ("F7"));
    }

    public void pasteTransformValuesToBuffer (Transform transformToPasteValues)
    {
        objectTransformData mainObjectTransformData = weaponsManager.getMainObjectTransformData ();

        if (mainObjectTransformData.objectTransformInfoList.Count > 0) {
            Vector3 newPosition = mainObjectTransformData.objectTransformInfoList [0].objectPosition;

            Quaternion newRotation = mainObjectTransformData.objectTransformInfoList [0].objectRotation;

            transformToPasteValues.localPosition = newPosition;

            transformToPasteValues.localRotation = newRotation;

            print ("Pasted transform values to " + transformToPasteValues.name + ": " + newPosition.ToString ("F7") + "_" + newRotation.eulerAngles.ToString ("F7"));
        } else {
            print ("WARNING: there is no previous transform info saved, make sure to press the copy button before the paste button");
        }
    }

    public void selectWeaponAnimator ()
    {
        if (useWeaponAnimatorFirstPerson) {
            if (mainWeaponAnimatorSystem.weaponAnimator != null) {
                GKC_Utils.setActiveGameObjectInEditor (mainWeaponAnimatorSystem.weaponAnimator.gameObject);
            } else {
                GKC_Utils.setActiveGameObjectInEditor (mainWeaponAnimatorSystem.gameObject);
            }
        }
    }

    //OVERRIDE FUNCTIONS FROM THE INHERIT CLASS
    public override bool isFireWeapon ()
    {
        return true;
    }

    public override string getWeaponName ()
    {
        return getWeaponSystemName ();
    }

    public override string getAmmoText ()
    {
        return weaponSystemManager.getCurrentAmmoText ();
    }

    public override int getProjectilesInWeaponMagazine ()
    {
        return weaponSystemManager.getProjectilesInMagazine ();
    }

    public override string getWeaponAmmoName ()
    {
        return weaponSystemManager.getWeaponSystemAmmoName ();
    }

    public override void setWeaponRemainAmmoAmount (int newRemainAmmoAmount)
    {
        weaponSystemManager.setRemainAmmoAmount (newRemainAmmoAmount);
    }

    public override bool isWeaponUseRemainAmmoFromInventoryActive ()
    {
        return weaponSystemManager.isUseRemainAmmoFromInventoryActive ();
    }
    //END OF OVERRIDE FUNCTIONS FROM THE INHERIT CLASS


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

        GKC_Utils.updateDirtyScene ("Update Weapon Info " + gameObject.name, gameObject);
    }

#if UNITY_EDITOR
    void OnDrawGizmos ()
    {
        if (!showThirdPersonGizmo && !showFirstPersonGizmo && !showFBAGizmo) {
            return;
        }

        if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
            DrawGizmos ();
        }
    }

    void OnDrawGizmosSelected ()
    {
        DrawGizmos ();
    }

    void DrawGizmos ()
    {
        if (showThirdPersonGizmo) {
            drawWeaponInfoPositions (thirdPersonWeaponInfo);
        }

        if (showFirstPersonGizmo) {
            drawWeaponInfoPositions (firstPersonWeaponInfo);
        }

        //		if (showFBAGizmo) {
        //			drawWeaponFBAInfoPositions (thirdPersonWeaponInfo);
        //		}
    }
#endif

    void drawWeaponInfoPositions (IKWeaponInfo info)
    {
        if (showPositionGizmo) {
            if (showMainWeaponPositionsGizmo) {
                Gizmos.color = Color.yellow;
                Gizmos.DrawSphere (info.aimPosition.position, 0.03f);
                Gizmos.color = Color.white;
                Gizmos.DrawLine (info.aimPosition.position, info.walkPosition.position);
                Gizmos.color = Color.green;
                Gizmos.DrawSphere (info.walkPosition.position, 0.03f);
            }

            if (showEditAttachmentGizmo) {
                if (info.hasAttachments) {
                    if (info.editAttachmentPosition != null) {
                        Gizmos.color = Color.white;
                        Gizmos.DrawLine (info.editAttachmentPosition.position, info.walkPosition.position);
                        Gizmos.color = Color.green;
                        Gizmos.DrawSphere (info.editAttachmentPosition.position, 0.03f);
                    }

                    if (info.useSightPosition) {
                        if (info.sightPosition != null) {
                            Gizmos.color = Color.white;
                            Gizmos.DrawLine (info.sightPosition.position, info.walkPosition.position);
                            Gizmos.color = Color.green;
                            Gizmos.DrawSphere (info.sightPosition.position, 0.03f);
                        }

                        if (info.sightRecoilPosition != null) {
                            Gizmos.color = Color.white;
                            Gizmos.DrawLine (info.sightRecoilPosition.position, info.sightPosition.position);
                            Gizmos.color = Color.green;
                            Gizmos.DrawSphere (info.sightRecoilPosition.position, 0.03f);
                        }
                    }
                }
            }

            if (showCollisionDetectionGizmo) {
                if (info.surfaceCollisionPosition != null) {
                    Gizmos.DrawLine (info.surfaceCollisionPosition.position, info.aimPosition.position);
                    Gizmos.color = Color.blue;
                    Gizmos.DrawSphere (info.surfaceCollisionPosition.position, 0.03f);
                }

                if (info.surfaceCollisionRayPosition != null) {
                    Gizmos.DrawLine (info.surfaceCollisionRayPosition.position, info.surfaceCollisionPosition.position);
                    Gizmos.color = Color.blue;
                    Gizmos.DrawSphere (info.surfaceCollisionRayPosition.position, 0.03f);
                }
            }
        }

        if (showWeaponWaypointGizmo) {
            for (int i = 0; i < info.keepPath.Count; i++) {
                if (i + 1 < info.keepPath.Count) {
                    Gizmos.color = Color.yellow;
                    Gizmos.DrawLine (info.keepPath [i].position, info.keepPath [i + 1].position);
                }

                if (i != info.keepPath.Count - 1) {
                    Gizmos.color = Color.red;
                    Gizmos.DrawSphere (info.keepPath [i].position, 0.03f);
                }
            }

            if (info.keepPath.Count > 0) {
                Gizmos.color = Color.white;
                Gizmos.DrawLine (info.keepPosition.position, info.keepPath [0].position);
            } else {
                Gizmos.DrawLine (info.keepPosition.position, info.walkPosition.position);
            }
        }

        if (showMainWeaponPositionsGizmo) {
            Gizmos.color = Color.red;
            Gizmos.DrawSphere (info.keepPosition.position, 0.03f);
            Gizmos.color = Color.white;
            Gizmos.DrawLine (info.aimPosition.position, info.aimRecoilPosition.position);

            if (info.walkRecoilPosition != null) {
                Gizmos.DrawLine (info.walkPosition.position, info.walkRecoilPosition.position);
            }

            Gizmos.color = Color.magenta;
            Gizmos.DrawSphere (info.aimRecoilPosition.position, 0.03f);

            if (info.walkRecoilPosition != null) {
                Gizmos.DrawSphere (info.walkRecoilPosition.position, 0.03f);
            }
        }

        if (showHandsWaypointGizmo) {
            for (int i = 0; i < info.handsInfo.Count; i++) {
                Gizmos.color = Color.blue;

                currentGizmoIKWeaponPosition = info.handsInfo [i];

                if (currentGizmoIKWeaponPosition.position != null) {
                    Gizmos.DrawSphere (currentGizmoIKWeaponPosition.position.position, 0.02f);
                }

                if (currentGizmoIKWeaponPosition.waypointFollower != null) {
                    Gizmos.color = Color.cyan;
                    Gizmos.DrawSphere (currentGizmoIKWeaponPosition.waypointFollower.position, 0.01f);
                }

                for (int j = 0; j < currentGizmoIKWeaponPosition.wayPoints.Count; j++) {
                    if (j == 0) {
                        if (currentGizmoIKWeaponPosition.handTransform != null) {
                            Gizmos.color = Color.black;
                            Gizmos.DrawLine (currentGizmoIKWeaponPosition.wayPoints [j].position, currentGizmoIKWeaponPosition.handTransform.position);
                        }
                    }

                    Gizmos.color = Color.gray;
                    Gizmos.DrawSphere (currentGizmoIKWeaponPosition.wayPoints [j].position, 0.01f);

                    if (j + 1 < currentGizmoIKWeaponPosition.wayPoints.Count) {
                        Gizmos.color = Color.yellow;
                        Gizmos.DrawLine (currentGizmoIKWeaponPosition.wayPoints [j].position, currentGizmoIKWeaponPosition.wayPoints [j + 1].position);
                    }
                }

                Gizmos.color = Color.blue;

                if (currentGizmoIKWeaponPosition.elbowInfo.position != null) {
                    Gizmos.DrawSphere (currentGizmoIKWeaponPosition.elbowInfo.position.position, 0.02f);
                }
            }
        }

        if (showCollisionDetectionGizmo) {
            if (info.checkSurfaceCollision) {
                if (info.surfaceCollisionRayPosition != null) {
                    if (weaponTransform != null) {

                        Gizmos.color = Color.white;

                        Gizmos.DrawLine (info.surfaceCollisionRayPosition.position, info.surfaceCollisionRayPosition.position +
                        info.collisionRayDistance * info.surfaceCollisionRayPosition.forward);

                        Gizmos.color = Color.red;

                        Gizmos.DrawSphere (info.surfaceCollisionRayPosition.position +
                        info.collisionRayDistance * info.surfaceCollisionRayPosition.forward, 0.01f);
                    } else {
                        weaponTransform = weaponGameObject.transform;
                    }
                }
            }
        }

        if (info.runPosition) {
            if (weaponTransform != null) {
                Gizmos.color = Color.white;

                Gizmos.DrawLine (info.walkPosition.position, info.runPosition.position);

                Gizmos.color = Color.red;

                Gizmos.DrawSphere (info.runPosition.position, 0.01f);
            } else {
                weaponTransform = weaponGameObject.transform;
            }
        }

        if (thirdPersonWeaponInfo.useMeleeAttack && thirdPersonWeaponInfo.showMeleeAttackGizmo) {
            showMeleeAttackGizmo (thirdPersonWeaponInfo);
        }

        if (firstPersonWeaponInfo.useMeleeAttack && firstPersonWeaponInfo.showMeleeAttackGizmo) {
            showMeleeAttackGizmo (firstPersonWeaponInfo);
        }
    }

    void showMeleeAttackGizmo (IKWeaponInfo weaponInfo)
    {
        Vector3 raycastPosition = weaponInfo.meleeAttackRaycastPosition.position;

        Vector3 raycastForward = transform.forward;

        if (player != null) {
            raycastForward = player.transform.forward;
        }

        float capsuleCastRadius = weaponInfo.meleeAttackRaycastDistance;

        float meleeAttackCapsuleDistance = weaponInfo.meleeAttackCapsuleDistance;

        Gizmos.color = Color.red;

        Vector3 point1 = raycastPosition;
        Vector3 point2 = raycastPosition + meleeAttackCapsuleDistance * raycastForward;

        Vector3 targetPosition = raycastPosition + meleeAttackCapsuleDistance * raycastForward;

        float distanceToTarget = GKC_Utils.distance (point1, point2);

        Vector3 rayDirection = point1 - point2;
        rayDirection = rayDirection / rayDirection.magnitude;

        point1 = point1 - capsuleCastRadius * rayDirection;
        point2 = point2 + capsuleCastRadius * rayDirection;

        Gizmos.DrawSphere (point1, capsuleCastRadius);

        Gizmos.color = Color.green;

        Gizmos.DrawSphere (point2, capsuleCastRadius);

        Gizmos.color = Color.blue;

        Vector3 scale = new Vector3 (capsuleCastRadius * 2, capsuleCastRadius * 2, distanceToTarget - capsuleCastRadius * 2);

        Matrix4x4 cubeTransform = Matrix4x4.TRS (((distanceToTarget / 2) * rayDirection) +
                                  targetPosition,
                                      Quaternion.LookRotation (rayDirection, point1 - point2), scale);


        Matrix4x4 oldGizmosMatrix = Gizmos.matrix;

        Gizmos.matrix *= cubeTransform;

        Gizmos.DrawCube (Vector3.zero, Vector3.one);

        Gizmos.matrix = oldGizmosMatrix;
    }

    [System.Serializable]
    public class weaponShotShakeInfo
    {
        public float shotForce;
        public float shakeSmooth;
        public float shakeDuration;
        public Vector3 shakePosition;
        public Vector3 shakeRotation;
    }
}