using System.Collections;
using System.Collections.Generic;
using GameKitController.Audio;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

public class grabbedObjectMeleeAttackSystem : MonoBehaviour
{
    //	[Header ("Main Settings")]
    //	[Space]

    public bool grabbedObjectMeleeAttackEnabled = true;

    public bool canGrabMeleeObjectsEnabled = true;

    public bool useAttackTypes;

    public float generalAttackDamageMultiplier = 1;

    public List<string> meleeAttackTypes = new List<string> ();

    public bool playerOnGroundToActivateAttack = true;

    public bool disableGrabObjectsInputWhenCarryingMeleeWeapon;

    public bool useThrowReturnMeleeWeaponSystemEnabled;

    public float minWaitTimeToUseSingleAttackType = 0.4f;

    //	[Space]
    //	[Header ("Damage Detection Settings")]
    //	[Space]

    public bool useCustomLayerToDetectSurfaces;
    public LayerMask customLayerToDetectSurfaces;

    public bool useCustomIgnoreTags;
    public List<string> customTagsToIgnoreList = new List<string> ();

    public bool checkTriggerSurfacesOnMeleeAttacks = true;

    public bool checkSurfacesWithCapsuleRaycastEnabled = true;

    public bool ignoreGetHealthFromDamagingObjects = true;

    public bool ignoreGetHealthFromDamagingObjectsOnWeaponInfo = true;

    public bool ignoreCutModeOnMeleeWeaponAttack = true;

    public bool placeTriggerInFrontOfCharacterOnAllAttacks;

    //	[Space]
    //	[Header ("Weapon Info List Settings")]
    //	[Space]

    public List<grabbedWeaponInfo> grabbedWeaponInfoList = new List<grabbedWeaponInfo> ();

    //	[Space]
    //	[Header ("Surface Info List Settings")]
    //	[Space]

    public bool checkSurfaceInfoEnabled = true;

    public string surfaceInfoOnMeleeAttackNameForNotFound = "Regular";
    public string surfaceInfoOnMeleeAttackNameForSwingOnAir = "Swing On Air";
    public List<surfaceInfoOnMeleeAttack> surfaceInfoOnMeleeAttackList = new List<surfaceInfoOnMeleeAttack> ();

    //	[Space]
    //	[Header ("Stamina Settings")]
    //	[Space]

    public bool useStaminaOnAttackEnabled = true;
    public string attackStaminaStateName = "Melee Attack With Grabbed Object";

    public float generalStaminaUseMultiplier = 1;

    //	[Space]
    //	[Header ("Cutting Mode Settings")]
    //	[Space]

    public bool cuttingModeEnabled = true;

    public UnityEvent eventOnCuttingModeStart;
    public UnityEvent eventOnCuttingModeEnd;

    //	[Space]
    //	[Header ("Block Mode Settings")]
    //	[Space]

    public bool blockModeEnabled = true;
    public float generalBlockProtectionMultiplier = 1;

    public string cancelBlockReactionStateName = "Disable Has Exit Time State";

    //	[Space]
    //	[Header ("Shield Settings")]
    //	[Space]

    public bool shieldCanBeUsedWithoutMeleeWeapon;

    public Transform rightHandMountPoint;
    public Transform leftHandMountPoint;
    public Transform shieldRightHandMountPoint;
    public Transform shieldLeftHandMountPoint;

    public Transform shieldBackMountPoint;

    public bool useRightHandMountPointForShieldActive;

    //	[Space]

    public UnityEvent eventToActivateMeleeModeWhenUsingShieldWithoutMeleeWeapon;

    //	[Space]
    //	[Header ("Match Target Settings")]
    //	[Space]

    public bool useMatchTargetSystemOnAttack;
    public bool ignoreAttackSettingToMatchTarget;
    public matchPlayerToTargetSystem mainMatchPlayerToTargetSystem;

    //	[Space]
    //	[Header ("Weapon Durability Settings")]
    //	[Space]

    public bool checkDurabilityOnAttackEnabled;
    public bool checkDurabilityOnBlockEnabled;

    public float generalAttackDurabilityMultiplier = 1;
    public float generalBlockDurabilityMultiplier = 1;
    //	[Space]

    public bool useEventOnDurabilityEmptyOnMeleeWeapon;
    public UnityEvent eventOnDurabilityEmptyOnMeleeWeapon;

    //	[Space]

    public bool useEventOnDurabilityEmptyOnBlock;
    public UnityEvent eventOnDurabilityEmptyOnBlock;

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

    public bool weaponsCanBeStolenFromCharacter = true;

    public string mainMeleeCombatAxesInputName = "Grab Objects";
    public string mainMeleeCombatBlockInputName = "Block Attack";

    public bool ignoreUseDrawKeepWeaponAnimation;

    //	[Space]
    //	[Header ("Weapon Extra Action Settings")]
    //	[Space]

    public bool showExtraActionIconTexture;
    public GameObject extraActionIconGameObject;
    public RawImage extraActionRawImage;

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

    public bool showDebugPrint;

    public bool grabbedObjectMeleeAttackActive;

    public bool carryingObject;

    public bool attackInProcess;

    public List<int> meleeAttackTypesAmount = new List<int> ();

    public hitCombat currentHitCombat;

    public hitCombat dualWieldHitCombat;

    public int currentAttackIndex;

    public bool blockActive;

    public bool blockActivePreviously;

    public bool objectThrown;


    public bool cuttingModeActive;

    public bool attackInputPausedForStamina;

    public bool damageTriggerInProcess;

    public bool meleeAttackInputPaused;

    public bool reducedBlockDamageProtectionActive;

    public bool canCancelBlockToStartAttackActive;

    public bool blockInputPaused;

    public bool isDualWieldWeapon;
    public dualWieldMeleeWeaponObjectSystem mainDualWieldMeleeWeaponObjectSystem;

    public bool throwWeaponActionPaused;

    public bool showDebugDraw;

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

    public bool shieldActive;

    public bool carryingShield;

    public string currentShieldName;

    public GameObject currentShieldGameObject;

    public Transform currentShieldHandMountPointTransformReference;
    public Transform currentShieldBackMountPointTransformReference;


    //	[Space]
    //	[Header ("Event Settings")]
    //	[Space]

    public bool useEventsOnAttack;
    public UnityEvent eventOnAttackStart;
    public UnityEvent eventOnAttackEnd;

    public bool useEventsOnBlockDamage;
    public UnityEvent eventOnBlockActivate;
    public UnityEvent eventOnBlockDeactivate;

    public UnityEvent eventToUpdateCharacterSurfaceOnBlockOn;
    public UnityEvent eventToUpdateCharacterSurfaceOnBlockOff;

    public bool useEventsOnGrabDropObject;
    public UnityEvent eventOnGrabObject;
    public UnityEvent eventOnDropObject;

    public bool useEventsOnAttackCantBeBlocked;
    public UnityEvent eventOnAttackCantBeBlocked;

    public bool hideInventoryQuickAccessSlotsWhenCarryingMeleeWeapon;
    public UnityEvent eventOnHideInventoryQuickAccessSlots;
    public UnityEvent eventOnShowInventoryQuickAccessSlots;


    public bool useEventToActivateParryStateIfAttackInProcess;
    public UnityEvent eventToActivateParryStateIfAttackInProcess;

    public bool useEventOnAttackBlockedPerfectly;
    public UnityEvent eventOnAttackBlockedPerfectly;

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

    public Transform currentGrabbedObjectTransform;
    public remoteEventSystem mainRemoteEventSystem;

    public GameObject playerControllerGameObject;
    public playerController mainPlayerController;

    public grabObjects mainGrabObjects;
    public health mainHealth;
    public Transform mainCameraTransform;

    public staminaSystem mainStaminaSystem;

    public Transform handPositionReference;

    public AudioSource mainAudioSource;

    public sliceSystem mainSliceSystem;

    public Animator mainAnimator;

    public findObjectivesSystem mainFindObjectivesSystem;

    public meleeWeaponsGrabbedManager mainMeleeWeaponsGrabbedManager;

    public playerInputManager playerInput;

    public Transform parentToPlaceTriggerInFrontOfCharacter;

    public meleeCombatThrowReturnWeaponSystem mainMeleeCombatThrowReturnWeaponSystem;

    public meleeUISystem mainMeleeUISystem;


    Transform objectRotationPoint;

    grabPhysicalObjectMeleeAttackSystem currentMeleeWeapon;

    grabPhysicalObjectMeleeAttackSystem lastMeleeWeaponSystemUsed;

    string lastKeepWeaponActionName;

    Transform lastWeaponParent;

    Vector3 lastWeaponLocalPosition;
    Vector3 lastWeaponLocalEuler;

    int attackListCount;

    Coroutine attackCoroutine;

    float lastTimeAttackActive;

    float lastTimeAttackComplete;

    float lastTimeDrawMeleeWeapon = -1;

    grabPhysicalObjectMeleeAttackSystem.attackInfo currentAttackInfo;

    Coroutine damageTriggerCoroutine;

    Coroutine dualWieldDamageTriggerCoroutine;

    grabPhysicalObjectSystem currentGrabPhysicalObjectSystem;

    Rigidbody currentObjectRigidbody;

    grabbedWeaponInfo currentGrabbedWeaponInfo;

    bool ignoreParryOnPerfectBlock;

    float capsuleCastRadius;
    float capsuleCastDistance;

    Vector3 currentRayOriginPosition;
    Vector3 currentRayTargetPosition;

    float distanceToTarget;
    Vector3 rayDirection;

    Vector3 point1;
    Vector3 point2;

    RaycastHit [] hits;

    Transform raycastCheckTransfrom;


    Vector3 originalHitCombatColliderSize;

    Vector3 originalHitCombatColliderPosition;

    BoxCollider currentHitCombatBoxCollider;

    Vector3 originalHitCombatColliderCenter;

    bool hitCombatParentChanged;

    bool isAttachedToSurface;

    bool surfaceDetectedIsDead;

    bool previousStrafeMode;

    bool currentAttackCanBeBlocked;

    Coroutine pauseBlockInputCoroutine;
    Coroutine disableHasExitTimeCoroutine;

    float lastTimeDamageTriggerActivated;

    bool attackActivatedOnAir;

    bool deflectProjectilesEnabled;

    bool deflectProjectilesOnBlockEnabled;

    float currentWaitTimeToNextAttack = 0;

    bool cutActivatedOnAttackChecked;

    LayerMask currentLayerMaskToCheck;

    float lastTimeCutActiveOnAttack = 0;

    float lastTimeSurfaceAudioPlayed;
    int lastSurfaceDetecetedIndex = -1;

    bool getHealthFromPerfectBlocksActive;
    float healthAmountFromPerfectBlocksValue = 1;

    bool checkDrawKeepWeaponAnimationPauseState;

    bool originalIgnoreUseDrawKeepWeaponAnimation;

    bool originalUseMatchTargetSystemOnAttack;

    bool useCustomSurfaceInfoOnMeleeAttackNameForSwingOnAir;

    string customSurfaceInfoOnMeleeAttackNameForSwingOnAir;

    private void InitializeAudioElements ()
    {
        bool mainAudioSourceLocated = mainAudioSource != null;

        foreach (var surfaceInfoOnMeleeAttack in surfaceInfoOnMeleeAttackList) {
            if (surfaceInfoOnMeleeAttack.soundsList != null && surfaceInfoOnMeleeAttack.soundsList.Count > 0) {
                surfaceInfoOnMeleeAttack.soundsAudioElements = new List<AudioElement> ();

                foreach (var sound in surfaceInfoOnMeleeAttack.soundsList) {
                    surfaceInfoOnMeleeAttack.soundsAudioElements.Add (new AudioElement { clip = sound });
                }
            }

            if (mainAudioSourceLocated) {
                foreach (var audioElement in surfaceInfoOnMeleeAttack.soundsAudioElements) {
                    audioElement.audioSource = mainAudioSource;
                }
            }
        }
    }

    public void updateSurfacesSoundInfo ()
    {
        InitializeAudioElements ();
    }

    private void Start ()
    {
        InitializeAudioElements ();

        originalIgnoreUseDrawKeepWeaponAnimation = ignoreUseDrawKeepWeaponAnimation;

        originalUseMatchTargetSystemOnAttack = useMatchTargetSystemOnAttack;
    }

    public bool isGrabbedObjectMeleeAttackEnabled ()
    {
        return grabbedObjectMeleeAttackEnabled;
    }

    public bool isCanGrabMeleeObjectsEnabled ()
    {
        return canGrabMeleeObjectsEnabled;
    }

    public Transform getRightHandMountPoint ()
    {
        return rightHandMountPoint;
    }

    public Transform getLeftHandMountPoint ()
    {
        return leftHandMountPoint;
    }

    public void checkGrabbedMeleeWeaponLocalPositionRotationValues ()
    {
        if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useCustomGrabbedWeaponReferencePosition) {
            if (currentGrabbedWeaponInfo.useGrabbedWeaponReferenceValues) {
                currentGrabbedObjectTransform.localEulerAngles = currentGrabbedWeaponInfo.grabbedWeaponReferenceValuesEuler;
                currentGrabbedObjectTransform.localPosition = currentGrabbedWeaponInfo.grabbedWeaponReferenceValuesPosition;
            } else {
                currentGrabbedObjectTransform.localRotation = currentGrabbedWeaponInfo.customGrabbedWeaponReferencePosition.localRotation;
                currentGrabbedObjectTransform.localPosition = currentGrabbedWeaponInfo.customGrabbedWeaponReferencePosition.localPosition;
            }
        }
    }

    public void checkKeepMeleeWeaponLocalPositionRotationValues ()
    {
        if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useCustomReferencePositionToKeepObject) {
            currentGrabbedObjectTransform.localRotation = currentGrabbedWeaponInfo.customReferencePositionToKeepObject.localRotation;
            currentGrabbedObjectTransform.localPosition = currentGrabbedWeaponInfo.customReferencePositionToKeepObject.localPosition;
        }
    }

    public bool isUseCustomGrabbedWeaponReferencePositionActive ()
    {
        if (currentGrabbedWeaponInfo != null) {
            return currentGrabbedWeaponInfo.useCustomGrabbedWeaponReferencePosition;
        }

        return false;
    }

    public bool isUseGrabbedWeaponReferenceValuesActive ()
    {
        if (currentGrabbedWeaponInfo != null) {
            return currentGrabbedWeaponInfo.useGrabbedWeaponReferenceValues;
        }

        return false;
    }

    public Vector3 getGrabbedWeaponReferenceValuesPosition ()
    {
        if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useGrabbedWeaponReferenceValues) {
            return currentGrabbedWeaponInfo.grabbedWeaponReferenceValuesPosition;
        }

        return Vector3.zero;
    }

    public Vector3 getGrabbedWeaponReferenceValuesEuler ()
    {
        if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useGrabbedWeaponReferenceValues) {
            return currentGrabbedWeaponInfo.grabbedWeaponReferenceValuesEuler;
        }

        return Vector3.zero;
    }

    public bool isUseReferenceToKeepObjectValuesActive ()
    {
        if (currentGrabbedWeaponInfo != null) {
            return currentGrabbedWeaponInfo.useReferenceToKeepObjectValues;
        }

        return false;
    }

    public Vector3 getReferenceToKeepObjectValuesPosition ()
    {
        if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useGrabbedWeaponReferenceValues) {
            return currentGrabbedWeaponInfo.referenceToKeepObjectValuesPosition;
        }

        return Vector3.zero;
    }

    public Vector3 getReferenceToKeepObjectValuesEuler ()
    {
        if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useGrabbedWeaponReferenceValues) {
            return currentGrabbedWeaponInfo.referenceToKeepObjectValuesEuler;
        }

        return Vector3.zero;
    }

    public Transform getCustomGrabbedWeaponReferencePosition ()
    {
        if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useCustomGrabbedWeaponReferencePosition) {
            return currentGrabbedWeaponInfo.customGrabbedWeaponReferencePosition;
        }

        return null;
    }

    public Transform getCustomReferencePositionToKeepObject ()
    {
        if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useCustomReferencePositionToKeepObject) {
            return currentGrabbedWeaponInfo.customReferencePositionToKeepObject;
        }

        return null;
    }

    public void setNewGrabPhysicalObjectSystem (grabPhysicalObjectSystem newGrabPhysicalObjectSystem)
    {
        currentGrabPhysicalObjectSystem = newGrabPhysicalObjectSystem;

        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setNewGrabPhysicalObjectSystem (currentGrabPhysicalObjectSystem);
        }
    }

    public void setCheckDrawKeepWeaponAnimationPauseState (bool state)
    {
        checkDrawKeepWeaponAnimationPauseState = state;
    }

    public void activateStartDrawAnimation ()
    {
        if (checkDrawKeepWeaponAnimationPauseState) {
            checkDrawKeepWeaponAnimationPauseState = false;

            return;
        }

        if (currentGrabbedWeaponInfo != null && currentMeleeWeapon.useDrawKeepWeaponAnimation && !ignoreUseDrawKeepWeaponAnimation) {
            mainPlayerController.activateCustomAction (currentMeleeWeapon.drawWeaponActionName);

            currentMeleeWeapon.enableOrDisableWeaponMeshActiveState (false);

            bool hideWeaponMeshResult = mainMeleeWeaponsGrabbedManager.checkIfHideWeaponMeshWhenNotUsedByName (currentMeleeWeapon.getWeaponName ());

            if (!hideWeaponMeshResult) {
                mainMeleeWeaponsGrabbedManager.enableOrDisableMeleeWeaponMeshOnCharacterBodyByName (true, currentMeleeWeapon.getWeaponName ());
            }
        }
    }

    public void activateEndDrawAnimation ()
    {
        if (checkDrawKeepWeaponAnimationPauseState) {
            checkDrawKeepWeaponAnimationPauseState = false;

            return;
        }

        if (currentGrabbedWeaponInfo != null && currentMeleeWeapon.useDrawKeepWeaponAnimation && !ignoreUseDrawKeepWeaponAnimation) {
            currentMeleeWeapon.enableOrDisableWeaponMeshActiveState (true);

            mainMeleeWeaponsGrabbedManager.enableOrDisableMeleeWeaponMeshOnCharacterBodyByName (false, currentMeleeWeapon.getWeaponName ());

            lastWeaponParent = currentMeleeWeapon.transform.parent;

            lastMeleeWeaponSystemUsed = currentMeleeWeapon;

            lastKeepWeaponActionName = lastMeleeWeaponSystemUsed.keepWeaponActionName;

            lastWeaponLocalPosition = currentMeleeWeapon.transform.localPosition;
            lastWeaponLocalEuler = currentMeleeWeapon.transform.localEulerAngles;
        }
    }

    public void enableOrDisableWeaponMeshActiveState (bool state)
    {
        if (currentGrabbedWeaponInfo != null) {
            currentMeleeWeapon.enableOrDisableWeaponMeshActiveState (state);
        }
    }

    public void activateStartKeepAnimation ()
    {
        if (lastMeleeWeaponSystemUsed != null) {
            if (checkDrawKeepWeaponAnimationPauseState) {
                checkDrawKeepWeaponAnimationPauseState = false;

                removeDrawKeepWeaponAnimationInfo ();

                return;
            }

            if (lastMeleeWeaponSystemUsed.useDrawKeepWeaponAnimation &&
                !ignoreUseDrawKeepWeaponAnimation &&
                mainMeleeWeaponsGrabbedManager.isWeaponInGrabbedInfoList (lastMeleeWeaponSystemUsed.getWeaponName ())) {

                mainPlayerController.activateCustomAction (lastKeepWeaponActionName);
            } else {
                removeDrawKeepWeaponAnimationInfo ();
            }
        }
    }

    public void removeDrawKeepWeaponAnimationInfo ()
    {
        lastMeleeWeaponSystemUsed = null;

        lastWeaponParent = null;
    }

    public void placeLastWeaponOnCharacterHand ()
    {
        bool lastMeleeWeaponSystemUsedLocated = lastMeleeWeaponSystemUsed != null;

        if (lastMeleeWeaponSystemUsedLocated) {
            lastMeleeWeaponSystemUsed.transform.SetParent (lastWeaponParent);

            lastMeleeWeaponSystemUsed.transform.localPosition = lastWeaponLocalPosition;
            lastMeleeWeaponSystemUsed.transform.localEulerAngles = lastWeaponLocalEuler;

            lastMeleeWeaponSystemUsed.setMainObjectColliderEnabledState (false);

            lastMeleeWeaponSystemUsed.mainGrabPhysicalObjectSystem.setGrabObjectTriggerState (false);

            lastMeleeWeaponSystemUsed.gameObject.SetActive (true);

            mainMeleeWeaponsGrabbedManager.enableOrDisableMeleeWeaponMeshOnCharacterBodyByName (false, lastMeleeWeaponSystemUsed.getWeaponName ());
        }

        if (currentObjectRigidbody != null) {
            currentObjectRigidbody.isKinematic = true;
        }
    }

    public void activateEndKeepAnimation ()
    {
        if (lastMeleeWeaponSystemUsed != null) {
            lastMeleeWeaponSystemUsed.transform.SetParent (null);

            lastMeleeWeaponSystemUsed.gameObject.SetActive (false);

            lastMeleeWeaponSystemUsed.setMainObjectColliderEnabledState (true);

            lastMeleeWeaponSystemUsed.mainGrabPhysicalObjectSystem.setGrabObjectTriggerState (true);

            bool hideWeaponMeshResult = mainMeleeWeaponsGrabbedManager.checkIfHideWeaponMeshWhenNotUsedByName (lastMeleeWeaponSystemUsed.getWeaponName ());

            if (!hideWeaponMeshResult) {
                mainMeleeWeaponsGrabbedManager.enableOrDisableMeleeWeaponMeshOnCharacterBodyByName (true, lastMeleeWeaponSystemUsed.getWeaponName ());
            }

            removeDrawKeepWeaponAnimationInfo ();
        }
    }

    public void setNewGrabPhysicalObjectMeleeAttackSystem (grabPhysicalObjectMeleeAttackSystem newGrabPhysicalObjectMeleeAttackSystem)
    {
        if (!grabbedObjectMeleeAttackEnabled) {
            return;
        }

        //		print (newGrabPhysicalObjectMeleeAttackSystem.getWeaponName ());

        currentMeleeWeapon = newGrabPhysicalObjectMeleeAttackSystem;

        if (currentMeleeWeapon != null) {
            mainPlayerController.setPlayerUsingMeleeWeaponsState (true);

            currentGrabbedObjectTransform = currentMeleeWeapon.transform;

            currentObjectRigidbody = currentGrabbedObjectTransform.GetComponent<Rigidbody> ();

            objectRotationPoint = currentMeleeWeapon.objectRotationPoint;

            grabbedObjectMeleeAttackActive = true;

            currentAttackByIndex = 0;

            isDualWieldWeapon = currentMeleeWeapon.isDualWieldWeapon;

            if (isDualWieldWeapon) {
                mainDualWieldMeleeWeaponObjectSystem = currentMeleeWeapon.mainDualWieldMeleeWeaponObjectSystem;

                dualWieldHitCombat = mainDualWieldMeleeWeaponObjectSystem.mainHitCombat;

                dualWieldHitCombat.setCheckTriggerSurfacesState (checkTriggerSurfacesOnMeleeAttacks);
            }

            currentHitCombat = currentMeleeWeapon.getMainHitCombat ();

            currentHitCombat.setCheckTriggerSurfacesState (checkTriggerSurfacesOnMeleeAttacks);

            if (useCustomLayerToDetectSurfaces) {
                currentHitCombat.setCustomLayerMask (customLayerToDetectSurfaces);
            }

            if (useCustomIgnoreTags) {
                currentHitCombat.setCustomTagsToIgnore (customTagsToIgnoreList);
            } else {
                currentHitCombat.setCustomTagsToIgnore (null);
            }

            currentHitCombat.setCustomDamageCanBeBlockedState (true);

            currentHitCombatBoxCollider = currentHitCombat.getMainCollider ().GetComponent<BoxCollider> ();

            originalHitCombatColliderCenter = currentHitCombatBoxCollider.center;

            originalHitCombatColliderSize = currentHitCombatBoxCollider.size;

            originalHitCombatColliderPosition = currentHitCombat.transform.localPosition;

            currentHitCombat.getOwner (playerControllerGameObject);

            currentHitCombat.setMainColliderEnabledState (true);

            attackListCount = currentMeleeWeapon.getAttackListCount ();

            capsuleCastRadius = currentMeleeWeapon.capsuleCastRadius;

            capsuleCastDistance = currentMeleeWeapon.capsuleCastDistance;

            carryingObject = true;

            mainMeleeWeaponsGrabbedManager.setIsCarryingObjectState (true);

            if (currentMeleeWeapon.disableMeleeObjectCollider) {
                setGrabbedObjectClonnedColliderEnabledState (false);
            }

            checkGrabbedWeaponInfoStateAtStart (currentMeleeWeapon.weaponInfoName, true);

            if (showDebugPrint) {
                print (currentGrabbedWeaponInfo.useEventsOnDamageDetected);
            }

            currentHitCombat.setSendMessageOnDamageDetectedState (currentGrabbedWeaponInfo.useEventsOnDamageDetected);

            if (currentGrabbedWeaponInfo.useEventsOnDamageDetected) {
                currentHitCombat.setCustomObjectToSendMessage (gameObject);
            }

            if (currentGrabbedWeaponInfo.setConfigureDamageAsConstantValueOnWeapon) {
                currentHitCombat.setConfigureDamageAsConstant (currentGrabbedWeaponInfo.configureDamageAsConstantValueOnWeapon);

                if (isDualWieldWeapon) {
                    dualWieldHitCombat.setConfigureDamageAsConstant (currentGrabbedWeaponInfo.configureDamageAsConstantValueOnWeapon);
                }
            }

            if (currentGrabbedWeaponInfo.useReferenceToKeepObjectMeshValues) {
                currentMeleeWeapon.setUseCustomReferencePositionToKeepObjectMesh (currentGrabbedWeaponInfo.useCustomReferencePositionToKeepObjectMesh,
                    currentGrabbedWeaponInfo.referenceToKeepObjectMeshValuesPosition, currentGrabbedWeaponInfo.referenceToKeepObjectMeshValuesEuler);
            } else {
                currentMeleeWeapon.setUseCustomReferencePositionToKeepObjectMesh (currentGrabbedWeaponInfo.useCustomReferencePositionToKeepObjectMesh,
                    currentGrabbedWeaponInfo.customReferencePositionToKeepObjectMesh);
            }

            checkEventOnGrabDropObject (true);

            raycastCheckTransfrom = currentMeleeWeapon.raycastCheckTransfrom;

            mainMeleeWeaponsGrabbedManager.checkWeaponToStore (currentMeleeWeapon.getWeaponName (), currentGrabbedObjectTransform.gameObject);


            if (currentGrabbedWeaponInfo.isEmptyWeaponToUseOnlyShield) {
                mainGrabObjects.setGrabObjectsInputPausedState (true);
            } else {
                mainGrabObjects.setGrabObjectsInputPausedState (false);
            }

            if (useThrowReturnMeleeWeaponSystemEnabled) {
                mainMeleeCombatThrowReturnWeaponSystem.setNewGrabPhysicalObjectMeleeAttackSystem (currentMeleeWeapon);
            }

            if (useThrowReturnMeleeWeaponSystemEnabled && currentMeleeWeapon.isObjectThrown ()) {
                if (showDebugPrint) {
                    print ("return weapon thrown");
                }

                mainMeleeCombatThrowReturnWeaponSystem.setObjectThrownState (true);

                mainPlayerController.setPlayerMeleeWeaponThrownState (true);

                mainMeleeCombatThrowReturnWeaponSystem.setSurfacecNotFoundState (true);

                currentGrabbedObjectTransform.position = currentGrabPhysicalObjectSystem.getLastPositionBeforeGrabbed ();
                currentGrabbedObjectTransform.rotation = currentGrabPhysicalObjectSystem.getLastRotationBeforeGrabbed ();

                //				if (mainMeleeCombatThrowReturnWeaponSystem.currentMeleeWeapon == null) {
                //					mainMeleeCombatThrowReturnWeaponSystem.setNewGrabPhysicalObjectMeleeAttackSystem (currentMeleeWeapon);
                //				}

                mainMeleeCombatThrowReturnWeaponSystem.inputThrowOrReturnObject ();
            } else {
                checkGrabbedMeleeWeaponLocalPositionRotationValues ();
            }

            currentGrabPhysicalObjectSystem.setLastParentAssigned (null);

            meleeAttackTypesAmount.Clear ();

            int meleeAttackTypesCount = meleeAttackTypes.Count;

            int attackInfoListCount = currentMeleeWeapon.attackInfoList.Count;

            for (int i = 0; i < meleeAttackTypesCount; i++) {

                int meleeAttackAmount = 0;

                for (int j = 0; j < attackInfoListCount; j++) {
                    if (currentMeleeWeapon.attackInfoList [j].attackType.Equals (meleeAttackTypes [i])) {
                        meleeAttackAmount++;
                    }
                }

                meleeAttackTypesAmount.Add (meleeAttackAmount);
            }

            checkIfCarryingShieldActive ();

            if (currentMeleeWeapon.useAbilitiesListToEnableOnWeapon) {
                GKC_Utils.enableOrDisableAbilityGroupByName (playerControllerGameObject.transform, true, currentMeleeWeapon.abilitiesListToEnableOnWeapon);
            }

            if (disableGrabObjectsInputWhenCarryingMeleeWeapon) {
                mainGrabObjects.setGrabObjectsInputDisabledState (true);
            }

            if (isDualWieldWeapon) {
                mainDualWieldMeleeWeaponObjectSystem.enableDualWieldMeleeweapobObject (this, currentGrabbedWeaponInfo.useEventsOnDamageDetected);
            }

            deflectProjectilesEnabled = currentMeleeWeapon.deflectProjectilesEnabled;

            deflectProjectilesOnBlockEnabled = currentMeleeWeapon.deflectProjectilesOnBlockEnabled;

            if (deflectProjectilesEnabled || deflectProjectilesOnBlockEnabled) {
                currentMeleeWeapon.mainArmoreSurfaceSystem.gameObject.SetActive (true);
            }

            lastTimeDrawMeleeWeapon = Time.time;

            if (currentMeleeWeapon.useExtraActions) {
                if (currentMeleeWeapon.useDefaultExtraActionIndex) {
                    currentMeleeWeapon.setNewExtraActionByIndex (currentMeleeWeapon.defaultExtraActionIndex, mainRemoteEventSystem);
                }

                if (showExtraActionIconTexture) {
                    setCurrentExtraActionTexture (currentMeleeWeapon.getActionIconTexture ());
                }
            }

            currentAttackInfoTemplateIndex = 0;

            if (!objectThrown) {
                if (currentGrabbedWeaponInfo.useMeleeWeaponAttackInfoList && currentGrabbedWeaponInfo.setInitialWeaponAttackInfoList) {
                    int newIndex = currentGrabbedWeaponInfo.initialWeaponAttackInfoListIndex;

                    if (newIndex >= currentGrabbedWeaponInfo.meleeWeaponAttackInfoList.Count) {
                        newIndex = 0;
                    }

                    setAttackInfoTemplateByIndex (newIndex);
                }
            }

            currentMeleeWeapon.setCurrentCharacter (playerControllerGameObject);

            currentMeleeWeapon.addObjectStatsToMainManager ();

            ignoreParryOnPerfectBlock = currentGrabbedWeaponInfo.ignoreParryOnPerfectBlock;

            useCustomSurfaceInfoOnMeleeAttackNameForSwingOnAir = currentMeleeWeapon.useCustomSurfaceInfoOnMeleeAttackNameForSwingOnAir;

            customSurfaceInfoOnMeleeAttackNameForSwingOnAir = currentMeleeWeapon.customSurfaceInfoOnMeleeAttackNameForSwingOnAir;

            currentMeleeWeapon.setNewArmorOwner (playerControllerGameObject.transform);

            if (ignoreParryOnPerfectBlock) {
                mainHealth.setIgnoreParryActiveState (true);
            }

            if (mainMeleeUISystem != null) {
                mainMeleeUISystem.enableOrDisableMeleeUI (true);

                mainMeleeUISystem.setCurrentMeleeWeaponName (currentMeleeWeapon.getWeaponName ());

                mainMeleeUISystem.setCurrrentMeleeWeaponIcon (GKC_Utils.getInventoryObjectIconByName (currentMeleeWeapon.getWeaponName ()));
            }
        } else {
            removeGrabPhysicalObjectMeleeAttackSystem ();
        }
    }

    public float getLastTimeDrawMeleeWeapon ()
    {
        return lastTimeDrawMeleeWeapon;
    }

    public List<int> getMeleeAttackTypesAmount ()
    {
        return meleeAttackTypesAmount;
    }

    bool removeWeaponsFromManager = true;

    public void setRemoveWeaponsFromManagerState (bool state)
    {
        removeWeaponsFromManager = state;
    }

    public void removeGrabPhysicalObjectMeleeAttackSystem ()
    {
        if (!carryingObject) {
            return;
        }

        mainPlayerController.setPlayerUsingMeleeWeaponsState (false);

        if (currentMeleeWeapon != null) {
            if (removeWeaponsFromManager) {
                mainMeleeWeaponsGrabbedManager.checkToDropWeaponFromList (currentMeleeWeapon.getWeaponName ());
            }

            if (objectThrown) {
                currentMeleeWeapon.checkDisableTrail ();

                if (removeWeaponsFromManager) {
                    currentMeleeWeapon.setObjectThrownState (false);
                }
            }
        }

        stopActivateGrabbedObjectMeleeAttackCoroutine ();

        stopActivateDamageTriggerCoroutine ();

        resumeState ();

        if (currentHitCombat != null) {
            currentHitCombat.setMainColliderEnabledState (false);
        }

        drawOrSheatheShield (false);

        shieldActive = false;

        if (blockActive) {
            blockActivePreviously = false;

            disableBlockState ();
        }

        if (cuttingModeActive) {
            enableOrDisableCuttingMode (false);
        }

        if (meleeAttackInputPaused) {
            stopDisableMeleeAttackInputPausedStateWithDurationCoroutine ();

            mainGrabObjects.setGrabObjectsInputPausedState (false);

            meleeAttackInputPaused = false;
        }

        previousStrafeMode = false;

        if (currentMeleeWeapon != null) {
            previousStrafeMode = currentMeleeWeapon.wasStrafeModeActivePreviously ();

            currentMeleeWeapon.setPreviousStrafeModeState (false);

            if (currentMeleeWeapon.useAbilitiesListToDisableOnWeapon) {
                GKC_Utils.enableOrDisableAbilityGroupByName (playerControllerGameObject.transform, false, currentMeleeWeapon.abilitiesListToDisableOnWeapon);
            }

            if (deflectProjectilesEnabled || deflectProjectilesOnBlockEnabled) {
                currentMeleeWeapon.mainArmoreSurfaceSystem.gameObject.SetActive (false);

                checkSetArmorActiveState (false);

                deflectProjectilesEnabled = false;

                deflectProjectilesOnBlockEnabled = false;
            }

            if (currentMeleeWeapon.useExtraActions) {
                currentMeleeWeapon.setNewExtraActionByIndex (0, mainRemoteEventSystem);

                disableExtraActionIconGameObject ();
            }

            currentMeleeWeapon.setCurrentCharacter (null);

            currentMeleeWeapon.setLastTimeWeaponDropped ();

            if (ignoreParryOnPerfectBlock) {
                mainHealth.setIgnoreParryActiveState (false);
            }

            ignoreParryOnPerfectBlock = false;
        }

        currentMeleeWeapon = null;

        currentGrabPhysicalObjectSystem = null;

        grabbedObjectMeleeAttackActive = false;

        currentHitCombat = null;

        objectRotationPoint = null;

        carryingObject = false;

        mainMeleeWeaponsGrabbedManager.setIsCarryingObjectState (false);

        blockActive = false;

        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.stopThrowStateOnRemoveMeleeWeapon ();
        }

        cuttingModeActive = false;

        checkGrabbedWeaponInfoStateAtEnd ();

        checkEventOnGrabDropObject (false);

        updateShieldStateOnAnimator ();

        if (disableGrabObjectsInputWhenCarryingMeleeWeapon) {
            mainGrabObjects.setGrabObjectsInputDisabledState (false);
        }

        currentAttackInfoTemplateIndex = 0;

        if (mainDualWieldMeleeWeaponObjectSystem != null) {
            mainDualWieldMeleeWeaponObjectSystem.disableDualWieldMeleeweapobObject ();

            dualWieldHitCombat = null;

            stopActivateDamageDualWieldTriggerCoroutine ();
        }

        mainDualWieldMeleeWeaponObjectSystem = null;

        lastTimeDrawMeleeWeapon = -1;

        setThrowWeaponActionPausedState (false);

        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.removeGrabPhysicalObjectMeleeAttackSystem ();
        }

        enableOrDisableMainMeleeUISystem (false);

        cancellingBlockStateToAttackInProcess = false;
    }

    public void enableOrDisableMainMeleeUISystem (bool state)
    {
        if (mainMeleeUISystem != null) {
            mainMeleeUISystem.enableOrDisableMeleeUI (state);
        }
    }

    public grabbedWeaponInfo getGrabbedWeaponInfoByName (string weaponInfoName)
    {
        int weaponIdex = grabbedWeaponInfoList.FindIndex (s => s.Name == weaponInfoName);

        if (weaponIdex > -1) {
            return grabbedWeaponInfoList [weaponIdex];
        }

        return null;
    }

    public void checkUpdateCustomReferencePositionsToKeepMeshValues (grabPhysicalObjectMeleeAttackSystem
        newGrabPhysicalObjectMeleeAttackSystem)
    {
        if (newGrabPhysicalObjectMeleeAttackSystem != null) {
            grabbedWeaponInfo currentGrabbedWeaponInfo =
                            getGrabbedWeaponInfoByName (newGrabPhysicalObjectMeleeAttackSystem.weaponInfoName);

            if (currentGrabbedWeaponInfo != null) {

                if (currentGrabbedWeaponInfo.useReferenceToKeepObjectMeshValues) {
                    newGrabPhysicalObjectMeleeAttackSystem.setUseCustomReferencePositionToKeepObjectMesh (currentGrabbedWeaponInfo.useCustomReferencePositionToKeepObjectMesh,
                        currentGrabbedWeaponInfo.referenceToKeepObjectMeshValuesPosition, currentGrabbedWeaponInfo.referenceToKeepObjectMeshValuesEuler);
                } else {
                    newGrabPhysicalObjectMeleeAttackSystem.setUseCustomReferencePositionToKeepObjectMesh (currentGrabbedWeaponInfo.useCustomReferencePositionToKeepObjectMesh,
                        currentGrabbedWeaponInfo.customReferencePositionToKeepObjectMesh);
                }
            }
        }
    }

    public void drawOrKeepMeleeWeapon ()
    {
        if (mainMeleeWeaponsGrabbedManager.meleeWeaponsGrabbedManagerActive) {
            mainMeleeWeaponsGrabbedManager.inputDrawOrKeepMeleeWeapon ();
        }
    }

    public void drawOrKeepMeleeWeaponWithoutCheckingInputActive ()
    {
        if (mainMeleeWeaponsGrabbedManager.meleeWeaponsGrabbedManagerActive) {
            mainMeleeWeaponsGrabbedManager.drawOrKeepMeleeWeaponWithoutCheckingInputActive ();
        }
    }

    public void drawMeleeWeaponGrabbedCheckingAnimationDelay ()
    {
        if (mainMeleeWeaponsGrabbedManager.meleeWeaponsGrabbedManagerActive) {
            mainMeleeWeaponsGrabbedManager.drawMeleeWeaponGrabbedCheckingAnimationDelay ();
        }
    }

    public void checkToKeepWeapon ()
    {
        mainMeleeWeaponsGrabbedManager.checkToKeepWeapon ();
    }

    public void checkToKeepWeaponWithoutCheckingInputActive ()
    {
        mainMeleeWeaponsGrabbedManager.checkToKeepWeaponWithoutCheckingInputActive ();
    }

    public void checkIfDropThrownWeaponWhenUsingDevice ()
    {
        if (mainMeleeWeaponsGrabbedManager.meleeWeaponsGrabbedManagerActive) {
            mainMeleeWeaponsGrabbedManager.checkIfDropThrownWeaponWhenUsingDevice ();
        }
    }

    public void setAttackInputPausedForStaminaState (bool state)
    {
        if (useStaminaOnAttackEnabled) {
            attackInputPausedForStamina = state;
        }
    }

    public void setThrowObjectInputPausedForStaminaState (bool state)
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setThrowObjectInputPausedForStaminaState (state);
        }
    }

    public bool canActivateAttack ()
    {
        if (currentWaitTimeToNextAttack == 0) {
            return true;
        } else {
            if (Time.time > lastTimeAttackActive + currentWaitTimeToNextAttack) {
                return true;
            } else {
                return false;
            }
        }
    }

    public void resetCurrentAttackByIndex ()
    {
        currentAttackByIndex = 0;
    }

    int currentAttackByIndex;

    public void activateGrabbedObjectMeleeAttackByIndex ()
    {
        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (meleeAttackInputPaused) {
            return;
        }

        activateGrabbedObjectMeleeAttack (currentMeleeWeapon.attackInfoList [currentAttackByIndex].attackType);

        currentAttackByIndex++;

        if (currentAttackByIndex >= currentMeleeWeapon.attackInfoList.Count) {
            currentAttackByIndex = 0;
        }
    }

    public void activateNextAttackIgnoringWaitingTimes ()
    {
        if (carryingObject && attackInProcess) {
            if (currentAttackInfo != null && currentAttackInfo.attackType != "") {
                ignoreTimeToPlayNextAttackActive = true;

                //ignoreAddAttackInputToStackActive = true;

                activateGrabbedObjectMeleeAttack (currentAttackInfo.attackType);

                ignoreTimeToPlayNextAttackActive = false;

                //ignoreAddAttackInputToStackActive = false;
            }
        }
    }

    public bool drawMeleeWeaponIfAttackInputPressedEnabled;

    bool ignoreTimeToPlayNextAttackActive;

    public void activateGrabbedObjectMeleeAttack (string attackType)
    {
        if (showDebugPrint) {
            print ("input activated");
        }

        if (!grabbedObjectMeleeAttackActive) {
            if (drawMeleeWeaponIfAttackInputPressedEnabled) {
                if (!mainMeleeWeaponsGrabbedManager.isMeleeWeaponsGrabbedManagerActive ()) {
                    return;
                }
            } else {
                return;
            }
        }

        if (meleeAttackInputPaused) {
            return;
        }

        if (!canUseWeaponsInput ()) {
            return;
        }

        if (showDebugPrint) {
            print ("1");
        }

        if (objectThrown) {
            return;
        }

        if (cuttingModeActive) {
            return;
        }

        if (cancellingBlockStateToAttackInProcess) {
            if (showDebugPrint) {
                print ("cancelling block to start attack in process");
            }

            return;
        }

        if (drawMeleeWeaponIfAttackInputPressedEnabled) {
            if (!carryingObject) {
                drawOrKeepMeleeWeapon ();

                if (showDebugPrint) {
                    print ("draw weapon by attack input");
                }

                return;
            }
        }

        attackActivatedOnAir = false;

        bool canActivateAttackOnAir = false;

        if (!mainPlayerController.isPlayerOnGround ()) {
            if (playerOnGroundToActivateAttack) {
                return;
            } else {
                canActivateAttackOnAir = true;

                attackActivatedOnAir = true;
            }
        }

        if (attackActivatedOnAir) {
            mainPlayerController.relaseJumpButtonIfAddForceWhileButtonPressedActive ();
        }

        if (showDebugPrint) {
            print ("2");
        }

        if (attackInputPausedForStamina && generalStaminaUseMultiplier > 0) {
            if (showDebugPrint) {
                print ("Not enough stamina, cancelling attack");
            }

            return;
        }

        if (!currentMeleeWeapon.attacksEnabled) {
            if (showDebugPrint) {
                print ("Attacks not enabled, cancelling attack");
            }

            return;
        }

        if (currentMeleeWeapon.keepGrabbedObjectState) {
            if (showDebugPrint) {
                print ("Melee weapon is in keep state, cancelling attack");
            }

            return;
        }

        if (currentMeleeWeapon.onlyAttackIfNoPreviousAttackInProcess) {
            if (attackInProcess) {
                if (showDebugPrint) {
                    print ("attack already in process, cancelling attack");
                }

                return;
            }
        }

        if (Time.time < lastTimeAttackActive + currentMeleeWeapon.minDelayBetweenAttacks) {
            if (showDebugPrint) {
                print ("Min delay between attacks in process, cancelling attack");
            }

            return;
        }

        if (!currentMeleeWeapon.onlyAttackIfNoPreviousAttackInProcess) {
            //currentAttackIndex > 0 && 

            if (currentAttackInfo != null) {
                //				print (currentAttackInfo.minDelayBeforeNextAttack);

                if (Time.time < lastTimeAttackActive + currentAttackInfo.minDelayBeforeNextAttack && !ignoreTimeToPlayNextAttackActive) {
                    if (showDebugPrint) {
                        print ("Min wait before next attack in process, cancelling attack");
                    }

                    currentWaitTimeToNextAttack = 0;

                    return;
                } else {
                    currentWaitTimeToNextAttack = currentAttackInfo.minDelayBeforeNextAttack;
                }
            }
        }

        if (currentMeleeWeapon.resetIndexIfNotAttackAfterDelay && !attackInProcess) {
            if (Time.time > lastTimeAttackComplete + currentMeleeWeapon.delayToResetIndexAfterAttack) {
                //				print ("reset attack index");

                currentAttackIndex = 0;

                if (showDebugPrint) {
                    print ("Reseting attack index as min time to reset has been reached");
                }

                currentWaitTimeToNextAttack = 0;
            }
        }

        if (showDebugPrint) {
            print ("3");
        }


        usingNumberOfAttackOfSameTypeActive = false;

        if (useAttackTypes) {
            if (showDebugPrint) {
                print ("attack all conditions checked");
            }

            int numberOfAttacksSameType = 0;

            int numberOfAttacksAvailable = currentMeleeWeapon.getAttackListCount ();

            for (int i = 0; i < numberOfAttacksAvailable; i++) {
                if (currentMeleeWeapon.attackInfoList [i].attackType.Equals (attackType)) {
                    numberOfAttacksSameType++;
                }
            }

            if (numberOfAttacksSameType == 1) {
                usingNumberOfAttackOfSameTypeActive = true;

                bool cancelAttack = false;

                if (minWaitTimeToUseSingleAttackType > 0) {
                    if (attackInProcess) {
                        cancelAttack = true;

                        if (showDebugPrint) {
                            print ("just one attack type available and it is in process, avoiding to play it again");
                        }
                    }

                    if (Time.time < lastTimeAttackComplete + minWaitTimeToUseSingleAttackType) {
                        cancelAttack = true;

                        if (showDebugPrint) {
                            print ("just one attack type available and it is waiting for last time attack complete, avoiding to play it again");
                        }
                    }
                } else {
                    if (currentAttackInfo != null && currentAttackInfo.attackType.Equals (attackType)) {
                        if (Time.time < lastTimeAttackActive + currentAttackInfo.minDelayBeforeNextAttack && !ignoreTimeToPlayNextAttackActive) {
                            cancelAttack = true;

                            if (showDebugPrint) {
                                print ("just one attack type available and it is waiting for min delay before next attack, avoiding to play it again");
                            }
                        }
                    }
                }

                if (cancelAttack) {
                    return;
                }
            }

            bool attackFound = false;

            while (!attackFound) {
                currentAttackInfo = currentMeleeWeapon.attackInfoList [currentAttackIndex];

                //				print (currentAttackInfo.attackType + " " + attackType);

                if (currentAttackInfo.attackType.Equals (attackType)) {
                    attackFound = true;

                    setNextAttackIndex ();
                } else {
                    setNextAttackIndex ();

                    numberOfAttacksAvailable--;

                    if (numberOfAttacksAvailable < 0) {
                        return;
                    }
                }
            }
        } else {
            currentAttackInfo = currentMeleeWeapon.attackInfoList [currentAttackIndex];
        }

        bool cancelAttackResult = false;

        if (canActivateAttackOnAir && currentAttackInfo.playerOnGroundToActivateAttack) {
            cancelAttackResult = true;

            if (showDebugPrint) {
                print ("trying to do an attack while on air for an attack that must be on ground");
            }
        }

        if (useStaminaOnAttackEnabled) {
            if (currentMeleeWeapon.objectUsesStaminaOnAttacks) {
                float staminaRequiredForAttack = currentAttackInfo.staminaUsedOnAttack * generalStaminaUseMultiplier;

                if (mainStaminaSystem.getCurrentStaminaAmount () < staminaRequiredForAttack) {
                    if (showDebugPrint) {
                        print ("not enough stamina for attack");
                    }

                    cancelAttackResult = true;
                }

                if (!cancelAttackResult) {
                    mainStaminaSystem.activeStaminaStateWithCustomAmount (attackStaminaStateName, staminaRequiredForAttack, currentAttackInfo.customRefillStaminaDelayAfterUse);
                }
            }
        }

        if (cancelAttackResult) {
            currentAttackIndex--;

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

            if (showDebugPrint) {
                print ("cancel attack");
            }

            return;
        }

        float currentDamageValue = currentAttackInfo.attackDamage * generalAttackDamageMultiplier;

        currentHitCombat.setNewHitDamage (currentDamageValue);

        if (isDualWieldWeapon) {
            dualWieldHitCombat.setNewHitDamage (currentDamageValue);
        }

        if (currentAttackInfo.useForceToApplyOnImpact) {
            currentHitCombat.setCustomForceAmount (currentAttackInfo.forceToApplyOnImpact);

            currentHitCombat.setCustomForceMode (currentAttackInfo.forceModeToApplyOnImpact);

            if (isDualWieldWeapon) {
                dualWieldHitCombat.setCustomForceAmount (currentAttackInfo.forceToApplyOnImpact);

                dualWieldHitCombat.setCustomForceMode (currentAttackInfo.forceModeToApplyOnImpact);
            }
        } else {
            currentHitCombat.setCustomForceAmount (0);

            currentHitCombat.removeCustomForceMode ();

            if (isDualWieldWeapon) {
                dualWieldHitCombat.setCustomForceAmount (0);

                dualWieldHitCombat.removeCustomForceMode ();
            }
        }

        int attackID = currentAttackIndex - 1;

        if (attackID < 0) {
            attackID = currentMeleeWeapon.getAttackListCount () - 1;
        }

        currentHitCombat.setTriggerId (attackID);

        if (isDualWieldWeapon) {
            dualWieldHitCombat.setTriggerId (attackID);
        }

        currentAttackCanBeBlocked = true;

        if (currentGrabbedWeaponInfo.attacksCantBeBlocked || currentAttackInfo.attackCantBeBlocked) {
            bool attackCanBeBlocked = true;

            if (currentGrabbedWeaponInfo.attackIDCantBeBlockedList.Count > 0) {
                attackCanBeBlocked = !currentGrabbedWeaponInfo.attackIDCantBeBlockedList.Contains (attackID);
            }

            if (currentAttackInfo.attackCantBeBlocked) {
                attackCanBeBlocked = false;
            }

            currentHitCombat.setCustomDamageCanBeBlockedState (attackCanBeBlocked);

            if (isDualWieldWeapon) {
                dualWieldHitCombat.setCustomDamageCanBeBlockedState (attackCanBeBlocked);
            }

            currentAttackCanBeBlocked = attackCanBeBlocked;
        }

        if (!currentAttackCanBeBlocked) {
            if (useEventsOnAttackCantBeBlocked) {
                eventOnAttackCantBeBlocked.Invoke ();
            }
        }

        //		print ("attack can be blocked " + currentAttackCanBeBlocked + "  " + currentAttackInfo.customActionName + " " + attackID);

        stopActivateGrabbedObjectMeleeAttackCoroutine ();

        attackCoroutine = StartCoroutine (activateGrabbedObjectMeleeAttackCoroutine ());

        stopActivateDamageTriggerCoroutine ();

        damageTriggerCoroutine = StartCoroutine (activateDamageTriggerCoroutine (true));

        if (isDualWieldWeapon) {
            stopActivateDamageDualWieldTriggerCoroutine ();

            dualWieldDamageTriggerCoroutine = StartCoroutine (activateDamageTriggerCoroutine (false));
        }

        if (!useAttackTypes) {
            setNextAttackIndex ();
        }
    }

    bool usingNumberOfAttackOfSameTypeActive = false;

    public void resetAttackIndex ()
    {
        currentAttackIndex = 0;

        currentWaitTimeToNextAttack = 0;
    }

    public void setNextAttackIndex ()
    {
        if (currentMeleeWeapon.useRandomAttackIndex) {
            currentAttackIndex = Random.Range (0, attackListCount - 1);
        } else {
            currentAttackIndex++;

            if (currentAttackIndex >= attackListCount) {
                currentAttackIndex = 0;
            }
        }
    }

    public void stopActivateGrabbedObjectMeleeAttackCoroutine ()
    {
        if (attackCoroutine != null) {
            StopCoroutine (attackCoroutine);
        }
    }

    bool cancellingBlockStateToAttackInProcess;

    IEnumerator activateGrabbedObjectMeleeAttackCoroutine ()
    {
        if (blockActive) {
            blockActivePreviously = true;

            disableBlockState ();
        }

        WaitForSeconds delay = new WaitForSeconds (0.1f);

        if (canCancelBlockToStartAttackActive) {
            cancellingBlockStateToAttackInProcess = true;

            if (showDebugPrint) {
                print ("cancel block");
            }

            mainAnimator.SetBool (cancelBlockReactionStateName, true);

            delay = new WaitForSeconds (0.3f);

            yield return delay;

            mainAnimator.SetBool (cancelBlockReactionStateName, false);

            //			checkDisableHasExitTimeAnimator ();

            canCancelBlockToStartAttackActive = false;

            cancellingBlockStateToAttackInProcess = false;
        }

        if (useMatchTargetSystemOnAttack && !attackActivatedOnAir) {

            bool useMatchTargetAttack = false;

            float matchPositionOffset = 0;

            if (currentAttackInfo.useMatchPositionSystem || ignoreAttackSettingToMatchTarget) {
                useMatchTargetAttack = true;
                matchPositionOffset = currentAttackInfo.matchPositionOffset;
            }

            if (currentMeleeWeapon.useMatchPositionSystemOnAllAttacks || ignoreAttackSettingToMatchTarget) {
                useMatchTargetAttack = true;

                if (currentAttackInfo.useMatchPositionSystem) {
                    matchPositionOffset = currentAttackInfo.matchPositionOffset;
                } else {
                    matchPositionOffset = currentMeleeWeapon.matchPositionOffsetOnAllAttacks;
                }
            }

            if (useMatchTargetAttack) {
                mainMatchPlayerToTargetSystem.activateMatchPosition (matchPositionOffset);
            }
        }

        lastTimeSurfaceAudioPlayed = 0;

        lastSurfaceDetecetedIndex = -1;

        checkEventsOnAttack (true);

        lastTimeAttackActive = Time.time;

        attackInProcess = true;

        mainPlayerController.setMeleeAttackInProcessState (true);

        mainGrabObjects.setGrabObjectsInputPausedState (true);

        if (currentAttackInfo.useRemoteEvent) {
            int remoteEventNameListCount = currentAttackInfo.remoteEventNameList.Count;

            for (int i = 0; i < remoteEventNameListCount; i++) {
                mainRemoteEventSystem.callRemoteEvent (currentAttackInfo.remoteEventNameList [i]);
            }

            if (currentAttackInfo.useRemoteEventWithString) {
                mainRemoteEventSystem.callRemoteEventWithString (currentAttackInfo.remoteEventWithStringName,
                    currentAttackInfo.remoteEventString);
            }
        }

        if (currentAttackInfo.useCustomAction) {
            if (currentAttackInfo.ignoreAttackAnimationAndDamageTrigger) {

            } else {
                if (usingNumberOfAttackOfSameTypeActive) {
                    if (mainPlayerController.getCurrentActionName ().Equals (currentAttackInfo.customActionName)) {
                        print ("character is already doing that attack, stopping to play again");

                        mainPlayerController.stopCustomAction (currentAttackInfo.customActionName);
                    }

                    usingNumberOfAttackOfSameTypeActive = false;
                }

                mainPlayerController.activateCustomAction (currentAttackInfo.customActionName);

                if (showDebugPrint) {
                    print ("attack activated :" + mainPlayerController.getCurrentActionName ());
                }
            }
        }

        float attackWaitDuration = 0;

        if (attackActivatedOnAir) {
            attackWaitDuration = currentAttackInfo.attackDurationOnAir / currentAttackInfo.attackAnimationSpeedOnAir;
        } else {
            attackWaitDuration = currentAttackInfo.attackDuration / currentAttackInfo.attackAnimationSpeed;
        }

        delay = new WaitForSeconds (attackWaitDuration);

        yield return delay;

        if (damageTriggerInProcess) {
            if (showDebugPrint) {
                print ("damage in process, waiting to finish");
            }

            while (damageTriggerInProcess) {

                yield return null;
            }
        }

        yield return null;

        lastTimeAttackComplete = Time.time;

        resumeState ();

        if (blockActivePreviously) {
            if (!blockInputPaused) {
                blockActivePreviously = false;

                delay = new WaitForSeconds (0.3f);

                yield return delay;

                setBlockActiveState (true);
            }
        } else {
            if (shieldActive) {
                updateShieldStateOnAnimator ();
            }
        }

        if (showDebugPrint) {
            print ("end of attack");
        }
    }

    public void stopActivateDamageTriggerCoroutine ()
    {
        if (damageTriggerCoroutine != null) {
            StopCoroutine (damageTriggerCoroutine);
        }
    }

    public void stopActivateDamageDualWieldTriggerCoroutine ()
    {
        if (dualWieldDamageTriggerCoroutine != null) {
            StopCoroutine (dualWieldDamageTriggerCoroutine);
        }
    }

    public void enableOrDisableDualWieldMeleeWeaponObject (bool state)
    {
        if (isDualWieldWeapon) {
            if (mainDualWieldMeleeWeaponObjectSystem != null) {
                mainDualWieldMeleeWeaponObjectSystem.enableOrDisableDualWieldMeleeWeaponObject (state);
            }
        }
    }

    public void resetActivateDamageTriggerCoroutine ()
    {
        if (showDebugPrint) {
            print ("Resetinng Activate Damage Trigger Coroutine on Melee Weapons");
        }

        if (damageTriggerInProcess) {
            //			print ("checking");
            if (Time.time > lastTimeDamageTriggerActivated + 0.05f) {
                stopActivateDamageTriggerCoroutine ();

                damageTriggerCoroutine = StartCoroutine (activateDamageTriggerCoroutine (true));

                if (isDualWieldWeapon) {
                    stopActivateDamageDualWieldTriggerCoroutine ();

                    dualWieldDamageTriggerCoroutine = StartCoroutine (activateDamageTriggerCoroutine (false));
                }

                //				print ("reset attack for delay of " + (Mathf.Abs (Time.time - (lastTimeDamageTriggerActivated + 0.05f))));
            }
        }
    }

    IEnumerator activateDamageTriggerCoroutine (bool enableMainHitCombat)
    {
        if (showDebugPrint) {
            print ("activate attack");

            if (attackActivatedOnAir) {
                print ("Attack on air ");
            } else {
                print ("Attack on ground");
            }
        }

        damageTriggerInProcess = true;

        lastTimeDamageTriggerActivated = Time.time;

        hitCombat attackHitCombat = currentHitCombat;

        if (!enableMainHitCombat) {
            attackHitCombat = dualWieldHitCombat;
        }

        attackHitCombat.setCurrentState (false);

        checkSetArmorActiveState (false);

        attackHitCombat.setIgnoreDetectedObjectsOnListState (false);

        if (currentMeleeWeapon.useGeneralDamageTypeID) {
            attackHitCombat.setNewDamageTypeID (currentMeleeWeapon.generalDamageTypeID);

        } else {
            attackHitCombat.setNewDamageTypeID (currentAttackInfo.damageTypeID);
        }

        int numberOfEventsTriggered = 0;

        float timer = Time.time;

        bool allEventsTriggered = false;

        bool useAnimationPercentageDuration = currentMeleeWeapon.useAnimationPercentageDuration;
        bool useAnimationPercentageOver100 = currentMeleeWeapon.useAnimationPercentageOver100;

        int damageTriggerActiveInfoListCount = 0;

        if (enableMainHitCombat) {
            if (attackActivatedOnAir) {
                damageTriggerActiveInfoListCount = currentAttackInfo.attackOnAirDamageTriggerActiveInfoList.Count;
            } else {
                damageTriggerActiveInfoListCount = currentAttackInfo.damageTriggerActiveInfoList.Count;
            }
        } else {
            damageTriggerActiveInfoListCount = currentAttackInfo.dualWieldDamageTriggerActiveInfoList.Count;
        }

        bool canActivateCurrentEvent = false;

        float currentAttackDuration = 0;

        if (attackActivatedOnAir) {
            currentAttackDuration = currentAttackInfo.attackDurationOnAir / currentAttackInfo.attackAnimationSpeedOnAir;
        } else {
            currentAttackDuration = currentAttackInfo.attackDuration / currentAttackInfo.attackAnimationSpeed;
        }

        if (currentAttackInfo.useSingleSlashDamageInfo) {
            if (hitCombatParentChanged) {
                attackHitCombat.transform.SetParent (objectRotationPoint);
                attackHitCombat.transform.localPosition = originalHitCombatColliderPosition;
                attackHitCombat.transform.localRotation = Quaternion.identity;

                Transform raycastCheckTransformParent = currentMeleeWeapon.raycastCheckTransformParent;
                raycastCheckTransformParent.SetParent (objectRotationPoint);
                raycastCheckTransformParent.localPosition = Vector3.zero;
                raycastCheckTransformParent.localRotation = Quaternion.identity;

                hitCombatParentChanged = false;
            }

            if (enableMainHitCombat) {
                setHitCombatScale (originalHitCombatColliderSize);

                setHitCombatOffset (originalHitCombatColliderCenter);
            } else {
                mainDualWieldMeleeWeaponObjectSystem.setOriginalHitCombatScale ();

                mainDualWieldMeleeWeaponObjectSystem.setOriginalHitCombatOffset ();
            }

            float delayToActivateSingleSlashDamageTrigger = currentAttackInfo.delayToActivateSingleSlashDamageTrigger;
            float delayToDeactivateSingleSlashDamageTrigger = currentAttackInfo.delayToDeactivateSingleSlashDamageTrigger;

            if (useAnimationPercentageDuration) {

                if (useAnimationPercentageOver100) {
                    delayToActivateSingleSlashDamageTrigger /= 100;
                    delayToDeactivateSingleSlashDamageTrigger /= 100;
                }

                delayToActivateSingleSlashDamageTrigger = currentAttackDuration * delayToActivateSingleSlashDamageTrigger;
                delayToDeactivateSingleSlashDamageTrigger = currentAttackDuration * delayToDeactivateSingleSlashDamageTrigger;
            }

            bool activateDamageTriggered = false;
            bool deactivateDamageTriggered = false;

            bool currentActivateDamageTriggerValue = false;

            float currentDelay = 0;

            while (!allEventsTriggered) {
                bool animatorIsPaused = mainAnimator.speed <= 0;

                if (animatorIsPaused) {
                    timer += Time.deltaTime;
                }

                if (!activateDamageTriggered) {
                    currentActivateDamageTriggerValue = true;
                } else {
                    currentActivateDamageTriggerValue = false;
                }

                if (!activateDamageTriggered || !deactivateDamageTriggered) {

                    canActivateCurrentEvent = false;

                    if (useAnimationPercentageDuration) {
                        if (!activateDamageTriggered) {
                            currentDelay = delayToActivateSingleSlashDamageTrigger;
                        } else {
                            currentDelay = delayToDeactivateSingleSlashDamageTrigger;
                        }
                    } else {
                        if (!activateDamageTriggered) {
                            currentDelay = currentAttackInfo.delayToActivateSingleSlashDamageTrigger;
                        } else {
                            currentDelay = currentAttackInfo.delayToDeactivateSingleSlashDamageTrigger;
                        }
                    }

                    if (Time.time > timer + currentDelay) {
                        canActivateCurrentEvent = true;
                    }

                    if (canActivateCurrentEvent) {

                        bool activateDamageTrigger = currentActivateDamageTriggerValue;

                        if (currentAttackInfo.ignoreAttackAnimationAndDamageTrigger) {
                            activateDamageTrigger = false;
                        }

                        attackHitCombat.setCurrentState (activateDamageTrigger);

                        if (activateDamageTrigger) {
                            attackHitCombat.reloadMainColliderEnabled ();
                        }

                        checkSetArmorActiveState (activateDamageTrigger);

                        if (activateDamageTrigger && currentAttackInfo.ignoreDetectedObjectsOnList) {
                            attackHitCombat.setIgnoreDetectedObjectsOnListState (true);
                        }

                        attackHitCombat.setNewDamageReactionID (currentAttackInfo.damageReactionID);

                        numberOfEventsTriggered++;

                        if (!activateDamageTriggered) {
                            activateDamageTriggered = true;

                            //							print ("activate first delay");
                        } else {
                            deactivateDamageTriggered = true;

                            //							print ("activate second delay");
                        }

                        if ((activateDamageTriggered && deactivateDamageTriggered) || numberOfEventsTriggered == 2) {
                            allEventsTriggered = true;
                        }

                        if (activateDamageTrigger) {
                            checkingNoDamageDetectionOnDualWieldTriggerActive = !enableMainHitCombat;

                            checkSurfaceFoundOnAttack (false);
                        }
                    }
                }

                yield return null;
            }

            //			print ("end of attack");
        } else {

            bool placeTriggerInFrontOfCharacterOnAllAttacksResult = currentGrabbedWeaponInfo.placeTriggerInFrontOfCharacterOnAllAttacks ||
                                                                    placeTriggerInFrontOfCharacterOnAllAttacks;

            grabPhysicalObjectMeleeAttackSystem.damageTriggerActiveInfo currentdamageTriggerActiveInfo = null;

            for (int i = 0; i < damageTriggerActiveInfoListCount; i++) {
                if (enableMainHitCombat) {
                    if (attackActivatedOnAir) {
                        currentdamageTriggerActiveInfo = currentAttackInfo.attackOnAirDamageTriggerActiveInfoList [i];
                    } else {
                        currentdamageTriggerActiveInfo = currentAttackInfo.damageTriggerActiveInfoList [i];
                    }
                } else {
                    currentdamageTriggerActiveInfo = currentAttackInfo.dualWieldDamageTriggerActiveInfoList [i];
                }

                currentdamageTriggerActiveInfo.delayTriggered = false;

                if (useAnimationPercentageDuration) {
                    float currentDelay = currentdamageTriggerActiveInfo.delayToActiveTrigger;

                    if (currentDelay > 1) {
                        print ("ERRRORORORROOROROR: DELAY IS HIGHER THAN 1 FIXXXXXXXXXXX----------------------------------------" +
                        ".............................................");
                    }

                    if (useAnimationPercentageOver100) {
                        currentDelay /= 100;
                    }

                    currentdamageTriggerActiveInfo.calculatedPercentageAttackDuration = currentAttackDuration * currentDelay;
                }
            }

            detectedObjectsOnReturn.Clear ();

            while (!allEventsTriggered) {
                if (currentAttackInfo == null) {
                    allEventsTriggered = true;

                } else {
                    bool animatorIsPaused = mainAnimator.speed <= 0;

                    if (animatorIsPaused) {
                        timer += Time.deltaTime;
                    }

                    for (int i = 0; i < damageTriggerActiveInfoListCount; i++) {
                        if (enableMainHitCombat) {
                            if (attackActivatedOnAir) {
                                currentdamageTriggerActiveInfo = currentAttackInfo.attackOnAirDamageTriggerActiveInfoList [i];
                            } else {
                                currentdamageTriggerActiveInfo = currentAttackInfo.damageTriggerActiveInfoList [i];
                            }
                        } else {
                            currentdamageTriggerActiveInfo = currentAttackInfo.dualWieldDamageTriggerActiveInfoList [i];
                        }

                        if (!currentdamageTriggerActiveInfo.delayTriggered) {

                            canActivateCurrentEvent = false;

                            if (useAnimationPercentageDuration) {
                                if (Time.time > timer + currentdamageTriggerActiveInfo.calculatedPercentageAttackDuration) {
                                    canActivateCurrentEvent = true;
                                }
                            } else {
                                if (Time.time > timer + currentdamageTriggerActiveInfo.delayToActiveTrigger) {
                                    canActivateCurrentEvent = true;
                                }
                            }

                            //print (currentdamageTriggerActiveInfo.delayToActiveTrigger + " " + i);

                            if (canActivateCurrentEvent) {

                                bool activateDamageTrigger = currentdamageTriggerActiveInfo.activateDamageTrigger;

                                if (currentAttackInfo.ignoreAttackAnimationAndDamageTrigger) {
                                    activateDamageTrigger = false;
                                }

                                attackHitCombat.setCurrentState (activateDamageTrigger);

                                if (activateDamageTrigger) {
                                    attackHitCombat.reloadMainColliderEnabled ();
                                }

                                checkSetArmorActiveState (activateDamageTrigger);

                                if (activateDamageTrigger && currentAttackInfo.ignoreDetectedObjectsOnList) {
                                    attackHitCombat.setIgnoreDetectedObjectsOnListState (true);
                                }

                                attackHitCombat.setNewDamageReactionID (currentAttackInfo.damageReactionID);

                                numberOfEventsTriggered++;

                                currentdamageTriggerActiveInfo.delayTriggered = true;

                                if (damageTriggerActiveInfoListCount == numberOfEventsTriggered) {
                                    allEventsTriggered = true;
                                }

                                if (currentdamageTriggerActiveInfo.setNewTriggerScale) {
                                    if (currentdamageTriggerActiveInfo.setOriginalScale) {
                                        if (enableMainHitCombat) {
                                            setHitCombatScale (originalHitCombatColliderSize);

                                            setHitCombatOffset (originalHitCombatColliderCenter);
                                        } else {
                                            mainDualWieldMeleeWeaponObjectSystem.setOriginalHitCombatScale ();

                                            mainDualWieldMeleeWeaponObjectSystem.setOriginalHitCombatOffset ();
                                        }
                                    } else {
                                        if (enableMainHitCombat) {
                                            setHitCombatScale (currentdamageTriggerActiveInfo.newTriggerScale);
                                        } else {
                                            mainDualWieldMeleeWeaponObjectSystem.setHitCombatScale (currentdamageTriggerActiveInfo.newTriggerScale);
                                        }

                                        if (currentdamageTriggerActiveInfo.newTriggerOffset != Vector3.zero) {
                                            if (enableMainHitCombat) {
                                                setHitCombatOffset (currentdamageTriggerActiveInfo.newTriggerOffset);
                                            } else {
                                                mainDualWieldMeleeWeaponObjectSystem.setHitCombatOffset (currentdamageTriggerActiveInfo.newTriggerOffset);
                                            }
                                        }
                                    }
                                }

                                if (currentdamageTriggerActiveInfo.changeDamageTriggerToLimb || placeTriggerInFrontOfCharacterOnAllAttacksResult) {
                                    Transform newParent = null;

                                    if (currentdamageTriggerActiveInfo.placeTriggerInFrontOfCharacter || placeTriggerInFrontOfCharacterOnAllAttacksResult) {
                                        newParent = parentToPlaceTriggerInFrontOfCharacter;

                                        if (newParent == null) {
                                            newParent = playerControllerGameObject.transform;
                                        }
                                    } else {
                                        newParent = getCharacterHumanBone (currentdamageTriggerActiveInfo.limbToPlaceTrigger);
                                    }

                                    if (newParent != null) {
                                        attackHitCombat.transform.SetParent (newParent);
                                        attackHitCombat.transform.localPosition = Vector3.zero;
                                        attackHitCombat.transform.localRotation = Quaternion.identity;

                                        Transform raycastCheckTransformParent = currentMeleeWeapon.raycastCheckTransformParent;
                                        raycastCheckTransformParent.SetParent (attackHitCombat.transform);
                                        raycastCheckTransformParent.localPosition = Vector3.zero;
                                        raycastCheckTransformParent.localRotation = Quaternion.identity;

                                        hitCombatParentChanged = true;
                                    }
                                } else {
                                    if (hitCombatParentChanged) {
                                        attackHitCombat.transform.SetParent (objectRotationPoint);
                                        attackHitCombat.transform.localPosition = originalHitCombatColliderPosition;
                                        attackHitCombat.transform.localRotation = Quaternion.identity;

                                        Transform raycastCheckTransformParent = currentMeleeWeapon.raycastCheckTransformParent;
                                        raycastCheckTransformParent.SetParent (objectRotationPoint);
                                        raycastCheckTransformParent.localPosition = Vector3.zero;
                                        raycastCheckTransformParent.localRotation = Quaternion.identity;

                                        hitCombatParentChanged = false;
                                    }
                                }

                                if (currentdamageTriggerActiveInfo.useEventOnAttack) {
                                    currentdamageTriggerActiveInfo.eventOnAtatck.Invoke ();
                                }

                                if (currentdamageTriggerActiveInfo.useRangeAttackID && currentGrabbedWeaponInfo.useRangeAttackID) {

                                    int rangeAttackID = currentdamageTriggerActiveInfo.rangeAttackID;

                                    int rangeAttackInfoListCount = currentGrabbedWeaponInfo.rangeAttackInfoList.Count;

                                    for (int k = 0; k < rangeAttackInfoListCount; k++) {
                                        if (currentGrabbedWeaponInfo.rangeAttackInfoList [k].rangeAttackID == rangeAttackID) {
                                            currentGrabbedWeaponInfo.rangeAttackInfoList [k].eventOnRangeAttack.Invoke ();
                                        }
                                    }
                                }

                                if (currentdamageTriggerActiveInfo.disableRangeAttackID && currentGrabbedWeaponInfo.useRangeAttackID) {

                                    int rangeAttackID = currentdamageTriggerActiveInfo.rangeAttackIDToDisable;

                                    int rangeAttackInfoListCount = currentGrabbedWeaponInfo.rangeAttackInfoList.Count;

                                    for (int k = 0; k < rangeAttackInfoListCount; k++) {
                                        if (currentGrabbedWeaponInfo.rangeAttackInfoList [k].rangeAttackID == rangeAttackID) {
                                            currentGrabbedWeaponInfo.rangeAttackInfoList [k].eventOnDisableRangeAttack.Invoke ();
                                        }
                                    }
                                }

                                if (activateDamageTrigger) {
                                    checkingNoDamageDetectionOnDualWieldTriggerActive = !enableMainHitCombat;

                                    checkSurfaceFoundOnAttack (false);

                                    if (currentMeleeWeapon.useEventsOnAllAttacks) {
                                        currentMeleeWeapon.checkEventOnAttackStartAndEnd (true);
                                    }
                                } else {
                                    if (currentMeleeWeapon.useEventsOnAllAttacks) {
                                        currentMeleeWeapon.checkEventOnAttackStartAndEnd (false);
                                    }
                                }

                                detectedObjectsOnReturn.Clear ();
                            } else {
                                if (checkSurfacesWithCapsuleRaycastEnabled) {
                                    if (currentdamageTriggerActiveInfo.checkSurfacesWithCapsuleRaycast &&
                                        currentdamageTriggerActiveInfo.activateDamageTrigger) {
                                        checkSurfacesDetectedRaycast (currentdamageTriggerActiveInfo.checkSurfaceCapsuleRaycastRadius, enableMainHitCombat);

                                        int hitsLength = hits.Length;

                                        if (hitsLength > 0) {
                                            for (int j = 0; j < hitsLength; j++) {
                                                GameObject currentObject = hits [j].collider.gameObject;

                                                if (!detectedObjectsOnReturn.Contains (currentObject)) {
                                                    attackHitCombat.checkTriggerInfo (hits [j].collider, true);

                                                    detectedObjectsOnReturn.Add (currentObject);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                yield return null;
            }

            yield return null;
        }

        damageTriggerInProcess = false;
    }

    public Transform getCharacterHumanBone (HumanBodyBones boneToFind)
    {
        return mainPlayerController.getCharacterHumanBone (boneToFind);
    }

    public Transform getCurrentGrabbedObjectTransform ()
    {
        return currentGrabbedObjectTransform;
    }

    public string getCurrentMeleeWeaponTypeName ()
    {
        if (currentGrabbedWeaponInfo != null) {
            return currentGrabbedWeaponInfo.Name;
        }

        return "";
    }

    public string getCurrentMeleeWeaponName ()
    {
        if (currentGrabbedWeaponInfo != null && currentMeleeWeapon != null) {
            return currentMeleeWeapon.getWeaponName ();
        }

        return "";
    }

    public bool canWeaponsBeStolenFromCharacter ()
    {
        return weaponsCanBeStolenFromCharacter;
    }

    public void setCanWeaponsBeStolenFromCharacter (bool state)
    {
        weaponsCanBeStolenFromCharacter = state;
    }

    public bool isSecondaryAbilityActiveOnCurrentWeapon ()
    {
        if (currentGrabbedWeaponInfo != null && currentMeleeWeapon != null) {
            return currentMeleeWeapon.isSecondaryAbilityActive ();
        }

        return false;
    }

    public void disableCurrentAttackInProcess ()
    {
        if (attackInProcess) {
            stopActivateGrabbedObjectMeleeAttackCoroutine ();

            stopActivateDamageTriggerCoroutine ();

            currentHitCombat.setCurrentState (false);

            currentHitCombat.setIgnoreDetectedObjectsOnListState (false);

            if (currentAttackInfo != null) {
                if (currentAttackInfo.useEventOnCancelAttack) {
                    currentAttackInfo.eventOnCancelAtatck.Invoke ();
                }
            }

            if (isDualWieldWeapon) {
                stopActivateDamageDualWieldTriggerCoroutine ();

                dualWieldHitCombat.setCurrentState (false);

                dualWieldHitCombat.setIgnoreDetectedObjectsOnListState (false);
            }

            checkSetArmorActiveState (false);

            lastTimeAttackComplete = Time.time;

            resumeState ();

            blockActivePreviously = false;
        }

        if (useThrowReturnMeleeWeaponSystemEnabled) {
            if (objectThrown) {
                if (!mainMeleeCombatThrowReturnWeaponSystem.isContinueObjecThrowActivated () &&
                    !mainMeleeCombatThrowReturnWeaponSystem.isObjectThrownTravellingToTarget ()) {
                    if (useThrowReturnMeleeWeaponSystemEnabled) {
                        mainMeleeCombatThrowReturnWeaponSystem.cancelThrowObject ();
                    }
                }
            }
        }
    }

    void checkSetArmorActiveState (bool state)
    {
        if (deflectProjectilesEnabled) {
            currentMeleeWeapon.mainArmoreSurfaceSystem.setArmorActiveState (state);

            if (state) {
                currentMeleeWeapon.setRegularDeflectProjectilesTriggerScaleValues ();
            }
        }
    }

    void checkSetArmorActiveOnBlockState (bool state)
    {
        if (deflectProjectilesOnBlockEnabled) {
            if (currentMeleeWeapon.useDurationToDeflectProjectilesOnBlock) {
                currentMeleeWeapon.mainArmoreSurfaceSystem.setEnableArmorSurfaceStateWithDuration (
                    currentMeleeWeapon.durationToDeflecltProjectilesOnBlock, state, false);
            } else {
                currentMeleeWeapon.mainArmoreSurfaceSystem.setArmorActiveState (state);
            }

            if (state) {
                currentMeleeWeapon.setBlockDeflectProjectilesTriggerScaleValues ();
            }
        }
    }

    public void checkDurabilityOnAttackOnCurrentWeapon (bool ignoreDurability, float extraDurabilityMultiplier)
    {
        if (!checkDurabilityOnAttackEnabled) {
            return;
        }

        if (!ignoreDurability) {
            if (extraDurabilityMultiplier == 0) {
                extraDurabilityMultiplier = generalAttackDurabilityMultiplier;
            } else {
                extraDurabilityMultiplier *= generalAttackDurabilityMultiplier;
            }

            if (currentMeleeWeapon.checkDurabilityOnAttack (extraDurabilityMultiplier)) {
                if (useEventOnDurabilityEmptyOnMeleeWeapon) {
                    eventOnDurabilityEmptyOnMeleeWeapon.Invoke ();
                }

                if (currentGrabbedWeaponInfo != null && currentGrabbedWeaponInfo.useEventOnEmptyDurability) {
                    currentGrabbedWeaponInfo.eventOnEmptyDurability.Invoke ();
                }
            }
        }
    }

    public void repairObjectFully (string weaponName)
    {
        mainMeleeWeaponsGrabbedManager.repairObjectFully (weaponName);
    }

    //START OF BLOCK FUNCTIONS
    public void checkDurabilityOnBlock ()
    {
        if (carryingObject) {
            if (checkDurabilityOnBlockEnabled) {
                if (shieldActive) {
                    if (mainMeleeWeaponsGrabbedManager.checkDurabilityOnBlockWithShield (generalBlockDurabilityMultiplier)) {
                        if (useEventOnDurabilityEmptyOnBlock) {
                            eventOnDurabilityEmptyOnBlock.Invoke ();
                        }
                    }
                } else {
                    if (currentMeleeWeapon.checkDurabilityOnBlock (generalBlockDurabilityMultiplier)) {
                        if (useEventOnDurabilityEmptyOnBlock) {
                            eventOnDurabilityEmptyOnBlock.Invoke ();
                        }
                    }
                }
            }
        }
    }

    public void checkOnAttackBlocked ()
    {
        if (carryingObject) {
            if (currentGrabbedWeaponInfo.getHealthFromBlocks) {
                float totalHealthAmount = currentGrabbedWeaponInfo.healthAmountFromBlocks;

                if (totalHealthAmount > 0 && !mainHealth.checkIfMaxHealth ()) {

                    mainHealth.getHealth (totalHealthAmount);
                }
            }
        }
    }

    public void checkOnAttackBlockedPerfectly ()
    {
        if (carryingObject) {
            bool getHealthFromPerfectBlocksResult = currentGrabbedWeaponInfo.getHealthFromPerfectBlocks || getHealthFromPerfectBlocksActive;

            if (getHealthFromPerfectBlocksResult) {
                float totalHealthAmount = 0;

                if (currentGrabbedWeaponInfo.getHealthFromPerfectBlocks) {
                    totalHealthAmount = currentGrabbedWeaponInfo.healthAmountFromPerfectBlocks;
                }

                if (getHealthFromPerfectBlocksActive) {
                    totalHealthAmount = healthAmountFromPerfectBlocksValue;
                }

                if (totalHealthAmount > 0 && !mainHealth.checkIfMaxHealthWithHealthManagement ()) {

                    mainHealth.setHealWithHealthManagement (totalHealthAmount);
                }
            }

            if (useEventOnAttackBlockedPerfectly) {
                eventOnAttackBlockedPerfectly.Invoke ();
            }
        }
    }

    public void setGetHealthFromPerfectBlocksActiveState (bool state)
    {
        getHealthFromPerfectBlocksActive = state;
    }

    public void setHealthAmountFromPerfectBlocksValue (float newValue)
    {
        healthAmountFromPerfectBlocksValue = newValue;
    }

    void checkDisableHasExitTimeAnimator ()
    {
        if (disableHasExitTimeCoroutine != null) {
            StopCoroutine (disableHasExitTimeCoroutine);
        }

        disableHasExitTimeCoroutine = StartCoroutine (checkDisablehasExitTimeAnimatorCoroutine ());
    }

    IEnumerator checkDisablehasExitTimeAnimatorCoroutine ()
    {
        mainAnimator.SetBool (cancelBlockReactionStateName, true);

        WaitForSeconds delay = new WaitForSeconds (0.2f);

        yield return delay;

        mainAnimator.SetBool (cancelBlockReactionStateName, false);
    }

    //CALLED ON DODGE/ROLL ACTION SYSTEM
    public void checkIfBlockInputIsCurrentlyInUse ()
    {
        //		print ("check if block input is in use");
        if (playerInput.isKeyboardButtonPressed (mainMeleeCombatAxesInputName, mainMeleeCombatBlockInputName)) {
            if (showDebugPrint) {
                print ("block is being pressed");
            }
        } else {
            if (showDebugPrint) {
                print ("block is not being pressed, disabling block");
            }

            disableBlockStateInProcess ();
        }
    }

    public void disableBlockStateInProcess ()
    {
        if (blockActive) {
            blockActivePreviously = false;

            setBlockActiveState (false);
        }
    }

    public void disableBlockActiveState ()
    {
        inputDeactivateBlock ();
    }

    public void checkEventsOnBlockDamage (bool state)
    {
        if (useEventsOnBlockDamage) {
            if (state) {
                eventOnBlockActivate.Invoke ();
            } else {
                eventOnBlockDeactivate.Invoke ();
            }
        }
    }

    public void checkEventsToUpdateCharacterSurfaceOnBlockStateChange ()
    {
        if (!carryingObject) {
            return;
        }

        if (blockActive) {
            eventToUpdateCharacterSurfaceOnBlockOn.Invoke ();
        } else {
            eventToUpdateCharacterSurfaceOnBlockOff.Invoke ();
        }
    }

    IEnumerator disableMeleeAttackInputPausedStateWithDurationCoroutine (float pauseDuration)
    {
        meleeAttackInputPaused = true;

        mainGrabObjects.setGrabObjectsInputPausedState (true);

        WaitForSeconds delay = new WaitForSeconds (pauseDuration);

        yield return delay;

        mainGrabObjects.setGrabObjectsInputPausedState (false);

        meleeAttackInputPaused = false;
    }

    public void checkIfBlockActive ()
    {
        if (blockActive) {
            setBlockActiveState (true);
        }
    }

    bool canBlockWithCurrentWeapon ()
    {
        bool setBlockActiveResult = false;

        if (shieldActive) {
            if (currentGrabbedWeaponInfo.weaponCanUseShield) {
                setBlockActiveResult = true;
            }
        } else {
            if (currentMeleeWeapon.canUseBlock) {
                setBlockActiveResult = true;
            }
        }

        return setBlockActiveResult;
    }

    public void setBlockActiveState (bool state)
    {
        bool setBlockActiveResult = canBlockWithCurrentWeapon ();

        if (setBlockActiveResult) {
            if (state) {
                if (shieldActive && currentGrabbedWeaponInfo.weaponCanUseShield) {
                    if (mainPlayerController.isStrafeModeActive ()) {
                        if (currentGrabbedWeaponInfo.strafeMovementBlockShieldID > 0) {
                            mainPlayerController.setCurrentStrafeIDValue (currentGrabbedWeaponInfo.strafeMovementBlockShieldID);
                        }
                    } else {
                        if (currentGrabbedWeaponInfo.regularMovementBlockShieldActionName != "") {
                            mainPlayerController.activateCustomAction (currentGrabbedWeaponInfo.regularMovementBlockShieldActionName);
                        }
                    }
                } else {
                    mainPlayerController.activateCustomAction (currentMeleeWeapon.blockActionName);

                    mainPlayerController.setCurrentStrafeIDValue (currentGrabbedWeaponInfo.strafeIDUsed);
                }

                mainHealth.setBlockDamageActiveState (true);

                if (shieldActive) {
                    if (reducedBlockDamageProtectionActive) {
                        mainHealth.setBlockDamageProtectionAmount (shieldReducedBlockDamageProtectionAmount *
                        generalBlockProtectionMultiplier);
                    } else {
                        mainHealth.setBlockDamageProtectionAmount (shieldBlockDamageProtectionAmount *
                        generalBlockProtectionMultiplier);
                    }

                    mainHealth.setBlockDamageRangleAngleState (shieldUseMaxBlockRangeAngle,
                        shieldMaxBlockRangeAngle);
                } else {
                    if (reducedBlockDamageProtectionActive) {
                        mainHealth.setBlockDamageProtectionAmount (currentMeleeWeapon.reducedBlockDamageProtectionAmount *
                        generalBlockProtectionMultiplier);
                    } else {
                        mainHealth.setBlockDamageProtectionAmount (currentMeleeWeapon.blockDamageProtectionAmount *
                        generalBlockProtectionMultiplier);
                    }

                    mainHealth.setBlockDamageRangleAngleState (currentMeleeWeapon.useMaxBlockRangeAngle,
                        currentMeleeWeapon.maxBlockRangeAngle);
                }

                if (shieldActive) {
                    if (mainPlayerController.isStrafeModeActive ()) {
                        mainHealth.setHitReactionBlockIDValue (currentGrabbedWeaponInfo.shieldIDStrafeMovement);
                    } else {
                        mainHealth.setHitReactionBlockIDValue (currentGrabbedWeaponInfo.shieldIDFreeMovement);
                    }
                } else {
                    mainHealth.setHitReactionBlockIDValue (currentMeleeWeapon.blockID);
                }

                blockActive = true;

                //print (blockActive);

                checkEventsOnBlockDamage (true);

                checkSetArmorActiveOnBlockState (true);

            } else {
                disableBlockState ();
            }
        }

        updateShieldStateOnAnimator ();
    }

    public void updateRegularBlockDamageProtectionValue ()
    {
        setBlockDamageProtectionValue (false);
    }

    public void updateReducedBlockDamageProtectionValue ()
    {
        setBlockDamageProtectionValue (true);
    }

    public void setBlockDamageProtectionValue (bool state)
    {
        reducedBlockDamageProtectionActive = state;

        if (blockActive) {
            if (!carryingObject) {
                return;
            }

            bool setBlockActiveResult = canBlockWithCurrentWeapon ();

            if (setBlockActiveResult) {
                if (shieldActive) {
                    if (reducedBlockDamageProtectionActive) {
                        mainHealth.setBlockDamageProtectionAmount (shieldReducedBlockDamageProtectionAmount *
                        generalBlockProtectionMultiplier);
                    } else {
                        mainHealth.setBlockDamageProtectionAmount (shieldBlockDamageProtectionAmount *
                        generalBlockProtectionMultiplier);
                    }
                } else {
                    if (reducedBlockDamageProtectionActive) {
                        mainHealth.setBlockDamageProtectionAmount (currentMeleeWeapon.reducedBlockDamageProtectionAmount *
                        generalBlockProtectionMultiplier);
                    } else {
                        mainHealth.setBlockDamageProtectionAmount (currentMeleeWeapon.blockDamageProtectionAmount *
                        generalBlockProtectionMultiplier);
                    }
                }
            }
        }
    }

    void disableBlockState ()
    {
        if (shieldActive && currentGrabbedWeaponInfo.weaponCanUseShield) {
            if (mainPlayerController.isStrafeModeActive ()) {
                if (currentGrabbedWeaponInfo.strafeMovementBlockShieldID > 0) {
                    mainPlayerController.setCurrentStrafeIDValue (currentGrabbedWeaponInfo.strafeIDUsed);
                }
            } else {
                if (currentGrabbedWeaponInfo.regularMovementBlockShieldActionName != "") {
                    mainPlayerController.stopCustomAction (currentGrabbedWeaponInfo.regularMovementBlockShieldActionName);
                }
            }
        } else {
            mainPlayerController.stopCustomAction (currentMeleeWeapon.blockActionName);
        }

        mainHealth.setBlockDamageActiveState (false);

        blockActive = false;

        checkEventsOnBlockDamage (false);

        mainHealth.setHitReactionBlockIDValue (-1);

        checkSetArmorActiveOnBlockState (false);
    }

    void updateBlockShieldState ()
    {
        //		print ("idhsidhs " + shieldActive + "  " + blockActive + "  " + currentGrabbedWeaponInfo.weaponCanUseShield);
        if (shieldActive && blockActive && currentGrabbedWeaponInfo.weaponCanUseShield) {
            mainPlayerController.updateStrafeModeActiveState ();

            //			print (mainPlayerController.isLookAlwaysInCameraDirectionActive ());

            if (mainPlayerController.isLookAlwaysInCameraDirectionActive ()) {
                if (currentGrabbedWeaponInfo.regularMovementBlockShieldActionName != "") {
                    mainPlayerController.stopCustomAction (currentGrabbedWeaponInfo.regularMovementBlockShieldActionName);
                }

                if (currentGrabbedWeaponInfo.strafeMovementBlockShieldID > 0) {
                    mainPlayerController.setCurrentStrafeIDValue (currentGrabbedWeaponInfo.strafeMovementBlockShieldID);
                }

                mainHealth.setHitReactionBlockIDValue (currentGrabbedWeaponInfo.shieldIDStrafeMovement);
            } else {
                if (currentGrabbedWeaponInfo.regularMovementBlockShieldActionName != "") {
                    mainPlayerController.activateCustomAction (currentGrabbedWeaponInfo.regularMovementBlockShieldActionName);
                }

                if (currentGrabbedWeaponInfo.strafeMovementBlockShieldID > 0) {
                    mainPlayerController.setCurrentStrafeIDValue (currentGrabbedWeaponInfo.strafeIDUsed);
                }

                mainHealth.setHitReactionBlockIDValue (currentGrabbedWeaponInfo.shieldIDFreeMovement);
            }
        }
    }

    public void disableBlockInputPausedStateWithDuration (float pauseDuration)
    {
        stopDisableBlockInputPausedStateWithDurationCoroutine ();

        pauseBlockInputCoroutine = StartCoroutine (disableBlockInputPausedStateWithDurationCoroutine (pauseDuration));
    }

    void stopDisableBlockInputPausedStateWithDurationCoroutine ()
    {
        if (pauseBlockInputCoroutine != null) {
            StopCoroutine (pauseBlockInputCoroutine);
        }
    }

    IEnumerator disableBlockInputPausedStateWithDurationCoroutine (float pauseDuration)
    {
        blockInputPaused = true;

        mainGrabObjects.setGrabObjectsInputPausedState (true);

        WaitForSeconds delay = new WaitForSeconds (pauseDuration);

        yield return delay;

        mainGrabObjects.setGrabObjectsInputPausedState (false);

        blockInputPaused = false;

        if (blockActivePreviously) {
            blockActivePreviously = false;

            delay = new WaitForSeconds (0.3f);

            yield return delay;

            setBlockActiveState (true);
        }
    }


    public void setBlockInputPausedState (bool state)
    {
        blockInputPaused = state;
    }

    public void setCanCancelBlockToStartAttackActiveState (bool state)
    {
        canCancelBlockToStartAttackActive = state;
    }
    //END OF BLOCK FUNCTIONS


    float shieldBlockDamageProtectionAmount;
    float shieldReducedBlockDamageProtectionAmount;
    bool shieldUseMaxBlockRangeAngle;
    float shieldMaxBlockRangeAngle;

    //START SHIELD FUNCTIONS
    public void setShieldProtectionValues (float blockDamageProtectionAmount, float reducedBlockDamageProtectionAmount,
                                           bool useMaxBlockRangeAngleValue, float maxBlockRangeAngleAmount)
    {
        shieldBlockDamageProtectionAmount = blockDamageProtectionAmount;
        shieldReducedBlockDamageProtectionAmount = reducedBlockDamageProtectionAmount;
        shieldUseMaxBlockRangeAngle = useMaxBlockRangeAngleValue;
        shieldMaxBlockRangeAngle = maxBlockRangeAngleAmount;
    }

    public void setShieldActiveState (bool state)
    {
        shieldActive = state;

        //		print ("shield state " + shieldActive + " " + carryingObject);

        if (!carryingObject) {
            if (mainMeleeWeaponsGrabbedManager.isCurrentMeleeWeaponSheathedOrCarried ()) {
                shieldActive = false;
            } else {
                if (shieldCanBeUsedWithoutMeleeWeapon) {
                    if (showDebugPrint) {
                        print ("not carrying melee weapon, using shield without weapon");
                    }

                    bool emptyMeleeWeaponForShieldFound = false;

                    int grabbedWeaponInfoListCount = grabbedWeaponInfoList.Count;

                    for (int i = 0; i < grabbedWeaponInfoListCount; i++) {
                        if (grabbedWeaponInfoList [i].isEmptyWeaponToUseOnlyShield) {
                            if (!grabbedObjectMeleeAttackActive) {
                                eventToActivateMeleeModeWhenUsingShieldWithoutMeleeWeapon.Invoke ();
                            }

                            mainMeleeWeaponsGrabbedManager.checkMeleeWeaponToUse (grabbedWeaponInfoList [i].Name, false);

                            emptyMeleeWeaponForShieldFound = true;
                        }
                    }

                    updateShieldStateOnAnimator ();

                    if (emptyMeleeWeaponForShieldFound) {
                        return;
                    }
                } else {
                    shieldActive = false;
                }
            }
        }

        if (currentGrabbedWeaponInfo != null && !currentGrabbedWeaponInfo.weaponCanUseShield) {
            shieldActive = false;
        }

        if (currentShieldGameObject != null) {
            bool setShieldMeshActiveResult = false;

            if (state) {
                setShieldMeshActiveResult = true;
            } else {
                if (checkingSetShieldActiveIfCarryingShield) {
                    if (!shieldActive) {
                        setShieldMeshActiveResult = false;
                    }
                } else {
                    setShieldMeshActiveResult = !mainMeleeWeaponsGrabbedManager.checkIfHideShieldMeshWhenNotUsedByName (currentShieldName);
                }
            }

            if (currentShieldGameObject.activeSelf != setShieldMeshActiveResult) {
                currentShieldGameObject.SetActive (setShieldMeshActiveResult);
            }

            if (shieldActive) {
                setShieldParentState (true);
            }
        }

        updateShieldStateOnAnimator ();
    }

    public string getEmptyWeaponToUseOnlyShield ()
    {
        int grabbedWeaponInfoListCount = grabbedWeaponInfoList.Count;

        for (int i = 0; i < grabbedWeaponInfoListCount; i++) {
            if (grabbedWeaponInfoList [i].isEmptyWeaponToUseOnlyShield) {
                return grabbedWeaponInfoList [i].Name;
            }
        }

        return "";
    }

    public void setShieldActiveFieldValueDirectly (bool state)
    {
        shieldActive = state;

        updateShieldStateOnAnimator ();
    }

    void updateShieldStateOnAnimator ()
    {
        if (blockActive) {
            if (shieldActive) {
                mainPlayerController.setCurrentShieldActiveValue (2);
            } else {
                mainPlayerController.setCurrentShieldActiveValue (0);
            }
        } else {
            if (shieldActive) {
                mainPlayerController.setCurrentShieldActiveValue (1);
            } else {
                mainPlayerController.setCurrentShieldActiveValue (0);
            }
        }

        //print (blockActive + " " + shieldActive);
    }

    public void drawOrSheatheShield (bool state)
    {
        if (carryingShield) {
            if (currentShieldGameObject != null) {

                bool setShieldMeshActiveResult = false;

                if (state) {
                    setShieldMeshActiveResult = true;
                } else {
                    setShieldMeshActiveResult = !mainMeleeWeaponsGrabbedManager.checkIfHideShieldMeshWhenNotUsedByName (currentShieldName);
                }

                if (currentShieldGameObject.activeSelf != setShieldMeshActiveResult) {
                    currentShieldGameObject.SetActive (setShieldMeshActiveResult);
                }

                if (shieldActive) {
                    setShieldParentState (state);
                }

                if (blockActive) {
                    disableShieldBlockActive ();
                }
            }
        }
    }

    public void setUseRightHandMountPointForShieldActiveState (bool state)
    {
        useRightHandMountPointForShieldActive = state;
    }

    public void setShieldParentState (bool state)
    {
        if (state) {
            if (useRightHandMountPointForShieldActive) {
                currentShieldGameObject.transform.SetParent (shieldRightHandMountPoint);
            } else {
                currentShieldGameObject.transform.SetParent (shieldLeftHandMountPoint);
            }

            currentShieldGameObject.transform.localPosition = currentShieldHandMountPointTransformReference.localPosition;
            currentShieldGameObject.transform.localRotation = currentShieldHandMountPointTransformReference.localRotation;
        } else {
            currentShieldGameObject.transform.SetParent (shieldBackMountPoint);

            currentShieldGameObject.transform.localPosition = currentShieldBackMountPointTransformReference.localPosition;
            currentShieldGameObject.transform.localRotation = currentShieldBackMountPointTransformReference.localRotation;
        }
    }

    bool checkingSetShieldActiveIfCarryingShield;

    public void checkIfCarryingShieldActive ()
    {
        checkingSetShieldActiveIfCarryingShield = true;

        setShieldActiveState (carryingShield);

        checkingSetShieldActiveIfCarryingShield = false;
    }

    public void setShieldInfo (string newShieldName, GameObject newShieldGameObject, Transform newShieldHandMountPointTransformReference,
                               Transform newShieldBackMountPointTransformReference, bool shieldCarriedOnRightArm, bool state)
    {
        currentShieldName = newShieldName;

        currentShieldGameObject = newShieldGameObject;

        currentShieldHandMountPointTransformReference = newShieldHandMountPointTransformReference;

        currentShieldBackMountPointTransformReference = newShieldBackMountPointTransformReference;

        useRightHandMountPointForShieldActive = shieldCarriedOnRightArm;

        carryingShield = state;

        if (blockActive) {
            disableShieldBlockActive ();
        }

        if (!carryingShield) {
            if (carryingObject) {
                if (shieldCanBeUsedWithoutMeleeWeapon) {
                    if (currentGrabbedWeaponInfo.isEmptyWeaponToUseOnlyShield) {
                        mainMeleeWeaponsGrabbedManager.disableCurrentMeleeWeapon (currentGrabbedWeaponInfo.Name);

                        print ("removing empty weapon used only when carrying just the shield");
                    }
                }
            }
        }
    }

    void disableShieldBlockActive ()
    {
        setBlockActiveState (false);

        if (showDebugPrint) {
            print ("check disable shield block state");
        }
    }
    //END SHIELD FUNCTIONS

    public bool checkIfCanUseMeleeWeaponPrefabByName (string weaponName)
    {
        return mainMeleeWeaponsGrabbedManager.checkIfCanUseMeleeWeaponPrefabByName (weaponName);
    }

    public int getCurrentNumberOfWeaponsAvailable ()
    {
        return mainMeleeWeaponsGrabbedManager.getCurrentNumberOfWeaponsAvailable ();
    }

    public void dropMeleeWeaponsExternallyWithoutResult ()
    {
        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (!carryingObject) {
            return;
        }

        mainGrabObjects.dropObject ();
    }

    public void dropMeleeWeaponsExternallyWithoutResultAndDestroyIt ()
    {
        if (currentMeleeWeapon != null) {
            if (attackInProcess) {
                disableCurrentAttackInProcess ();

                mainPlayerController.stopAllActionsOnActionSystem ();
            }

            GameObject lastWeaponObject = currentMeleeWeapon.gameObject;

            dropMeleeWeaponsExternallyWithoutResult ();

            if (lastWeaponObject != null) {
                Destroy (lastWeaponObject);
            }
        }
    }

    public bool dropMeleeWeaponsExternally ()
    {
        if (!grabbedObjectMeleeAttackActive) {
            return false;
        }

        if (!carryingObject) {
            return false;
        }

        mainGrabObjects.dropObject ();

        return true;
    }

    public void drawNextWeaponAvailable ()
    {
        mainMeleeWeaponsGrabbedManager.drawNextWeaponAvailable ();
    }

    public void drawRandomWeaponFromPrefabList (string previousWeaponName)
    {
        mainMeleeWeaponsGrabbedManager.drawRandomWeaponFromPrefabList (previousWeaponName);
    }

    public void resetStartWithWeaponCheckedOnCharacterSpawn ()
    {
        mainMeleeWeaponsGrabbedManager.resetStartWithWeaponCheckedOnCharacterSpawn ();
    }

    void setOriginalHitCombatScale ()
    {
        setHitCombatScale (originalHitCombatColliderSize);
    }

    void setOriginalHitCombatOffset ()
    {
        setHitCombatOffset (originalHitCombatColliderCenter);
    }

    void setHitCombatScale (Vector3 newScale)
    {
        if (currentHitCombatBoxCollider != null) {
            currentHitCombatBoxCollider.size = newScale;
        }
    }

    void setHitCombatOffset (Vector3 newValue)
    {
        if (currentHitCombatBoxCollider != null) {
            currentHitCombatBoxCollider.center = newValue;
        }
    }

    public void resumeState ()
    {
        attackInProcess = false;

        mainPlayerController.setMeleeAttackInProcessState (false);

        cutActivatedOnAttackChecked = false;

        lastTimeCutActiveOnAttack = 0;

        damageTriggerInProcess = false;

        if (currentHitCombat != null) {
            currentHitCombat.setCurrentState (false);

            setHitCombatScale (originalHitCombatColliderSize);

            setHitCombatOffset (originalHitCombatColliderCenter);

            if (hitCombatParentChanged) {
                currentHitCombat.transform.SetParent (objectRotationPoint);
                currentHitCombat.transform.localPosition = originalHitCombatColliderPosition;
                currentHitCombat.transform.localRotation = Quaternion.identity;

                Transform raycastCheckTransformParent = currentMeleeWeapon.raycastCheckTransformParent;
                raycastCheckTransformParent.SetParent (objectRotationPoint);
                raycastCheckTransformParent.localPosition = Vector3.zero;
                raycastCheckTransformParent.localRotation = Quaternion.identity;

                hitCombatParentChanged = false;
            }


            if (isDualWieldWeapon) {
                dualWieldHitCombat.setCurrentState (false);

                mainDualWieldMeleeWeaponObjectSystem.setOriginalHitCombatScale ();

                mainDualWieldMeleeWeaponObjectSystem.setOriginalHitCombatOffset ();
            }

            checkSetArmorActiveState (false);
        }

        checkEventsOnAttack (false);

        mainGrabObjects.setGrabObjectsInputPausedState (false);

        currentWaitTimeToNextAttack = 0;
    }

    public void checkEventsOnAttack (bool state)
    {
        if (useEventsOnAttack) {
            if (state) {
                eventOnAttackStart.Invoke ();
            } else {
                eventOnAttackEnd.Invoke ();
            }
        }
    }

    public void checkEventWhenKeepingOrDrawingMeleeWeapon (bool state)
    {
        if ((carryingObject || state) && currentMeleeWeapon != null) {
            currentMeleeWeapon.checkEventWhenKeepingOrDrawingMeleeWeapon (state);

            if (currentGrabbedWeaponInfo != null) {

                if (currentGrabbedWeaponInfo.useEventsOnKeepOrDrawMeleeWeapon) {
                    if (state) {
                        currentGrabbedWeaponInfo.eventsOnKeepMeleeWeapon.Invoke ();
                    } else {
                        currentGrabbedWeaponInfo.eventsOnDrawMeleeWeapon.Invoke ();
                    }
                }
            }
        }
    }

    public void setRemoteEventOnCurrentMeleeWeapon (string remoteEventName)
    {
        if (carryingObject && currentMeleeWeapon != null) {
            remoteEventSystem currentRemoteEventSystem = currentMeleeWeapon.GetComponent<remoteEventSystem> ();

            if (currentRemoteEventSystem != null) {

                if (showDebugPrint) {
                    print ("remote event on weapon activated");
                }

                currentRemoteEventSystem.callRemoteEvent (remoteEventName);
            }
        }
    }

    public void setRemoteEventsOnCurrentMeleeWeapon (List<string> remoteEventNameList, GameObject weaponObject)
    {
        if (weaponObject != null) {
            remoteEventSystem currentRemoteEventSystem = weaponObject.GetComponent<remoteEventSystem> ();

            if (currentRemoteEventSystem != null) {

                if (showDebugPrint) {
                    print ("remote event on weapon activated");
                }

                int remoteEventNameListCount = remoteEventNameList.Count;

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

    public bool setDamageTypeAndReactionInfo (string newBuffObjectName)
    {
        if (carryingObject && currentMeleeWeapon != null) {
            return currentMeleeWeapon.setDamageTypeAndReactionInfo (newBuffObjectName);
        }

        return false;
    }

    public void activateReturnProjectilesOnContact ()
    {
        if (carryingObject && currentMeleeWeapon != null) {
            currentMeleeWeapon.sendReturnProjectilesOnContactInfo (playerControllerGameObject.transform, mainCameraTransform);

            if (currentGrabbedWeaponInfo.useEventsOnDeflectProjectile) {
                currentGrabbedWeaponInfo.eventsOnDeflectProjectile.Invoke ();
            }
        }
    }

    public void setNewMeleeWeaponAttackInfoTemplate (string templateName)
    {
        if (carryingObject && currentMeleeWeapon != null && currentGrabbedWeaponInfo.useMeleeWeaponAttackInfoList && !attackInProcess) {
            int templateIndex = currentGrabbedWeaponInfo.meleeWeaponAttackInfoList.FindIndex (a => a.Name == templateName);

            if (templateIndex > -1) {
                setAttackInfoTemplateByIndex (templateIndex);
            }
        }
    }

    int currentAttackInfoTemplateIndex = 0;

    public void setNextMeleeWeaponAttackInfoTemplate ()
    {
        if (carryingObject && currentMeleeWeapon != null && currentGrabbedWeaponInfo.useMeleeWeaponAttackInfoList && !attackInProcess) {
            currentAttackInfoTemplateIndex++;

            if (currentAttackInfoTemplateIndex >= currentGrabbedWeaponInfo.meleeWeaponAttackInfoList.Count) {
                currentAttackInfoTemplateIndex = 0;
            }

            setAttackInfoTemplateByIndex (currentAttackInfoTemplateIndex);
        }
    }

    void setAttackInfoTemplateByIndex (int newIndex)
    {
        currentAttackIndex = 0;

        currentAttackInfoTemplateIndex = newIndex;

        meleeWeaponAttackInfo currentMeleeWeaponAttackInfo = currentGrabbedWeaponInfo.meleeWeaponAttackInfoList [newIndex];

        currentMeleeWeapon.setNewMeleeWeaponAttackInfoTemplate (currentMeleeWeaponAttackInfo, false);

        currentMeleeWeapon.copyTemplateToWeaponAttackInfo (false);

        attackListCount = currentMeleeWeapon.getAttackListCount ();

        meleeWeaponInfo mainMeleeWeaponInfo = currentMeleeWeaponAttackInfo.mainMeleeWeaponInfo;

        if (mainMeleeWeaponInfo.setNewMovementValues) {
            if (mainMeleeWeaponInfo.setNewIdleID) {
                mainPlayerController.setCurrentIdleIDValue (mainMeleeWeaponInfo.idleIDUsed);
            } else {
                mainPlayerController.setCurrentIdleIDValue (0);
            }

            if (mainMeleeWeaponInfo.setNewCrouchID) {
                mainPlayerController.setCurrentCrouchIDValue (mainMeleeWeaponInfo.crouchIDUsed);
            } else {
                mainPlayerController.setCurrentCrouchIDValue (0);
            }

            if (mainMeleeWeaponInfo.setNewMovementID) {
                mainPlayerController.setPlayerStatusIDValue (mainMeleeWeaponInfo.movementIDUsed);
            } else {
                mainPlayerController.resetPlayerStatusID ();
            }

            mainPlayerController.setCurrentStrafeIDValue (mainMeleeWeaponInfo.strafeIDUsed);

            if (mainMeleeWeaponInfo.useStrafeMode && mainPlayerController.isPlayerMovingOn3dWorld ()) {
                mainPlayerController.activateOrDeactivateStrafeMode (true);

                setStrafeModeOnAISystemState (true);
            } else {
                currentMeleeWeapon.setPreviousStrafeModeState (false);

                mainPlayerController.activateOrDeactivateStrafeMode (false);
            }

            currentGrabbedWeaponInfo.activateStrafeModeOnLockOnTargetActive = mainMeleeWeaponInfo.activateStrafeModeOnLockOnTargetActive;

            if (mainMeleeWeaponInfo.toggleStrafeModeIfRunningActive) {
                mainPlayerController.setDisableStrafeModeExternallyIfIncreaseWalkSpeedActiveState (true);
            } else {
                mainPlayerController.setDisableStrafeModeExternallyIfIncreaseWalkSpeedActiveState (false);
            }

            if (mainMeleeWeaponInfo.setSprintEnabledStateWithWeapon) {
                if (!mainMeleeWeaponInfo.sprintEnabledStateWithWeapon && mainPlayerController.isPlayerRunning ()) {
                    mainPlayerController.stopSprint ();
                }

                mainPlayerController.setSprintEnabledState (mainMeleeWeaponInfo.sprintEnabledStateWithWeapon);
            } else {
                mainPlayerController.setOriginalSprintEnabledValue ();
            }
        }
    }

    public void inputSetNextMeleeWeaponAttackInfoTemplate ()
    {
        setNextMeleeWeaponAttackInfoTemplate ();
    }

    public void checkGrabbedWeaponInfoStateAtStart (string weaponInfoName, bool checkIfWeaponThrown)
    {
        currentGrabbedWeaponInfo = null;

        int grabbedWeaponInfoListCount = grabbedWeaponInfoList.Count;

        for (int i = 0; i < grabbedWeaponInfoListCount; i++) {
            if (grabbedWeaponInfoList [i].Name.Equals (weaponInfoName)) {
                currentGrabbedWeaponInfo = grabbedWeaponInfoList [i];

                if (useThrowReturnMeleeWeaponSystemEnabled) {
                    mainMeleeCombatThrowReturnWeaponSystem.setCurrentGrabbedWeaponInfo (currentGrabbedWeaponInfo);
                }

                bool setWeaponState = true;

                if (checkIfWeaponThrown && currentMeleeWeapon.isObjectThrown ()) {
                    setWeaponState = false;
                }

                if (setWeaponState) {
                    if (removeWeaponsFromManager) {
                        currentMeleeWeapon.setPreviousStrafeModeState (mainPlayerController.isStrafeModeActive ());

                        currentGrabbedWeaponInfo.previousStrafeMode = mainPlayerController.isStrafeModeActive ();
                    } else {
                        currentMeleeWeapon.setPreviousStrafeModeState (false);

                        currentGrabbedWeaponInfo.previousStrafeMode = false;

                        mainPlayerController.activateOrDeactivateStrafeMode (false);

                        setStrafeModeOnAISystemState (false);
                    }

                    if (currentGrabbedWeaponInfo.useStrafeMode && mainPlayerController.isPlayerMovingOn3dWorld ()) {
                        mainPlayerController.activateOrDeactivateStrafeMode (true);

                        setStrafeModeOnAISystemState (true);
                    } else {
                        if (!checkIfWeaponThrown) {
                            if (showDebugPrint) {
                                print ("checking strafe mode when returning thrown weapon");
                            }

                            currentMeleeWeapon.setPreviousStrafeModeState (false);

                            currentGrabbedWeaponInfo.previousStrafeMode = false;

                            mainPlayerController.activateOrDeactivateStrafeMode (false);
                        }
                    }

                    if (currentGrabbedWeaponInfo.toggleStrafeModeIfRunningActive) {
                        mainPlayerController.setDisableStrafeModeExternallyIfIncreaseWalkSpeedActiveState (true);
                    }

                    mainPlayerController.setCurrentStrafeIDValue (currentGrabbedWeaponInfo.strafeIDUsed);

                    if (currentGrabbedWeaponInfo.setNewIdleID) {
                        mainPlayerController.setCurrentIdleIDValue (currentGrabbedWeaponInfo.idleIDUsed);
                    }

                    if (currentGrabbedWeaponInfo.setNewCrouchID) {
                        mainPlayerController.setCurrentCrouchIDValue (currentGrabbedWeaponInfo.crouchIDUsed);
                    }

                    if (currentGrabbedWeaponInfo.setNewMovementID) {
                        mainPlayerController.setPlayerStatusIDValue (currentGrabbedWeaponInfo.movementIDUsed);
                    }

                    if (currentGrabbedWeaponInfo.setSprintEnabledStateWithWeapon) {
                        if (!currentGrabbedWeaponInfo.sprintEnabledStateWithWeapon && mainPlayerController.isPlayerRunning ()) {
                            mainPlayerController.stopSprint ();
                        }

                        mainPlayerController.setSprintEnabledState (currentGrabbedWeaponInfo.sprintEnabledStateWithWeapon);
                    }

                    if (currentGrabbedWeaponInfo.useEventsOnGrabDropObject) {
                        currentGrabbedWeaponInfo.eventOnGrabObject.Invoke ();
                    }

                    if (currentGrabbedWeaponInfo.useRemoteEventsOnGrabObject) {
                        setRemoteEventsOnCurrentMeleeWeapon (currentGrabbedWeaponInfo.remoteEventOnGrabObject, currentMeleeWeapon.gameObject);
                    }
                }
            }
        }
    }

    public void checkGrabbedWeaponInfoStateAtEnd ()
    {
        if (currentGrabbedWeaponInfo != null) {
            if (currentGrabbedWeaponInfo.setPreviousStrafeModeOnDropObject) {
                mainPlayerController.activateOrDeactivateStrafeMode (previousStrafeMode);

                setStrafeModeOnAISystemState (previousStrafeMode);
            }

            mainPlayerController.setCurrentStrafeIDValue (0);

            if (currentGrabbedWeaponInfo.setNewIdleID) {
                mainPlayerController.setCurrentIdleIDValue (0);
            }

            if (currentGrabbedWeaponInfo.setNewCrouchID) {
                mainPlayerController.setCurrentCrouchIDValue (0);
            }

            if (currentGrabbedWeaponInfo.setNewMovementID) {
                mainPlayerController.resetPlayerStatusID ();
            }

            if (currentGrabbedWeaponInfo.setSprintEnabledStateWithWeapon) {
                mainPlayerController.setOriginalSprintEnabledValue ();
            }

            if (currentGrabbedWeaponInfo.useEventsOnGrabDropObject) {
                currentGrabbedWeaponInfo.eventOnDropObject.Invoke ();
            }

            if (currentGrabbedWeaponInfo.toggleStrafeModeIfRunningActive) {
                mainPlayerController.setDisableStrafeModeExternallyIfIncreaseWalkSpeedActiveState (false);
            }

            if (currentGrabbedWeaponInfo.useRemoteEventsOnDropObject) {
                if (currentGrabbedObjectTransform != null) {
                    setRemoteEventsOnCurrentMeleeWeapon (currentGrabbedWeaponInfo.remoteEventOnDropObject, currentGrabbedObjectTransform.gameObject);
                }
            }
        }

        currentGrabbedWeaponInfo.previousStrafeMode = false;

        currentGrabbedWeaponInfo = null;
    }

    public void checkLookAtTargetActiveState ()
    {
        if (carryingObject && currentGrabbedWeaponInfo != null) {
            bool lookingAtTarget = mainPlayerController.isPlayerLookingAtTarget ();

            bool lockedCameraActive = mainPlayerController.isLockedCameraStateActive ();

            bool canSetStrafeMode = false;

            if (lockedCameraActive) {
                if (mainPlayerController.istargetToLookLocated ()) {
                    canSetStrafeMode = true;
                } else {
                    if (lookingAtTarget) {
                        canSetStrafeMode = true;

                        lookingAtTarget = false;
                    }
                }
            } else {
                canSetStrafeMode = true;
            }

            if (lookingAtTarget) {
                if (canSetStrafeMode) {
                    if (currentGrabbedWeaponInfo.activateStrafeModeOnLockOnTargetActive) {
                        mainPlayerController.activateOrDeactivateStrafeMode (true);

                        setStrafeModeOnAISystemState (true);
                    }
                }
            } else {
                if (canSetStrafeMode) {
                    if (currentGrabbedWeaponInfo.activateStrafeModeOnLockOnTargetActive) {
                        mainPlayerController.activateOrDeactivateStrafeMode (false);

                        setStrafeModeOnAISystemState (false);
                    }
                }
            }

            updateBlockShieldState ();
        }
    }

    public void checkLookAtTargetDeactivateState ()
    {
        if (carryingObject && currentGrabbedWeaponInfo != null) {
            if (currentGrabbedWeaponInfo.activateStrafeModeOnLockOnTargetActive) {
                mainPlayerController.activateOrDeactivateStrafeMode (false);

                setStrafeModeOnAISystemState (false);
            }

            updateBlockShieldState ();
        }
    }

    public void setStrafeModeOnAISystemState (bool state)
    {
        if (mainFindObjectivesSystem != null) {
            mainFindObjectivesSystem.setStrafeModeActive (state);
        }
    }

    public void setStrafeModeState (bool state, int strafeID)
    {
        mainPlayerController.activateOrDeactivateStrafeMode (state);

        mainPlayerController.setCurrentStrafeIDValue (strafeID);
    }

    public void setCurrentCrouchIDValue (int crouchID)
    {
        mainPlayerController.setCurrentCrouchIDValue (crouchID);
    }

    public bool isStrafeModeActive ()
    {
        return mainPlayerController.isStrafeModeActive ();
    }

    public int getCurrentStrafeID ()
    {
        return mainPlayerController.getCurrentStrafeIDValue ();
    }

    public int getCurrentCrouchID ()
    {
        return mainPlayerController.getCurrentCrouchIDValue ();
    }

    public bool isActionActive ()
    {
        return mainPlayerController.isActionActive ();
    }

    public void setObjectThrownState (bool state)
    {
        objectThrown = state;
    }



    void checkSurfacesDetectedRaycast (float capsuleRadius, bool enableMainHitCombat)
    {
        if (enableMainHitCombat) {
            currentRayOriginPosition = raycastCheckTransfrom.position;
            currentRayTargetPosition = currentRayOriginPosition + capsuleCastDistance * raycastCheckTransfrom.forward;
        } else {
            currentRayOriginPosition = mainDualWieldMeleeWeaponObjectSystem.raycastCheckTransfrom.position;
            currentRayTargetPosition = currentRayOriginPosition + capsuleCastDistance * raycastCheckTransfrom.forward;
        }

        distanceToTarget = GKC_Utils.distance (currentRayOriginPosition, currentRayTargetPosition);
        rayDirection = currentRayOriginPosition - currentRayTargetPosition;
        rayDirection = rayDirection / rayDirection.magnitude;

        if (showDebugDraw) {
            Debug.DrawLine (currentRayTargetPosition, (distanceToTarget * rayDirection) + currentRayTargetPosition, Color.red, 2);
        }

        point1 = currentRayOriginPosition - capsuleCastRadius * rayDirection;
        point2 = currentRayTargetPosition + capsuleCastRadius * rayDirection;

        hits = Physics.CapsuleCastAll (point1, point2, capsuleRadius, rayDirection, 0, currentHitCombat.layerMask);
    }

    public void setGrabbedObjectClonnedColliderEnabledState (bool state)
    {
        mainGrabObjects.setGrabbedObjectClonnedColliderEnabledState (state);
    }

    List<GameObject> detectedObjectsOnReturn = new List<GameObject> ();

    bool checkingDamageDetectionOnDualWieldTriggerActive;

    public void setDamageDetectedOnDualWieldTriggerById (int attackID)
    {
        checkingDamageDetectionOnDualWieldTriggerActive = true;

        checkingNoDamageDetectionOnDualWieldTriggerActive = true;

        setDamageDetectedOnTriggerById (attackID);

        checkingDamageDetectionOnDualWieldTriggerActive = false;
    }

    public void setDamageDetectedOnTriggerById (int attackID)
    {
        if (!carryingObject) {
            return;
        }

        if (currentGrabbedWeaponInfo.useEventsOnDamageDetected) {
            int eventOnDamageInfoListCount = currentGrabbedWeaponInfo.eventOnDamageInfoList.Count;

            for (int i = 0; i < eventOnDamageInfoListCount; i++) {
                eventOnDamageInfo currentEventOnDamageInfo = currentGrabbedWeaponInfo.eventOnDamageInfoList [i];

                if (currentEventOnDamageInfo.damageInfoID == attackID) {
                    currentEventOnDamageInfo.eventOnDamageDetected.Invoke ();

                    if (currentEventOnDamageInfo.useRemoteEvent) {
                        bool useRemoteEvents = false;

                        GameObject objectDetected = null;

                        if (checkingDamageDetectionOnDualWieldTriggerActive) {
                            objectDetected = dualWieldHitCombat.getLastSurfaceDetected ();
                        } else {
                            objectDetected = currentHitCombat.getLastSurfaceDetected ();
                        }

                        if (objectDetected != null) {

                            if (showDebugPrint) {
                                print ("object detected to set remote event");
                            }

                            if (currentGrabbedWeaponInfo.checkObjectsToUseRemoteEventsOnDamage) {
                                if ((1 << objectDetected.layer & currentGrabbedWeaponInfo.layerToUseRemoteEventsOnDamage.value) == 1 << objectDetected.layer) {
                                    useRemoteEvents = true;
                                }
                            } else {
                                useRemoteEvents = true;
                            }

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

                                if (currentRemoteEventSystem != null) {
                                    if (showDebugPrint) {
                                        print (currentRemoteEventSystem.name);
                                    }

                                    int remoteEventNameListCount = currentEventOnDamageInfo.remoteEventNameList.Count;

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

                    checkSurfaceFoundOnAttack (true);

                    checkingDamageDetectionOnDualWieldTriggerActive = false;

                    return;
                }
            }
        }

        checkSurfaceFoundOnAttack (true);

        checkingDamageDetectionOnDualWieldTriggerActive = false;
    }

    bool checkingNoDamageDetectionOnDualWieldTriggerActive;

    public void setNoDamageDetectedOnDualWieldTriggerById (GameObject objectDeteted)
    {
        checkingNoDamageDetectionOnDualWieldTriggerActive = true;

        checkSurfaceFoundOnAttack (true);
    }

    public void setNoDamageDetectedOnTriggerById (GameObject objectDetected)
    {
        checkSurfaceFoundOnAttack (true);
    }

    public void setPressDownState ()
    {
        if (currentGrabbedWeaponInfo != null && currentMeleeWeapon != null) {
            if (currentGrabbedWeaponInfo.useEventsOnPressDownState) {
                currentGrabbedWeaponInfo.eventOnPressDownState.Invoke ();
            }
        }
    }

    public void setPressUpState ()
    {
        if (currentGrabbedWeaponInfo != null && currentMeleeWeapon != null) {
            if (currentGrabbedWeaponInfo.useEventsOnPressUpState) {
                currentGrabbedWeaponInfo.eventOnPressUpState.Invoke ();
            }
        }
    }


    //Input functions
    public void inputSetPressDownState ()
    {
        if (showDebugPrint) {
            print ("input activated");
        }

        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (meleeAttackInputPaused) {
            return;
        }

        if (!canUseWeaponsInput ()) {
            return;
        }

        if (showDebugPrint) {
            print ("1");
        }

        if (objectThrown) {
            return;
        }

        if (cuttingModeActive) {
            return;
        }

        setPressDownState ();
    }

    public void inputSetPressUpState ()
    {
        if (showDebugPrint) {
            print ("input activated");
        }

        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (meleeAttackInputPaused) {
            return;
        }

        if (!canUseWeaponsInput ()) {
            return;
        }

        if (showDebugPrint) {
            print ("1");
        }

        if (objectThrown) {
            return;
        }

        if (cuttingModeActive) {
            return;
        }

        setPressUpState ();
    }


    public void inputActivateBlock ()
    {
        if (!blockModeEnabled) {
            return;
        }

        if (blockInputPaused) {
            return;
        }

        if (!canUseWeaponsInput ()) {
            return;
        }

        if (!grabbedObjectMeleeAttackActive) {
            blockActivePreviously = false;

            return;
        }

        if (objectThrown) {
            return;
        }

        if (cuttingModeActive) {
            return;
        }

        if (currentMeleeWeapon.keepGrabbedObjectState) {
            return;
        }

        if (attackInProcess) {
            blockActivePreviously = true;

            return;
        }

        if (blockActive) {
            return;
        }

        if (!mainPlayerController.isPlayerOnGround ()) {
            return;
        }

        setBlockActiveState (true);
    }

    public void inputDeactivateBlock ()
    {
        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (!canUseWeaponsInput ()) {
            return;
        }

        if (attackInProcess) {

            blockActivePreviously = false;

            return;
        }

        if (objectThrown) {
            return;
        }

        if (!blockActive) {
            return;
        }

        if (cuttingModeActive) {
            return;
        }

        setBlockActiveState (false);
    }

    public void inputSetNextExtraActionOnMeleeWeapon ()
    {
        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (objectThrown) {
            return;
        }

        if (meleeAttackInputPaused) {
            return;
        }

        if (!canUseWeaponsInput ()) {
            return;
        }

        if (cuttingModeActive) {
            return;
        }

        if (!currentMeleeWeapon.useExtraActions) {
            return;
        }

        currentMeleeWeapon.setNextExtraActionOnMeleeWeapon (mainRemoteEventSystem);

        if (showExtraActionIconTexture) {
            setCurrentExtraActionTexture (currentMeleeWeapon.getActionIconTexture ());
        }
    }

    void setCurrentExtraActionTexture (Texture currentExtraActionTexture)
    {
        if (showExtraActionIconTexture) {
            if (extraActionIconGameObject != null) {
                if (currentExtraActionTexture != null) {

                    if (!extraActionIconGameObject.activeSelf) {
                        extraActionIconGameObject.SetActive (true);
                    }

                    extraActionRawImage.texture = currentExtraActionTexture;
                } else {
                    if (extraActionIconGameObject.activeSelf) {
                        extraActionIconGameObject.SetActive (false);
                    }
                }
            }
        }
    }

    void disableExtraActionIconGameObject ()
    {
        if (showExtraActionIconTexture) {
            if (extraActionIconGameObject != null) {
                if (extraActionIconGameObject.activeSelf) {
                    extraActionIconGameObject.SetActive (false);
                }
            }
        }
    }

    public void enableExtraActionByName (string actionName)
    {
        enableOrDisableExtraActionByName (actionName, true);
    }

    public void disableExtraActionByName (string actionName)
    {
        enableOrDisableExtraActionByName (actionName, false);
    }

    public void enableOrDisableExtraActionByName (string actionName, bool state)
    {
        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (!carryingObject) {
            return;
        }

        if (!currentMeleeWeapon.useExtraActions) {
            return;
        }

        currentMeleeWeapon.enableOrDisableExtraActionByName (actionName, state);
    }

    public void inputActivateCurrentExtraActionOnMeleeWeapon ()
    {
        if (!throwWeaponActionPaused) {
            return;
        }

        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (meleeAttackInputPaused) {
            return;
        }

        if (!canUseWeaponsInput ()) {
            return;
        }

        if (objectThrown) {
            return;
        }

        if (cuttingModeActive) {
            return;
        }

        if (!currentMeleeWeapon.useExtraActions) {
            return;
        }

        if (currentMeleeWeapon.checkIfCarryingMeleeWeaponToActivateAction ()) {
            if (!carryingObject) {
                return;
            }
        }

        currentMeleeWeapon.activateCurrentExtraActionOnMeleeWeapon (mainRemoteEventSystem);
    }

    public void setThrowWeaponActionPausedState (bool state)
    {
        throwWeaponActionPaused = state;

        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setThrowWeaponActionPausedState (state);
        }
    }

    public void inputThrowOrReturnObject ()
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.inputThrowOrReturnObject ();
        }
    }

    public void inputPressDownThrowObject ()
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.inputPressDownThrowObject ();
        }
    }

    public void inputPressUpThrowObject ()
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.inputPressUpThrowObject ();
        }
    }

    public void inputEnableOrDisableCuttingMode ()
    {
        if (!grabbedObjectMeleeAttackActive) {
            return;
        }

        if (!canUseWeaponsInput ()) {
            return;
        }

        if (objectThrown) {
            return;
        }

        if (blockActive) {
            return;
        }

        if (attackInProcess) {
            return;
        }

        if (currentMeleeWeapon.canActivateCuttingMode) {
            enableOrDisableCuttingMode (!cuttingModeActive);
        }
    }

    public void inputActivateTeleport ()
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.inputActivateTeleport ();
        }
    }

    public void enableOrDisableCuttingMode (bool state)
    {
        if (!cuttingModeEnabled) {
            return;
        }

        cuttingModeActive = state;

        if (cuttingModeActive) {
            eventOnCuttingModeStart.Invoke ();
        } else {
            eventOnCuttingModeEnd.Invoke ();
        }

        if (shieldActive) {
            setShieldParentState (!cuttingModeActive);
        }
    }

    public void checkObjectsDetectedOnCuttingMode ()
    {
        if (cuttingModeActive) {
            List<GameObject> hitsGameObjectList = new List<GameObject> ();

            hitsGameObjectList = mainSliceSystem.getLastCollidersListDetected ();

            int hitsGameObjectListCount = hitsGameObjectList.Count;

            if (hitsGameObjectListCount > 0) {
                for (int i = 0; i < hitsGameObjectListCount; i++) {
                    string surfaceName = surfaceInfoOnMeleeAttackNameForSwingOnAir;

                    if (useCustomSurfaceInfoOnMeleeAttackNameForSwingOnAir) {
                        surfaceName = customSurfaceInfoOnMeleeAttackNameForSwingOnAir;
                    }

                    RaycastHit hit = new RaycastHit ();

                    Vector3 raycastPosition = playerControllerGameObject.transform.position + playerControllerGameObject.transform.up;

                    Vector3 raycastDirection = hitsGameObjectList [i].transform.position - raycastPosition;

                    raycastDirection = raycastDirection / raycastDirection.magnitude;

                    float currentRaycastDistance = GKC_Utils.distance (raycastPosition, hitsGameObjectList [i].transform.position);

                    currentRaycastDistance += 1;

                    Physics.Raycast (raycastPosition, raycastDirection, out hit, currentRaycastDistance, currentHitCombat.layerMask);

                    bool ignoreDurability = true;
                    float extraDurabilityMultiplier = 0;

                    meleeAttackSurfaceInfo currentMeleeAttackSurfaceInfo = hitsGameObjectList [i].GetComponent<meleeAttackSurfaceInfo> ();

                    bool sendSurfaceLocatedToCheck = true;

                    if (currentMeleeAttackSurfaceInfo != null) {
                        if (!currentMeleeAttackSurfaceInfo.isSurfaceEnabled ()) {
                            sendSurfaceLocatedToCheck = false;
                        } else {
                            surfaceName = currentMeleeAttackSurfaceInfo.getSurfaceName ();

                            currentMeleeAttackSurfaceInfo.checkEventOnSurfaceDetected ();
                        }

                        if (checkDurabilityOnAttackEnabled) {
                            if (!currentMeleeAttackSurfaceInfo.ignoreDurability) {
                                ignoreDurability = false;

                                extraDurabilityMultiplier = currentMeleeAttackSurfaceInfo.extraDurabilityMultiplier;
                            }
                        }
                    } else {
                        sendSurfaceLocatedToCheck = false;
                    }

                    if (sendSurfaceLocatedToCheck) {
                        checkSurfaceFoundOnAttackToProcess (surfaceName, true, hit.point, hit.normal, false, false);
                    }

                    checkDurabilityOnAttackOnCurrentWeapon (ignoreDurability, extraDurabilityMultiplier);
                }
            } else {
                checkSurfaceFoundOnAttack (false);
            }
        }
    }

    public void checkEventOnGrabDropObject (bool state)
    {
        checKEventsHideShowInventoryQuickAccessSlots (state);

        if (useEventsOnGrabDropObject) {
            if (state) {
                eventOnGrabObject.Invoke ();
            } else {
                eventOnDropObject.Invoke ();
            }
        }
    }

    public void checkEventsIfObjectGrabbed ()
    {
        if (carryingObject) {
            checkEventOnGrabDropObject (true);
        }
    }

    public void checKEventsHideShowInventoryQuickAccessSlots (bool state)
    {
        if (hideInventoryQuickAccessSlotsWhenCarryingMeleeWeapon) {
            if (state) {
                eventOnHideInventoryQuickAccessSlots.Invoke ();
            } else {
                eventOnShowInventoryQuickAccessSlots.Invoke ();
            }
        }
    }

    public void setThrowObjectEnabledState (bool state)
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setThrowObjectEnabledState (state);
        }
    }

    public void setReturnObjectEnabledState (bool state)
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setReturnObjectEnabledState (state);
        }
    }

    public void setApplyDamageOnSurfaceDetectedOnReturnEnabledState (bool state)
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setApplyDamageOnSurfaceDetectedOnReturnEnabledState (state);
        }
    }

    public void setApplyDamageOnObjectReturnPathEnabledState (bool state)
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setApplyDamageOnObjectReturnPathEnabledState (state);
        }
    }

    public void setGeneralDamageMultiplierOnObjectReturnValue (float newValue)
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setGeneralDamageMultiplierOnObjectReturnValue (newValue);
        }
    }

    public void setGeneralDamageMultiplierOnReturnPathValue (float newValue)
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setGeneralDamageMultiplierOnReturnPathValue (newValue);
        }
    }

    public void setGeneralDamageOnSurfaceDetectedOnThrowValue (float newValue)
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            mainMeleeCombatThrowReturnWeaponSystem.setGeneralDamageOnSurfaceDetectedOnThrowValue (newValue);
        }
    }

    public void setCuttingModeEnabledState (bool state)
    {
        cuttingModeEnabled = state;
    }

    public void setBlockModeEnabledState (bool state)
    {
        blockModeEnabled = state;
    }

    public void setGeneralBlockProtectionMultiplierValue (float newValue)
    {
        generalBlockProtectionMultiplier = newValue;
    }

    public void setUseStaminaOnAttackEnabledState (bool state)
    {
        useStaminaOnAttackEnabled = state;
    }

    public void setGeneralStaminaUseMultiplierValue (float newValue)
    {
        generalStaminaUseMultiplier = newValue;
    }

    public float getGeneralStaminaUseMultiplier ()
    {
        return generalStaminaUseMultiplier;
    }

    public void setGeneralAttackDamageMultiplierValue (float newValue)
    {
        generalAttackDamageMultiplier = newValue;
    }

    public void generalAttackDamageMultiplierIncreaseStat (float extraValue)
    {
        generalAttackDamageMultiplier += extraValue;
    }

    public void initializeGeneralAttackDamageMultiplierStatAmount (float newValue)
    {
        generalAttackDamageMultiplier = newValue;
    }

    public float getGeneralAttackDamageMultiplierValue ()
    {
        return generalAttackDamageMultiplier;
    }

    public bool isObjectThrownTravellingToTarget ()
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            return mainMeleeCombatThrowReturnWeaponSystem.isObjectThrownTravellingToTarget ();
        }

        return false;
    }

    public bool isAttackInProcess ()
    {
        return attackInProcess;
    }

    public bool isCuttingModeActive ()
    {
        return cuttingModeActive;
    }

    public void checkIfActivateParryStateIfAttackInProcess ()
    {
        if (useEventToActivateParryStateIfAttackInProcess) {
            //			print ("1");

            if (isCarryingObject ()) {

                //				print ("2 " + (isAttackInProcess ()) + " " + Mathf.Abs (Time.time - lastTimeAttackComplete));

                if (isAttackInProcess () || Time.time < lastTimeAttackComplete + 0.5f) {

                    //					print ("3 " + isAttackInProcess ());

                    eventToActivateParryStateIfAttackInProcess.Invoke ();
                }
            }
        }
    }

    public bool isBlockActive ()
    {
        return blockActive;
    }

    public bool canUseWeaponsInput ()
    {
        if (playerIsBusy ()) {
            return false;
        }

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

        return true;
    }

    public bool playerIsBusy ()
    {
        if (mainPlayerController.isUsingDevice ()) {
            return true;
        }

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

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

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

        return false;
    }

    public float getLastTimeObjectReturn ()
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            return mainMeleeCombatThrowReturnWeaponSystem.getLastTimeObjectReturn ();
        }

        return 0;
    }

    public float getLastTimeObjectThrown ()
    {
        if (useThrowReturnMeleeWeaponSystemEnabled) {
            return mainMeleeCombatThrowReturnWeaponSystem.getLastTimeObjectThrown ();
        }

        return 0;
    }

    public bool isCurrentWeaponThrown ()
    {
        return objectThrown;
    }

    public void setMeleeAttackInputPausedState (bool state)
    {
        meleeAttackInputPaused = state;
    }

    Coroutine pauseMeleeAttackInputCoroutine;

    public void disableMeleeAttackInputPausedStateWithDuration (float pauseDuration)
    {
        stopDisableMeleeAttackInputPausedStateWithDurationCoroutine ();

        pauseMeleeAttackInputCoroutine = StartCoroutine (disableMeleeAttackInputPausedStateWithDurationCoroutine (pauseDuration));
    }

    void stopDisableMeleeAttackInputPausedStateWithDurationCoroutine ()
    {
        if (pauseMeleeAttackInputCoroutine != null) {
            StopCoroutine (pauseMeleeAttackInputCoroutine);
        }
    }

    public bool isCarryingObject ()
    {
        return carryingObject;
    }

    public bool checkIfCurrentWeaponignoreUseIKOnHands ()
    {
        if (carryingObject) {
            return currentMeleeWeapon.ignoreUseIKOnHands;
        }

        return false;
    }

    public bool isCurrentWeaponIsCarriedOnRightHand ()
    {
        if (carryingObject) {
            return currentGrabPhysicalObjectSystem.useRightHand;
        }

        return false;
    }

    bool aimingBowActive;

    public bool isAimingBowActive ()
    {
        return aimingBowActive;
    }

    public void setAimBowState (bool state)
    {
        aimingBowActive = state;
    }

    public grabPhysicalObjectMeleeAttackSystem getCurrentGrabPhysicalObjectMeleeAttackSystem ()
    {
        return currentMeleeWeapon;
    }

    public void checkSurfaceFoundOnAttack (bool surfaceLocated)
    {
        if (!checkSurfaceInfoEnabled) {
            return;
        }

        if (objectThrown) {
            return;
        }

        cutActivatedOnAttackChecked = false;

        lastTimeCutActiveOnAttack = 0;

        string surfaceName = surfaceInfoOnMeleeAttackNameForSwingOnAir;

        if (useCustomSurfaceInfoOnMeleeAttackNameForSwingOnAir) {
            surfaceName = customSurfaceInfoOnMeleeAttackNameForSwingOnAir;
        }

        Vector3 attackPosition = Vector3.zero;
        Vector3 attackNormal = Vector3.zero;

        RaycastHit hit = new RaycastHit ();

        bool useMainHitCombat = true;

        if (checkingNoDamageDetectionOnDualWieldTriggerActive) {
            useMainHitCombat = false;
        }

        checkingNoDamageDetectionOnDualWieldTriggerActive = false;

        if (showDebugPrint) {
            print ("Surface located " + surfaceLocated + " using main hit combat " + useMainHitCombat);
        }

        bool ignoreDurability = true;
        float extraDurabilityMultiplier = 0;

        if (surfaceLocated) {
            GameObject lastSurfaceDetected = null;

            if (useMainHitCombat) {
                lastSurfaceDetected = currentHitCombat.getLastSurfaceDetected ();

                currentHitCombat.setLastSurfaceDetected (null);

                currentLayerMaskToCheck = currentHitCombat.layerMask;
            } else {
                lastSurfaceDetected = dualWieldHitCombat.getLastSurfaceDetected ();

                dualWieldHitCombat.setLastSurfaceDetected (null);

                currentLayerMaskToCheck = dualWieldHitCombat.layerMask;
            }

            GameObject surfaceFound = null;

            if (lastSurfaceDetected != null) {
                Collider lastSurfaceDetectedCollider = lastSurfaceDetected.GetComponent<Collider> ();

                Vector3 mainDamagePositionTransformPosition = currentMeleeWeapon.mainDamagePositionTransform.position;

                if (!useMainHitCombat) {
                    mainDamagePositionTransformPosition = mainDualWieldMeleeWeaponObjectSystem.mainDamagePositionTransform.position;
                }

                Vector3 raycastPositionTarget = lastSurfaceDetectedCollider.ClosestPointOnBounds (mainDamagePositionTransformPosition);

                List<Transform> raycastCheckTransfromList = currentMeleeWeapon.raycastCheckTransfromList;

                if (!useMainHitCombat) {
                    raycastCheckTransfromList = mainDualWieldMeleeWeaponObjectSystem.raycastCheckTransfromList;
                }

                int raycastCheckTransfromListCount = raycastCheckTransfromList.Count;

                for (int i = 0; i < raycastCheckTransfromListCount; i++) {
                    if (!surfaceFound) {
                        Vector3 raycastPosition = raycastCheckTransfromList [i].position;

                        Vector3 raycastDirection = raycastPositionTarget - raycastPosition;

                        raycastDirection = raycastDirection / raycastDirection.magnitude;

                        float currentRaycastDistance = GKC_Utils.distance (raycastPosition, raycastPositionTarget);

                        currentRaycastDistance += 0.5f;

                        if (showDebugDraw) {
                            Debug.DrawLine (raycastPosition, raycastPositionTarget, Color.black, 6);

                            Debug.DrawLine (raycastPosition, raycastPosition + raycastDirection, Color.red, 4);

                            Debug.DrawLine (raycastPosition + raycastDirection,
                                raycastPosition + (0.5f * raycastDirection), Color.white, 4);

                            Debug.DrawLine (raycastPositionTarget, raycastPositionTarget - (0.5f * raycastDirection), Color.yellow, 4);
                        }

                        if (Physics.Raycast (raycastPosition, raycastDirection, out hit, currentRaycastDistance, currentLayerMaskToCheck)) {
                            if (showDebugPrint) {
                                print ("detected " + lastSurfaceDetected.name + " and raycast " + hit.collider.gameObject.name);
                            }

                            if (hit.collider.gameObject != playerControllerGameObject) {
                                surfaceFound = hit.collider.gameObject;
                            }
                        } else {
                            if (showDebugPrint) {
                                print ("detected " + lastSurfaceDetected.name + " no raycast found");
                            }

                            if (raycastPositionTarget != Vector3.zero) {
                                attackPosition = raycastPositionTarget;

                                attackNormal = lastSurfaceDetectedCollider.transform.position - attackPosition;

                                attackNormal = attackNormal / attackNormal.magnitude;
                            }
                        }
                    }
                }

                bool checkCutModeOnAttack = false;

                if (!ignoreCutModeOnMeleeWeaponAttack && currentAttackInfo.useCutModeOnAttack) {
                    if (isDualWieldWeapon) {
                        if (Time.time > lastTimeCutActiveOnAttack + 0.3f || lastTimeCutActiveOnAttack == 0) {
                            checkCutModeOnAttack = true;
                        }
                    } else {
                        if (!cutActivatedOnAttackChecked) {
                            checkCutModeOnAttack = true;
                        }
                    }
                }

                if (checkCutModeOnAttack) {
                    Vector3 cutOverlapBoxSize = currentMeleeWeapon.cutOverlapBoxSize;
                    Transform cutPositionTransform = currentMeleeWeapon.cutPositionTransform;
                    Transform cutDirectionTransform = currentMeleeWeapon.cutDirectionTransform;

                    Transform planeDefiner1 = currentMeleeWeapon.planeDefiner1;
                    Transform planeDefiner2 = currentMeleeWeapon.planeDefiner2;
                    Transform planeDefiner3 = currentMeleeWeapon.planeDefiner3;

                    if (!useMainHitCombat) {
                        cutPositionTransform = mainDualWieldMeleeWeaponObjectSystem.cutPositionTransform;
                        cutDirectionTransform = mainDualWieldMeleeWeaponObjectSystem.cutDirectionTransform;

                        planeDefiner1 = mainDualWieldMeleeWeaponObjectSystem.planeDefiner1;
                        planeDefiner2 = mainDualWieldMeleeWeaponObjectSystem.planeDefiner2;
                        planeDefiner3 = mainDualWieldMeleeWeaponObjectSystem.planeDefiner3;
                    }

                    mainSliceSystem.setCustomCutTransformValues (cutOverlapBoxSize, cutPositionTransform, cutDirectionTransform,
                        planeDefiner1, planeDefiner2, planeDefiner3);

                    //					print ("CHECK CUT");

                    mainSliceSystem.activateCutExternally ();

                    cutActivatedOnAttackChecked = true;

                    lastTimeCutActiveOnAttack = Time.time;
                }

                if (currentAttackInfo.pushCharactersOnDamage && currentAttackInfo.messageNameToSend != "") {

                    bool activatePushCharacter = true;

                    if (currentAttackInfo.useProbabilityToPushCharacters) {
                        float pushProbability = Random.Range (1, 100);

                        pushProbability /= 100;

                        //						print (lastSurfaceDetected.name + " " + currentAttackInfo.pushCharactersOnDamage + " " + pushProbability);

                        if (currentAttackInfo.probability < pushProbability) {
                            activatePushCharacter = false;
                        }
                    }

                    if (currentAttackInfo.useIgnoreTagsToPush) {
                        if (currentAttackInfo.tagsToIgnorePush.Contains (lastSurfaceDetected.tag)) {
                            activatePushCharacter = false;
                        }
                    }

                    if (activatePushCharacter) {
                        Vector3 pushCharacterDirection = Vector3.zero;

                        if (currentAttackInfo.ignoreMeleeWeaponAttackDirection) {
                            pushCharacterDirection = currentAttackInfo.pushForceAmount * playerControllerGameObject.transform.forward;
                        } else {
                            pushCharacterDirection = currentAttackInfo.pushForceAmount * currentMeleeWeapon.mainDamagePositionTransform.forward;
                        }

                        if (currentAttackInfo.useExtraPushDirection) {
                            Transform playerTransform = playerControllerGameObject.transform;

                            pushCharacterDirection += currentAttackInfo.extraPushDirection.x * playerTransform.right;
                            pushCharacterDirection += currentAttackInfo.extraPushDirection.y * playerTransform.up;
                            pushCharacterDirection += currentAttackInfo.extraPushDirection.z * playerTransform.forward;

                            pushCharacterDirection *= currentAttackInfo.extraPushForce;
                        }

                        lastSurfaceDetected.SendMessage (currentAttackInfo.messageNameToSend, pushCharacterDirection, SendMessageOptions.DontRequireReceiver);
                    }
                }

                if (!ignoreGetHealthFromDamagingObjectsOnWeaponInfo) {
                    if (currentAttackInfo.getHealthFromDamagingObjects) {
                        float totalHealthAmount = currentHitCombat.getLastDamageApplied () * currentAttackInfo.healthFromDamagingObjectsMultiplier;

                        if (totalHealthAmount > 0 && !mainHealth.checkIfMaxHealth ()) {

                            mainHealth.getHealth (totalHealthAmount);
                        }
                    }
                }

                if (!ignoreGetHealthFromDamagingObjects) {
                    if (currentGrabbedWeaponInfo.getHealthFromDamagingObjects) {
                        float totalHealthAmount = currentHitCombat.getLastDamageApplied () * currentGrabbedWeaponInfo.healthFromDamagingObjectsMultiplier;

                        if (totalHealthAmount > 0 && !mainHealth.checkIfMaxHealth ()) {

                            mainHealth.getHealth (totalHealthAmount);
                        }
                    }
                }
            }

            if (surfaceFound != null) {
                if (showDebugPrint) {
                    print ("SURFACE FOUND " + surfaceFound.name);
                }

                attackPosition = hit.point;
                attackNormal = hit.normal;
            } else {
                if (showDebugPrint) {
                    print ("SURFACE NOT FOUND BY RAYCAST!!!!!!!!!!");
                }
            }

            if (lastSurfaceDetected != null) {
                if (showDebugPrint) {
                    print ("lastSurfaceDetected " + lastSurfaceDetected.name);
                }

                meleeAttackSurfaceInfo currentMeleeAttackSurfaceInfo = lastSurfaceDetected.GetComponent<meleeAttackSurfaceInfo> ();

                if (currentMeleeAttackSurfaceInfo != null) {
                    if (!currentMeleeAttackSurfaceInfo.isSurfaceEnabled ()) {
                        surfaceLocated = false;
                    } else {

                        surfaceName = currentMeleeAttackSurfaceInfo.getSurfaceName ();

                        if (currentMeleeAttackSurfaceInfo.useRemoteEventOnWeapon) {
                            remoteEventSystem currentRemoteEventSystem = currentMeleeWeapon.GetComponent<remoteEventSystem> ();

                            if (currentRemoteEventSystem != null) {

                                if (showDebugPrint) {
                                    print ("remote event on weapon detected");
                                }

                                int remoteEventOnWeaponNameListCount = currentMeleeAttackSurfaceInfo.remoteEventOnWeaponNameList.Count;

                                for (int j = 0; j < remoteEventOnWeaponNameListCount; j++) {
                                    currentRemoteEventSystem.callRemoteEvent (currentMeleeAttackSurfaceInfo.remoteEventOnWeaponNameList [j]);
                                }
                            }
                        }

                        if (currentMeleeWeapon.useRemoteEventOnSurfacesDetected) {
                            if (currentMeleeAttackSurfaceInfo.useRemoteEvent) {
                                remoteEventSystem currentRemoteEventSystem = lastSurfaceDetected.GetComponent<remoteEventSystem> ();

                                if (currentRemoteEventSystem != null) {

                                    if (showDebugPrint) {
                                        print ("remote event on object detected");
                                    }

                                    int remoteEventNameListCount = currentMeleeAttackSurfaceInfo.remoteEventNameList.Count;

                                    for (int j = 0; j < remoteEventNameListCount; j++) {
                                        string currentRemoteEventName = currentMeleeAttackSurfaceInfo.remoteEventNameList [j];

                                        if (currentMeleeWeapon.isRemoteEventIncluded (currentRemoteEventName)) {
                                            currentRemoteEventSystem.callRemoteEvent (currentRemoteEventName);
                                        }
                                    }
                                }
                            }
                        }

                        currentMeleeAttackSurfaceInfo.checkEventOnSurfaceDetected ();
                    }

                    if (checkDurabilityOnAttackEnabled) {
                        if (!currentMeleeAttackSurfaceInfo.ignoreDurability) {
                            ignoreDurability = false;

                            extraDurabilityMultiplier = currentMeleeAttackSurfaceInfo.extraDurabilityMultiplier;
                        }
                    }
                } else {
                    GameObject currentCharacter = applyDamage.getCharacterOrVehicle (lastSurfaceDetected);

                    if (currentCharacter != null) {
                        currentMeleeAttackSurfaceInfo = currentCharacter.GetComponent<meleeAttackSurfaceInfo> ();

                        if (currentMeleeAttackSurfaceInfo != null) {
                            if (!currentMeleeAttackSurfaceInfo.isSurfaceEnabled ()) {
                                surfaceLocated = false;
                            } else {
                                surfaceName = currentMeleeAttackSurfaceInfo.getSurfaceName ();

                                currentMeleeAttackSurfaceInfo.checkEventOnSurfaceDetected ();
                            }

                            if (checkDurabilityOnAttackEnabled) {
                                if (!currentMeleeAttackSurfaceInfo.ignoreDurability) {
                                    ignoreDurability = false;

                                    extraDurabilityMultiplier = currentMeleeAttackSurfaceInfo.extraDurabilityMultiplier;
                                }
                            }
                        } else {
                            if (surfaceInfoOnMeleeAttackNameForNotFound != "") {
                                surfaceName = surfaceInfoOnMeleeAttackNameForNotFound;

                                ignoreDurability = false;

                                extraDurabilityMultiplier = 1;
                            }
                        }
                    } else {
                        surfaceLocated = false;
                    }

                    if (!surfaceLocated) {
                        return;
                    }
                }
            } else {
                if (showDebugPrint) {
                    print ("SURFACE NOT FOUND BY TRIGGER!!!!!!!!!!");
                }
            }
        }

        bool ignoreBounceEvent = false;

        if (!currentAttackCanBeBlocked) {
            ignoreBounceEvent = true;
        }

        bool ignoreSoundOnSurface = false;

        if (attackActivatedOnAir && currentAttackInfo.pauseSoundIfAttackOnAir) {
            ignoreSoundOnSurface = true;
        }

        checkSurfaceFoundOnAttackToProcess (surfaceName, surfaceLocated, attackPosition, attackNormal, ignoreBounceEvent, ignoreSoundOnSurface);

        checkDurabilityOnAttackOnCurrentWeapon (ignoreDurability, extraDurabilityMultiplier);
    }

    public void checkSurfaceFoundOnAttackToProcess (string surfaceName, bool surfaceLocated, Vector3 attackPosition, Vector3 attackNormal,
                                                    bool ignoreBounceEvent, bool ignoreSoundOnSurface)
    {

        if (showDebugPrint) {
            print ("surface name " + surfaceName);
        }

        int surfaceInfoOnMeleeAttackListCount = surfaceInfoOnMeleeAttackList.Count;

        for (int i = 0; i < surfaceInfoOnMeleeAttackListCount; i++) {
            surfaceInfoOnMeleeAttack currentSurfaceInfo = surfaceInfoOnMeleeAttackList [i];

            if (surfaceName.Equals (currentSurfaceInfo.surfaceName)) {

                int soundIndex = 0;

                if (currentSurfaceInfo.useSoundsListOnOrder) {
                    currentSurfaceInfo.currentSoundIndex++;

                    if (currentSurfaceInfo.currentSoundIndex >= currentSurfaceInfo.soundsAudioElements.Count) {
                        currentSurfaceInfo.currentSoundIndex = 0;
                    }

                    soundIndex = currentSurfaceInfo.currentSoundIndex;
                } else {
                    soundIndex = Random.Range (0, currentSurfaceInfo.soundsAudioElements.Count);
                }

                bool soundCanBePlayed = false;

                if (Time.time > lastTimeSurfaceAudioPlayed + 0.5f) {
                    soundCanBePlayed = true;
                }

                if (lastSurfaceDetecetedIndex == -1 || lastSurfaceDetecetedIndex != i) {
                    soundCanBePlayed = true;
                }

                if (soundCanBePlayed && !meleeAttackSoundPaused) {
                    if (!ignoreSoundOnSurface) {
                        AudioPlayer.PlayOneShot (currentSurfaceInfo.soundsAudioElements [soundIndex], gameObject);
                    }

                    lastTimeSurfaceAudioPlayed = Time.time;

                    lastSurfaceDetecetedIndex = i;
                }

                if (surfaceLocated) {
                    if (!ignoreBounceEvent) {
                        if (currentSurfaceInfo.surfaceActivatesBounceOnCharacter) {
                            currentSurfaceInfo.eventOnBounceCharacter.Invoke ();
                        }
                    }

                    if (currentSurfaceInfo.useParticlesOnSurface && attackPosition != Vector3.zero) {
                        GameObject newParticles = null;

                        if (currentSurfaceInfo.useRandomParticlesOnSurfaceList) {
                            int randomIndex = Random.Range (0, currentSurfaceInfo.randomParticlesOnSurfaceList.Count);

                            newParticles = (GameObject)Instantiate (currentSurfaceInfo.randomParticlesOnSurfaceList [randomIndex],
                                Vector3.zero, Quaternion.identity);

                        } else {
                            newParticles = (GameObject)Instantiate (currentSurfaceInfo.particlesOnSurface,
                                Vector3.zero, Quaternion.identity);
                        }

                        newParticles.transform.position = attackPosition;
                        newParticles.transform.LookAt (attackPosition + 3 * attackNormal);
                    }
                }

                //				print ("surface type detected " + surfaceName);

                return;
            }
        }
    }

    bool meleeAttackSoundPaused;

    public void setMeleeAttackSoundPausedState (bool state)
    {
        meleeAttackSoundPaused = state;
    }

    public void addEventOnDamageInfoList (string weaponTypeName)
    {
        int currentIndex = grabbedWeaponInfoList.FindIndex (a => a.Name.Equals (weaponTypeName));

        if (currentIndex > -1) {
            eventOnDamageInfo newEventOnDamageInfo = new eventOnDamageInfo ();

            newEventOnDamageInfo.damageInfoID = grabbedWeaponInfoList [currentIndex].eventOnDamageInfoList.Count;

            grabbedWeaponInfoList [currentIndex].eventOnDamageInfoList.Add (newEventOnDamageInfo);
        }
    }

    public void setIgnoreCutModeOnMeleeWeaponAttackState (bool state)
    {
        ignoreCutModeOnMeleeWeaponAttack = state;
    }

    public void setCheckDurabilityOnAttackEnabledState (bool state)
    {
        checkDurabilityOnAttackEnabled = state;
    }

    public void setCheckDurabilityOnBlockEnabledState (bool state)
    {
        checkDurabilityOnBlockEnabled = state;
    }

    public void setGeneralAttackDurabilityMultiplier (float newValue)
    {
        generalAttackDurabilityMultiplier = newValue;
    }

    public void setGeneralBlockDurabilityMultiplier (float newValue)
    {
        generalBlockDurabilityMultiplier = newValue;
    }

    public void setIgnoreUseDrawKeepWeaponAnimationState (bool state)
    {
        ignoreUseDrawKeepWeaponAnimation = state;
    }

    public void setOriginalIgnoreUseDrawKeepWeaponAnimationState ()
    {
        setIgnoreUseDrawKeepWeaponAnimationState (originalIgnoreUseDrawKeepWeaponAnimation);
    }

    public void setUseMatchTargetSystemOnAttackState (bool state)
    {
        useMatchTargetSystemOnAttack = state;
    }

    public void setOriginaloriginalUseMatchTargetSystemOnAttackState ()
    {
        setUseMatchTargetSystemOnAttackState (originalUseMatchTargetSystemOnAttack);
    }

    //EDITOR FUNCTIONS
    public void setCheckDurabilityOnAttackEnabledStateFromEditor (bool state)
    {
        setCheckDurabilityOnAttackEnabledState (state);

        updateComponent ();
    }

    public void setCheckDurabilityOnBlockEnabledStateFromEditor (bool state)
    {
        setCheckDurabilityOnBlockEnabledState (state);

        updateComponent ();
    }

    public void setGeneralAttackDurabilityMultiplierFromEditor (float newValue)
    {
        setGeneralAttackDurabilityMultiplier (newValue);

        updateComponent ();
    }

    public void setGeneralBlockDurabilityMultiplierFromEditor (float newValue)
    {
        setGeneralBlockDurabilityMultiplier (newValue);

        updateComponent ();
    }

    public void setCustomIgnoreTagsForCharacterFromEditor ()
    {
        if (playerControllerGameObject != null) {
            useCustomIgnoreTags = true;

            customTagsToIgnoreList.Clear ();

            customTagsToIgnoreList.Add (playerControllerGameObject.tag);

            updateComponent ();
        }
    }

    public void setUseMatchTargetSystemOnAttackStateFromEditor (bool state)
    {
        setUseMatchTargetSystemOnAttackState (state);

        updateComponent ();
    }

    public void setIgnoreCutModeOnMeleeWeaponAttackStateFromEditor (bool state)
    {
        setIgnoreCutModeOnMeleeWeaponAttackState (state);

        updateComponent ();
    }

    public void setIgnoreUseDrawKeepWeaponAnimationStateFromEditor (bool state)
    {
        setIgnoreUseDrawKeepWeaponAnimationState (state);

        updateComponent ();
    }

    public void updateGrabbedWeaponReferenceValuesOnAllWeaponInfoList ()
    {
        int grabbedWeaponInfoListCount = grabbedWeaponInfoList.Count;

        for (int i = 0; i < grabbedWeaponInfoListCount; i++) {
            if (grabbedWeaponInfoList [i].useCustomGrabbedWeaponReferencePosition) {
                if (grabbedWeaponInfoList [i].useGrabbedWeaponReferenceValues) {
                    if (grabbedWeaponInfoList [i].customGrabbedWeaponReferencePosition != null) {
                        grabbedWeaponInfoList [i].grabbedWeaponReferenceValuesPosition = grabbedWeaponInfoList [i].customGrabbedWeaponReferencePosition.localPosition;
                        grabbedWeaponInfoList [i].grabbedWeaponReferenceValuesEuler = grabbedWeaponInfoList [i].customGrabbedWeaponReferencePosition.localEulerAngles;
                    }
                }
            }


            if (grabbedWeaponInfoList [i].useCustomReferencePositionToKeepObjectMesh) {
                if (grabbedWeaponInfoList [i].useReferenceToKeepObjectMeshValues) {
                    if (grabbedWeaponInfoList [i].customReferencePositionToKeepObjectMesh != null) {
                        grabbedWeaponInfoList [i].referenceToKeepObjectMeshValuesPosition = grabbedWeaponInfoList [i].customReferencePositionToKeepObjectMesh.localPosition;
                        grabbedWeaponInfoList [i].referenceToKeepObjectMeshValuesEuler = grabbedWeaponInfoList [i].customReferencePositionToKeepObjectMesh.localEulerAngles;
                    }
                }
            }

            if (grabbedWeaponInfoList [i].useCustomReferencePositionToKeepObject) {
                if (grabbedWeaponInfoList [i].useReferenceToKeepObjectValues) {
                    if (grabbedWeaponInfoList [i].customReferencePositionToKeepObject != null) {
                        grabbedWeaponInfoList [i].referenceToKeepObjectValuesPosition = grabbedWeaponInfoList [i].customReferencePositionToKeepObject.localPosition;
                        grabbedWeaponInfoList [i].referenceToKeepObjectValuesEuler = grabbedWeaponInfoList [i].customReferencePositionToKeepObject.localEulerAngles;
                    }
                }
            }
        }

        updateComponent ();
    }

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

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

    [System.Serializable]
    public class grabbedWeaponInfo
    {
        public string Name;

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

        public bool setNewIdleID;
        public int idleIDUsed;

        public bool useStrafeMode;
        public int strafeIDUsed;
        public bool setPreviousStrafeModeOnDropObject;
        public bool previousStrafeMode;

        public bool activateStrafeModeOnLockOnTargetActive;
        public bool deactivateStrafeModeOnLockOnTargetDeactivate;

        [Space]

        public bool toggleStrafeModeIfRunningActive;

        public bool setSprintEnabledStateWithWeapon;
        public bool sprintEnabledStateWithWeapon;

        [Space]

        public bool setNewCrouchID;
        public int crouchIDUsed;

        [Space]

        public bool setNewMovementID;
        public int movementIDUsed;

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

        public bool weaponCanUseShield;

        public int shieldID;

        public string regularMovementBlockShieldActionName;

        public int strafeMovementBlockShieldID;

        public int shieldIDFreeMovement;
        public int shieldIDStrafeMovement;

        public bool isEmptyWeaponToUseOnlyShield;

        [Space]
        [Header ("Damage Trigger Settings")]
        [Space]

        public bool placeTriggerInFrontOfCharacterOnAllAttacks;

        public bool setConfigureDamageAsConstantValueOnWeapon;
        public bool configureDamageAsConstantValueOnWeapon;

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

        public bool useEventsOnGrabDropObject;
        public UnityEvent eventOnGrabObject;
        public UnityEvent eventOnDropObject;

        [Space]
        [Header ("Keep/Draw Weapon Events Settings")]
        [Space]

        public bool useEventsOnKeepOrDrawMeleeWeapon;

        public UnityEvent eventsOnKeepMeleeWeapon;
        public UnityEvent eventsOnDrawMeleeWeapon;

        [Space]
        [Header ("Remote Events Settings")]
        [Space]

        public bool useRemoteEventsOnGrabObject;
        public List<string> remoteEventOnGrabObject = new List<string> ();

        [Space]

        public bool useRemoteEventsOnDropObject;
        public List<string> remoteEventOnDropObject = new List<string> ();

        [Space]
        [Header ("Attacks Unable To Block Settings")]
        [Space]

        public bool attacksCantBeBlocked;

        public List<int> attackIDCantBeBlockedList = new List<int> ();

        [Space]
        [Header ("Damage Detected Settings")]
        [Space]

        public bool useEventsOnDamageDetected;

        public bool checkObjectsToUseRemoteEventsOnDamage;
        public LayerMask layerToUseRemoteEventsOnDamage;

        public List<eventOnDamageInfo> eventOnDamageInfoList = new List<eventOnDamageInfo> ();

        [Space]
        [Header ("Obtain Health From Damage Applied Settings")]
        [Space]

        public bool getHealthFromDamagingObjects;
        public float healthFromDamagingObjectsMultiplier = 1;

        [Space]
        [Header ("Obtain Health From Blocks Settings")]
        [Space]

        public bool getHealthFromBlocks;
        public float healthAmountFromBlocks = 1;

        public bool getHealthFromPerfectBlocks;
        public float healthAmountFromPerfectBlocks = 1;

        [Space]
        [Header ("Range Attack Settings")]
        [Space]

        public bool useRangeAttackID;
        public List<rangeAttackInfo> rangeAttackInfoList = new List<rangeAttackInfo> ();

        [Space]
        [Header ("Press Up/Down Events Settings")]
        [Space]

        public bool useEventsOnPressDownState;
        public UnityEvent eventOnPressDownState;

        public bool useEventsOnPressUpState;
        public UnityEvent eventOnPressUpState;

        [Space]
        [Header ("Deflect Projectile Events Settings")]
        [Space]

        public bool useEventsOnDeflectProjectile;
        public UnityEvent eventsOnDeflectProjectile;

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

        public bool ignoreParryOnPerfectBlock;

        [Space]
        [Header ("Custom Position Reference Settings")]
        [Space]

        public bool useCustomGrabbedWeaponReferencePosition;
        public Transform customGrabbedWeaponReferencePosition;

        [Space]

        public bool useGrabbedWeaponReferenceValues;
        public Vector3 grabbedWeaponReferenceValuesPosition;
        public Vector3 grabbedWeaponReferenceValuesEuler;

        [Space]

        public bool useCustomReferencePositionToKeepObjectMesh;
        public Transform customReferencePositionToKeepObjectMesh;

        [Space]

        public bool useReferenceToKeepObjectMeshValues;
        public Vector3 referenceToKeepObjectMeshValuesPosition;
        public Vector3 referenceToKeepObjectMeshValuesEuler;

        [Space]

        public bool useCustomReferencePositionToKeepObject;
        public Transform customReferencePositionToKeepObject;

        [Space]

        public bool useReferenceToKeepObjectValues;
        public Vector3 referenceToKeepObjectValuesPosition;
        public Vector3 referenceToKeepObjectValuesEuler;

        [Space]
        [Header ("Attack List Info Template Settings")]
        [Space]

        public bool useMeleeWeaponAttackInfoList;

        public bool setInitialWeaponAttackInfoList;

        public int initialWeaponAttackInfoListIndex;

        public List<meleeWeaponAttackInfo> meleeWeaponAttackInfoList = new List<meleeWeaponAttackInfo> ();

        [Space]
        [Header ("Weapon Durability Settings")]
        [Space]

        public bool useEventOnEmptyDurability;
        public UnityEvent eventOnEmptyDurability;
    }

    [System.Serializable]
    public class eventOnDamageInfo
    {
        public int damageInfoID;
        public UnityEvent eventOnDamageDetected;

        public bool useRemoteEvent;
        public List<string> remoteEventNameList;
    }

    [System.Serializable]
    public class surfaceInfoOnMeleeAttack
    {
        public string surfaceName;

        [Space]
        [Header ("Sounds And Particles Settings")]
        [Space]

        public bool useSoundsListOnOrder;
        public int currentSoundIndex;
        public List<AudioClip> soundsList;
        public List<AudioElement> soundsAudioElements;

        public bool useParticlesOnSurface;
        public GameObject particlesOnSurface;

        public bool useRandomParticlesOnSurfaceList;
        public List<GameObject> randomParticlesOnSurfaceList = new List<GameObject> ();

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

        public bool surfaceActivatesBounceOnCharacter;
        public UnityEvent eventOnBounceCharacter;
        public bool stopAttackOnBounce;
    }

    [System.Serializable]
    public class rangeAttackInfo
    {
        public int rangeAttackID;
        public UnityEvent eventOnRangeAttack;
        public UnityEvent eventOnDisableRangeAttack;
    }
}