using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using UnityEngine.Events;
using GKC.Localization;

using System.Linq;

public class usingDevicesSystem : MonoBehaviour
{
    public bool canUseDevices;

    public RawImage touchButtonRawImage;
    public Texture originalTouchButtonRawImage;

    public GameObject touchButton;
    public GameObject touchButtonIcon;
    public GameObject iconButton;
    public RectTransform iconButtonRectTransform;

    public Text actionText;
    public Text keyText;
    public Text objectNameText;

    public RawImage objectImage;
    public Text objectDescriptionText;
    public Text objectAmountText;

    public string useDeviceFunctionName = "activateDevice";

    public string extraTextStartActionKey = "[";
    public string extraTextEndActionKey = "]";

    public int defaultDeviceNameFontSize = 17;

    public string setCurrentUserOnDeviceFunctionName = "setCurrentUser";

    public string useDevicesActionName = "Activate Device";

    public List<string> tagsForDevices = new List<string> ();
    public Camera examinateDevicesCamera;
    public bool usePickUpAmountIfEqualToOne;
    public bool usedByAI;

    public bool driving;
    public bool iconButtonCanBeShown = true;
    public GameObject objectToUse;

    public GameObject interactionMessageGameObject;
    public Text interactionMessageText;

    public GameObject currentVehicle;
    public List<deviceInfo> deviceList = new List<deviceInfo> ();

    bool deviceListContainsElements;

    public List<GameObject> deviceGameObjectList = new List<GameObject> ();

    public deviceInfo currentDeviceInfo;

    deviceInfo deviceInfoToCheck;

    public LayerMask layer;
    public float raycastDistance;

    public bool searchingDevicesWithRaycast;
    public bool secondaryDeviceFound;

    public bool showUseDeviceIconEnabled = true;
    public bool useDeviceButtonEnabled = true;
    public bool useFixedDeviceIconPosition;
    public bool deviceOnScreenIfUseFixedIconPosition;

    public bool useFixedDeviceIconPositionOnFBA;
    public bool followDeviceIconPositionOnFBAIfObjectOnScreen;

    public bool showInteractionPanelIfObjectNotOnScreen;

    public bool getClosestDeviceToCameraCenter;

    public bool useMaxDistanceToCameraCenter;
    public float maxDistanceToCameraCenter = 20;

    public bool currentDeviceIsPickup;

    public bool holdButtonToTakePickupsAround;
    public float holdButtonTime = 0.5f;

    public bool showCurrentDeviceAmount = true;
    public GameObject currentDeviceAmountTextPanel;
    public Text currentDeviceAmountText;

    public bool useDeviceFoundShader;
    public Shader deviceFoundShader;
    public float shaderOutlineWidth;
    public Color shaderOutlineColor;

    public bool examiningObject;

    public GameObject examineObjectRenderTexturePanel;
    public Transform examineObjectBlurPanelParent;

    public Camera examineObjectRenderCamera;

    public bool showDetectedDevicesIconOnScreen;
    public GameObject detectedDevicesIconPrefab;
    public Transform detectedDevicesIconParent;

    public bool useMinDistanceToUseDevices;
    public float minDistanceToUseDevices = 4;

    public bool useInteractionActions;
    public List<interactionActionInfo> interactionActionInfoList = new List<interactionActionInfo> ();

    public bool useIconButtonInfoList;
    public List<iconButtonInfo> iconButtonInfoList = new List<iconButtonInfo> ();
    public string defaultIconButtonName = "Default";
    iconButtonInfo currentIconButtonInfo;
    string currentIconButtonNameToSearch;

    public bool useOnlyDeviceIfVisibleOnCamera;

    public bool disableInteractionTouchButtonIfNotDevicesDetected;
    public bool keepInteractionTouchButtonAlwaysActive;

    public bool useGameObjectListToIgnore;
    public List<GameObject> gameObjectListToIgnore = new List<GameObject> ();

    public playerController playerControllerManager;
    public grabObjects grabObjectsManager;
    public playerInputManager playerInput;
    public Camera mainCamera;
    public playerCamera playerCameraManager;
    public Transform mainCameraTransform;

    bool checkingOnTriggerExitActive;

    public bool checkIfPlayerColliderInsideBoundOfDeviceOnExit;

    public List<multipleInteractionInfo> multipleInteractionInfoList = new List<multipleInteractionInfo> ();

    float lastTimePressedButton;
    bool holdingButton;

    Touch currentTouch;

    deviceStringAction deviceStringManager;

    Vector3 currentIconPosition;

    Coroutine showObjectMessageCoroutine;

    RaycastHit hit;
    deviceStringAction secondaryDeviceStringManager;
    GameObject currentRaycastFoundObject;
    deviceInfo secondaryDeviceInfo;

    Vector3 currentPosition;

    string currentDeviceActionText;
    public string currenDeviceActionName;
    int currentDeviceNameTextFontSize;

    Texture currentDeviceIconTexture;
    string currentDeviceDescription;
    int currentDeviceDescriptionFontSize;

    Vector3 devicePosition;
    Vector3 screenPoint;
    Vector3 centerScreen;
    float currentDistanceToTarget;
    float minDistanceToTarget;
    int currentTargetIndex;
    bool deviceCloseEnoughToScreenCenter;

    float currentAngleWithTarget;

    GameObject objectToRemoveAferStopUse;

    GameObject currentDeviceToUseFound;

    Vector3 originalDeviceIconPosition;

    bool firstPersonActive;
    bool cameraViewChecked;

    bool isFullBodyAwarenessActive;

    Vector2 mainCanvasSizeDelta;
    Vector2 halfMainCanvasSizeDelta;

    Vector2 iconPosition2d;
    bool usingScreenSpaceCamera;

    bool targetOnScreen;

    Coroutine pauseUseDeviceButtonForDuration;

    bool useCustomMinDistanceToUseDevice;
    float customMinDistanceToUseDevice;

    bool ignoreDistanceToDevice;

    bool usingDevicePreviously;

    float screenWidth;
    float screenHeight;

    GameObject currentTouchButtonIcon;
    Text currentKetText;
    string currentExtraTextStartActionKey;
    string currentExtraTextEndActionKey;

    bool currentUseMultipleTouchButtonIcon;
    List<GameObject> currentMultipleTouchButtonIconList;

    bool useMultipleInteractionInfo;

    Text currentActionText;
    Text currentObjectNameText;

    List<Text> currentKeyTextList = new List<Text> ();
    List<Text> currentActionTextList = new List<Text> ();

    RawImage currentObjectImage;
    Text currentObjectDescriptionText;

    int deviceListCount;


    public Collider mainCollider;
    public bool ignoreCheckIfObstacleBetweenDeviceAndPlayer = true;

    bool touchButtonLocated;

    bool usingNewTouchButtonRawImageIcon;

    multipleInteractionSystem currentMultipleInteractionSystem;

    GameObject currentDeviceToUseHoldInteraction;

    public bool holdInteractionButtonEnabled;

    float currentHoldInteractionButtonDuration;

    public bool holdingInteractionButtonActive;

    Image currentHoldInteractionSlider;

    Coroutine holdInteractionButtonCoroutine;
    string currentMultipleInteractionName;

    bool checkMultipleInteractionActive;

    bool showHoldInteractionTimer;
    Text holdInteractionTimerText;

    bool pauseVehicleGetOffInput;

    bool initialCheck;

    bool iconButtonActive;

    //Editor variables
    public bool showIntereactionSettings;
    public bool showOutlineShaderSettings;
    public bool showEventsSettings;
    public bool showOtherSettings;
    public bool showDebugSettings;
    public bool showAllSettings;
    public bool showComponents;
    public bool showUISettings;

    void Start ()
    {
        if (iconButton != null) {
            originalDeviceIconPosition = iconButton.transform.position;
        }

        mainCanvasSizeDelta = playerCameraManager.getMainCanvasSizeDelta ();
        halfMainCanvasSizeDelta = mainCanvasSizeDelta * 0.5f;
        usingScreenSpaceCamera = playerCameraManager.isUsingScreenSpaceCamera ();

        touchButtonLocated = touchButton != null;

        if (mainCamera == null) {
            mainCamera = playerCameraManager.getMainCamera ();
        }
    }

    void FixedUpdate ()
    {
        if (usedByAI) {
            return;
        }

        if (!initialCheck) {
            if (keepInteractionTouchButtonAlwaysActive) {
                if (touchButton.activeSelf != true) {
                    touchButton.SetActive (true);
                }
            }

            initialCheck = true;
        }

        isFullBodyAwarenessActive = playerCameraManager.isFullBodyAwarenessActive ();

        firstPersonActive = playerCameraManager.isFirstPersonActive () || isFullBodyAwarenessActive;

        //set the icon button above the device to use, just to indicate to the player that he can activate a device by pressing T
        if (deviceListContainsElements && deviceList.Count > 0 && !examiningObject && !driving) {
            screenWidth = Screen.width;
            screenHeight = Screen.height;

            int index = getclosestDevice (true, true);

            if (iconButtonCanBeShown && index != -1) {
                currentDeviceInfo = deviceList [index];

                //show a secondary device string action inside the current object to use
                if (searchingDevicesWithRaycast) {
                    if (Physics.Raycast (mainCameraTransform.position, mainCameraTransform.TransformDirection (Vector3.forward), out hit, raycastDistance, layer)) {
                        if (currentRaycastFoundObject != hit.collider.gameObject) {
                            currentRaycastFoundObject = hit.collider.gameObject;

                            secondaryDeviceStringManager = currentRaycastFoundObject.GetComponent<deviceStringAction> ();

                            if (secondaryDeviceStringManager != null) {
                                secondaryDeviceInfo = new deviceInfo ();

                                secondaryDeviceInfo.deviceGameObject = currentRaycastFoundObject;

                                storeDeviceInfo (ref secondaryDeviceInfo, secondaryDeviceStringManager);

                                string deviceAction = secondaryDeviceStringManager.getDeviceAction ();

                                setKeyText (true);

                                currentDeviceActionText = deviceAction;

                                setActionAndNameText (deviceAction, secondaryDeviceStringManager.getDeviceName ());

                                currentDeviceIconTexture = deviceStringManager.iconTexture;
                                currentDeviceDescription = deviceStringManager.objectDescription;
                                currentDeviceDescriptionFontSize = deviceStringManager.descriptionFontSize;

                                setExtraActionInfo (currentDeviceIconTexture, currentDeviceDescription);

                                currentDeviceNameTextFontSize = secondaryDeviceStringManager.getTextFontSize ();

                                if (currentDeviceNameTextFontSize <= 0 && defaultDeviceNameFontSize > 0) {
                                    currentDeviceNameTextFontSize = defaultDeviceNameFontSize;
                                }

                                if (currentDeviceNameTextFontSize > 0) {
                                    objectNameText.fontSize = currentDeviceNameTextFontSize;
                                }

                                secondaryDeviceFound = true;
                            } else {
                                secondaryDeviceFound = false;

                                string deviceAction = deviceStringManager.getDeviceAction ();

                                currentDeviceActionText = deviceAction;

                                setActionAndNameText (deviceAction, deviceStringManager.getDeviceName ());

                                currentDeviceIconTexture = deviceStringManager.iconTexture;
                                currentDeviceDescription = deviceStringManager.objectDescription;
                                currentDeviceDescriptionFontSize = deviceStringManager.descriptionFontSize;

                                setExtraActionInfo (currentDeviceIconTexture, currentDeviceDescription);

                                currentDeviceNameTextFontSize = deviceStringManager.getTextFontSize ();

                                if (currentDeviceNameTextFontSize <= 0 && defaultDeviceNameFontSize > 0) {
                                    currentDeviceNameTextFontSize = defaultDeviceNameFontSize;
                                }

                                if (currentDeviceNameTextFontSize > 0) {
                                    objectNameText.fontSize = currentDeviceNameTextFontSize;
                                }
                            }
                        }
                    } else {
                        removeSecondaryDeviceInfo ();
                    }

                    if (secondaryDeviceFound) {
                        setIconButtonCanBeShownState (true);

                        currentDeviceInfo = secondaryDeviceInfo;
                    } else {
                        if (!deviceStringManager.showIcon) {
                            currentDeviceInfo = null;
                        }
                        removeSecondaryDeviceInfo ();
                    }
                }

                if (showUseDeviceIconEnabled) {
                    if (currentDeviceInfo != null) {
                        bool useFixedIconPositionResult = false;

                        if (useFixedDeviceIconPosition) {
                            useFixedIconPositionResult = true;
                        } else {
                            if (isFullBodyAwarenessActive && useFixedDeviceIconPositionOnFBA && !followDeviceIconPositionOnFBAIfObjectOnScreen) {
                                useFixedIconPositionResult = true;
                            }
                        }

                        if (useFixedIconPositionResult && !deviceOnScreenIfUseFixedIconPosition) {
                            enableOrDisableIconButton (true);

                            iconButton.transform.position = originalDeviceIconPosition;
                        } else {
                            //check if the current device to use has two separated positions to show the device icon on third person and firs person
                            if (!useFixedDeviceIconPosition && currentDeviceInfo.useSeparatedTransformForEveryView) {
                                if (firstPersonActive) {
                                    if (!cameraViewChecked) {
                                        setCurrentDeviceStringManagerInfo (currentDeviceInfo);

                                        cameraViewChecked = true;
                                    }
                                } else {
                                    if (cameraViewChecked) {
                                        setCurrentDeviceStringManagerInfo (currentDeviceInfo);

                                        cameraViewChecked = false;
                                    }
                                }
                            }

                            if (currentDeviceInfo.positionToIcon != null) {
                                currentIconPosition = currentDeviceInfo.positionToIcon.position;

                                if (!currentDeviceInfo.useTransformForStringAction) {
                                    if (currentDeviceInfo.useLocalOffset) {
                                        currentIconPosition += currentDeviceInfo.actionOffset * currentDeviceInfo.positionToIcon.up;
                                    } else {
                                        currentIconPosition += currentDeviceInfo.actionOffset * Vector3.up;
                                    }
                                }

                                if (usingScreenSpaceCamera) {
                                    screenPoint = mainCamera.WorldToViewportPoint (currentIconPosition);
                                    targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < 1 && screenPoint.y > 0 && screenPoint.y < 1;
                                } else {
                                    screenPoint = mainCamera.WorldToScreenPoint (currentIconPosition);
                                    targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < screenWidth && screenPoint.y > 0 && screenPoint.y < screenHeight;
                                }

                                if (targetOnScreen) {
                                    if (useFixedIconPositionResult || currentDeviceInfo.useFixedDeviceIconPosition) {

                                        if (useIconButtonInfoList) {
                                            if (currentIconButtonInfo != null && currentIconButtonInfo.useFixedPosition) {
                                                iconButton.transform.position = currentIconButtonInfo.fixedPositionTransform.position;
                                            } else {
                                                iconButton.transform.position = originalDeviceIconPosition;
                                            }
                                        } else {
                                            iconButton.transform.position = originalDeviceIconPosition;
                                        }

                                    } else {
                                        bool useDynamicIconPositionResult = true;

                                        if (useIconButtonInfoList) {
                                            if (currentIconButtonInfo != null) {
                                                if (currentIconButtonInfo.useFixedPosition) {
                                                    if (currentIconButtonInfo.fixedPositionTransform != null) {
                                                        iconButton.transform.position = currentIconButtonInfo.fixedPositionTransform.position;
                                                    } else {
                                                        iconButton.transform.position = originalDeviceIconPosition;
                                                    }

                                                    useDynamicIconPositionResult = false;
                                                }
                                            }
                                        }

                                        if (useDynamicIconPositionResult) {
                                            if (usingScreenSpaceCamera) {
                                                iconPosition2d = new Vector2 ((screenPoint.x * mainCanvasSizeDelta.x) - halfMainCanvasSizeDelta.x,
                                                    (screenPoint.y * mainCanvasSizeDelta.y) - halfMainCanvasSizeDelta.y);

                                                iconButtonRectTransform.anchoredPosition = iconPosition2d;
                                            } else {
                                                iconButton.transform.position = new Vector3 (screenPoint.x, screenPoint.y, 0);
                                            }
                                        }
                                    }

                                    enableOrDisableIconButton (true);
                                } else {
                                    bool showInteractionPanelIfObjectNotOnScreenResult = showInteractionPanelIfObjectNotOnScreen;

                                    if (isFullBodyAwarenessActive && useFixedDeviceIconPositionOnFBA && followDeviceIconPositionOnFBAIfObjectOnScreen) {
                                        showInteractionPanelIfObjectNotOnScreenResult = true;
                                    }

                                    if (showInteractionPanelIfObjectNotOnScreenResult) {
                                        enableOrDisableIconButton (true);

                                        iconButton.transform.position = originalDeviceIconPosition;
                                    } else {
                                        enableOrDisableIconButton (false);
                                    }
                                }
                            } else {
                                enableOrDisableIconButton (false);
                            }
                        }
                    } else {
                        enableOrDisableIconButton (false);
                    }
                }
            } else {
                enableOrDisableIconButton (false);
            }
        } else {
            enableOrDisableIconButton (false);
        }
    }

    public void removeSecondaryDeviceInfo ()
    {
        currentRaycastFoundObject = null;
        secondaryDeviceStringManager = null;
        secondaryDeviceInfo = null;
    }

    public void enableOrDisableIconButton (bool state)
    {
        if (iconButtonActive != state) {
            setIconButtonState (state);
        }
    }

    public void setUseMinDistanceToUseDevicesState (bool state)
    {
        useMinDistanceToUseDevices = state;
    }


    public bool checkIfDevicesGameObjectDetectedNotActive;

    public int getclosestDevice (bool activeDevicesIcons, bool checkForCameraDistance)
    {
        currentTargetIndex = -1;
        minDistanceToTarget = Mathf.Infinity;
        currentPosition = transform.position;

        centerScreen = new Vector3 (screenWidth / 2, screenHeight / 2, 0);

        deviceListCount = deviceList.Count;

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

            deviceInfoToCheck = deviceList [i];

            if (deviceInfoToCheck.deviceGameObject != null) {

                if (checkIfDevicesGameObjectDetectedNotActive) {
                    if (!deviceInfoToCheck.deviceGameObject.activeInHierarchy) {
                        if (showDetectedDevicesIconOnScreen) {
                            if (deviceInfoToCheck.deviceIcon != null) {
                                Destroy (deviceInfoToCheck.deviceIcon);
                            }
                        }

                        deviceList.RemoveAt (i);

                        deviceGameObjectList.RemoveAt (i);

                        i = 0;

                        deviceListCount = deviceList.Count;

                        if (deviceListCount == 0) {
                            deviceListContainsElements = false;
                        }

                        return -1;
                    }
                }

                devicePosition = deviceInfoToCheck.deviceTransform.position;


                if (deviceInfoToCheck.removeDeviceFromPlayerListOnMaxDistance) {
                    float distanceToObject = GKC_Utils.distance (transform.position, devicePosition);

                    if (distanceToObject > deviceInfoToCheck.maxDistanceToRemoveDeviceFromPlayerList) {
                        if (showDetectedDevicesIconOnScreen) {
                            if (deviceInfoToCheck.deviceIcon != null) {
                                Destroy (deviceInfoToCheck.deviceIcon);
                            }
                        }

                        deviceList.RemoveAt (i);

                        deviceGameObjectList.RemoveAt (i);

                        i = 0;

                        deviceListCount = deviceList.Count;

                        if (deviceListCount == 0) {
                            deviceListContainsElements = false;
                        }

                        return -1;
                    }
                }

                if (getClosestDeviceToCameraCenter && !playerControllerManager.isLockedCameraStateActive ()) {
                    screenPoint = mainCamera.WorldToScreenPoint (devicePosition);

                    currentDistanceToTarget = GKC_Utils.distance (screenPoint, centerScreen);

                    deviceCloseEnoughToScreenCenter = false;

                    if (useMaxDistanceToCameraCenter) {
                        if (currentDistanceToTarget < maxDistanceToCameraCenter) {
                            deviceCloseEnoughToScreenCenter = true;
                        }
                    } else {
                        if (deviceInfoToCheck.useMaxDistanceToCameraCenter) {
                            if (currentDistanceToTarget < deviceInfoToCheck.maxDistanceToCameraCenter) {
                                deviceCloseEnoughToScreenCenter = true;
                            }

                        } else {
                            deviceCloseEnoughToScreenCenter = true;
                        }
                    }

                    if (deviceCloseEnoughToScreenCenter) {
                        if (currentDistanceToTarget < minDistanceToTarget) {
                            minDistanceToTarget = currentDistanceToTarget;
                            currentTargetIndex = i;
                        }
                    }
                } else {
                    currentDistanceToTarget = GKC_Utils.distance (devicePosition, currentPosition);

                    if (currentDistanceToTarget < minDistanceToTarget) {
                        minDistanceToTarget = currentDistanceToTarget;
                        currentTargetIndex = i;
                    }
                }

            } else {
                if (showDetectedDevicesIconOnScreen) {
                    if (deviceInfoToCheck.deviceIcon != null) {
                        Destroy (deviceInfoToCheck.deviceIcon);
                    }
                }

                deviceList.RemoveAt (i);

                deviceGameObjectList.RemoveAt (i);

                i = 0;

                deviceListCount = deviceList.Count;

                if (deviceListCount == 0) {
                    deviceListContainsElements = false;
                }
            }
        }

        bool removeCurrentTargetIndex = false;

        if (!ignoreCheckIfObstacleBetweenDeviceAndPlayer) {
            if (currentTargetIndex > -1 && deviceListCount > currentTargetIndex) {
                deviceInfo temporalDeviceInfo = deviceList [currentTargetIndex];

                if (temporalDeviceInfo.checkIfObstacleBetweenDeviceAndPlayer) {

                    Vector3 targetPosition = currentPosition + transform.up;

                    Vector3 devicePosition = temporalDeviceInfo.deviceTransform.position;

                    //for every enemy in front of the camera, use a raycast, if it finds an obstacle between the enemy and the camera, the enemy is removed from the list
                    Vector3 direction = targetPosition - devicePosition;

                    direction = direction / direction.magnitude;

                    if (Physics.Raycast (devicePosition, direction, out hit, raycastDistance, layer)) {

                        if (hit.collider != mainCollider) {
                            removeCurrentTargetIndex = true;

                            currentTargetIndex = -1;
                        }
                    }
                }
            }
        }

        if (currentTargetIndex > -1 && deviceListCount > currentTargetIndex) {

            if (checkForCameraDistance) {
                if (useMinDistanceToUseDevices) {
                    deviceInfo temporalDeviceInfo = deviceList [currentTargetIndex];

                    useCustomMinDistanceToUseDevice = temporalDeviceInfo.useCustomMinDistanceToUseDevice;
                    customMinDistanceToUseDevice = temporalDeviceInfo.customMinDistanceToUseDevice;

                    ignoreDistanceToDevice = temporalDeviceInfo.ignoreDistanceToDevice;

                    currentDistanceToTarget = GKC_Utils.distance (temporalDeviceInfo.deviceTransform.position, currentPosition);

                    if (!ignoreDistanceToDevice) {
                        if ((!useCustomMinDistanceToUseDevice && currentDistanceToTarget > minDistanceToUseDevices) ||
                            (useCustomMinDistanceToUseDevice && currentDistanceToTarget > customMinDistanceToUseDevice)) {

                            removeCurrentTargetIndex = true;

                            currentTargetIndex = -1;
                        }
                    }
                }

                if (useOnlyDeviceIfVisibleOnCamera && currentTargetIndex > -1 && !playerControllerManager.isUsingDevice ()) {
                    deviceInfo temporalDeviceInfo = deviceList [currentTargetIndex];

                    if (!temporalDeviceInfo.ignoreUseOnlyDeviceIfVisibleOnCamera) {

                        if (temporalDeviceInfo.useCustomDeviceTransformPosition) {
                            devicePosition = temporalDeviceInfo.customDeviceTransformPosition.position;
                        } else {
                            devicePosition = temporalDeviceInfo.deviceTransform.position;
                        }

                        if (usingScreenSpaceCamera) {
                            screenPoint = mainCamera.WorldToViewportPoint (devicePosition);
                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < 1 && screenPoint.y > 0 && screenPoint.y < 1;
                        } else {
                            screenPoint = mainCamera.WorldToScreenPoint (devicePosition);
                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < screenWidth && screenPoint.y > 0 && screenPoint.y < screenHeight;
                        }

                        if (!targetOnScreen) {
                            removeCurrentTargetIndex = true;

                            currentTargetIndex = -1;
                        }
                    }
                }
            }

            if (currentTargetIndex > -1) {
                deviceInfo temporalDeviceInfo = deviceList [currentTargetIndex];

                if (temporalDeviceInfo.useCustomMinAngleToUse) {
                    Vector3 directionToCheck = temporalDeviceInfo.deviceTransform.forward;

                    if (temporalDeviceInfo.useRelativeDirectionBetweenPlayerAndObject) {
                        directionToCheck = temporalDeviceInfo.deviceTransform.position - transform.position;

                        directionToCheck = directionToCheck / directionToCheck.magnitude;
                    }

                    currentAngleWithTarget = Vector3.SignedAngle (transform.forward, directionToCheck, transform.up);

                    if (Math.Abs (currentAngleWithTarget) > temporalDeviceInfo.customMinAngleToUseDevice) {
                        removeCurrentTargetIndex = true;

                        currentTargetIndex = -1;
                    }
                }
            }
        }

        if (showDetectedDevicesIconOnScreen && activeDevicesIcons) {
            for (int i = 0; i < deviceListCount; i++) {
                deviceInfoToCheck = deviceList [i];

                if (deviceInfoToCheck.deviceGameObject != null) {
                    if (i != currentTargetIndex) {
                        if (deviceInfoToCheck.positionToIcon != null) {
                            devicePosition = deviceInfoToCheck.positionToIcon.position;
                        } else {
                            devicePosition = deviceInfoToCheck.deviceTransform.position;
                        }

                        //Show icons on the screen for every device found
                        targetOnScreen = false;

                        if (usingScreenSpaceCamera) {
                            screenPoint = mainCamera.WorldToViewportPoint (devicePosition);
                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < 1 && screenPoint.y > 0 && screenPoint.y < 1;
                        } else {
                            screenPoint = mainCamera.WorldToScreenPoint (devicePosition);
                            targetOnScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < screenWidth && screenPoint.y > 0 && screenPoint.y < screenHeight;
                        }

                        if (targetOnScreen) {
                            if (!deviceInfoToCheck.deviceIcon.activeSelf) {
                                deviceInfoToCheck.deviceIcon.SetActive (true);
                            }

                            if (usingScreenSpaceCamera) {
                                iconPosition2d = new Vector2 ((screenPoint.x * mainCanvasSizeDelta.x) - halfMainCanvasSizeDelta.x, (screenPoint.y * mainCanvasSizeDelta.y) - halfMainCanvasSizeDelta.y);

                                deviceInfoToCheck.deviceIconRectTransform.anchoredPosition = iconPosition2d;
                            } else {
                                deviceInfoToCheck.deviceIconRectTransform.position = new Vector3 (screenPoint.x, screenPoint.y, 0);
                            }
                        } else {
                            if (deviceInfoToCheck.deviceIcon.activeSelf) {
                                deviceInfoToCheck.deviceIcon.SetActive (false);
                            }
                        }
                    } else {
                        if (deviceInfoToCheck.deviceIcon.activeSelf) {
                            deviceInfoToCheck.deviceIcon.SetActive (false);
                        }
                    }
                }
            }
        }

        if (removeCurrentTargetIndex) {
            if (objectToUse != null) {
                checkIfSetOriginalShaderToPreviousDeviceFound (objectToUse);
            }

            objectToUse = null;

            return -1;
        }

        if (getClosestDeviceToCameraCenter && useMaxDistanceToCameraCenter) {
            if (currentTargetIndex == -1 && objectToUse != null) {

                checkIfSetOriginalShaderToPreviousDeviceFound (objectToUse);

                objectToUse = null;

                return -1;
            }
        }

        if (currentTargetIndex != -1) {
            deviceInfo temporalDeviceInfo = deviceList [currentTargetIndex];

            if (objectToUse != temporalDeviceInfo.deviceGameObject) {

                if (objectToUse != null) {
                    checkIfSetOriginalShaderToPreviousDeviceFound (objectToUse);
                }

                objectToUse = temporalDeviceInfo.deviceGameObject;

                setCurrentDeviceStringManagerInfo (temporalDeviceInfo);

                removeSecondaryDeviceInfo ();

                checkIfSetNewShaderToDeviceFound (objectToUse);
            }
        }

        return currentTargetIndex;
    }

    public void setCurrentDeviceStringManagerInfo (deviceInfo deviceToUseInfo)
    {
        //get the action made by the current device
        string deviceAction = "";

        deviceStringManager = objectToUse.GetComponent<deviceStringAction> ();

        if (deviceStringManager != null) {
            storeDeviceInfo (ref deviceToUseInfo, deviceStringManager);

            deviceAction = deviceStringManager.getDeviceAction ();
        }

        if (deviceAction == null) {
            deviceAction = "";
        }

        if (deviceStringManager != null) {
            //show the icon in the hud of the screen according to the deviceStringAction component
            if ((deviceStringManager.showIcon && deviceAction.Length > 0 && deviceStringManager.iconEnabled) || searchingDevicesWithRaycast) {
                setIconButtonCanBeShownState (true);
            } else {
                setIconButtonCanBeShownState (false);
            }

            //enable the interection button in the touch screen
            if (deviceStringManager.showTouchIconButton) {
                enableOrDisableTouchButton (true);
            } else {
                enableOrDisableTouchButton (false);
            }
        } else {
            setIconButtonCanBeShownState (false);

            enableOrDisableTouchButton (false);
        }

        if (useIconButtonInfoList) {
            bool customIconButtonInfoFound = false;

            if (deviceStringManager != null) {
                if (deviceStringManager.useCustomIconButtonInfo) {
                    currentIconButtonNameToSearch = deviceStringManager.customIconButtonInfoName;
                } else {
                    currentIconButtonNameToSearch = defaultIconButtonName;
                }
            } else {
                currentIconButtonNameToSearch = defaultIconButtonName;
            }

            for (int i = 0; i < iconButtonInfoList.Count; i++) {
                if (iconButtonInfoList [i].Name.Equals (currentIconButtonNameToSearch)) {
                    currentIconButtonInfo = iconButtonInfoList [i];

                    customIconButtonInfoFound = true;

                } else {
                    if (iconButtonInfoList [i].iconButtonPanel.activeSelf) {
                        iconButtonInfoList [i].iconButtonPanel.SetActive (false);
                    }
                }
            }

            if (!customIconButtonInfoFound) {
                currentIconButtonInfo = null;
            }
        }

        setKeyText (true);

        if (actionText != null) {
            currentDeviceActionText = deviceAction;

            if (deviceStringManager != null) {
                currenDeviceActionName = deviceStringManager.getDeviceName ();

                currentDeviceNameTextFontSize = deviceStringManager.getTextFontSize ();

                currentDeviceIconTexture = deviceStringManager.iconTexture;
                currentDeviceDescription = deviceStringManager.objectDescription;
                currentDeviceDescriptionFontSize = deviceStringManager.descriptionFontSize;
            }

            setInteractionButtonName ();

            updateCurrentIconButtonInfo (true);
        }
    }

    public void checkIfSetNewShaderToDeviceFound (GameObject objectToCheck)
    {
        currentDeviceToUseFound = objectToCheck;

        if (useDeviceFoundShader) {
            //print ("new on device" + currenDeviceActionName);

            outlineObjectSystem currentOutlineObjectSystem = objectToCheck.GetComponent<outlineObjectSystem> ();

            if (currentOutlineObjectSystem != null) {
                currentOutlineObjectSystem.setOutlineState (true, deviceFoundShader, shaderOutlineWidth, shaderOutlineColor, playerControllerManager);
            }
        }
    }

    public void checkIfSetOriginalShaderToPreviousDeviceFound (GameObject objectToCheck)
    {
        if (useDeviceFoundShader) {
            //			print ("original on device" + objectToCheck.name);

            outlineObjectSystem currentOutlineObjectSystem = objectToCheck.GetComponent<outlineObjectSystem> ();

            if (currentOutlineObjectSystem != null) {
                if (!grabObjectsManager.useObjectToGrabFoundShader || !grabObjectsManager.isCurrentObjectToGrabFound (currentOutlineObjectSystem.getMeshParent ())) {
                    currentOutlineObjectSystem.setOutlineState (false, null, 0, Color.white, playerControllerManager);
                }
            }
        }

        currentDeviceToUseFound = null;
    }

    public bool isCurrentDeviceToUseFound (GameObject objectToCheck)
    {
        if (currentDeviceToUseFound == objectToCheck) {
            return true;
        }

        return false;
    }

    public void setInteractionButtonName ()
    {
        if (objectToUse == null) {
            return;
        }

        if (objectNameText != null) {
            setActionAndNameText (currentDeviceActionText, currenDeviceActionName);

            setExtraActionInfo (currentDeviceIconTexture, currentDeviceDescription);

            int currentAmount = 0;

            pickUpObject currentPickUpObject = objectToUse.GetComponentInParent<pickUpObject> ();

            if (currentPickUpObject != null) {
                currentAmount = currentPickUpObject.amount;

                currentDeviceIsPickup = true;
            } else {
                currentDeviceIsPickup = false;
            }

            if (currentDeviceIsPickup && showCurrentDeviceAmount) {
                if (currentAmount > 1 || (usePickUpAmountIfEqualToOne && currentAmount == 1)) {
                    if (!currentDeviceAmountTextPanel.activeSelf) {
                        currentDeviceAmountTextPanel.SetActive (true);
                    }

                    if (currentDeviceIsPickup) {
                        currentDeviceAmountText.text = "x " + currentAmount;
                    }
                } else {
                    if (currentDeviceAmountTextPanel.activeSelf) {
                        currentDeviceAmountTextPanel.SetActive (false);
                    }
                }
            } else {
                if (currentDeviceAmountTextPanel.activeSelf) {
                    currentDeviceAmountTextPanel.SetActive (false);
                }
            }

            if (currentDeviceNameTextFontSize <= 0 && defaultDeviceNameFontSize > 0) {
                currentDeviceNameTextFontSize = defaultDeviceNameFontSize;
            }

            if (currentDeviceNameTextFontSize > 0) {
                objectNameText.fontSize = currentDeviceNameTextFontSize;
            }
        }
    }

    //check if the player enters or exits the trigger of a device

    void OnTriggerEnter (Collider col)
    {
        if (playerControllerManager.isUsingDevice ()) {
            return;
        }

        checkTriggerInfo (col, true);
    }

    void OnTriggerExit (Collider col)
    {
        checkingOnTriggerExitActive = true;

        checkTriggerInfo (col, false);

        checkingOnTriggerExitActive = false;
    }

    public void checkTriggerInfo (Collider col, bool isEnter)
    {
        if (!isInTagsForDevicesList (col.gameObject)) {
            return;
        }

        if (useGameObjectListToIgnore) {
            if (gameObjectListToIgnore.Contains (col.gameObject)) {
                return;
            }
        }

        if (driving) {
            return;
        }

        if (!isEnter && checkIfPlayerColliderInsideBoundOfDeviceOnExit && checkingOnTriggerExitActive) {
            //print (col.bounds.Intersects (playerControllerManager.getMainCapsuleColliderBounds ()));

            //print (col.gameObject.name + " " + isEnter + " " + col.name);

            if (col.bounds.Intersects (playerControllerManager.getMainCapsuleColliderBounds ())) {

                //print ("player inside devices, cancelling");

                return;
            }
        }

        if (isEnter) {
            //if the player is driving, he can't use any other device
            if (!canUseDevices || driving) {
                return;
            }

            if (usedByAI) {
                return;
            }

            GameObject usableObjectFound = col.gameObject;

            if (!existInDeviceList (usableObjectFound)) {
                addDeviceToList (usableObjectFound);

                deviceStringManager = usableObjectFound.GetComponent<deviceStringAction> ();

                if (deviceStringManager != null) {
                    if (deviceStringManager.useRaycastToDetectDeviceParts) {
                        searchingDevicesWithRaycast = true;
                    }
                } else {
                    print ("WARNING: Device String Action component hasn't been configured on " + usableObjectFound.name);
                }
            }
        } else {
            //when the player exits from the trigger of a device, if he is not driving, set the device to null
            //else the player is driving, so the current device is that vehicle, so the device can't be changed
            GameObject usableObjectFound = col.gameObject;

            if (existInDeviceList (usableObjectFound)) {

                deviceStringAction currentDeviceToRemove = usableObjectFound.GetComponent<deviceStringAction> ();

                if (currentDeviceToRemove != null) {
                    if (currentDeviceToRemove.useRaycastToDetectDeviceParts) {
                        searchingDevicesWithRaycast = false;
                    }
                }

                if (driving) {
                    if (usableObjectFound != currentVehicle) {
                        removeDeviceFromList (usableObjectFound);
                    }
                } else {
                    removeDeviceFromList (usableObjectFound);
                }

                checkIfSetOriginalShaderToPreviousDeviceFound (usableObjectFound);
            }

            if (!driving) {
                enableOrDisableTouchButton (false);
            }

            if (deviceList.Count == 0) {
                objectToUse = null;

                setIconButtonCanBeShownState (false);

                currentDeviceInfo = null;

                deviceListContainsElements = false;
            }
        }
    }

    public void addDeviceToListIfNotAlreadyIncluded (GameObject deviceToAdd)
    {
        if (!existInDeviceList (deviceToAdd)) {
            addDeviceToList (deviceToAdd);
        }
    }

    public void addDeviceToList (GameObject deviceToAdd)
    {
        if (useGameObjectListToIgnore) {
            if (gameObjectListToIgnore.Contains (deviceToAdd)) {
                return;
            }
        }

        deviceInfo newDeviceInfo = new deviceInfo ();
        newDeviceInfo.deviceGameObject = deviceToAdd;

        if (newDeviceInfo.deviceGameObject != null) {
            newDeviceInfo.deviceTransform = newDeviceInfo.deviceGameObject.transform;
        }

        if (showDetectedDevicesIconOnScreen) {
            GameObject newScreenIcon = (GameObject)Instantiate (detectedDevicesIconPrefab, Vector3.zero, Quaternion.identity, detectedDevicesIconParent);

            newScreenIcon.transform.localScale = Vector3.one;
            newScreenIcon.transform.localPosition = Vector3.zero;

            newDeviceInfo.deviceIcon = newScreenIcon;
            newDeviceInfo.deviceIconRectTransform = newScreenIcon.GetComponent<RectTransform> ();
        }

        deviceStringAction newDeviceStringAction = deviceToAdd.GetComponent<deviceStringAction> ();

        if (newDeviceStringAction != null) {
            storeDeviceInfo (ref newDeviceInfo, newDeviceStringAction);
        }

        deviceList.Add (newDeviceInfo);

        deviceGameObjectList.Add (deviceToAdd);

        deviceListContainsElements = true;
    }

    void storeDeviceInfo (ref deviceInfo newDeviceInfo, deviceStringAction deviceToCopy)
    {
        newDeviceInfo.useSeparatedTransformForEveryView = deviceToCopy.useSeparatedTransformForEveryViewEnabled ();

        if (newDeviceInfo.useSeparatedTransformForEveryView) {
            if (firstPersonActive) {
                newDeviceInfo.positionToIcon = deviceToCopy.getTransformForIconFirstPerson ();
            } else {
                newDeviceInfo.positionToIcon = deviceToCopy.getTransformForIconThirdPerson ();
            }
        } else {
            newDeviceInfo.positionToIcon = deviceToCopy.getRegularTransformForIcon ();
        }

        newDeviceInfo.useTransformForStringAction = deviceToCopy.useTransformForStringAction;
        newDeviceInfo.actionOffset = deviceToCopy.actionOffset;
        newDeviceInfo.useLocalOffset = deviceToCopy.useLocalOffset;

        newDeviceInfo.useCustomMinDistanceToUseDevice = deviceToCopy.useCustomMinDistanceToUseDevice;
        newDeviceInfo.customMinDistanceToUseDevice = deviceToCopy.customMinDistanceToUseDevice;

        newDeviceInfo.ignoreDistanceToDevice = deviceToCopy.ignoreDistanceToDevice;

        newDeviceInfo.useCustomMinAngleToUse = deviceToCopy.useCustomMinAngleToUse;
        newDeviceInfo.customMinAngleToUseDevice = deviceToCopy.customMinAngleToUseDevice;
        newDeviceInfo.useRelativeDirectionBetweenPlayerAndObject = deviceToCopy.useRelativeDirectionBetweenPlayerAndObject;

        newDeviceInfo.removeDeviceFromPlayerListOnMaxDistance = deviceToCopy.removeDeviceFromPlayerListOnMaxDistance;
        newDeviceInfo.maxDistanceToRemoveDeviceFromPlayerList = deviceToCopy.maxDistanceToRemoveDeviceFromPlayerList;

        newDeviceInfo.ignoreUseOnlyDeviceIfVisibleOnCamera = deviceToCopy.ignoreUseOnlyDeviceIfVisibleOnCamera;

        newDeviceInfo.useCustomDeviceTransformPosition = deviceToCopy.useCustomDeviceTransformPosition;
        newDeviceInfo.customDeviceTransformPosition = deviceToCopy.customDeviceTransformPosition;

        newDeviceInfo.useFixedDeviceIconPosition = deviceToCopy.useFixedDeviceIconPosition;

        newDeviceInfo.checkIfObstacleBetweenDeviceAndPlayer = deviceToCopy.checkIfObstacleBetweenDeviceAndPlayer;

        newDeviceInfo.useMaxDistanceToCameraCenter = deviceToCopy.useMaxDistanceToCameraCenter;
        newDeviceInfo.maxDistanceToCameraCenter = deviceToCopy.maxDistanceToCameraCenter;
    }

    public bool ignoreIfPlayerMenuActiveState;

    public bool ignoreIfUsingDeviceActiveState;

    public void setIgnoreIfPlayerMenuActiveState (bool state)
    {
        ignoreIfPlayerMenuActiveState = state;
    }

    public void setIgnoreIfUsingDeviceActiveState (bool state)
    {
        ignoreIfUsingDeviceActiveState = state;
    }

    //call the device action
    public void useDevice ()
    {
        if (!playerControllerManager.canPlayerRagdollMove ()) {
            return;
        }

        //		print (playerControllerManager.isPlayerMenuActive () + " " + !playerControllerManager.isUsingDevice ());
        //
        //		print (ignoreIfPlayerMenuActiveState + " " + ignoreIfUsingDeviceActiveState);

        if ((!ignoreIfPlayerMenuActiveState && playerControllerManager.isPlayerMenuActive ()) &&
            (ignoreIfUsingDeviceActiveState && !playerControllerManager.isUsingDevice ())) {
            //			print ("cancel use device");

            return;
        }

        GameObject usableObjectFound = objectToUse;

        if (secondaryDeviceInfo != null) {
            usableObjectFound = secondaryDeviceInfo.deviceGameObject;
        }

        if (usableObjectFound != null && canUseDevices) {

            //			print ("checkign use device " + usableObjectFound.name);

            if (holdInteractionButtonEnabled) {
                if (!holdingInteractionButtonActive) {
                    if (deviceStringManager != null) {
                        //						print (deviceStringManager.deviceName + " " + deviceStringManager.deviceAction);

                        if (deviceStringManager.useHoldInteractionButton) {
                            holdingInteractionButtonActive = true;

                            currentHoldInteractionButtonDuration = deviceStringManager.holdInteractionButtonDuration;

                            currentDeviceToUseHoldInteraction = usableObjectFound;

                            if (currentIconButtonInfo != null) {
                                currentHoldInteractionSlider = currentIconButtonInfo.holdInteractionSlider;

                                showHoldInteractionTimer = currentIconButtonInfo.showHoldInteractionTimer;
                                holdInteractionTimerText = currentIconButtonInfo.holdInteractionTimerText;
                            }

                            stopHoldInteractionButtonCoroutine ();

                            holdInteractionButtonCoroutine = StartCoroutine (updateHoldInteractionButtonCoroutine ());

                            return;
                        } else {
                            if (holdingInteractionButtonActive) {
                                disableHoldInteractionButtonState ();
                            }
                        }
                    }
                } else {
                    if (deviceStringManager != null) {
                        if (!deviceStringManager.useHoldInteractionButton) {
                            if (holdingInteractionButtonActive) {
                                disableHoldInteractionButtonState ();
                            }
                        }
                    }
                }
            }

            if (checkMultipleInteractionActive) {
                currentMultipleInteractionSystem = usableObjectFound.GetComponent<multipleInteractionSystem> ();

                bool checkMultipleInteractionResult = true;

                if (currentMultipleInteractionSystem == null) {
                    checkMultipleInteractionResult = false;
                }

                if (deviceStringManager == null) {
                    checkMultipleInteractionResult = false;
                } else {
                    if (!deviceStringManager.useMultipleInteraction) {
                        checkMultipleInteractionResult = false;
                    }
                }

                if (checkMultipleInteractionResult) {
                    for (int i = 0; i < multipleInteractionInfoList.Count; i++) {
                        if (multipleInteractionInfoList [i].inputName.Equals (currentMultipleInteractionName)) {
                            bool interactionTypeLocated =
                                multipleInteractionInfoList [i].multipleInteractionNameList.Any (x => deviceStringManager.multipleInteractionNameList.Contains (x));

                            if (interactionTypeLocated) {
                                currentMultipleInteractionSystem.activateInteraction (multipleInteractionInfoList [i].multipleInteractionNameList, gameObject);
                            }
                        }
                    }
                } else {
                    return;
                }
            }

            vehicleHUDManager currentVehicleHUDManager = usableObjectFound.GetComponent<vehicleHUDManager> ();

            if (currentVehicleHUDManager != null) {
                setCurrentVehicleGameObject (usableObjectFound);

                currentVehicleHUDManager.setCurrentPassenger (gameObject);
            }

            mainRiderSystem currentMainRiderSystem = usableObjectFound.GetComponent<mainRiderSystem> ();

            if (currentMainRiderSystem != null) {
                if (!currentMainRiderSystem.isVehicleOnlyForOnePlayerActive ()) {
                    currentMainRiderSystem.setCurrentPassenger (gameObject);
                }
            }

            			//print (usableObjectFound.name + " " + currentDeviceIsPickup);

            if (currentDeviceIsPickup) {
                pickUpObject currentPickUpObject = usableObjectFound.GetComponentInParent<pickUpObject> ();

                if (currentPickUpObject != null) {
                    currentPickUpObject.setCurrentUser (gameObject);
                }
            }

            usableObjectFound.SendMessage (setCurrentUserOnDeviceFunctionName, gameObject, SendMessageOptions.DontRequireReceiver);

            usableObjectFound.SendMessage (useDeviceFunctionName, SendMessageOptions.DontRequireReceiver);

            //			print ("sending signal to device " + usableObjectFound.name);

            if (playerControllerManager.isUsingDevice ()) {
                checkIfSetOriginalShaderToPreviousDeviceFound (usableObjectFound);

                usingDevicePreviously = true;
            } else {
                if (existInDeviceList (usableObjectFound)) {
                    //print (usableObjectFound.name + " in device list");
                    checkIfSetNewShaderToDeviceFound (usableObjectFound);
                } else {
                    checkIfSetOriginalShaderToPreviousDeviceFound (usableObjectFound);
                    //print (usableObjectFound.name + " not in device list");
                }

                if (usingDevicePreviously) {
                    //					print ("previoulsy using device, change player collider state to search close devices to use");

                    bool isMainColliderEnabled = playerControllerManager.isMainColliderEnabled ();

                    playerControllerManager.setMainColliderState (false);
                    playerControllerManager.setMainColliderState (true);

                    playerControllerManager.setMainColliderState (isMainColliderEnabled);
                }

                usingDevicePreviously = false;
            }

            if (deviceStringManager != null) {
                if (deviceStringManager.setUsingDeviceState) {
                    deviceStringManager.checkSetUsingDeviceState ();
                }

                if (deviceStringManager.usingDevice) {
                    if (deviceStringManager.hideIconOnUseDevice) {
                        setIconButtonCanBeShownState (false);
                    }
                } else {
                    if (deviceStringManager.showIconOnStopUseDevice) {
                        setIconButtonCanBeShownState (true);
                    }
                }
            }

            checkIfRemoveDeviceFromList ();

            if (!usableObjectFound) {
                return;
            }

            if (usableObjectFound.GetComponent<useInventoryObject> ()) {
                return;
            }

            if (secondaryDeviceInfo == null) {
                deviceStringManager = usableObjectFound.GetComponent<deviceStringAction> ();
            }

            //if the device is a turret or a chest, disable the icon
            if (deviceStringManager != null) {
                if (deviceStringManager.disableIconOnPress) {
                    OnTriggerExit (usableObjectFound.GetComponent<Collider> ());

                    return;
                }

                if (deviceStringManager.hideIconOnPress) {
                    setIconButtonCanBeShownState (false);
                }

                if (deviceStringManager.reloadDeviceActionOnPress) {
                    checkDeviceName ();
                }
            }

            setInteractionButtonName ();
        }
    }

    public void useCurrentDevice (GameObject currentObjectToUse)
    {
        //		print ("Device To Use " + currentObjectToUse.name);

        objectToUse = currentObjectToUse;

        useDevice ();
    }

    public void setObjectToRemoveAferStopUse (GameObject objectToRemove)
    {
        objectToRemoveAferStopUse = objectToRemove;
    }

    public void checkIfRemoveDeviceFromList ()
    {
        if (!playerControllerManager.isUsingDevice ()) {
            if (objectToUse != null && objectToRemoveAferStopUse != null && objectToUse == objectToRemoveAferStopUse) {

                removeDeviceFromList (objectToRemoveAferStopUse);

                objectToRemoveAferStopUse = null;

                getclosestDevice (false, false);
            }
        }
    }

    public void takePickupsAround ()
    {
        if (!playerControllerManager.canPlayerRagdollMove () || !canUseDevices) {
            return;
        }

        List<GameObject> currentDeviceGameObjectList = new List<GameObject> (deviceGameObjectList);

        for (int i = 0; i < currentDeviceGameObjectList.Count; i++) {
            GameObject usableObjectFound = currentDeviceGameObjectList [i];

            if (usableObjectFound != null) {

                pickUpObject currentPickUpObject = usableObjectFound.GetComponentInParent<pickUpObject> ();

                if (currentPickUpObject != null) {
                    bool pickObjectResult = true;

                    if (holdingInteractionButtonActive) {

                        deviceStringAction currentDeviceStringAction = currentPickUpObject.GetComponentInChildren<deviceStringAction> ();

                        if (currentDeviceStringAction != null) {
                            if (currentDeviceStringAction.useHoldInteractionButton) {
                                pickObjectResult = false;
                            }
                        }
                    }

                    if (pickObjectResult) {
                        bool originalIgnoreExamineObjectBeforeStoreEnabled = currentPickUpObject.ignoreExamineObjectBeforeStoreEnabled;

                        currentPickUpObject.ignoreExamineObjectBeforeStoreEnabled = true;

                        usableObjectFound.SendMessage (useDeviceFunctionName, SendMessageOptions.DontRequireReceiver);

                        currentPickUpObject.ignoreExamineObjectBeforeStoreEnabled = originalIgnoreExamineObjectBeforeStoreEnabled;
                    }
                }
            }
        }

        getclosestDevice (false, false);
    }

    public void updateClosestDeviceList ()
    {
        getclosestDevice (false, false);
    }

    public void enableOrDisableTouchButton (bool state)
    {
        if (keepInteractionTouchButtonAlwaysActive) {
            return;
        }

        if (touchButtonLocated) {
            if (touchButton.activeSelf != state) {
                touchButton.SetActive (state);
            }
        }
    }

    //disable the icon showed when the player is inside a device's trigger
    public void disableIcon ()
    {
        enableOrDisableTouchButton (false);

        setIconButtonCanBeShownState (true);

        driving = false;

        objectToUse = null;
    }

    public void setIconButtonCanBeShownState (bool state)
    {
        iconButtonCanBeShown = state;
    }

    void updateCurrentIconButtonInfo (bool state)
    {
        if (useIconButtonInfoList && currentIconButtonInfo != null) {

            if (currentIconButtonInfo.iconButtonPanel.activeSelf != state) {
                currentIconButtonInfo.iconButtonPanel.SetActive (state);
            }
        }
    }

    public void setIconButtonState (bool state)
    {
        updateCurrentIconButtonInfo (state);

        if (iconButton.activeSelf != state) {
            iconButton.SetActive (state);
        }

        if (disableInteractionTouchButtonIfNotDevicesDetected) {
            enableOrDisableTouchButton (state);
        }

        iconButtonActive = state;

        if (!state) {
            if (showDetectedDevicesIconOnScreen) {
                for (int i = 0; i < deviceList.Count; i++) {
                    if (deviceList [i] != null) {
                        if (deviceList [i].deviceIcon.activeSelf) {
                            deviceList [i].deviceIcon.SetActive (false);
                        }
                    }
                }
            }
        }
    }

    public bool getCurrentIconButtonState ()
    {
        return iconButtonActive;
    }

    public void removeVehicleFromList ()
    {
        if (currentVehicle != null) {
            removeDeviceFromList (currentVehicle);
        }
    }

    public void setDrivingState (bool state)
    {
        //if the player is driving, and he is inside the trigger of other vehicle, disable the icon to use the other vehicle
        driving = state;

        setIconButtonCanBeShownState (!state);
    }

    public void setCurrentVehicle (GameObject vehicle)
    {
        setCurrentVehicleGameObject (vehicle);
    }

    public void removeCurrentVehicle (GameObject vehicle)
    {
        if (driving) {
            return;
        }

        if (vehicle == currentVehicle) {
            setCurrentVehicleGameObject (null);
        }
    }

    void setCurrentVehicleGameObject (GameObject newVehicle)
    {
        currentVehicle = newVehicle;
    }

    public void clearDeviceList ()
    {
        if (showDetectedDevicesIconOnScreen) {
            for (int i = 0; i < deviceList.Count; i++) {
                if (deviceList [i].deviceIcon != null) {
                    Destroy (deviceList [i].deviceIcon);
                }
            }
        }

        deviceList.Clear ();

        deviceGameObjectList.Clear ();

        deviceListContainsElements = false;
    }

    public void clearDeviceListButOne (GameObject objectToKeep)
    {
        for (int i = 0; i < deviceList.Count; i++) {
            if (deviceList [i].deviceGameObject != objectToKeep) {

                if (showDetectedDevicesIconOnScreen) {
                    if (deviceList [i].deviceIcon != null) {
                        Destroy (deviceList [i].deviceIcon);
                    }
                }

                if (holdingInteractionButtonActive) {
                    if (deviceList [i].deviceGameObject == currentDeviceToUseHoldInteraction) {
                        stopHoldInteractionButtonCoroutine ();

                        holdingInteractionButtonActive = false;
                    }
                }

                deviceList.RemoveAt (i);

                deviceGameObjectList.RemoveAt (i);

                i = 0;
            }
        }

        if (deviceList.Count == 0) {
            deviceListContainsElements = false;
        }
    }

    public void checkDeviceName ()
    {
        GameObject usableObjectFound = objectToUse;

        if (secondaryDeviceInfo != null) {
            usableObjectFound = secondaryDeviceInfo.deviceGameObject;
        }

        if (usableObjectFound != null) {
            deviceStringManager = usableObjectFound.GetComponent<deviceStringAction> ();

            if (deviceStringManager != null) {
                string deviceAction = "";

                deviceAction = deviceStringManager.getDeviceAction ();

                setKeyText (true);

                currentDeviceActionText = deviceAction;

                setActionAndNameText (deviceAction, deviceStringManager.getDeviceName ());

                currentDeviceIconTexture = deviceStringManager.iconTexture;
                currentDeviceDescription = deviceStringManager.objectDescription;
                currentDeviceDescriptionFontSize = deviceStringManager.descriptionFontSize;

                setExtraActionInfo (currentDeviceIconTexture, currentDeviceDescription);

                currentDeviceNameTextFontSize = deviceStringManager.getTextFontSize ();

                if (currentDeviceNameTextFontSize <= 0 && defaultDeviceNameFontSize > 0) {
                    currentDeviceNameTextFontSize = defaultDeviceNameFontSize;
                }

                if (currentDeviceNameTextFontSize > 0) {
                    objectNameText.fontSize = currentDeviceNameTextFontSize;
                }
            }
        }
    }

    public void reloadDeviceStringActionOnPlayer (GameObject objectToCheck)
    {
        if (objectToUse != null && objectToUse == objectToCheck) {
            checkDeviceName ();
        }
    }

    public bool existInDeviceList (GameObject objecToCheck)
    {
        if (objecToCheck != null) {
            if (deviceGameObjectList.Contains (objecToCheck)) {
                return true;
            }
        }

        return false;
    }

    public void removeDeviceFromList (GameObject objectToRemove)
    {
        for (int i = 0; i < deviceList.Count; i++) {
            if (deviceList [i].deviceGameObject == objectToRemove) {

                if (showDetectedDevicesIconOnScreen) {
                    if (deviceList [i].deviceIcon != null) {
                        Destroy (deviceList [i].deviceIcon);
                    }
                }

                deviceList.RemoveAt (i);

                deviceGameObjectList.RemoveAt (i);

                if (holdingInteractionButtonActive) {
                    if (objectToRemove == currentDeviceToUseHoldInteraction) {
                        stopHoldInteractionButtonCoroutine ();

                        holdingInteractionButtonActive = false;
                    }
                }
            }
        }

        if (deviceList.Count == 0) {
            objectToUse = null;
            currentDeviceInfo = null;

            deviceListContainsElements = false;
        }
    }

    public void removeDeviceFromListExternalCall (GameObject objectToRemove)
    {
        StartCoroutine (removeDeviceFromListExternalCallCoroutine (objectToRemove));
    }

    IEnumerator removeDeviceFromListExternalCallCoroutine (GameObject objectToRemove)
    {
        WaitForSeconds delay = new WaitForSeconds (0.01f);

        yield return delay;

        removeDeviceFromList (objectToRemove);

        checkIfSetOriginalShaderToPreviousDeviceFound (objectToRemove);
    }

    public void removeDeviceFromListUsingParent (GameObject objectToRemove)
    {
        for (int i = 0; i < deviceList.Count; i++) {
            if (deviceList [i].deviceTransform.IsChildOf (objectToRemove.transform)) {
                removeDeviceFromList (deviceList [i].deviceGameObject);
            }
        }
    }

    public bool isInTagsForDevicesList (GameObject objectToCheck)
    {
        if (tagsForDevices.Contains (objectToCheck.tag)) {
            return true;
        }

        return false;
    }

    public void setExamineteDevicesCameraState (bool state, bool useBlurUIPanel)
    {
        examinateDevicesCamera.enabled = state;

        if (useBlurUIPanel) {
            examineObjectRenderCamera.enabled = state;
        }

        examiningObject = state;
    }

    public Camera getExaminateDevicesCamera ()
    {
        return examinateDevicesCamera;
    }

    public bool isExaminingObject ()
    {
        return examiningObject;
    }

    public bool anyDeviceDetected ()
    {
        return deviceList.Count > 0 || deviceGameObjectList.Count > 0;
    }

    public GameObject getExamineObjectRenderTexturePanel ()
    {
        return examineObjectRenderTexturePanel;
    }

    public Transform getExamineObjectBlurPanelParent ()
    {
        return examineObjectBlurPanelParent;
    }

    public void setKeyText (bool state)
    {
        //set the key text in the icon with the current action
        if (keyText != null) {

            currentTouchButtonIcon = touchButtonIcon;
            currentKetText = keyText;
            currentExtraTextStartActionKey = extraTextStartActionKey;
            currentExtraTextEndActionKey = extraTextEndActionKey;

            useMultipleInteractionInfo = false;

            currentUseMultipleTouchButtonIcon = false;

            if (useIconButtonInfoList) {
                if (currentIconButtonInfo != null) {
                    currentTouchButtonIcon = currentIconButtonInfo.touchButtonIcon;
                    currentKetText = currentIconButtonInfo.keyText;
                    currentExtraTextStartActionKey = currentIconButtonInfo.extraTextStartActionKey;
                    currentExtraTextEndActionKey = currentIconButtonInfo.extraTextEndActionKey;

                    useMultipleInteractionInfo = currentIconButtonInfo.useMultipleInteractionInfo;

                    if (useMultipleInteractionInfo) {
                        currentKeyTextList = currentIconButtonInfo.keyTextList;
                    }

                    currentUseMultipleTouchButtonIcon = currentIconButtonInfo.useMultipleTouchButtonIcon;

                    if (currentUseMultipleTouchButtonIcon) {
                        currentMultipleTouchButtonIconList = currentIconButtonInfo.multipleTouchButtonIconList;
                    }
                }
            }

            bool touchControlsActive = playerInput.isUsingTouchControls ();

            bool useSingleCurrentTouchButtonResult = true;

            if (currentUseMultipleTouchButtonIcon) {
                if (currentMultipleTouchButtonIconList.Count > 0) {
                    for (int i = 0; i < currentMultipleTouchButtonIconList.Count; i++) {
                        if (currentMultipleTouchButtonIconList [i].gameObject.activeSelf != touchControlsActive) {
                            currentMultipleTouchButtonIconList [i].gameObject.SetActive (touchControlsActive);
                        }
                    }

                    useSingleCurrentTouchButtonResult = false;
                }
            }

            if (currentTouchButtonIcon != null) {
                if (useSingleCurrentTouchButtonResult) {
                    if (currentTouchButtonIcon.activeSelf != touchControlsActive) {
                        currentTouchButtonIcon.SetActive (touchControlsActive);
                    }
                } else {
                    if (currentTouchButtonIcon.activeSelf != false) {
                        currentTouchButtonIcon.SetActive (false);
                    }
                }
            }

            if (useMultipleInteractionInfo) {
                for (int i = 0; i < currentKeyTextList.Count; i++) {
                    if (currentKeyTextList [i].gameObject.activeSelf != !touchControlsActive) {
                        currentKeyTextList [i].gameObject.SetActive (!touchControlsActive);
                    }
                }
            } else {
                if (currentKetText != null) {
                    if (currentKetText.gameObject.activeSelf != !touchControlsActive) {
                        currentKetText.gameObject.SetActive (!touchControlsActive);
                    }
                }
            }

            if (!touchControlsActive) {
                if (useMultipleInteractionInfo) {
                    for (int i = 0; i < currentKeyTextList.Count; i++) {
                        string textValue = "";

                        if (state) {
                            if (deviceStringManager != null && deviceStringManager.multipleInteractionNameList.Count > i) {
                                string buttonKeyValue = getInteractionActionName (deviceStringManager.multipleInteractionNameList [i]);

                                if (buttonKeyValue != "") {

                                    textValue = currentExtraTextStartActionKey +
                                    playerInput.getButtonKey (buttonKeyValue) +
                                    currentExtraTextEndActionKey;
                                }
                            }
                        }

                        currentKeyTextList [i].text = textValue;
                    }
                } else {
                    if (currentKetText != null) {
                        if (state) {
                            currentKetText.text = currentExtraTextStartActionKey + playerInput.getButtonKey (useDevicesActionName) + currentExtraTextEndActionKey;
                        } else {
                            currentKetText.text = "";
                        }
                    }
                }
            }
        }
    }

    string getInteractionActionName (string interactionName)
    {
        for (int i = 0; i < multipleInteractionInfoList.Count; i++) {
            if (multipleInteractionInfoList [i].multipleInteractionNameList.Contains (interactionName)) {
                return multipleInteractionInfoList [i].inputName;
            }
        }

        return "";
    }

    public void setActionAndNameText (string newActionText, string newObjectNameText)
    {
        if (actionText != null) {
            currentActionText = actionText;
            currentObjectNameText = objectNameText;

            useMultipleInteractionInfo = false;

            if (useIconButtonInfoList) {
                if (currentIconButtonInfo != null) {
                    if (currentIconButtonInfo.actionText != null) {
                        currentActionText = currentIconButtonInfo.actionText;
                    }

                    if (currentIconButtonInfo.objectNameText != null) {
                        currentObjectNameText = currentIconButtonInfo.objectNameText;
                    }

                    useMultipleInteractionInfo = currentIconButtonInfo.useMultipleInteractionInfo;

                    if (useMultipleInteractionInfo) {
                        currentActionTextList = currentIconButtonInfo.actionTextList;
                    }
                }
            }

            bool isCheckLanguageActive = gameLanguageSelector.isCheckLanguageActive ();

            if (isCheckLanguageActive) {
                if (newObjectNameText != null && newObjectNameText != "") {
                    newObjectNameText = interactionObjectsLocalizationManager.GetLocalizedValue (newObjectNameText);
                }

                currentObjectNameText.text = newObjectNameText;
            }

            if (useMultipleInteractionInfo) {
                for (int i = 0; i < currentActionTextList.Count; i++) {
                    if (deviceStringManager.multipleInteractionNameList.Count > i) {
                        string keyTextValue = deviceStringManager.multipleInteractionNameList [i];

                        if (isCheckLanguageActive) {
                            keyTextValue = interactionObjectsLocalizationManager.GetLocalizedValue (keyTextValue);
                        }

                        currentActionTextList [i].text = keyTextValue;
                    }
                }
            } else {
                if (isCheckLanguageActive) {
                    if (newActionText != null && newActionText != "") {
                        newActionText = interactionObjectsLocalizationManager.GetLocalizedValue (newActionText);
                    }
                }

                currentActionText.text = newActionText;
            }
        }
    }

    public void setExtraActionInfo (Texture newIcon, string newDescription)
    {
        currentObjectImage = objectImage;
        currentObjectDescriptionText = objectDescriptionText;

        if (useIconButtonInfoList) {
            if (currentIconButtonInfo != null) {
                if (currentIconButtonInfo.objectImage != null) {
                    currentObjectImage = currentIconButtonInfo.objectImage;
                }

                if (currentIconButtonInfo.objectDescriptionText != null) {
                    currentObjectDescriptionText = currentIconButtonInfo.objectDescriptionText;
                }
            }
        }

        if (currentObjectImage != null) {
            if (newIcon != null) {
                if (currentObjectImage.gameObject.activeSelf != true) {
                    currentObjectImage.gameObject.SetActive (true);
                }

                currentObjectImage.texture = newIcon;
            } else {
                if (currentObjectImage.gameObject.activeSelf != false) {
                    currentObjectImage.gameObject.SetActive (false);
                }
            }
        }

        if (currentObjectDescriptionText != null) {
            if (newDescription != "") {
                if (currentObjectDescriptionText.gameObject.activeSelf != true) {
                    currentObjectDescriptionText.gameObject.SetActive (true);
                }

                if (gameLanguageSelector.isCheckLanguageActive ()) {
                    newDescription = interactionObjectsLocalizationManager.GetLocalizedValue (newDescription);
                }

                currentObjectDescriptionText.text = newDescription;

                currentObjectDescriptionText.fontSize = currentDeviceDescriptionFontSize;
            } else {
                if (currentObjectDescriptionText.gameObject.activeSelf != false) {
                    currentObjectDescriptionText.gameObject.SetActive (false);
                }
            }
        }

        checkNewTouchButtonRawImageIcon ();
    }

    void checkNewTouchButtonRawImageIcon ()
    {
        bool usingCustomTouchButtonRawImage = false;

        if (useIconButtonInfoList) {
            if (currentIconButtonInfo != null && currentIconButtonInfo.setNewTouchButtonRawImageIcon && touchButtonRawImage != null) {
                touchButtonRawImage.texture = currentIconButtonInfo.newTouchButtonRawImageIcon;

                usingNewTouchButtonRawImageIcon = true;

                usingCustomTouchButtonRawImage = true;
            }
        }

        if (!usingCustomTouchButtonRawImage) {
            if (usingNewTouchButtonRawImageIcon && touchButtonRawImage != null) {
                touchButtonRawImage.texture = originalTouchButtonRawImage;

                usingNewTouchButtonRawImageIcon = false;
            }
        }
    }

    public void updateUIInfo ()
    {
        checkDeviceName ();
    }

    public void checkShowObjectMessage (string message, float waitTime)
    {
        if (showObjectMessageCoroutine != null) {
            StopCoroutine (showObjectMessageCoroutine);
        }

        showObjectMessageCoroutine = StartCoroutine (showObjectMessage (message, waitTime));
    }

    IEnumerator showObjectMessage (string message, float waitTime)
    {
        if (gameLanguageSelector.isCheckLanguageActive ()) {
            message = interactionObjectsLocalizationManager.GetLocalizedValue (message);
        }

        interactionMessageText.text = message;

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

        WaitForSeconds delay = new WaitForSeconds (waitTime);

        yield return delay;

        if (waitTime > 0) {
            interactionMessageGameObject.SetActive (false);
        }
    }

    public void stopShowObjectMessage ()
    {
        if (showObjectMessageCoroutine != null) {
            StopCoroutine (showObjectMessageCoroutine);
        }

        if (interactionMessageGameObject.activeSelf) {
            interactionMessageGameObject.SetActive (false);
        }
    }

    public string getCurrentDeviceActionText ()
    {
        return currentDeviceActionText;
    }

    public bool hasDeviceToUse ()
    {
        return objectToUse != null;
    }

    public void setUseDeviceButtonEnabledState (bool state)
    {
        useDeviceButtonEnabled = state;

        holdingButton = false;
    }

    int useDeviceButtonEnabledCounter = 0;

    public void setUseDeviceButtonEnabledStateByCounter (bool state)
    {
        if (state) {
            useDeviceButtonEnabledCounter++;
        } else {
            useDeviceButtonEnabledCounter--;

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

        if (useDeviceButtonEnabledCounter == 0) {
            setUseDeviceButtonEnabledState (true);
        } else {
            setUseDeviceButtonEnabledState (false);
        }
    }

    public void setPauseUseDeviceButtonForDurationState (float pauseDuration)
    {
        stopSetPauseUseDeviceButtonForDurationState ();

        pauseUseDeviceButtonForDuration = StartCoroutine (setPauseUseDeviceButtonForDurationStateCoroutine (pauseDuration));
    }

    public void stopSetPauseUseDeviceButtonForDurationState ()
    {
        if (pauseUseDeviceButtonForDuration != null) {
            StopCoroutine (pauseUseDeviceButtonForDuration);
        }
    }

    IEnumerator setPauseUseDeviceButtonForDurationStateCoroutine (float pauseDuration)
    {
        useDeviceButtonEnabled = false;

        WaitForSeconds delay = new WaitForSeconds (pauseDuration);

        yield return delay;

        useDeviceButtonEnabled = true;
    }

    public void checkIfPickObjectsAround ()
    {
        if (holdingButton) {
            if (Time.time > lastTimePressedButton + holdButtonTime) {
                //print ("take all");
                takePickupsAround ();

                holdingButton = false;
            } else {

                if (!holdingInteractionButtonActive) {
                    useDevice ();
                }
            }
        }

        holdingButton = false;
    }

    public void checkIfStopUseDeviceIfDrivingVehicle ()
    {
        if (driving) {
            if (currentVehicle != null) {
                useCurrentDevice (currentVehicle);
            }
        }
    }

    public void checkIfStopUseDevice ()
    {
        if (playerControllerManager.isUsingDevice ()) {
            useDevice ();
        }
    }

    void checkInteractionActions ()
    {
        if (useInteractionActions) {
            bool playerCanUseActionsResult = (!playerControllerManager.isGamePaused () && !playerControllerManager.isPlayerMenuActive ());

            for (int i = 0; i < interactionActionInfoList.Count; i++) {

                if (!interactionActionInfoList [i].canBeUsedOnGamePaused || playerCanUseActionsResult) {

                    interactionActionInfoList [i].eventOnInteraction.Invoke ();
                }
            }
        }
    }

    IEnumerator updateHoldInteractionButtonCoroutine ()
    {
        //		print ("start hold coroutine");

        float timer = 0;

        bool targetReached = false;

        bool currentHoldInteractionSliderLocated = currentHoldInteractionSlider != null;

        bool holdInteractionTimerTextLocated = holdInteractionTimerText != null;

        if (currentHoldInteractionSliderLocated) {
            currentHoldInteractionSlider.fillAmount = 0;
        }

        if (holdInteractionTimerText != null) {
            holdInteractionTimerText.gameObject.SetActive (true);
        }

        while (!targetReached) {
            timer += Time.deltaTime;

            if (timer >= currentHoldInteractionButtonDuration) {
                targetReached = true;
            } else {
                if (currentHoldInteractionSliderLocated) {
                    currentHoldInteractionSlider.fillAmount = timer / currentHoldInteractionButtonDuration;

                    if (showHoldInteractionTimer) {
                        if (holdInteractionTimerTextLocated) {
                            holdInteractionTimerText.text = (currentHoldInteractionButtonDuration - timer).ToString ("F1");
                        }
                    }
                }
            }

            yield return null;
        }

        if (currentDeviceToUseHoldInteraction != null && deviceGameObjectList.Contains (currentDeviceToUseHoldInteraction)) {
            useCurrentDevice (currentDeviceToUseHoldInteraction);

            checkInteractionActions ();
        }

        if (currentHoldInteractionSliderLocated) {
            currentHoldInteractionSlider.fillAmount = 0;
        }

        if (holdInteractionTimerText != null) {
            holdInteractionTimerText.gameObject.SetActive (false);
        }

        holdingInteractionButtonActive = false;
    }

    public void stopHoldInteractionButtonCoroutine ()
    {
        //		print ("stop coroutine hold");

        if (holdInteractionButtonCoroutine != null) {
            StopCoroutine (holdInteractionButtonCoroutine);
        }

        if (currentHoldInteractionSlider != null) {
            currentHoldInteractionSlider.fillAmount = 0;
        }

        if (holdInteractionTimerText != null) {
            holdInteractionTimerText.text = "";
        }
    }

    public void setPauseVehicleGetOffInputState (bool state)
    {
        pauseVehicleGetOffInput = state;
    }

    public bool ispauseVehicleGetOffInputActive ()
    {
        return pauseVehicleGetOffInput;
    }

    //CALL INPUT FUNCTIONS
    public void inputActivateDeviceByInteractionNameText (Text interactionNameText)
    {
        if (interactionNameText == null) {
            return;
        }

        if (useMultipleInteractionInfo) {
            if (currentIconButtonInfo != null) {
                if (currentIconButtonInfo.actionTextList.Count > 0) {
                    if (currentIconButtonInfo.actionTextList.Contains (interactionNameText)) {
                        string currentButtonActionNameText = interactionNameText.text;

                        //						print (currentIconButtonInfo.Name + " " + currentButtonActionNameText);

                        bool isCheckLanguageActive = gameLanguageSelector.isCheckLanguageActive ();

                        for (int i = 0; i < multipleInteractionInfoList.Count; i++) {
                            if (isCheckLanguageActive) {
                                for (int j = 0; j < multipleInteractionInfoList [i].multipleInteractionNameList.Count; j++) {
                                    string currentText = multipleInteractionInfoList [i].multipleInteractionNameList [j];

                                    string keyTextValue = interactionObjectsLocalizationManager.GetLocalizedValue (currentText);

                                    if (keyTextValue == null || keyTextValue == "") {
                                        keyTextValue = currentText;
                                    }

                                    //									print (keyTextValue);

                                    if (currentButtonActionNameText.Equals (keyTextValue)) {
                                        //										print (multipleInteractionInfoList [i].inputName);

                                        inputActivateDeviceByName (multipleInteractionInfoList [i].inputName);

                                        return;
                                    }
                                }
                            } else {
                                if (multipleInteractionInfoList [i].multipleInteractionNameList.Contains (currentButtonActionNameText)) {
                                    //									print (multipleInteractionInfoList [i].inputName);

                                    inputActivateDeviceByName (multipleInteractionInfoList [i].inputName);

                                    return;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    public void inputActivateDeviceByName (string interactionName)
    {
        currentMultipleInteractionName = interactionName;

        checkMultipleInteractionActive = true;

        inputActivateDevice ();

        checkMultipleInteractionActive = false;

        currentMultipleInteractionName = "";
    }

    public void inputActivateDevice ()
    {
        if (useDeviceButtonEnabled) {
            bool useDeviceResult = false;

            if (!currentDeviceIsPickup || !holdButtonToTakePickupsAround) {
                useDeviceResult = true;
            }

            if (currentDeviceIsPickup) {
                if (deviceStringManager != null) {
                    if (deviceStringManager.useHoldInteractionButton) {
                        useDeviceResult = true;
                    }
                }
            }

            if (useDeviceResult) {
                useDevice ();
            }
        }

        //		print ("press down interaction button");

        if (holdingInteractionButtonActive) {
            return;
        }

        checkInteractionActions ();
    }

    public void inputHoldToPickObjectsAround ()
    {
        if (useDeviceButtonEnabled) {
            if (currentDeviceIsPickup && holdButtonToTakePickupsAround) {
                holdingButton = true;

                lastTimePressedButton = Time.time;
            }
        }
    }

    public void inputReleaseToPickObjectsAround ()
    {
        if (useDeviceButtonEnabled) {
            if (currentDeviceIsPickup && holdButtonToTakePickupsAround) {
                checkIfPickObjectsAround ();
            }

            if (holdInteractionButtonEnabled) {
                if (holdingInteractionButtonActive) {
                    disableHoldInteractionButtonState ();
                }
            }
        }
    }


    void disableHoldInteractionButtonState ()
    {
        if (holdingInteractionButtonActive) {
            stopHoldInteractionButtonCoroutine ();

            holdingInteractionButtonActive = false;

            if (currentHoldInteractionSlider != null) {
                currentHoldInteractionSlider.fillAmount = 0;
            }

            if (holdInteractionTimerText != null) {
                holdInteractionTimerText.gameObject.SetActive (false);
            }

            //					print ("release hold button");
        }
    }

    public void setUsedByAIState (bool state)
    {
        usedByAI = state;
    }

    public void setCanUseDevicesState (bool state)
    {
        canUseDevices = state;
    }

    public void setUseDeviceFoundShaderState (bool state)
    {
        useDeviceFoundShader = state;
    }

    public void setUseDeviceFoundShaderStateFromEditor (bool state)
    {
        setUseDeviceFoundShaderState (state);

        updateComponent ();
    }

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

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

    [System.Serializable]
    public class deviceInfo
    {
        public GameObject deviceGameObject;
        public Transform deviceTransform;

        public Transform positionToIcon;
        public bool useTransformForStringAction;
        public bool useSeparatedTransformForEveryView;
        public float actionOffset;
        public bool useLocalOffset;

        public GameObject deviceIcon;
        public RectTransform deviceIconRectTransform;

        public bool useCustomMinDistanceToUseDevice;
        public float customMinDistanceToUseDevice;

        public bool ignoreDistanceToDevice;

        public bool useCustomMinAngleToUse;
        public float customMinAngleToUseDevice;
        public bool useRelativeDirectionBetweenPlayerAndObject;

        public bool removeDeviceFromPlayerListOnMaxDistance;
        public float maxDistanceToRemoveDeviceFromPlayerList;

        public bool ignoreUseOnlyDeviceIfVisibleOnCamera;

        public bool useCustomDeviceTransformPosition;
        public Transform customDeviceTransformPosition;

        public bool useFixedDeviceIconPosition;

        public bool checkIfObstacleBetweenDeviceAndPlayer;

        public bool useMaxDistanceToCameraCenter;
        public float maxDistanceToCameraCenter;
    }

    [System.Serializable]
    public class interactionActionInfo
    {
        public string Name;
        public UnityEvent eventOnInteraction;
        public bool canBeUsedOnGamePaused;
    }

    [System.Serializable]
    public class iconButtonInfo
    {
        public string Name;
        public GameObject iconButtonPanel;
        public Text keyText;
        public Text actionText;
        public Text objectNameText;
        public GameObject touchButtonIcon;
        public string extraTextStartActionKey = "[";
        public string extraTextEndActionKey = "]";

        public RawImage objectImage;
        public Text objectDescriptionText;

        public bool useFixedPosition;
        public Transform fixedPositionTransform;

        public bool setNewTouchButtonRawImageIcon;
        public Texture newTouchButtonRawImageIcon;

        public bool useMultipleInteractionInfo;

        public Image holdInteractionSlider;

        public bool showHoldInteractionTimer;
        public Text holdInteractionTimerText;

        public bool useMultipleTouchButtonIcon;
        public List<GameObject> multipleTouchButtonIconList = new List<GameObject> ();

        public List<Text> keyTextList = new List<Text> ();
        public List<Text> actionTextList = new List<Text> ();
    }

    [System.Serializable]
    public class multipleInteractionInfo
    {
        public string inputName;

        public List<string> multipleInteractionNameList = new List<string> ();
    }
}