FueraDeEscala/Assets/Game Kit Controller/Scripts/Grab Objects/grabPhysicalObjectSystem.cs

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

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

    public bool grabObjectPhysically = true;

    public string objectName;

    public LayerMask layerForUsers;

    public Vector3 colliderScale;
    public Vector3 colliderOffset;

    public string tagForObjectWhenActive;
    public string tagForObjectWhenInactive;

    public bool carryObjectOutOfPlayerBody;

    public bool disableObjectColliderWhileGrabbed;

    [Space]

    public bool ignoreToGrabPhysicallyIfPickedWithAimingMode;

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

    public bool setRigidbodyMassValue;
    public float rigidbodyMassValue = 1;

    public bool setCustomLayerOnCollidersOnGrab;

    public string customLayerOnCollidersOnGrab;

    public bool useCustomRigidbodiesParent;
    public Transform customRigidbodiesParent;

    [Space]
    [Header ("Grab Object Animation Settings")]
    [Space]

    public bool changeAnimationSpeed;
    [Range (0, 1)] public float animationSpeed = 1;
    public bool setNewMovementTreeID;
    public int newMovementTreeID;
    public bool applyAnimatorVelocityWithoutMoving;

    public bool disableJumpOnGrabbedObject;
    public bool disableRunOnGrabbedObject;
    public bool disableCrouchOnGrabbedObjet;

    [Space]
    [Header ("Grab Object Settings")]
    [Space]

    public bool checkViewToGrabObject;
    public bool canBeGrabbedOnFirstPerson = true;
    public bool canBeGrabbedOnThirdPerson = true;

    [Space]
    [Header ("Transform Reference Settings")]
    [Space]

    public Transform referencePosition;

    public bool useReferencePositionForEveryView;
    public Transform referencePositionThirdPerson;
    public Transform referencePositionFirstPerson;

    public Transform referencePositionFBA;

    public Transform referencePositionToKeepObject;

    [Space]
    [Header ("Mount Point Settings")]
    [Space]

    public bool useBoneToKeepObject;
    public HumanBodyBones boneToKeepObject;

    public bool useMountPointToKeepObject;
    public string mountPointTokeepObjectName;

    [Space]
    [Header ("Generic Mode Settings")]
    [Space]

    public bool canBeGrabbedOnGenericMode;

    public string mountPointNameToCarryOnGenericMode = "Mouth";

    public bool setCustomObjectScaleOnGenericMode;

    public Vector3 customObjectScaleOnGenericMode;

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

    public bool IKSystemEnabled = true;

    public bool useRightHand = true;
    public bool useLeftHand = true;
    public Transform rightHandPosition;
    public Transform lefHandPosition;

    public bool useRightElbow;
    public bool useLeftElbow;
    public Transform rightElbowPosition;
    public Transform lefElbowPosition;

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

    public bool useAnimationGrabbingHand;
    public int rightGrabbingHandID;
    public int leftGrabbingHandID;

    [Space]
    [Header ("Grab Object Parent Settings")]
    [Space]

    public bool useRightHandForObjectParent = true;

    [Space]
    [Header ("Kinematic List Settings")]
    [Space]

    public bool setExtraListKinematic;
    public List<Rigidbody> extraListKinematic = new List<Rigidbody> ();

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

    public bool useMeleeAttackSystem;
    public grabPhysicalObjectMeleeAttackSystem mainGrabPhysicalObjectMeleeAttackSystem;

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

    public bool enableTransparencyOnFBA;

    [Space]

    public bool useThrowAnimationOnCharacterEnabled;

    public string throwAnimationOneHand = "Throw Physical Object One Hand";

    public string throwAnimationTwoHands = "Throw Physical Object Two Hands";

    public bool useDelayToThrowObjectDuringAnimation;

    public float delayToThrowObjectDuringAnimation;

    public bool ignoreShowObjectNameOnGrabObjectsSystem;

    [Space]
    [Header ("Extra Collider Settings")]
    [Space]

    public bool objectUsesExtraColliderList;

    public List<Collider> extraColliderList = new List<Collider> ();

    public bool checkExtraCollidersInParent;

    public Transform extraCollidersParent;

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

    public bool objectGrabed;

    public bool objectIsCharacter;
    public GameObject character;
    public Transform characterBody;

    public bool keepGrabbedObjectState;

    public List<grabObjects> grabObjectsList = new List<grabObjects> ();

    public Transform currentObjectParent;

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

    public bool useEventsOnGrabDrop;
    public UnityEvent eventOnGrab;
    public UnityEvent eventOnDrop;

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

    public bool useRemoteEventOnObjectsFound;
    public List<string> remoteEventNameListOnStart = new List<string> ();
    public List<string> remoteEventNameListOnEnd = new List<string> ();

    [Space]
    [Header ("Grab Object Type Settings")]
    [Space]

    public bool objectMeshInsideMainParent;
    public Transform objectMeshMainParent;
    public bool useMeshCollider;
    public bool useBoxCollider;

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

    public bool showGizmo;
    public Color gizmoColor = Color.red;

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

    public GameObject objectToGrabParent;

    public Collider grabObjectTrigger;

    public Collider mainCollider;

    public Rigidbody mainRigidbody;


    grabObjects grabObjectsManager;

    GameObject currentUser;
    grabObjects currentGrabObjectDetected;

    List<Rigidbody> rigidbodyList = new List<Rigidbody> ();
    List<float> rigidbodyMassList = new List<float> ();

    List<int> layerMaskList = new List<int> ();

    Vector3 lastPositionBeforeGrabbed;
    Quaternion lastRotationBeforeGrabbed;

    Vector3 lastPositionBeforeDropped;
    Quaternion lastRotationBeforeDropped;

    Vector3 originalScale = -Vector3.one;


    void Start ()
    {
        assignObjectToGrabParentIfNull ();
    }

    public void assignObjectToGrabParentIfNull ()
    {
        if (objectToGrabParent == null) {
            objectToGrabParent = gameObject;
        }
    }

    public void setRigidbodyList ()
    {
        if (rigidbodyList.Count == 0) {

            assignObjectToGrabParentIfNull ();

            Transform currentRigidbodiesParent = objectToGrabParent.transform;

            if (useCustomRigidbodiesParent) {
                currentRigidbodiesParent = customRigidbodiesParent;
            }

            Component [] components = currentRigidbodiesParent.GetComponentsInChildren (typeof (Rigidbody));

            foreach (Rigidbody child in components) {
                rigidbodyMassList.Add (child.mass);

                rigidbodyList.Add (child);

                layerMaskList.Add (child.gameObject.layer);
            }
        }
    }

    public void grabObject (GameObject currentPlayer)
    {
        if (objectGrabed) {
            return;
        }

        //print ("grab object");
        objectGrabed = true;

        grabObjectsManager = currentPlayer.GetComponent<grabObjects> ();

        setGrabObjectTriggerState (false);

        assignObjectToGrabParentIfNull ();

        lastPositionBeforeGrabbed = objectToGrabParent.transform.position;
        lastRotationBeforeGrabbed = objectToGrabParent.transform.rotation;


        grabPhysicalObjectInfo newGrabPhysicalObjectInfo = new grabPhysicalObjectInfo ();

        newGrabPhysicalObjectInfo.objectToGrab = objectToGrabParent;
        newGrabPhysicalObjectInfo.IKSystemEnabled = IKSystemEnabled;

        newGrabPhysicalObjectInfo.changeAnimationSpeed = changeAnimationSpeed;
        newGrabPhysicalObjectInfo.animationSpeed = animationSpeed;

        newGrabPhysicalObjectInfo.setNewMovementTreeID = setNewMovementTreeID;
        newGrabPhysicalObjectInfo.newMovementTreeID = newMovementTreeID;

        newGrabPhysicalObjectInfo.applyAnimatorVelocityWithoutMoving = applyAnimatorVelocityWithoutMoving;

        newGrabPhysicalObjectInfo.disableJumpOnGrabbedObject = disableJumpOnGrabbedObject;
        newGrabPhysicalObjectInfo.disableRunOnGrabbedObject = disableRunOnGrabbedObject;
        newGrabPhysicalObjectInfo.disableCrouchOnGrabbedObjet = disableCrouchOnGrabbedObjet;

        newGrabPhysicalObjectInfo.rightHandPosition = rightHandPosition;
        newGrabPhysicalObjectInfo.lefHandPosition = lefHandPosition;
        newGrabPhysicalObjectInfo.useRightHand = useRightHand;
        newGrabPhysicalObjectInfo.useLeftHand = useLeftHand;
        newGrabPhysicalObjectInfo.useRightElbow = useRightElbow;
        newGrabPhysicalObjectInfo.useLeftElbow = useLeftElbow;
        newGrabPhysicalObjectInfo.rightElbowPosition = rightElbowPosition;
        newGrabPhysicalObjectInfo.lefElbowPosition = lefElbowPosition;

        newGrabPhysicalObjectInfo.useAnimationGrabbingHand = useAnimationGrabbingHand;
        newGrabPhysicalObjectInfo.rightGrabbingHandID = rightGrabbingHandID;
        newGrabPhysicalObjectInfo.leftGrabbingHandID = leftGrabbingHandID;

        newGrabPhysicalObjectInfo.useRightHandForObjectParent = useRightHandForObjectParent;

        grabObjectsManager.grabPhysicalObject (newGrabPhysicalObjectInfo);

        for (int i = 0; i < grabObjectsList.Count; i++) {
            if (grabObjectsList [i] != grabObjectsManager) {
                grabObjectsList [i].removeCurrentPhysicalObjectToGrabFound (objectToGrabParent);
            }
        }

        if (setRigidbodyMassValue || setCustomLayerOnCollidersOnGrab) {

            setRigidbodyList ();

            string customLayerName = "Ignore Raycast";

            if (setCustomLayerOnCollidersOnGrab) {
                customLayerName = customLayerOnCollidersOnGrab;
            }

            int ignoreRaycastLayerIndex = LayerMask.NameToLayer (customLayerName);

            for (int i = 0; i < rigidbodyList.Count; i++) {
                if (rigidbodyMassValue >= 0) {
                    rigidbodyList [i].mass = rigidbodyMassValue;
                }

                rigidbodyList [i].gameObject.layer = ignoreRaycastLayerIndex;
            }
        }

        if (setExtraListKinematic) {
            for (int i = 0; i < extraListKinematic.Count; i++) {
                if (extraListKinematic [i] != null) {
                    extraListKinematic [i].isKinematic = true;
                }
            }
        }

        if (objectIsCharacter) {
            if (character != null) {
                ragdollActivator currentRagdollActivator = character.GetComponent<ragdollActivator> ();

                if (currentRagdollActivator != null) {
                    currentRagdollActivator.setCheckGetUpPausedState (true);
                }
            }
        }

        checkEventsOnGrabDrop (true);

        checkRemoteEvents (true);

        if (disableObjectColliderWhileGrabbed) {
            setMainColliderEnabledState (false);
        }
    }

    public void dropObject ()
    {
        //print ("drop object");
        objectGrabed = false;

        lastPositionBeforeDropped = objectToGrabParent.transform.position;
        lastRotationBeforeDropped = objectToGrabParent.transform.rotation;

        if (grabObjectsManager != null) {
            grabObjectsManager.dropPhysicalObject ();
        }

        grabObjectsManager = null;

        setGrabObjectTriggerState (true);

        if (setExtraListKinematic) {
            for (int i = 0; i < extraListKinematic.Count; i++) {
                if (extraListKinematic [i] != null) {
                    extraListKinematic [i].isKinematic = false;
                }
            }
        }

        if (setRigidbodyMassValue || setCustomLayerOnCollidersOnGrab) {
            for (int i = 0; i < rigidbodyList.Count; i++) {
                rigidbodyList [i].mass = rigidbodyMassList [i];

                rigidbodyList [i].gameObject.layer = layerMaskList [i];
            }
        }

        if (objectIsCharacter) {
            assignObjectToGrabParentIfNull ();

            if (character != null) {
                ragdollActivator currentRagdollActivator = character.GetComponent<ragdollActivator> ();

                if (currentRagdollActivator != null) {
                    currentRagdollActivator.setCheckGetUpPausedState (false);

                    if (characterBody == null) {
                        characterBody = currentRagdollActivator.characterBody.transform;
                    }
                }
            }

            if (characterBody != null) {
                characterBody.transform.position = objectToGrabParent.transform.position;
            }

            objectToGrabParent.transform.SetParent (characterBody);
        }

        checkEventsOnGrabDrop (false);

        checkRemoteEvents (false);

        if (disableObjectColliderWhileGrabbed) {
            setMainColliderEnabledState (true);
        }

        keepGrabbedObjectState = false;

        currentObjectParent = null;
    }

    public void checkParentAssignedState ()
    {
        checkNewParentAssignedState (objectToGrabParent.transform.parent);
    }

    public void checkNewParentAssignedState (Transform newParent)
    {

    }

    public bool isUseReferencePositionForEveryViewActive ()
    {
        return useReferencePositionForEveryView;
    }

    public Transform getReferencePositionThirdPerson ()
    {
        return referencePositionThirdPerson;
    }

    public Transform getReferencePositionFirstPerson ()
    {
        return referencePositionFirstPerson;
    }

    public Transform getReferencePositionFBA ()
    {
        return referencePositionFBA;
    }

    public Transform getReferencePosition ()
    {
        return referencePosition;
    }

    public string getObjectName ()
    {
        if (objectName == "") {
            objectName = gameObject.name;
        }

        return objectName;
    }

    public bool isIgnoreShowObjectNameOnGrabObjectsSystemActive ()
    {
        return ignoreShowObjectNameOnGrabObjectsSystem;
    }

    public bool isCanBeGrabbedOnGenericModeEnabled ()
    {
        return canBeGrabbedOnGenericMode;
    }

    public bool isIgnoreToGrabPhysicallyIfPickedWithAimingModeActive ()
    {
        return ignoreToGrabPhysicallyIfPickedWithAimingMode;
    }

    void OnTriggerEnter (Collider col)
    {
        checkTriggerInfo (col, true);
    }

    void OnTriggerExit (Collider col)
    {
        checkTriggerInfo (col, false);
    }

    public void checkTriggerInfo (Collider col, bool isEnter)
    {
        if (objectGrabed) {
            return;
        }

        if ((1 << col.gameObject.layer & layerForUsers.value) == 1 << col.gameObject.layer) {
            //if the player is entering in the trigger
            currentGrabObjectDetected = col.gameObject.GetComponent<grabObjects> ();

            if (currentGrabObjectDetected != null) {
                assignObjectToGrabParentIfNull ();

                if (isEnter) {

                    if (!currentGrabObjectDetected.isGrabObjectsPhysicallyEnabled ()) {
                        return;
                    }

                    currentUser = col.gameObject;

                    if (grabObjectPhysically) {
                        if (objectIsCharacter) {
                            if (character == currentUser) {
                                return;
                            }
                        }

                        grabObjectsList.Add (currentGrabObjectDetected);

                        currentGrabObjectDetected.addCurrentPhysicalObjectToGrabFound (objectToGrabParent);
                    }
                } else {
                    if (objectToGrabParent != null) {
                        currentGrabObjectDetected.removeCurrentPhysicalObjectToGrabFound (objectToGrabParent);
                    }

                    grabObjectsList.Remove (currentGrabObjectDetected);
                }
            }
        }
    }

    public void removeAllGrabObjectsFound ()
    {
        assignObjectToGrabParentIfNull ();

        for (int i = grabObjectsList.Count - 1; i >= 0; i--) {

            if (grabObjectsList [i].isCarryingPhysicalObject () && grabObjectsList [i].getCurrentPhysicalObjectGrabbed () != null &&
                grabObjectsList [i].getCurrentPhysicalObjectGrabbed () == objectToGrabParent) {

                grabObjectsList [i].dropObject ();
            }

            grabObjectsList [i].removeCurrentPhysicalObjectToGrabFound (objectToGrabParent);

            grabObjectsList.RemoveAt (i);
        }
    }

    public void setCurrentPlayer (GameObject newPlayer)
    {
        checkTriggerInfo (newPlayer.GetComponent<Collider> (), true);
    }

    public bool isGrabObjectPhysicallyEnabled ()
    {
        return grabObjectPhysically;
    }

    public bool isCanBeGrabbedOnFirstPersonEnabled ()
    {
        return canBeGrabbedOnFirstPerson;
    }

    public bool isCanBeGrabbedOnThirdPersonEnabled ()
    {
        return canBeGrabbedOnThirdPerson;
    }

    public void disableGrabPhysicalObject ()
    {
        grabObjectPhysically = false;

        if (currentUser != null) {

            assignObjectToGrabParentIfNull ();

            currentUser.GetComponent<grabObjects> ().removeCurrentPhysicalObjectToGrabFound (objectToGrabParent);
        }
    }

    public void setGrabObjectPhysicallyEnabledState (bool state)
    {
        grabObjectPhysically = state;
    }

    public void setGrabObjectPhysicallyEnabledStateFromEditor (bool state)
    {
        setGrabObjectPhysicallyEnabledState (state);

        updateComponent ();
    }

    public void setMainColliderEnabledState (bool state)
    {
        if (mainCollider != null) {
            mainCollider.enabled = state;
        }
    }

    public void setGrabObjectTriggerState (bool state)
    {
        if (grabObjectTrigger != null) {
            grabObjectTrigger.enabled = state;
        }
    }

    public void setGrabObjectTriggerStateFromEditor (bool state)
    {
        setGrabObjectTriggerState (state);

        updateComponent ();
    }

    public void setCharacterBody (Transform newCharacterBody)
    {
        characterBody = newCharacterBody;

        updateComponent ();
    }

    public void setCharacter (GameObject newCharacter)
    {
        character = newCharacter;

        updateComponent ();
    }


    public void setObjectToGrabParent (GameObject newObjectToGrabParent)
    {
        objectToGrabParent = newObjectToGrabParent;

        updateComponent ();
    }

    public void setActiveOrInactiveObjectState (bool state)
    {
        if (state) {
            if (tagForObjectWhenActive == "") {
                tagForObjectWhenActive = "box";
            }

            objectToGrabParent.tag = tagForObjectWhenActive;
        } else {
            if (tagForObjectWhenInactive == "") {
                tagForObjectWhenInactive = "Untagged";
            }

            objectToGrabParent.tag = tagForObjectWhenInactive;
        }
    }

    public void checkEventsOnGrabDrop (bool state)
    {
        if (useEventsOnGrabDrop) {
            if (state) {
                eventOnGrab.Invoke ();
            } else {
                eventOnDrop.Invoke ();
            }
        }
    }

    public void disableGrabPhysicalObjectComponent ()
    {
        removeAllGrabObjectsFound ();

        setGrabObjectTriggerState (false);

        setActiveOrInactiveObjectState (false);
    }

    public bool isUseRightHandActive ()
    {
        return useRightHand;
    }

    public bool isUseLeftHandActive ()
    {
        return useLeftHand;
    }

    public bool hasObjectMeleeAttackSystem ()
    {
        return useMeleeAttackSystem;
    }

    public grabPhysicalObjectMeleeAttackSystem getMainGrabPhysicalObjectMeleeAttackSystem ()
    {
        return mainGrabPhysicalObjectMeleeAttackSystem;
    }

    public void activateReturnProjectilesOnContact ()
    {
        if (grabObjectsManager != null) {
            grabObjectsManager.activateReturnProjectilesOnContact ();
        }
    }

    public void checkRemoteEvents (bool state)
    {
        if (state) {
            checkRemoteEventOnStart ();
        } else {
            checkRemoteEventOnEnd ();
        }
    }

    public void checkRemoteEventOnStart ()
    {
        if (useRemoteEventOnObjectsFound) {
            if (currentUser != null) {
                remoteEventSystem currentRemoteEventSystem = currentUser.GetComponent<remoteEventSystem> ();

                if (currentRemoteEventSystem != null) {
                    for (int i = 0; i < remoteEventNameListOnStart.Count; i++) {
                        currentRemoteEventSystem.callRemoteEvent (remoteEventNameListOnStart [i]);
                    }
                }
            }
        }
    }

    public void checkRemoteEventOnEnd ()
    {
        if (useRemoteEventOnObjectsFound) {
            if (currentUser != null) {
                remoteEventSystem currentRemoteEventSystem = currentUser.GetComponent<remoteEventSystem> ();

                if (currentRemoteEventSystem != null) {
                    for (int i = 0; i < remoteEventNameListOnEnd.Count; i++) {
                        currentRemoteEventSystem.callRemoteEvent (remoteEventNameListOnEnd [i]);
                    }
                }
            }
        }
    }

    public void setKeepOrCarryGrabbebObjectState (bool state)
    {
        if (objectGrabed) {
            keepGrabbedObjectState = state;

            if (useMeleeAttackSystem) {
                mainGrabPhysicalObjectMeleeAttackSystem.setKeepOrCarryGrabbebObjectState (state);
            }
        }
    }

    public void assignObjectParent (Transform newParent)
    {
        currentObjectParent = newParent;
    }

    public Transform getCurrentObjectParent ()
    {
        return currentObjectParent;
    }

    public Vector3 getLastPositionBeforeGrabbed ()
    {
        return lastPositionBeforeGrabbed;
    }

    public Quaternion getLastRotationBeforeGrabbed ()
    {
        return lastRotationBeforeGrabbed;
    }

    public Vector3 getLastPositionBeforeDropped ()
    {
        return lastPositionBeforeDropped;
    }

    public Quaternion getLastRotationBeforeDropped ()
    {
        return lastRotationBeforeDropped;
    }

    Transform lastParentAssigned;

    public void setLastParentAssigned (Transform newParent)
    {
        lastParentAssigned = newParent;
    }

    public Transform getLastParentAssigned ()
    {
        return lastParentAssigned;
    }

    public void grabPhysicalObjectExternally (GameObject currentPlayer)
    {
        if (currentPlayer == null) {
            return;
        }

        GKC_Utils.grabPhysicalObjectExternally (currentPlayer, gameObject);
    }

    public Rigidbody getMainRigidbody ()
    {
        if (mainRigidbody == null) {
            return objectToGrabParent.GetComponent<Rigidbody> ();
        }

        return mainRigidbody;
    }

    public void setCustomScale (Vector3 newValue)
    {
        if (originalScale == -Vector3.one) {
            originalScale = transform.localScale;
        }

        transform.localScale = newValue;
    }

    public void setOriginalScale ()
    {
        if (originalScale != -Vector3.one) {
            setCustomScale (originalScale);
        }
    }

    public List<Collider> getExtraColliderList ()
    {
        if (objectUsesExtraColliderList) {

            List<Collider> newColliderList = new List<Collider> ();

            if (extraColliderList.Count > 0) {
                newColliderList.AddRange (extraColliderList);
            }

            if (checkExtraCollidersInParent) {
                Component [] components = extraCollidersParent.GetComponentsInChildren (typeof (Collider));

                int componentsLength = components.Length;

                for (int i = 0; i < componentsLength; i++) {
                    Collider currentChildCollider = components [i] as Collider;

                    if (!currentChildCollider.isTrigger) {
                        newColliderList.Add (currentChildCollider);
                    }
                }
            }

            if (newColliderList.Count > 0) {
                return newColliderList;
            }
        }

        return null;
    }

    public bool getObjectUsesExtraColliderListState ()
    {
        return objectUsesExtraColliderList;
    }

    //EDITOR FUNCTIONS
    void updateComponent ()
    {
        GKC_Utils.updateComponent (this);
    }

#if UNITY_EDITOR
    void OnDrawGizmos ()
    {
        if (!showGizmo) {
            return;
        }

        if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
            DrawGizmos ();
        }
    }

    void OnDrawGizmosSelected ()
    {
        DrawGizmos ();
    }

    void DrawGizmos ()
    {
        if (showGizmo) {
            GKC_Utils.drawRectangleGizmo (transform.position, transform.rotation, colliderOffset, colliderScale, gizmoColor);

            if (rightHandPosition) {
                Gizmos.DrawSphere (rightHandPosition.position, 0.2f);
            }

            if (lefHandPosition) {
                Gizmos.DrawSphere (lefHandPosition.position, 0.2f);
            }
        }
    }
#endif

    [System.Serializable]
    public class grabPhysicalObjectInfo
    {
        public GameObject objectToGrab;
        public bool IKSystemEnabled;

        public bool changeAnimationSpeed;
        public float animationSpeed;

        public bool setNewMovementTreeID;
        public int newMovementTreeID;

        public bool applyAnimatorVelocityWithoutMoving;

        public bool disableJumpOnGrabbedObject;
        public bool disableRunOnGrabbedObject;
        public bool disableCrouchOnGrabbedObjet;

        public Transform rightHandPosition;
        public Transform lefHandPosition;
        public bool useRightHand;
        public bool useLeftHand;
        public bool useRightElbow;
        public bool useLeftElbow;
        public Transform rightElbowPosition;
        public Transform lefElbowPosition;

        public bool useRightHandForObjectParent;

        public bool useAnimationGrabbingHand;
        public int rightGrabbingHandID;
        public int leftGrabbingHandID;
    }
}