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

public class lockedCameraSystem : MonoBehaviour
{
    public LayerMask layerToPlaceNewCamera;
    public bool useRaycastToPlaceCameras;
    public Vector3 eventTriggerScale;
    public List<cameraElement> lockedCameraList = new List<cameraElement> ();

    public bool showGizmo;
    public bool showGizmoOnPlaying;
    public Color gizmoColor;
    public Color gizmoLabelColor;

    public float gizmoRadius = 0.3f;
    public float gizmoArrowLength = 1.4f;
    public float gizmoArrowLineLength = 3.4f;
    public float gizmoArrowAngle = 20;

    public Color gizmoArrowColor;
    public GameObject cameraTransformPrefab;
    public GameObject cameraTriggerPrefab;
    public bool useFreeHandle;
    public float handleRadius = 0.1f;
    public Color handleGizmoColor;

    public Color boundColor = Color.red;

    public bool showDoPositionHandles;
    public bool showButtons = true;
    public float buttonsSize = 0.1f;

    public bool showFloorTriggersCubes;
    public Color floorTriggersCubesColor;

    public bool showWaypointList;
    public Color waypointListColor;

    [TextArea (5, 10)]
    public string cameraViewExplanation = "" +
        "Camera Axis is the pivot of the camera and Camera Position is the parent where the main " +
        "camera is attached. To adjust the view of the locked camera, only apply position on the X and Z " +
        "values of the Camera Axis transform. Camera position tansform must remain on 0,0,0 position.\n\n" +
        "For rotation, you can adjust the Y Axis of the Camera Axis Transform and the X Axis of the Camera " +
        "Position transform, to adjust the view of such camera\n";


    playerCamera playerCameraManager;
    GameObject currentPlayer;

    void Start ()
    {
        cameraElement currentCameraElement;
        cameraAxis currentCameraAxis;

        int lockedCameraListCount = lockedCameraList.Count;

        for (int i = 0; i < lockedCameraListCount; i++) {
            currentCameraElement = lockedCameraList [i];

            int cameraTransformListCount = currentCameraElement.cameraTransformList.Count;

            for (int j = 0; j < cameraTransformListCount; j++) {

                currentCameraAxis = currentCameraElement.cameraTransformList [j];

                if (currentCameraAxis.axis != null) {
                    currentCameraAxis.originalPivotRotationY = currentCameraAxis.axis.localEulerAngles.y;
                } else {
                    print ("WARNING: camera axis on " + currentCameraElement.name + " " + currentCameraAxis.name + " not found, check the locked camera" +
                    "system inspector");
                }

                if (currentCameraAxis.cameraPosition != null) {
                    currentCameraAxis.originalCameraRotationX = currentCameraAxis.cameraPosition.localEulerAngles.x;
                    currentCameraAxis.originalCameraLocalPosition = currentCameraAxis.cameraPosition.localPosition;
                    currentCameraAxis.originalCameraForward = currentCameraAxis.axis.InverseTransformDirection (currentCameraAxis.cameraPosition.forward);
                } else {
                    print ("WARNING: camera position on " + currentCameraElement.name + " " + currentCameraAxis.name + " not found, check the locked camera" +
                    "system inspector");
                }

                if (currentCameraAxis.axis != null) {
                    currentCameraAxis.originalCameraAxisLocalPosition = currentCameraAxis.axis.localPosition;
                } else {
                    print ("WARNING: camera axis on " + currentCameraElement.name + " " + currentCameraAxis.name + " not found, check the locked camera" +
                    "system inspector");
                }

                if (currentCameraAxis.lockedCameraPivot != null) {
                    currentCameraAxis.originalLockedCameraPivotPosition = currentCameraAxis.lockedCameraPivot.position;
                }
            }
        }

        StartCoroutine (checkCamerasCoroutine ());
    }

    IEnumerator checkCamerasCoroutine ()
    {
        WaitForSeconds delay = new WaitForSeconds (0.0001f);

        yield return delay;

        checkStartGameWithView ();
    }

    void checkStartGameWithView ()
    {
        cameraElement currentCameraElement;
        cameraAxis currentCameraAxis;

        int lockedCameraListCount = lockedCameraList.Count;

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

            currentCameraElement = lockedCameraList [i];

            int cameraTransformListCount = currentCameraElement.cameraTransformList.Count;

            for (int j = 0; j < cameraTransformListCount; j++) {
                currentCameraAxis = currentCameraElement.cameraTransformList [j];

                if (currentCameraAxis.startGameWithThisView) {

                    if (!currentCameraAxis.smoothTransitionAtStart) {
                        currentCameraAxis.previoslyUseSmoohtTransitionState = currentCameraAxis.smoothCameraTransition;

                        currentCameraAxis.smoothCameraTransition = false;
                    }

                    if (currentCameraAxis.useMultiplePlayers) {
                        for (int k = 0; k < currentCameraAxis.playerForViewList.Count; k++) {
                            if (currentCameraAxis.playerForViewList [k] != null) {
                                getPlayerGameObject (currentCameraAxis.playerForViewList [k]);
                                setCameraTransform (currentCameraAxis.cameraPosition.gameObject);
                            }
                        }
                    } else {
                        if (currentCameraAxis.playerForView != null) {
                            getPlayerGameObject (currentCameraAxis.playerForView);
                            setCameraTransform (currentCameraAxis.cameraPosition.gameObject);
                        }
                    }

                    if (!currentCameraAxis.smoothTransitionAtStart) {
                        currentCameraAxis.smoothCameraTransition = currentCameraAxis.previoslyUseSmoohtTransitionState;
                    }
                }

                if (currentCameraAxis.setAIToStartOn2_5DView) {
                    if (currentCameraAxis.setViewOnAllAIOnScene) {
                        findObjectivesSystem [] findObjectivesSystemList = FindObjectsOfType<findObjectivesSystem> ();

                        foreach (findObjectivesSystem currentFindObjectivesSystem in findObjectivesSystemList) {
                            currentFindObjectivesSystem.enableOrDisable2_5ModeOnAIWithPivotPositionValues (true,
                                currentCameraAxis.originalLockedCameraPivotPosition, currentCameraAxis.moveInXAxisOn2_5d);
                        }
                    } else {
                        int AIForViewListCount = currentCameraAxis.AIForViewList.Count;

                        for (int k = 0; k < AIForViewListCount; k++) {
                            if (currentCameraAxis.AIForViewList [k] != null) {
                                findObjectivesSystem currentFindObjectivesSystem = currentCameraAxis.AIForViewList [k].GetComponentInChildren<findObjectivesSystem> ();

                                if (currentFindObjectivesSystem != null) {
                                    currentFindObjectivesSystem.enableOrDisable2_5ModeOnAIWithPivotPositionValues (true,
                                        currentCameraAxis.cameraPosition.position, currentCameraAxis.moveInXAxisOn2_5d);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    public void setCameraTransform (GameObject cameraTransform)
    {
        if (playerCameraManager == null) {
            return;
        }

        if (playerCameraManager != null && playerCameraManager.getCurrentLockedCameraTransform () == cameraTransform.transform) {
            return;
        }

        cameraElement currentCameraElement;
        cameraAxis currentCameraAxis;

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

            currentCameraElement = lockedCameraList [i];

            for (int j = 0; j < lockedCameraList [i].cameraTransformList.Count; j++) {

                currentCameraAxis = currentCameraElement.cameraTransformList [j];

                if (currentCameraAxis.cameraPosition == cameraTransform.transform) {
                    if (currentCameraElement.setCameraToFree) {
                        playerCameraManager.setCameraToFreeOrLocked (playerCamera.typeOfCamera.free, currentCameraAxis);
                    } else {
                        playerCameraManager.setCameraToFreeOrLocked (playerCamera.typeOfCamera.locked, currentCameraAxis);

                        if (currentCameraAxis.useCameraLimitSystem) {
                            currentCameraAxis.mainCamera2_5dZoneLimitSystem.setCameraLimitOnPlayer (playerCameraManager.getPlayerControllerGameObject ());
                        }
                    }

                    currentCameraElement.isCurrentCameraTransform = true;
                } else {
                    currentCameraElement.isCurrentCameraTransform = false;
                }
            }
        }
    }

    public void findPlayerOnScene ()
    {
        getPlayerGameObject (GKC_Utils.findMainPlayerOnScene ());
    }

    public void getPlayerGameObject (GameObject objectToCheck)
    {
        if (!objectToCheck) {
            return;
        }

        currentPlayer = objectToCheck;

        playerComponentsManager mainPlayerComponentsManager = currentPlayer.GetComponent<playerComponentsManager> ();

        if (mainPlayerComponentsManager != null) {
            playerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();
        } else {
            //			print (objectToCheck.name);

            vehicleHUDManager currentvehicleHUDManager = applyDamage.getVehicleHUDManager (objectToCheck);

            if (currentvehicleHUDManager != null && currentvehicleHUDManager.isVehicleBeingDriven ()) {
                currentPlayer = currentvehicleHUDManager.getCurrentDriver ();

                if (currentPlayer != null) {
                    mainPlayerComponentsManager = currentPlayer.GetComponent<playerComponentsManager> ();

                    if (mainPlayerComponentsManager != null) {
                        playerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();
                    }
                }
            }
        }
    }

    public void setLockedCameraToEditorCameraPosition (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        Camera currentCameraEditor = GKC_Utils.getCameraEditor ();

        if (currentCameraEditor != null) {
            Vector3 editorCameraPosition = currentCameraEditor.transform.position;
            Quaternion editorCameraRotation = currentCameraEditor.transform.rotation;
            Vector3 editorCameraEuler = editorCameraRotation.eulerAngles;

            cameraAxis currentCameraAxis = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex];

            Transform axisTransform = currentCameraAxis.axis;

            Transform cameraTransform = currentCameraAxis.cameraPosition;

            axisTransform.position = editorCameraPosition;

            axisTransform.rotation = Quaternion.Euler (new Vector3 (0, editorCameraEuler.y, 0));

            cameraTransform.localRotation = Quaternion.Euler (new Vector3 (editorCameraEuler.x, 0, 0));

            if (currentCameraAxis.lockedCameraPivot != null) {
                Transform currentLockedCameraPivot = currentCameraAxis.lockedCameraPivot;

                //GKC_Utils.unpackPrefabObject (gameObject);

                //axisTransform.SetParent (null);

                Vector3 temporalAxisPosition = axisTransform.position;
                Quaternion temporalAxisRotation = axisTransform.rotation;

                currentLockedCameraPivot.position = currentCameraAxis.axis.position;
                currentLockedCameraPivot.rotation = currentCameraAxis.axis.rotation;

                //currentCameraAxis.axis.SetParent (currentLockedCameraPivot);

                axisTransform.position = temporalAxisPosition;
                axisTransform.rotation = temporalAxisRotation;
            }

            if (currentCameraAxis.followPlayerPosition && currentCameraAxis.useTopDownView) {
                if (currentCameraAxis.lockedCameraPivot != null) {
                    Transform currentLockedCameraPivot = currentCameraAxis.lockedCameraPivot;

                    Vector3 axisTransformTargetPosition = currentLockedCameraPivot.position;

                    Vector3 axisTransformTargetEuler = currentLockedCameraPivot.eulerAngles;

                    currentLockedCameraPivot.localPosition = Vector3.zero;
                    currentLockedCameraPivot.localRotation = Quaternion.identity;

                    axisTransform.position = editorCameraPosition;

                    axisTransform.eulerAngles = axisTransformTargetEuler;

                    cameraTransform.localPosition = Vector3.zero;
                }
            }
        }

        updateComponent ();
    }

    public void setEditorCameraPositionToLockedCamera (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        Transform lockedCameraTransform = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex].cameraPosition;

        setEditorCameraPosition (lockedCameraTransform);
    }

    void duplicateCameraAxisValues (cameraAxis newState, cameraAxis stateToDuplicate)
    {
        newState.useDifferentCameraFov = stateToDuplicate.useDifferentCameraFov;
        newState.fovValue = stateToDuplicate.fovValue;

        newState.followPlayerPosition = stateToDuplicate.followPlayerPosition;
        newState.putCameraOutsideOfPivot = stateToDuplicate.putCameraOutsideOfPivot;
        newState.followPlayerPositionSmoothly = stateToDuplicate.followPlayerPositionSmoothly;
        newState.followPlayerPositionSpeed = stateToDuplicate.followPlayerPositionSpeed;
        newState.useLerpToFollowPlayerPosition = stateToDuplicate.useLerpToFollowPlayerPosition;

        newState.useSeparatedVerticalHorizontalSpeed = stateToDuplicate.useSeparatedVerticalHorizontalSpeed;
        newState.verticalFollowPlayerPositionSpeed = stateToDuplicate.verticalFollowPlayerPositionSpeed;
        newState.horizontalFollowPlayerPositionSpeed = stateToDuplicate.horizontalFollowPlayerPositionSpeed;

        newState.lookAtPlayerPosition = stateToDuplicate.lookAtPlayerPosition;
        newState.lookAtPlayerPositionSpeed = stateToDuplicate.lookAtPlayerPositionSpeed;

        newState.lookAtCustomTarget = stateToDuplicate.lookAtCustomTarget;

        newState.lookAtCustomMultipleTargets = stateToDuplicate.lookAtCustomMultipleTargets;

        newState.useRotationLimits = stateToDuplicate.useRotationLimits;
        newState.rotationLimitsX = stateToDuplicate.rotationLimitsX;
        newState.rotationLimitsY = stateToDuplicate.rotationLimitsY;

        newState.usePositionOffset = stateToDuplicate.usePositionOffset;
        newState.positionOffset = stateToDuplicate.positionOffset;

        newState.smoothCameraTransition = stateToDuplicate.smoothCameraTransition;
        newState.cameraTransitionSpeed = stateToDuplicate.cameraTransitionSpeed;


        newState.smoothTransitionAtStart = stateToDuplicate.smoothTransitionAtStart;
        newState.previoslyUseSmoohtTransitionState = stateToDuplicate.previoslyUseSmoohtTransitionState;

        newState.setAIToStartOn2_5DView = stateToDuplicate.setAIToStartOn2_5DView;

        newState.setViewOnAllAIOnScene = stateToDuplicate.setViewOnAllAIOnScene;

        newState.cameraCanRotate = stateToDuplicate.cameraCanRotate;

        newState.rangeAngleX = stateToDuplicate.rangeAngleX;
        newState.rangeAngleY = stateToDuplicate.rangeAngleY;

        newState.useSpringRotation = stateToDuplicate.useSpringRotation;
        newState.springRotationDelay = stateToDuplicate.springRotationDelay;

        newState.smoothRotation = stateToDuplicate.smoothRotation;
        newState.rotationSpeed = stateToDuplicate.rotationSpeed;

        newState.originalPivotRotationY = stateToDuplicate.originalPivotRotationY;
        newState.originalCameraRotationX = stateToDuplicate.originalCameraRotationX;

        newState.canUseZoom = stateToDuplicate.canUseZoom;
        newState.zoomValue = stateToDuplicate.zoomValue;

        newState.useZoomByMovingCamera = stateToDuplicate.useZoomByMovingCamera;
        newState.zoomCameraOffsets = stateToDuplicate.zoomCameraOffsets;
        newState.zoomByMovingCameraSpeed = stateToDuplicate.zoomByMovingCameraSpeed;
        newState.zoomByMovingCameraAmount = stateToDuplicate.zoomByMovingCameraAmount;
        newState.zoomByMovingCameraDirectlyProportional = stateToDuplicate.zoomByMovingCameraDirectlyProportional;

        newState.canMoveCamera = stateToDuplicate.canMoveCamera;

        newState.moveCameraSpeed = stateToDuplicate.moveCameraSpeed;
        newState.moveCameraLimitsX = stateToDuplicate.moveCameraLimitsX;
        newState.moveCameraLimitsY = stateToDuplicate.moveCameraLimitsY;
        newState.smoothCameraMovement = stateToDuplicate.smoothCameraMovement;
        newState.smoothCameraSpeed = stateToDuplicate.smoothCameraSpeed;
        newState.useSpringMovement = stateToDuplicate.useSpringMovement;
        newState.springMovementDelay = stateToDuplicate.springMovementDelay;

        newState.originalCameraAxisLocalPosition = stateToDuplicate.originalCameraAxisLocalPosition;
        newState.originalLockedCameraPivotPosition = stateToDuplicate.originalLockedCameraPivotPosition;
        newState.originalCameraLocalPosition = stateToDuplicate.originalCameraLocalPosition;

        newState.originalCameraForward = stateToDuplicate.originalCameraForward;

        newState.followFixedCameraPosition = stateToDuplicate.followFixedCameraPosition;

        newState.changeLockedCameraDirectionOnInputReleased = stateToDuplicate.changeLockedCameraDirectionOnInputReleased;

        newState.useWaypoints = stateToDuplicate.useWaypoints;
        newState.useRaycastToPlaceWaypoints = stateToDuplicate.useRaycastToPlaceWaypoints;

        newState.useSpline = stateToDuplicate.useSpline;

        newState.splineAccuracy = stateToDuplicate.splineAccuracy;

        newState.useZeroCameraTransition = stateToDuplicate.useZeroCameraTransition;

        newState.useHorizontalOffsetOnFaceSide = stateToDuplicate.useHorizontalOffsetOnFaceSide;
        newState.horizontalOffsetOnFaceSide = stateToDuplicate.horizontalOffsetOnFaceSide;
        newState.inputToleranceOnFaceSide = stateToDuplicate.inputToleranceOnFaceSide;
        newState.horizontalOffsetOnFaceSideSpeed = stateToDuplicate.horizontalOffsetOnFaceSideSpeed;

        newState.useHorizontalOffsetOnFaceSideOnMoving = stateToDuplicate.useHorizontalOffsetOnFaceSideOnMoving;
        newState.horizontalOffsetOnFaceSideOnMoving = stateToDuplicate.horizontalOffsetOnFaceSideOnMoving;
        newState.inputToleranceOnFaceSideOnMoving = stateToDuplicate.inputToleranceOnFaceSideOnMoving;
        newState.horizontalOffsetOnFaceSideOnMovingSpeed = stateToDuplicate.horizontalOffsetOnFaceSideOnMovingSpeed;

        newState.useBoundToFollowPlayer = stateToDuplicate.useBoundToFollowPlayer;
        newState.heightBoundTop = stateToDuplicate.heightBoundTop;
        newState.widthBoundRight = stateToDuplicate.widthBoundRight;
        newState.widthBoundLeft = stateToDuplicate.widthBoundLeft;
        newState.depthBoundFront = stateToDuplicate.depthBoundFront;
        newState.depthBoundBackward = stateToDuplicate.depthBoundBackward;
        newState.boundOffset = stateToDuplicate.boundOffset;

        newState.useTankControls = stateToDuplicate.useTankControls;

        newState.playerCanMoveOnAimInTankMode = stateToDuplicate.playerCanMoveOnAimInTankMode;


        newState.followSplinePathForPlayerPosition = stateToDuplicate.followSplinePathForPlayerPosition;

        newState.splineForPlayerPosition = stateToDuplicate.splineForPlayerPosition;

        newState.followPlayerRotationDirectionEnabled = stateToDuplicate.followPlayerRotationDirectionEnabled;

        newState.followPlayerRotationDirectionSpeed = stateToDuplicate.followPlayerRotationDirectionSpeed;
        

        newState.use2_5dView = stateToDuplicate.use2_5dView;

        newState.useDefaultZValue2_5d = stateToDuplicate.useDefaultZValue2_5d;
        newState.moveInXAxisOn2_5d = stateToDuplicate.moveInXAxisOn2_5d;

        newState.reverseMovementDirection = stateToDuplicate.reverseMovementDirection;

        newState.moveCameraLimitsX2_5d = stateToDuplicate.moveCameraLimitsX2_5d;
        newState.moveCameraLimitsY2_5d = stateToDuplicate.moveCameraLimitsY2_5d;

        newState.use2_5dVerticalOffsetOnMove = stateToDuplicate.use2_5dVerticalOffsetOnMove;
        newState.verticalTopOffsetOnMove = stateToDuplicate.verticalTopOffsetOnMove;
        newState.verticalBottomOffsetOnMove = stateToDuplicate.verticalBottomOffsetOnMove;
        newState.verticalOffsetOnMoveSpeed = stateToDuplicate.verticalOffsetOnMoveSpeed;

        newState.clampAimDirections = stateToDuplicate.clampAimDirections;
        newState.numberOfAimDirections = stateToDuplicate.numberOfAimDirections;

        newState.useCircleCameraLimit2_5d = stateToDuplicate.useCircleCameraLimit2_5d;
        newState.circleCameraLimit2_5d = stateToDuplicate.circleCameraLimit2_5d;
        newState.scaleCircleCameraLimitWithDistanceToCamera2_5d = stateToDuplicate.scaleCircleCameraLimitWithDistanceToCamera2_5d;
        newState.circleCameraLimitScaleClamp2_5d = stateToDuplicate.circleCameraLimitScaleClamp2_5d;

        newState.adjustPlayerPositionToFixed2_5dPosition = stateToDuplicate.adjustPlayerPositionToFixed2_5dPosition;

        newState.moveReticleInFixedCircleRotation2_5d = stateToDuplicate.moveReticleInFixedCircleRotation2_5d;

        newState.useTopDownView = stateToDuplicate.useTopDownView;

        newState.extraTopDownYRotation = stateToDuplicate.extraTopDownYRotation;

        newState.moveCameraLimitsXTopDown = stateToDuplicate.moveCameraLimitsXTopDown;
        newState.moveCameraLimitsYTopDown = stateToDuplicate.moveCameraLimitsYTopDown;
        newState.use8DiagonalAim = stateToDuplicate.use8DiagonalAim;
        newState.useRelativeMovementToLockedCamera = stateToDuplicate.useRelativeMovementToLockedCamera;

        newState.useCircleCameraLimitTopDown = stateToDuplicate.useCircleCameraLimitTopDown;
        newState.circleCameraLimitTopDown = stateToDuplicate.circleCameraLimitTopDown;
        newState.scaleCircleCameraLimitWithDistanceToCamera = stateToDuplicate.scaleCircleCameraLimitWithDistanceToCamera;
        newState.circleCameraLimitScaleClamp = stateToDuplicate.circleCameraLimitScaleClamp;
        newState.moveReticleInFixedCircleRotationTopDown = stateToDuplicate.moveReticleInFixedCircleRotationTopDown;

        newState.changeRootMotionActive = stateToDuplicate.changeRootMotionActive;
        newState.useRootMotionActive = stateToDuplicate.useRootMotionActive;

        newState.canRotateCameraHorizontally = stateToDuplicate.canRotateCameraHorizontally;
        newState.horizontalCameraRotationSpeed = stateToDuplicate.horizontalCameraRotationSpeed;
        newState.useMouseInputToRotateCameraHorizontally = stateToDuplicate.useMouseInputToRotateCameraHorizontally;
        newState.useFixedRotationAmount = stateToDuplicate.useFixedRotationAmount;
        newState.fixedRotationAmountToRight = stateToDuplicate.fixedRotationAmountToRight;
        newState.fixedRotationAmountToLeft = stateToDuplicate.fixedRotationAmountToLeft;
        newState.fixedRotationAmountSpeed = stateToDuplicate.fixedRotationAmountSpeed;

        newState.useLockedCameraRotationInputToggle = stateToDuplicate.useLockedCameraRotationInputToggle;

        newState.ignoreCameraRotationToLeftAndRightInput = stateToDuplicate.ignoreCameraRotationToLeftAndRightInput;

        newState.checkPossibleTargetsBelowCursor = stateToDuplicate.checkPossibleTargetsBelowCursor;

        newState.showCameraCursorWhenNotAiming = stateToDuplicate.showCameraCursorWhenNotAiming;

        newState.useCustomPivotHeightOffset = stateToDuplicate.useCustomPivotHeightOffset;
        newState.customPivotOffset = stateToDuplicate.customPivotOffset;

        newState.reticleOffset = stateToDuplicate.reticleOffset;

        newState.useAimAssist = stateToDuplicate.useAimAssist;
        newState.lookOnlyIfTargetOnScreen = stateToDuplicate.lookOnlyIfTargetOnScreen;
        newState.lookOnlyIfTargetVisible = stateToDuplicate.lookOnlyIfTargetVisible;
        newState.moveCameraCursorSpeed = stateToDuplicate.moveCameraCursorSpeed;

        newState.canUseManualLockOn = stateToDuplicate.canUseManualLockOn;

        newState.setDeactivateRootMotionOnStrafeActiveOnLockedViewValue = stateToDuplicate.setDeactivateRootMotionOnStrafeActiveOnLockedViewValue;
        newState.deactivateRootMotionOnStrafeActiveOnLockedView = stateToDuplicate.deactivateRootMotionOnStrafeActiveOnLockedView;

        newState.useOldSchoolAim = stateToDuplicate.useOldSchoolAim;
        newState.aimOffsetUp = stateToDuplicate.aimOffsetUp;
        newState.aimOffsetDown = stateToDuplicate.aimOffsetDown;
        newState.aimOffsetChangeSpeed = stateToDuplicate.aimOffsetChangeSpeed;

        newState.setCanMoveWhileAimLockedCameraState = stateToDuplicate.setCanMoveWhileAimLockedCameraState;
        newState.canMoveWhileAimLockedCamera = stateToDuplicate.canMoveWhileAimLockedCamera;

        newState.usePointAndClickSystem = stateToDuplicate.usePointAndClickSystem;

        newState.useTransparetSurfaceSystem = stateToDuplicate.useTransparetSurfaceSystem;

        newState.useDistanceToTransformToMoveCameraCloserOrFarther = stateToDuplicate.useDistanceToTransformToMoveCameraCloserOrFarther;

        newState.moveCameraCloserOrFartherSpeed = stateToDuplicate.moveCameraCloserOrFartherSpeed;
        newState.useDistanceDirectlyProportional = stateToDuplicate.useDistanceDirectlyProportional;

        newState.useClampCameraForwardDirection = stateToDuplicate.useClampCameraForwardDirection;

        newState.useClampCameraBackwardDirection = stateToDuplicate.useClampCameraBackwardDirection;
        newState.clampCameraBackwardDirection = stateToDuplicate.clampCameraBackwardDirection;

        newState.cameraDistanceMultiplier = stateToDuplicate.cameraDistanceMultiplier;

        newState.useCameraLimitSystem = stateToDuplicate.useCameraLimitSystem;
        newState.mainCamera2_5dZoneLimitSystem = stateToDuplicate.mainCamera2_5dZoneLimitSystem;
        newState.disablePreviousCameraLimitSystem = stateToDuplicate.disablePreviousCameraLimitSystem;

        newState.canChangeCameraToFreeViewByInput = stateToDuplicate.canChangeCameraToFreeViewByInput;

        newState.rotatePlayerToward2dCameraOnTriggerEnter = stateToDuplicate.rotatePlayerToward2dCameraOnTriggerEnter;
    }

    public void duplicateLockedCamera (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        addNewCameraTransformElememnt (lockedCameraListIndex);

        int currentCameraElementIndex = lockedCameraList [lockedCameraListIndex].cameraTransformList.Count - 1;

        cameraAxis currentCameraElement = lockedCameraList [lockedCameraListIndex].cameraTransformList [currentCameraElementIndex];

        cameraAxis currentCameraElementToDuplicate = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex];

        duplicateCameraAxisValues (currentCameraElement, currentCameraElementToDuplicate);

        currentCameraElement.cameraParentTransform.position = currentCameraElementToDuplicate.cameraParentTransform.position;
        currentCameraElement.axis.position = currentCameraElementToDuplicate.axis.position;

        currentCameraElement.cameraPosition.position = currentCameraElementToDuplicate.cameraPosition.position;
        currentCameraElement.cameraTriggerParentTransform.position = currentCameraElementToDuplicate.cameraTriggerParentTransform.position;

        for (int i = 0; i < currentCameraElementToDuplicate.triggerTransform.Count; i++) {
            if (currentCameraElement.triggerTransform.Count < i) {
                addCameraTrigger (lockedCameraListIndex, currentCameraElementIndex);
            }

            currentCameraElement.triggerTransform [i].position = currentCameraElementToDuplicate.triggerTransform [i].position;
            currentCameraElement.triggerTransform [i].localScale = currentCameraElementToDuplicate.triggerTransform [i].localScale;
        }

        updateComponent ();
    }

    public void assignPlayerToStartOnLockedCamera (GameObject newPlayer)
    {
        if (lockedCameraList.Count > 0) {

            cameraElement currentCameraElement = lockedCameraList [0];

            if (currentCameraElement.cameraTransformList.Count > 0) {
                cameraAxis currentCameraAxis = currentCameraElement.cameraTransformList [0];

                currentCameraAxis.startGameWithThisView = true;

                currentCameraAxis.playerForView = newPlayer;

                updateComponent ();
            }
        }
    }

    public void addLookAtCustomMultipleTargetsList (Transform newTransform)
    {
        addOrRemoveLookAtCustomMultipleTargetsList (newTransform, true);
    }

    public void removeLookAtCustomMultipleTargetsList (Transform newTransform)
    {
        addOrRemoveLookAtCustomMultipleTargetsList (newTransform, false);
    }

    public void addOrRemoveLookAtCustomMultipleTargetsList (Transform newTransform, bool state)
    {
        if (lockedCameraList.Count > 0) {

            cameraElement currentCameraElement = lockedCameraList [0];

            if (currentCameraElement.cameraTransformList.Count > 0) {
                cameraAxis currentCameraAxis = currentCameraElement.cameraTransformList [0];

                if (state) {
                    if (!currentCameraAxis.lookAtCustomMultipleTargetsList.Contains (newTransform)) {
                        currentCameraAxis.lookAtCustomMultipleTargetsList.Add (newTransform);
                    }
                } else {
                    if (currentCameraAxis.lookAtCustomMultipleTargetsList.Contains (newTransform)) {
                        currentCameraAxis.lookAtCustomMultipleTargetsList.Remove (newTransform);
                    }
                }
            }
        }
    }

    public static void setEditorCameraPosition (Transform transformToUse)
    {
        GKC_Utils.alignViewToObject (transformToUse);
    }

    public void addNewCameraTransformElememnt (int index)
    {
        Vector3 positionToInstantiate = transform.position;
        Quaternion rotationToInstantiate = Quaternion.identity;

        cameraElement currentCameraElement = lockedCameraList [index];

        int newCameraTransformElementIndex = currentCameraElement.cameraTransformList.Count + 1;

        if (currentCameraElement.cameraTransformList.Count > 0 && !useRaycastToPlaceCameras) {
            positionToInstantiate = currentCameraElement.cameraTransformList [currentCameraElement.cameraTransformList.Count - 1].cameraParentTransform.position;
            rotationToInstantiate = currentCameraElement.cameraTransformList [currentCameraElement.cameraTransformList.Count - 1].cameraParentTransform.rotation;
        } else {
            Camera currentCameraEditor = GKC_Utils.getCameraEditor ();

            if (currentCameraEditor != null) {
                Vector3 editorCameraPosition = currentCameraEditor.transform.position;
                Vector3 editorCameraForward = currentCameraEditor.transform.forward;

                RaycastHit hit;

                if (Physics.Raycast (editorCameraPosition, editorCameraForward, out hit, Mathf.Infinity, layerToPlaceNewCamera)) {
                    positionToInstantiate = hit.point + Vector3.up * 0.1f;
                }
            }
        }

        GameObject newCameraTransformElement = (GameObject)Instantiate (cameraTransformPrefab, positionToInstantiate, rotationToInstantiate);
        cameraAxisComponentsInfo newCameraAxisComponentsInfo = newCameraTransformElement.GetComponent<cameraAxisComponentsInfo> ();

        newCameraTransformElement.name = "Locked Camera Position " + newCameraTransformElementIndex;
        newCameraTransformElement.transform.SetParent (currentCameraElement.parentList);

        cameraAxis newCameraAxis = new cameraAxis ();

        newCameraAxis.name = "Camera " + (currentCameraElement.cameraTransformList.Count + 1);
        newCameraAxis.axis = newCameraAxisComponentsInfo.cameraAxisInfo.axis;
        newCameraAxis.cameraPosition = newCameraAxisComponentsInfo.cameraAxisInfo.cameraPosition;
        newCameraAxis.cameraTriggerParentTransform = newCameraAxisComponentsInfo.cameraAxisInfo.cameraTriggerParentTransform;
        newCameraAxis.triggerTransform = newCameraAxisComponentsInfo.cameraAxisInfo.triggerTransform;
        newCameraAxis.cameraParentTransform = newCameraAxisComponentsInfo.cameraAxisInfo.cameraParentTransform;

        currentCameraElement.cameraTransformList.Add (newCameraAxis);

        eventTriggerSystem cameraEventTriggerSystem = newCameraTransformElement.GetComponentInChildren<eventTriggerSystem> ();

        cameraEventTriggerSystem.eventList [0].objectToCall = gameObject;

        newCameraTransformElement.GetComponentInChildren<BoxCollider> ().transform.localScale = eventTriggerScale;

        DestroyImmediate (newCameraTransformElement.GetComponent<cameraAxisComponentsInfo> ());

        updateComponent ();
    }

    public void removeNewCameraTransformElememnt (int lockedCameraListIndex, int cameraTransformListIndex, bool updateInspector)
    {
        cameraElement currentCameraElement = lockedCameraList [lockedCameraListIndex];
        cameraAxis currentCameraAxis = currentCameraElement.cameraTransformList [cameraTransformListIndex];

        if (currentCameraAxis.cameraParentTransform != null) {
            DestroyImmediate (currentCameraAxis.cameraParentTransform.gameObject);
        }

        if (updateInspector) {
            currentCameraElement.cameraTransformList.RemoveAt (cameraTransformListIndex);

            updateComponent ();
        }
    }

    public void removeAllCameraTransformElements (int index)
    {
        for (int i = 0; i < lockedCameraList [index].cameraTransformList.Count; i++) {
            removeNewCameraTransformElememnt (index, i, false);
        }

        lockedCameraList [index].cameraTransformList.Clear ();

        updateComponent ();
    }

    public void removeAllCameraZones ()
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            removeAllCameraTransformElements (i);
        }

        for (int i = 0; i < lockedCameraList.Count; i++) {
            removeCameraZone (i, false);
        }

        lockedCameraList.Clear ();
    }

    public void addNewCameraZone ()
    {
        GameObject newCameraZone = new GameObject ();

        newCameraZone.name = "New Camera Zone";

        cameraElement newCameraElement = new cameraElement ();

        newCameraElement.name = "New Camera Zone";
        newCameraElement.parentList = newCameraZone.transform;
        newCameraZone.transform.SetParent (transform);

        lockedCameraList.Add (newCameraElement);

        updateComponent ();
    }

    public void removeCameraZone (int index, bool updateInspector)
    {
        removeAllCameraTransformElements (index);

        if (lockedCameraList [index].parentList != null) {
            DestroyImmediate (lockedCameraList [index].parentList.gameObject);
        }

        if (updateInspector) {
            lockedCameraList.RemoveAt (index);

            updateComponent ();
        }
    }

    public void addCameraTrigger (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        Vector3 positionToInstantiate = transform.position;

        Quaternion rotationToInstantiate = Quaternion.identity;

        cameraAxis currentCameraAxis = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex];

        Vector3 cameraTriggerScale = Vector3.one;

        if (currentCameraAxis.triggerTransform.Count > 0) {
            positionToInstantiate = currentCameraAxis.triggerTransform [currentCameraAxis.triggerTransform.Count - 1].position;
            rotationToInstantiate = currentCameraAxis.triggerTransform [currentCameraAxis.triggerTransform.Count - 1].rotation;
            cameraTriggerScale = currentCameraAxis.triggerTransform [currentCameraAxis.triggerTransform.Count - 1].localScale;
        }

        GameObject newCameraTrigger = (GameObject)Instantiate (cameraTriggerPrefab, positionToInstantiate, rotationToInstantiate);

        newCameraTrigger.name = "Camera Event Trigger";

        newCameraTrigger.transform.localScale = cameraTriggerScale;
        newCameraTrigger.transform.SetParent (currentCameraAxis.cameraTriggerParentTransform);

        currentCameraAxis.triggerTransform.Add (newCameraTrigger.transform);

        eventTriggerSystem cameraEventTriggerSystem = newCameraTrigger.GetComponentInChildren<eventTriggerSystem> ();

        cameraEventTriggerSystem.eventList [0].objectToCall = gameObject;

        cameraEventTriggerSystem.eventList [0].objectToSend = currentCameraAxis.cameraPosition.gameObject;

        updateComponent ();
    }

    public void removeCameraTrigger (int lockedCameraListIndex, int cameraTransformListIndex, int cameraTriggerIndex, bool updateInspector)
    {
        cameraElement currentCameraElement = lockedCameraList [lockedCameraListIndex];

        cameraAxis currentCameraAxis = currentCameraElement.cameraTransformList [cameraTransformListIndex];

        DestroyImmediate (currentCameraAxis.triggerTransform [cameraTriggerIndex].gameObject);

        if (updateInspector) {
            currentCameraAxis.triggerTransform.RemoveAt (cameraTriggerIndex);

            updateComponent ();
        }
    }

    public void removeAllCameraTriggers (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        cameraElement currentCameraElement = lockedCameraList [lockedCameraListIndex];

        cameraAxis currentCameraAxis = currentCameraElement.cameraTransformList [cameraTransformListIndex];

        for (int i = 0; i < currentCameraAxis.triggerTransform.Count; i++) {
            removeCameraTrigger (lockedCameraListIndex, cameraTransformListIndex, i, false);
        }

        currentCameraAxis.triggerTransform.Clear ();

        updateComponent ();
    }

    public void selectCurrentTrigger (int lockedCameraListIndex, int cameraTransformListIndex, int cameraTriggerIndex)
    {
        GKC_Utils.setActiveGameObjectInEditor (lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex].triggerTransform [cameraTriggerIndex].gameObject);
    }

    public void addWaypoint (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        Vector3 positionToInstantiate = transform.position;
        Quaternion rotationToInstantiate = Quaternion.identity;
        cameraAxis currentCameraAxis = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex];

        if (currentCameraAxis.waypointList.Count > 0 && !currentCameraAxis.useRaycastToPlaceWaypoints) {
            positionToInstantiate = currentCameraAxis.waypointList [currentCameraAxis.waypointList.Count - 1].position;
            rotationToInstantiate = currentCameraAxis.waypointList [currentCameraAxis.waypointList.Count - 1].rotation;
        } else {
            Camera currentCameraEditor = GKC_Utils.getCameraEditor ();

            if (currentCameraEditor != null) {
                Vector3 editorCameraPosition = currentCameraEditor.transform.position;
                Vector3 editorCameraForward = currentCameraEditor.transform.forward;

                RaycastHit hit;

                if (Physics.Raycast (editorCameraPosition, editorCameraForward, out hit, Mathf.Infinity, layerToPlaceNewCamera)) {
                    positionToInstantiate = hit.point + Vector3.up * 0.1f;
                }
            }
        }

        GameObject newWaypoint = new GameObject ();

        newWaypoint.name = "Waypoint " + (currentCameraAxis.waypointList.Count + 1);

        newWaypoint.transform.position = positionToInstantiate;
        newWaypoint.transform.rotation = rotationToInstantiate;

        if (currentCameraAxis.waypointParentTransform == null) {
            GameObject newWaypointParent = new GameObject ();

            newWaypointParent.name = "Waypoint List Parent";

            newWaypointParent.transform.position = transform.position;
            newWaypointParent.transform.rotation = transform.rotation;
            newWaypointParent.transform.SetParent (currentCameraAxis.cameraParentTransform);
            currentCameraAxis.waypointParentTransform = newWaypointParent.transform;
        }

        newWaypoint.transform.SetParent (currentCameraAxis.waypointParentTransform);

        currentCameraAxis.waypointList.Add (newWaypoint.transform);

        updateComponent ();
    }

    public void removeWaypoint (int lockedCameraListIndex, int cameraTransformListIndex, int waypointIndex, bool updateInspector)
    {
        cameraElement currentCameraElement = lockedCameraList [lockedCameraListIndex];

        cameraAxis currentCameraAxis = currentCameraElement.cameraTransformList [cameraTransformListIndex];

        DestroyImmediate (currentCameraAxis.waypointList [waypointIndex].gameObject);

        if (updateInspector) {
            currentCameraAxis.waypointList.RemoveAt (waypointIndex);

            updateComponent ();
        }
    }

    public void removeAllWaypoints (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        cameraElement currentCameraElement = lockedCameraList [lockedCameraListIndex];

        cameraAxis currentCameraAxis = currentCameraElement.cameraTransformList [cameraTransformListIndex];

        for (int i = 0; i < currentCameraAxis.waypointList.Count; i++) {
            removeWaypoint (lockedCameraListIndex, cameraTransformListIndex, i, false);
        }

        currentCameraAxis.waypointList.Clear ();

        updateComponent ();
    }

    public void setGizmosState (bool state)
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            lockedCameraList [i].showGizmo = state;
        }
    }

    public void setCameraParentListName (string name, int index)
    {
        lockedCameraList [index].parentList.name = name;
    }

    public void addLockedCameraPivot (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        cameraAxis currentCameraAxis = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex];

        if (currentCameraAxis.lockedCameraPivot == null) {
            GameObject newLockedCameraPivot = new GameObject ();

            newLockedCameraPivot.name = "Camera Pivot";

            newLockedCameraPivot.transform.SetParent (currentCameraAxis.cameraParentTransform);
            newLockedCameraPivot.transform.position = currentCameraAxis.axis.position;
            newLockedCameraPivot.transform.rotation = currentCameraAxis.axis.rotation;

            currentCameraAxis.lockedCameraPivot = newLockedCameraPivot.transform;

            currentCameraAxis.axis.SetParent (newLockedCameraPivot.transform);

            updateComponent ();
        }
    }

    public void addLockedCameraPivot2_5d (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        cameraAxis currentCameraAxis = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex];

        if (currentCameraAxis.lockedCameraPivot != null) {
            GameObject newLockedCameraPivot2_5d = new GameObject ();

            newLockedCameraPivot2_5d.name = "2.5d Pivot";

            newLockedCameraPivot2_5d.transform.SetParent (currentCameraAxis.lockedCameraPivot);

            newLockedCameraPivot2_5d.transform.localPosition = Vector3.zero;
            newLockedCameraPivot2_5d.transform.localRotation = Quaternion.identity;
            currentCameraAxis.pivot2_5d = newLockedCameraPivot2_5d.transform;

            GameObject newLockedCameraLookDirection2_5d = new GameObject ();

            newLockedCameraLookDirection2_5d.name = "2.5d Look Direction";

            newLockedCameraLookDirection2_5d.transform.SetParent (newLockedCameraPivot2_5d.transform);

            newLockedCameraLookDirection2_5d.transform.localPosition = Vector3.zero;
            newLockedCameraLookDirection2_5d.transform.localRotation = Quaternion.identity;
            currentCameraAxis.lookDirection2_5d = newLockedCameraLookDirection2_5d.transform;

            updateComponent ();
        }
    }

    public void addLockedCameraPivotTopDown (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        cameraAxis currentCameraAxis = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex];

        if (currentCameraAxis.lockedCameraPivot != null) {
            GameObject newLockedCameraPivotTopDown = new GameObject ();

            newLockedCameraPivotTopDown.name = "Top Down Pivot";

            newLockedCameraPivotTopDown.transform.SetParent (currentCameraAxis.lockedCameraPivot);

            newLockedCameraPivotTopDown.transform.localPosition = Vector3.zero;
            newLockedCameraPivotTopDown.transform.localRotation = Quaternion.identity;
            currentCameraAxis.topDownPivot = newLockedCameraPivotTopDown.transform;

            GameObject newLockedCameraLookDirectionTopDown = new GameObject ();

            newLockedCameraLookDirectionTopDown.name = "Top Down Look Direction";

            newLockedCameraLookDirectionTopDown.transform.SetParent (newLockedCameraPivotTopDown.transform);

            newLockedCameraLookDirectionTopDown.transform.localPosition = Vector3.zero;
            newLockedCameraLookDirectionTopDown.transform.localRotation = Quaternion.identity;
            currentCameraAxis.topDownLookDirection = newLockedCameraLookDirectionTopDown.transform;

            updateComponent ();
        }
    }

    public void setAllCamerasAsPointAndClickOrFree (bool state)
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            for (int j = 0; j < lockedCameraList [i].cameraTransformList.Count; j++) {
                lockedCameraList [i].cameraTransformList [j].usePointAndClickSystem = state;
            }
        }

        updateComponent ();
    }

    public void setCanChangeCameraToFreeViewByInputInAllCameras (bool state)
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            for (int j = 0; j < lockedCameraList [i].cameraTransformList.Count; j++) {
                lockedCameraList [i].cameraTransformList [j].canChangeCameraToFreeViewByInput = state;
            }
        }

        updateComponent ();
    }

    public void setAllCamerasAsTankControlsOrRegular (bool state)
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            for (int j = 0; j < lockedCameraList [i].cameraTransformList.Count; j++) {
                lockedCameraList [i].cameraTransformList [j].useTankControls = state;
            }
        }

        updateComponent ();
    }

    public void setAllCamerasAsRelativeMovementsOrRegular (bool state)
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            for (int j = 0; j < lockedCameraList [i].cameraTransformList.Count; j++) {
                lockedCameraList [i].cameraTransformList [j].useRelativeMovementToLockedCamera = state;
            }
        }

        updateComponent ();
    }

    public void setAllCamerasAsChangeRootMotionEnabledOrDisabled (bool state)
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            for (int j = 0; j < lockedCameraList [i].cameraTransformList.Count; j++) {
                lockedCameraList [i].cameraTransformList [j].changeRootMotionActive = state;
            }
        }

        updateComponent ();
    }

    public void setAllCamerasAsUseRootMotionEnabledOrDisabled (bool state)
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            for (int j = 0; j < lockedCameraList [i].cameraTransformList.Count; j++) {
                lockedCameraList [i].cameraTransformList [j].useRootMotionActive = state;
            }
        }

        updateComponent ();
    }

    public void setAllCamerasAsUseClampAimDirectionEnabledOrDisabled (bool state)
    {
        for (int i = 0; i < lockedCameraList.Count; i++) {
            for (int j = 0; j < lockedCameraList [i].cameraTransformList.Count; j++) {
                lockedCameraList [i].cameraTransformList [j].clampAimDirections = state;
            }
        }

        updateComponent ();
    }

    public void updateTriggers ()
    {
        cameraElement currentCameraElement;
        cameraAxis currentCameraAxis;

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

            currentCameraElement = lockedCameraList [i];

            for (int j = 0; j < currentCameraElement.cameraTransformList.Count; j++) {

                currentCameraAxis = currentCameraElement.cameraTransformList [j];

                for (int k = 0; k < currentCameraAxis.triggerTransform.Count; k++) {
                    if (currentCameraAxis.triggerTransform [k] != null) {
                        eventTriggerSystem currenteventTriggerSystem = currentCameraAxis.triggerTransform [k].GetComponent<eventTriggerSystem> ();
                        currenteventTriggerSystem.dontUseDelay = true;


                        GKC_Utils.updateComponent (currenteventTriggerSystem);
                    }
                }
            }
        }
    }

    public void changeViewToCameraInEditor (int lockedCameraListIndex, int cameraTransformListIndex)
    {
        if (currentPlayer != null) {
            cameraAxis currentCameraAxis = lockedCameraList [lockedCameraListIndex].cameraTransformList [cameraTransformListIndex];

            if (!currentCameraAxis.smoothTransitionAtStart) {
                currentCameraAxis.previoslyUseSmoohtTransitionState = currentCameraAxis.smoothCameraTransition;

                currentCameraAxis.smoothCameraTransition = false;
            }

            setCameraTransform (currentCameraAxis.cameraPosition.gameObject);
        }
    }

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

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

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

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

    void OnDrawGizmosSelected ()
    {
        DrawGizmos ();
    }

    void DrawGizmos ()
    {
        if (showGizmo && (!Application.isPlaying || showGizmoOnPlaying)) {
            cameraElement currentCameraElement;
            cameraAxis currentCameraAxis;

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

                currentCameraElement = lockedCameraList [i];

                if (currentCameraElement.showGizmo) {
                    for (int j = 0; j < currentCameraElement.cameraTransformList.Count; j++) {
                        Gizmos.color = gizmoColor;

                        currentCameraAxis = currentCameraElement.cameraTransformList [j];

                        if (currentCameraAxis.axis != null) {
                            Gizmos.DrawSphere (currentCameraAxis.axis.position, gizmoRadius);
                        }

                        for (int k = 0; k < currentCameraAxis.triggerTransform.Count; k++) {
                            if (currentCameraAxis.triggerTransform [k] != null) {
                                Gizmos.DrawLine (currentCameraAxis.axis.position, currentCameraAxis.triggerTransform [k].position);

                                if (showFloorTriggersCubes) {
                                    Gizmos.color = floorTriggersCubesColor;
                                    Gizmos.DrawCube (currentCameraAxis.triggerTransform [k].position, currentCameraAxis.triggerTransform [k].localScale);
                                }
                            }
                        }

                        if (currentCameraAxis.cameraPosition != null) {
                            Gizmos.DrawLine (currentCameraAxis.cameraPosition.position, currentCameraAxis.axis.position);

                            GKC_Utils.drawGizmoArrow (currentCameraAxis.cameraPosition.position,
                                currentCameraAxis.cameraPosition.forward * gizmoArrowLineLength, gizmoArrowColor, gizmoArrowLength, gizmoArrowAngle);
                        }

                        if (currentCameraAxis.followPlayerPosition || currentCameraAxis.lookAtPlayerPosition) {
                            if (currentCameraAxis.lockedCameraPivot != null) {
                                Vector3 pivotPosition = currentCameraAxis.lockedCameraPivot.position +
                                                        currentCameraAxis.lockedCameraPivot.up *
                                                        currentCameraAxis.axis.localPosition.y;

                                Gizmos.DrawLine (currentCameraAxis.axis.position, pivotPosition);

                                Gizmos.DrawLine (pivotPosition, currentCameraAxis.lockedCameraPivot.position);
                            }
                        }

                        if (currentCameraAxis.useBoundToFollowPlayer && currentCameraAxis.lockedCameraPivot != null) {
                            drawBoundGizmo (currentCameraAxis.lockedCameraPivot.position, currentCameraAxis, boundColor);
                        }

                        if (showWaypointList) {
                            for (int k = 0; k < currentCameraAxis.waypointList.Count; k++) {
                                if (currentCameraAxis.waypointList [k] != null) {

                                    Gizmos.color = waypointListColor;
                                    Gizmos.DrawSphere (currentCameraAxis.waypointList [k].position, gizmoRadius);

                                    if (k + 1 < currentCameraAxis.waypointList.Count) {
                                        Gizmos.color = Color.white;
                                        Gizmos.DrawLine (currentCameraAxis.waypointList [k].position, currentCameraAxis.waypointList [k + 1].position);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
#endif


    public static void drawBoundGizmo (Vector3 currentPosition, cameraAxis currentCameraAxis, Color newBoundColor)
    {
        Vector3 depthFrontPosition = Vector3.zero;
        Vector3 depthBackwardPosition = Vector3.zero;

        bool useMoveInXAxisOn2_5d = currentCameraAxis.moveInXAxisOn2_5d || currentCameraAxis.useTopDownView;

        float heightBoundTop = currentCameraAxis.heightBoundTop;
        float widthBoundRight = currentCameraAxis.widthBoundRight;
        float widthBoundLeft = currentCameraAxis.widthBoundLeft;
        float depthBoundFront = currentCameraAxis.depthBoundFront;
        float depthBoundBackward = currentCameraAxis.depthBoundBackward;

        Vector3 horizontalRightUpperLinePosition = currentPosition + Vector3.up * heightBoundTop;
        Vector3 horizontalLeftUpperLinePosition = currentPosition + Vector3.up * heightBoundTop;
        Vector3 horizontalRightLowerLinePosition = currentPosition;
        Vector3 horizontalLeftLowerLinePosition = currentPosition;
        Vector3 verticalRightUpperLinePosition = currentPosition + Vector3.up * heightBoundTop;
        Vector3 verticalRightLowerLinePosition = currentPosition;
        Vector3 verticalLeftUpperLinePosition = currentPosition + Vector3.up * heightBoundTop;
        Vector3 verticalLefttLowerLinePosition = currentPosition;

        float totalWidth = widthBoundRight + widthBoundLeft;
        float totalheight = heightBoundTop;

        Gizmos.color = newBoundColor;

        if (useMoveInXAxisOn2_5d) {
            horizontalRightUpperLinePosition += Vector3.right * widthBoundRight;
            horizontalLeftUpperLinePosition -= Vector3.right * widthBoundLeft;
            horizontalRightLowerLinePosition += Vector3.right * widthBoundRight;
            horizontalLeftLowerLinePosition -= Vector3.right * widthBoundLeft;
            verticalRightUpperLinePosition += Vector3.right * widthBoundRight;
            verticalRightLowerLinePosition += Vector3.right * widthBoundRight;
            verticalLeftUpperLinePosition -= Vector3.right * widthBoundLeft;
            verticalLefttLowerLinePosition -= Vector3.right * widthBoundLeft;

            depthFrontPosition = currentPosition + Vector3.right * widthBoundRight / 2 - Vector3.right * widthBoundLeft / 2;
            depthFrontPosition += Vector3.up * heightBoundTop / 2;

            Gizmos.DrawCube (depthFrontPosition, new Vector3 (totalWidth, totalheight, 0));
        } else {
            horizontalRightUpperLinePosition += Vector3.forward * widthBoundRight;
            horizontalLeftUpperLinePosition -= Vector3.forward * widthBoundLeft;
            horizontalRightLowerLinePosition += Vector3.forward * widthBoundRight;
            horizontalLeftLowerLinePosition -= Vector3.forward * widthBoundLeft;
            verticalRightUpperLinePosition += Vector3.forward * widthBoundRight;
            verticalRightLowerLinePosition += Vector3.forward * widthBoundRight;
            verticalLeftUpperLinePosition -= Vector3.forward * widthBoundLeft;
            verticalLefttLowerLinePosition -= Vector3.forward * widthBoundLeft;

            depthFrontPosition = currentPosition + Vector3.forward * widthBoundRight / 2 - Vector3.forward * widthBoundLeft / 2;
            depthFrontPosition += Vector3.up * heightBoundTop / 2;

            Gizmos.DrawCube (depthFrontPosition, new Vector3 (0, totalheight, totalWidth));
        }

        Gizmos.color = Color.white;

        Gizmos.DrawLine (horizontalRightUpperLinePosition, horizontalLeftUpperLinePosition);
        Gizmos.DrawLine (horizontalRightLowerLinePosition, horizontalLeftLowerLinePosition);

        Gizmos.DrawLine (verticalRightUpperLinePosition, verticalRightLowerLinePosition);
        Gizmos.DrawLine (verticalLeftUpperLinePosition, verticalLefttLowerLinePosition);

        if (depthBoundFront != 0 || depthBoundBackward != 0) {
            Gizmos.color = newBoundColor / 2;

            if (useMoveInXAxisOn2_5d) {
                depthFrontPosition = currentPosition + Vector3.forward * depthBoundFront / 2 + Vector3.right * widthBoundRight / 2 - Vector3.right * widthBoundLeft / 2;
                depthFrontPosition += Vector3.up * heightBoundTop / 2;

                Gizmos.DrawCube (depthFrontPosition, new Vector3 (totalWidth, totalheight, depthBoundFront));

                depthBackwardPosition = currentPosition - Vector3.forward * depthBoundBackward / 2 + Vector3.right * widthBoundRight / 2 - Vector3.right * widthBoundLeft / 2;
                depthBackwardPosition += Vector3.up * heightBoundTop / 2;

                Gizmos.DrawCube (depthBackwardPosition, new Vector3 (totalWidth, totalheight, depthBoundBackward));
            } else {

                depthFrontPosition = currentPosition + Vector3.right * depthBoundFront / 2 + Vector3.forward * widthBoundRight / 2 - Vector3.forward * widthBoundLeft / 2;
                depthFrontPosition += Vector3.up * heightBoundTop / 2;

                Gizmos.DrawCube (depthFrontPosition, new Vector3 (depthBoundFront, totalheight, totalWidth));

                depthBackwardPosition = currentPosition - Vector3.right * depthBoundBackward / 2 + Vector3.forward * widthBoundRight / 2 - Vector3.forward * widthBoundLeft / 2;
                depthBackwardPosition += Vector3.up * heightBoundTop / 2;

                Gizmos.DrawCube (depthBackwardPosition, new Vector3 (depthBoundBackward, totalheight, totalWidth));
            }
        }
    }

    [System.Serializable]
    public class cameraElement
    {
        public string name;
        public Transform parentList;
        public List<cameraAxis> cameraTransformList = new List<cameraAxis> ();
        public bool isCurrentCameraTransform;
        public bool setCameraToFree;
        public bool showGizmo = true;
    }

    [System.Serializable]
    public class cameraAxis
    {
        public string name;
        public Transform axis;
        public Transform cameraPosition;

        public bool useDifferentCameraFov;
        public float fovValue;

        public Transform cameraTriggerParentTransform;
        public List<Transform> triggerTransform = new List<Transform> ();

        public bool followPlayerPosition;
        public bool putCameraOutsideOfPivot;
        public bool followPlayerPositionSmoothly;
        public float followPlayerPositionSpeed;
        public bool useLerpToFollowPlayerPosition;

        public bool keepSmoothFollowOnVehicleDriving;

        public bool useSeparatedVerticalHorizontalSpeed;
        public float verticalFollowPlayerPositionSpeed;
        public float horizontalFollowPlayerPositionSpeed;

        public bool lookAtPlayerPosition;
        public float lookAtPlayerPositionSpeed;
        public Transform lockedCameraPivot;

        public bool lookAtCustomTarget;
        public Transform customTargetToLook;
        public bool lookAtCustomMultipleTargets;
        public List<Transform> lookAtCustomMultipleTargetsList = new List<Transform> ();

        public bool useRotationLimits;
        public Vector2 rotationLimitsX = new Vector2 (-90, 90);
        public Vector2 rotationLimitsY = new Vector2 (-90, 90);

        public bool usePositionOffset;
        public Vector3 positionOffset;

        public bool smoothCameraTransition;
        public float cameraTransitionSpeed;
        public Transform cameraParentTransform;

        public bool startGameWithThisView;
        public GameObject playerForView;
        public bool useMultiplePlayers;
        public List<GameObject> playerForViewList = new List<GameObject> ();
        public bool smoothTransitionAtStart;
        public bool previoslyUseSmoohtTransitionState;

        public bool setAIToStartOn2_5DView;
        public List<GameObject> AIForViewList = new List<GameObject> ();
        public bool setViewOnAllAIOnScene;

        public bool cameraCanRotate;

        public Vector2 rangeAngleX = new Vector2 (-90, 90);
        public Vector2 rangeAngleY = new Vector2 (-90, 90);

        public bool useSpringRotation;
        public float springRotationDelay;

        public bool smoothRotation;
        public float rotationSpeed;

        public float originalPivotRotationY;
        public float originalCameraRotationX;

        public bool canUseZoom;
        public float zoomValue;

        public bool useZoomByMovingCamera;
        public Vector2 zoomCameraOffsets;
        public float zoomByMovingCameraSpeed;
        public float zoomByMovingCameraAmount = 1;
        public bool zoomByMovingCameraDirectlyProportional = true;

        public bool canMoveCamera;

        public float moveCameraSpeed;
        public Vector2 moveCameraLimitsX = new Vector2 (-2, 2);
        public Vector2 moveCameraLimitsY = new Vector2 (-2, 2);
        public bool smoothCameraMovement;
        public float smoothCameraSpeed;
        public bool useSpringMovement;
        public float springMovementDelay;

        public Vector3 originalCameraAxisLocalPosition;
        public Vector3 originalLockedCameraPivotPosition;
        public Vector3 originalCameraLocalPosition;

        public Vector3 originalCameraForward;

        public bool followFixedCameraPosition;

        public bool changeLockedCameraDirectionOnInputReleased = true;

        //Waypoints variables
        public bool useWaypoints;
        public bool useRaycastToPlaceWaypoints;

        public List<Transform> waypointList = new List<Transform> ();
        public Transform waypointParentTransform;

        public bool useSpline;
        public BezierSpline mainSpline;

        public float splineAccuracy = 100;

        public bool useZeroCameraTransition;

        public bool useHorizontalOffsetOnFaceSide;
        public float horizontalOffsetOnFaceSide;
        public float inputToleranceOnFaceSide;
        public float horizontalOffsetOnFaceSideSpeed;

        public bool useHorizontalOffsetOnFaceSideOnMoving;
        public float horizontalOffsetOnFaceSideOnMoving;
        public float inputToleranceOnFaceSideOnMoving;
        public float horizontalOffsetOnFaceSideOnMovingSpeed;

        public bool useBoundToFollowPlayer;
        public float heightBoundTop;
        public float widthBoundRight;
        public float widthBoundLeft;
        public float depthBoundFront;
        public float depthBoundBackward;
        public Vector3 boundOffset;

        public bool useTankControls;

        public bool playerCanMoveOnAimInTankMode = true;

        public bool followSplinePathForPlayerPosition;

        public BezierSpline splineForPlayerPosition;

        public bool followPlayerRotationDirectionEnabled;

        public float followPlayerRotationDirectionSpeed = 10;

        //2.5d variables
        public bool use2_5dView;
        public Transform pivot2_5d;
        public Transform lookDirection2_5d;
        public bool useDefaultZValue2_5d;
        public bool moveInXAxisOn2_5d;

        public bool reverseMovementDirection;

        public Vector2 moveCameraLimitsX2_5d = new Vector2 (-3, 3);
        public Vector2 moveCameraLimitsY2_5d = new Vector2 (-3, 3);

        public bool use2_5dVerticalOffsetOnMove;
        public float verticalTopOffsetOnMove;
        public float verticalBottomOffsetOnMove;
        public float verticalOffsetOnMoveSpeed;

        public bool clampAimDirections;
        public numberOfAimDirection numberOfAimDirections = numberOfAimDirection.eight;

        public enum numberOfAimDirection
        {
            eight = 8,
            four = 4,
            two = 2
        }

        public bool useCircleCameraLimit2_5d;
        public float circleCameraLimit2_5d;
        public bool scaleCircleCameraLimitWithDistanceToCamera2_5d;
        public Vector2 circleCameraLimitScaleClamp2_5d;

        public float adjustPlayerPositionToFixed2_5dPosition = 5;

        public bool moveReticleInFixedCircleRotation2_5d = true;

        //Top down variables
        public bool useTopDownView;
        public Transform topDownPivot;
        public Transform topDownLookDirection;

        public float extraTopDownYRotation;

        public Vector2 moveCameraLimitsXTopDown = new Vector2 (-4, 4);
        public Vector2 moveCameraLimitsYTopDown = new Vector2 (-3, 3);
        public bool use8DiagonalAim;
        public bool useRelativeMovementToLockedCamera = true;

        public bool useCircleCameraLimitTopDown;
        public float circleCameraLimitTopDown;
        public bool scaleCircleCameraLimitWithDistanceToCamera;
        public Vector2 circleCameraLimitScaleClamp;
        public bool moveReticleInFixedCircleRotationTopDown = true;

        public bool changeRootMotionActive;
        public bool useRootMotionActive = true;

        public bool canRotateCameraHorizontally;
        public float horizontalCameraRotationSpeed;
        public bool useMouseInputToRotateCameraHorizontally;
        public bool useFixedRotationAmount;
        public float fixedRotationAmountToRight;
        public float fixedRotationAmountToLeft;
        public float fixedRotationAmountSpeed;

        public bool useLockedCameraRotationInputToggle;
        public bool ignoreCameraRotationToLeftAndRightInput;


        public bool checkPossibleTargetsBelowCursor = true;

        public bool showCameraCursorWhenNotAiming;

        public bool useCustomPivotHeightOffset;
        public float customPivotOffset = 1.52f;

        public float reticleOffset;

        //Look at target variables
        public bool useAimAssist = true;
        public bool lookOnlyIfTargetOnScreen;
        public bool lookOnlyIfTargetVisible;
        public float moveCameraCursorSpeed = 0.1f;

        public bool canUseManualLockOn;

        public bool setDeactivateRootMotionOnStrafeActiveOnLockedViewValue;
        public bool deactivateRootMotionOnStrafeActiveOnLockedView;

        public bool useOldSchoolAim;
        public float aimOffsetUp;
        public float aimOffsetDown;
        public float aimOffsetChangeSpeed;

        public bool setCanMoveWhileAimLockedCameraState;
        public bool canMoveWhileAimLockedCamera;

        //Point and click varaibles
        public bool usePointAndClickSystem;

        //Event variables
        public bool useUnityEvent;
        public bool useUnityEventOnEnter;
        public UnityEvent unityEventOnEnter;
        public bool useUnityEventOnExit;
        public UnityEvent unityEventOnExit;

        public bool useTransparetSurfaceSystem;

        public bool useDistanceToTransformToMoveCameraCloserOrFarther;
        public Transform transformToCalculateDistance;
        public float moveCameraCloserOrFartherSpeed;
        public bool useDistanceDirectlyProportional;

        public bool useClampCameraForwardDirection;

        public bool useClampCameraBackwardDirection;
        public float clampCameraBackwardDirection;

        public float cameraDistanceMultiplier = 1;

        public bool useCameraLimitSystem;
        public camera2_5dZoneLimitSystem mainCamera2_5dZoneLimitSystem;
        public bool disablePreviousCameraLimitSystem;

        public bool canChangeCameraToFreeViewByInput;

        public bool rotatePlayerToward2dCameraOnTriggerEnter;

        public cameraAxis ()
        {

        }
    }
}