using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;

using UnityEngine.Events;

public class playerCharactersManager : MonoBehaviour
{
    public bool searchPlayersAtStart;

    public int currentNumberOfPlayers = 1;

    public GameObject mainCharacter;

    public List<playerInfo> playerList = new List<playerInfo> ();

    public string cameraStateNameToUse = "1 Player";

    public List<cameraStates> cameraStatesList = new List<cameraStates> ();

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

    public Vector3 newPlayerPositionOffset;

    public Vector2 regularReferenceResolution = new Vector2 (1280, 720);
    public Vector2 splitReferenceResolution = new Vector2 (2560, 1440);

    public bool ignoreCheckEmptyCharactersOnStartEnabled;


    Vector3 currentCharacterPosition;

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

    public playerInfo currentPlayeraInfoActive;

    public bool setCurrentCharacterToControlAndAIAtStart;

    public string currentCharacterToControlName = "Player 1";

    public float delayTimeToChangeBetweenCharacters = 1;

    public bool keepActiveOnlyCurrentPlayerSelected;

    public bool changeCameraPositionAtOnceOnCharacterChange;

    public bool setCurrentPlayerPositionToPreviousCharacter;

    int currentCharacterToControlIndex;

    public string [] cameraStatesListString;
    public int currentCameraStateIndex;

    bool characterToControlAtStartConfigured;

    float lastTimeCharacterChange;

    playerInfo previousCharacterInfoActive;

    public bool configureLocalMultiplayerCharactersOnAwake;
    public int numberOfPlayersOnAwake;
    public string cameraStateNameOnAwake;

    public dynamicSplitScreenSystem mainDynamicSplitScreenSystem;

    public GameObject extraPlayerPrefab;

    public Transform initialMultiplayerSpawnPosition;


    //Online elements

    public GameObject onlinePlayerPrefab;

    public bool useTransformPositionListToSpawnOnlinePlayer;

    public List<Transform> transformPositionListToSpawnOnlinePlayer = new List<Transform> ();


    public bool spawnOnlinePlayersOnStart;
    public int numberOfOnlinePlayersToSpawnOnStart;



    static List<playerInfo> playerListValue = new List<playerInfo> ();
    static int playerListCount;


    private static playerCharactersManager _playerCharactersManagerInstance;

    public static playerCharactersManager Instance { get { return _playerCharactersManagerInstance; } }

    bool instanceInitialized;

    bool useCustomPositionOnAddSpawnedPlayerOnSceneActive;
    Vector3 customPositionOnAddSpawnedPlayerOnScene;
    Quaternion customRotationOnAddSpawnedPlayerOnScene;


    public void getComponentInstance ()
    {
        if (instanceInitialized) {
            return;
        }

        if (_playerCharactersManagerInstance != null && _playerCharactersManagerInstance != this) {
            Destroy (this.gameObject);

            return;
        }

        _playerCharactersManagerInstance = this;

        instanceInitialized = true;
    }

    public void getComponentInstanceOnApplicationPlaying ()
    {
        if (Application.isPlaying) {
            getComponentInstance ();
        }
    }

    void Awake ()
    {
        getComponentInstance ();

        if (configureLocalMultiplayerCharactersOnAwake) {
            currentNumberOfPlayers = numberOfPlayersOnAwake;

            cameraStateNameToUse = cameraStateNameOnAwake;
        }

        if (!ignoreCheckEmptyCharactersOnStartEnabled) {
            checkPlayerElementsOnScene ();
        }

        if (searchPlayersAtStart) {
            searchPlayersOnTheLevel (false, false);
        }

        if (configureLocalMultiplayerCharactersOnAwake) {
            if (mainCharacter != null) {
                setNumberOfPlayers (false);
            } else {
                addExtraPlayerOnSceneForMultiplayer (currentNumberOfPlayers);
            }

            setCameraConfiguration (false);

            updateHUD (false);

            setPlayerID (false);

            assignMapSystem (false);
        }

        if (playerList.Count >= 1) {
            currentPlayeraInfoActive = playerList [0];
        }

        playerListValue = playerList;

        playerListCount = playerList.Count;
    }

    void Start ()
    {
        if (setCurrentCharacterToControlAndAIAtStart) {
            StartCoroutine (checkInitialStateOnCharacters ());
        }

        if (spawnOnlinePlayersOnStart) {
            StartCoroutine (checkspawnOnlinePlayersOnStartCoroutine ());
        }
    }

    IEnumerator checkInitialStateOnCharacters ()
    {
        yield return new WaitForSeconds (0.1f);

        if (setCurrentCharacterToControlAndAIAtStart && !characterToControlAtStartConfigured) {
            if (playerList.Count > 1) {
                setAsCurrentCharacterToControlByName (currentCharacterToControlName);

                characterToControlAtStartConfigured = true;
            }
        }
    }

    IEnumerator checkspawnOnlinePlayersOnStartCoroutine ()
    {
        yield return new WaitForSeconds (0.2f);

        for (int i = 0; i < numberOfOnlinePlayersToSpawnOnStart; i++) {
            spawnPlayerOnSceneForMultiplayer ();
        }

    }

    public void checkPlayerElementsOnScene ()
    {
        bool checkingEmptyPlayerElements = checkNotNullPlayerElements ();

        if (checkingEmptyPlayerElements) {
            searchPlayersOnTheLevel (false, false);
        }
    }

    public void spawnPlayerOnSceneForMultiplayer ()
    {
        if (onlinePlayerPrefab != null) {
            GameObject newCharacter = (GameObject)Instantiate (onlinePlayerPrefab, Vector3.zero, Quaternion.identity);

            addSpawnedPlayerOnSceneForMultiplayer (newCharacter);
        }
    }

    public void addSpawnedPlayerOnSceneForMultiplayerWithCustomPositionRotation (GameObject newCharacter, Vector3 newPosition, Quaternion newRotation)
    {
        useCustomPositionOnAddSpawnedPlayerOnSceneActive = true;

        customPositionOnAddSpawnedPlayerOnScene = newPosition;

        customRotationOnAddSpawnedPlayerOnScene = newRotation;

        addSpawnedPlayerOnSceneForMultiplayer (newCharacter);

        useCustomPositionOnAddSpawnedPlayerOnSceneActive = false;
    }

    public void addSpawnedPlayerOnSceneForMultiplayer (GameObject newCharacter)
    {
        if (mainCharacter == null) {
            mainCharacter = newCharacter;
        }

        print ("SPAWN PLAYER");

        newCharacter.transform.SetParent (transform);

        playerComponentsManager mainplayerComponentsManager = newCharacter.GetComponentInChildren<playerComponentsManager> ();

        if (mainplayerComponentsManager != null) {
            GameObject newPlayerGameObject = mainplayerComponentsManager.gameObject;

            if (useTransformPositionListToSpawnOnlinePlayer) {
                GKC_PlayerPrefabSpawner currentGKC_PlayerPrefabSpawner = newCharacter.GetComponent<GKC_PlayerPrefabSpawner> ();

                if (currentGKC_PlayerPrefabSpawner != null) {
                    if (useCustomPositionOnAddSpawnedPlayerOnSceneActive) {
                        currentGKC_PlayerPrefabSpawner.setPositionToSpawn (customPositionOnAddSpawnedPlayerOnScene);

                        currentGKC_PlayerPrefabSpawner.setRotationToSpawn (customRotationOnAddSpawnedPlayerOnScene.eulerAngles);
                    } else {
                        int currentTransformPositionIndex = playerListCount;

                        if (currentTransformPositionIndex >= transformPositionListToSpawnOnlinePlayer.Count) {
                            currentTransformPositionIndex = transformPositionListToSpawnOnlinePlayer.Count - 1;
                        }

                        if (currentTransformPositionIndex < transformPositionListToSpawnOnlinePlayer.Count) {
                            currentGKC_PlayerPrefabSpawner.setPositionToSpawn (transformPositionListToSpawnOnlinePlayer [currentTransformPositionIndex].position);

                            currentGKC_PlayerPrefabSpawner.setRotationToSpawn (transformPositionListToSpawnOnlinePlayer [currentTransformPositionIndex].eulerAngles);
                        }
                    }
                }
            }


            addPlayerToList (newPlayerGameObject, playerList.Count, false);

            playerListValue = playerList;

            playerListCount = playerList.Count;

            currentPlayeraInfoActive = playerList [0];
        }
    }

    void addPlayerToList (GameObject newPlayerGameObject, int playerIndex, bool creatingNewPlayers)
    {
        playerInfo newPlayerInfo = new playerInfo ();

        newPlayerInfo.Name = "Player " + (playerIndex + 1);
        newPlayerInfo.playerControllerGameObject = newPlayerGameObject;

        newPlayerInfo.mainPlayerComponentsManager = newPlayerInfo.playerControllerGameObject.GetComponent<playerComponentsManager> ();

        newPlayerInfo.playerControllerManager = newPlayerInfo.mainPlayerComponentsManager.getPlayerController ();

        newPlayerInfo.playerControllerManager.setPlayerID (playerIndex + 1);

        newPlayerInfo.playerCameraGameObject = newPlayerInfo.playerControllerManager.getPlayerCameraGameObject ();

        newPlayerInfo.playerCameraManager = newPlayerInfo.mainPlayerComponentsManager.getPlayerCamera ();

        newPlayerInfo.playerInput = newPlayerInfo.mainPlayerComponentsManager.getPlayerInputManager ();

        newPlayerInfo.pauseManager = newPlayerInfo.mainPlayerComponentsManager.getPauseManager ();

        newPlayerInfo.mainFriendListManager = newPlayerInfo.mainPlayerComponentsManager.getFriendListManager ();

        newPlayerInfo.mainSwitchCompanionSystem = newPlayerInfo.mainPlayerComponentsManager.getSwitchCompanionSystem ();

        newPlayerInfo.mainSaveGameSystem = newPlayerInfo.mainPlayerComponentsManager.getSaveGameSystem ();

        newPlayerInfo.playerParentGameObject = newPlayerInfo.pauseManager.transform.parent.gameObject;
        newPlayerInfo.playerParentGameObject.name = newPlayerInfo.Name;

        if (playerIndex == 0) {
            currentCharacterPosition = newPlayerInfo.playerControllerGameObject.transform.position;
        }

        if (creatingNewPlayers) {
            if (newPlayerInfo.playerParentGameObject != mainCharacter) {
                currentCharacterPosition += newPlayerPositionOffset;
                newPlayerInfo.playerControllerGameObject.transform.position = currentCharacterPosition;
                newPlayerInfo.playerCameraGameObject.transform.position = currentCharacterPosition;
            }
        }

        playerList.Add (newPlayerInfo);
    }

    public void addExtraPlayerOnSceneForMultiplayer (int numberOfExtraPlayers)
    {
        if (extraPlayerPrefab != null) {
            int newNumberOfPlayers = playerList.Count;

            for (int i = 0; i < numberOfExtraPlayers; i++) {
                GameObject newCharacter = (GameObject)Instantiate (extraPlayerPrefab, Vector3.zero, Quaternion.identity);

                if (mainCharacter == null) {
                    mainCharacter = newCharacter;
                }

                int numberOfPlayers = playerList.Count;

                newNumberOfPlayers++;

                newCharacter.name = "Player " + newNumberOfPlayers;
                newCharacter.transform.SetParent (transform);
            }

            updatePlayersInfoOnTheLevel ();

            Vector3 newPosition = Vector3.zero;
            Quaternion newRotation = Quaternion.identity;

            if (initialMultiplayerSpawnPosition != null) {
                newPosition = initialMultiplayerSpawnPosition.position;
                newRotation = initialMultiplayerSpawnPosition.rotation;
            }

            for (int i = 0; i < playerList.Count; i++) {
                playerInfo newPlayerInfo = playerList [i];

                newPlayerInfo.playerControllerGameObject.transform.position = newPosition;
                newPlayerInfo.playerCameraGameObject.transform.position = newPosition;

                newPlayerInfo.playerControllerGameObject.transform.rotation = newRotation;
                newPlayerInfo.playerCameraGameObject.transform.rotation = newRotation;

                newPosition += newPlayerPositionOffset;
            }
        }
    }

    public void addNewPlayerSpawned (GameObject newPlayer)
    {
        if (mainCharacter == null) {
            mainCharacter = newPlayer;
        }

        currentNumberOfPlayers++;

        newPlayer.name = "Player " + currentNumberOfPlayers;
        newPlayer.transform.SetParent (transform);

        updatePlayersInfoOnTheLevel ();

        setCameraConfiguration (false);

        updateHUD (false);

        setPlayerID (false);

        assignMapSystem (false);

        playerListValue = playerList;

        playerListCount = playerList.Count;

        currentPlayeraInfoActive = playerList [0];
    }

    public void setNewPositionToPlayersOnScene (List<Transform> positionList)
    {
        int numberOfPlayers = playerList.Count;

        for (int i = 0; i < numberOfPlayers; i++) {
            if (playerList [i].playerControllerGameObject != null) {
                Transform currentCharacter = playerList [i].playerControllerGameObject.transform;

                if (currentCharacter != null && positionList.Count <= i) {
                    currentCharacter.position = positionList [i].position;

                    currentCharacter.rotation = positionList [i].rotation;
                }
            }
        }
    }

    public void updatePlayersInfoOnTheLevel ()
    {
        searchPlayersOnTheLevel (false, false);
    }

    public bool checkNotNullPlayerElements ()
    {
        if (playerList.Count == 0) {
            return true;
        }

        for (int i = 0; i < playerList.Count; i++) {
            if (playerList [i].playerControllerGameObject == null) {
                return true;
            }
        }

        return false;
    }

    public void searchPlayersOnTheLevel (bool creatingNewPlayers, bool creatingCharactersOnEditor)
    {
        playerController mainPlayerController = null;

        if ((creatingNewPlayers && creatingCharactersOnEditor) ||
            (!creatingNewPlayers && creatingCharactersOnEditor)) {
            if (playerList.Count > 0) {
                if (playerList [0].playerControllerManager != null) {
                    mainPlayerController = playerList [0].playerControllerManager;
                }
            }
        }

        playerList.Clear ();

        auxPlayerList.Clear ();

        currentCharacterPosition = Vector3.zero;

        playerController [] childrens = FindObjectsOfType<playerController> ();

        foreach (playerController c in childrens) {
            if (!c.isCharacterUsedByAI ()) {
                auxPlayerList.Add (c.gameObject);
            }
        }

        if ((creatingNewPlayers && creatingCharactersOnEditor) ||
            (!creatingNewPlayers && creatingCharactersOnEditor)) {
            if (mainPlayerController != null) {
                auxPlayerList.Remove (mainPlayerController.gameObject);

                auxPlayerList.Insert (0, mainPlayerController.gameObject);

                print ("original player asssigned at start");

                for (int i = 0; i < auxPlayerList.Count; i++) {
                    print (auxPlayerList [i].name);
                }
            }
        }

        for (int i = 0; i < auxPlayerList.Count; i++) {
            addPlayerToList (auxPlayerList [i], i, creatingNewPlayers);
        }

        if (creatingCharactersOnEditor) {
            updateComponent ();
        }
    }

    public void setExtraCharacterList ()
    {
        extraCharacterList.Clear ();

        for (int i = 0; i < playerList.Count; i++) {
            if (playerList [i].playerParentGameObject != mainCharacter) {

                extraCharacterList.Add (playerList [i].playerParentGameObject);
            }
        }

        updateComponent ();
    }

    public void setPlayerID (bool creatingCharactersOnEditor)
    {
        int numberOfPlayerID = 0;

        for (int i = 0; i < playerList.Count; i++) {
            playerInfo currentPlayerInfo = playerList [i];

            if (currentPlayerInfo.playerInput.useOnlyKeyboard) {
                numberOfPlayerID--;
            }

            currentPlayerInfo.playerControllerManager.setPlayerID (i + 1 + numberOfPlayerID);
            currentPlayerInfo.playerInput.setPlayerID (i + 1 + numberOfPlayerID);

            if (creatingCharactersOnEditor) {
                GKC_Utils.updateComponent (currentPlayerInfo.playerControllerManager);
            }
        }

        print ("Player IDs configured");

        if (creatingCharactersOnEditor) {
            updateComponent ();
        }
    }

    public void setNumberOfPlayers (bool creatingCharactersOnEditor)
    {
        int newNumberOfPlayers = currentNumberOfPlayers - 1 - extraCharacterList.Count;

        if (newNumberOfPlayers > 0) {
            for (int i = 0; i < newNumberOfPlayers; i++) {
                GameObject newCharacter = (GameObject)Instantiate (mainCharacter, mainCharacter.transform.position, mainCharacter.transform.rotation);
                newCharacter.name = "Player " + (i + 2);
                newCharacter.transform.SetParent (transform);

                extraCharacterList.Add (newCharacter);
            }
        } else {
            newNumberOfPlayers = Mathf.Abs (newNumberOfPlayers);

            print (newNumberOfPlayers);

            newNumberOfPlayers = extraCharacterList.Count - newNumberOfPlayers;

            for (int i = extraCharacterList.Count - 1; i >= newNumberOfPlayers; i--) {
                DestroyImmediate (extraCharacterList [i]);
            }

            for (int i = 0; i < extraCharacterList.Count; i++) {
                if (extraCharacterList [i] == null) {
                    extraCharacterList.RemoveAt (i);
                    i = 0;
                }
            }

            if (currentNumberOfPlayers == 1) {
                extraCharacterList.Clear ();
            }
        }

        searchPlayersOnTheLevel (true, creatingCharactersOnEditor);

        print ("Players configured: " + playerList.Count);

        if (creatingCharactersOnEditor) {
            int playerListCount = playerList.Count;

            for (int i = 0; i < playerListCount; i++) {
                playerList [i].playerInput.checkStoreTouchButtonListIfListEmpty ();
            }

            updateComponent ();
        }
    }

    public void setCameraConfiguration (bool creatingCharactersOnEditor)
    {
        for (int i = 0; i < playerList.Count; i++) {

            List<Camera> currentCameraList = playerList [i].playerCameraManager.getCameraList ();

            cameraStates currentCameraStates = getCameraStateByName (cameraStateNameToUse);

            if (currentCameraStates != null) {

                int cameraInfoListCount = currentCameraStates.cameraInfoList.Count;

                for (int j = 0; j < currentCameraList.Count; j++) {
                    int currentIndex = -1;

                    if (cameraInfoListCount >= currentNumberOfPlayers) {
                        currentIndex = i;
                    } else {
                        if (cameraInfoListCount == 1) {
                            currentIndex = 0;
                        }
                    }

                    if (currentIndex != -1) {
                        currentCameraList [j].rect =
                            new Rect (currentCameraStates.cameraInfoList [currentIndex].newX,
                            currentCameraStates.cameraInfoList [currentIndex].newY,
                                currentCameraStates.cameraInfoList [currentIndex].newW,
                                currentCameraStates.cameraInfoList [currentIndex].newH);
                    }

                    if (creatingCharactersOnEditor) {
                        GKC_Utils.updateComponent (currentCameraList [j]);
                    }
                }

                menuPause currentPauseManager = playerList [i].pauseManager;


                Camera canvasCamera = currentPauseManager.getMainCanvasCamera ();

                bool activatingMultiplayer = currentNumberOfPlayers > 1;

                if (currentCameraStateIndex >= 0 && currentCameraStateIndex < cameraStatesList.Count) {
                    if (currentCameraStates.numberfOfPlayers == 1) {
                        activatingMultiplayer = false;
                    }
                }

                canvasCamera.gameObject.SetActive (activatingMultiplayer);

                List<menuPause.canvasInfo> currentCanvasInfoList = currentPauseManager.getCanvasInfoList ();

                if (currentCanvasInfoList.Count == 0) {
                    currentPauseManager.addNewCanvasToList (currentPauseManager.getMainCanvas ());

                    currentCanvasInfoList = currentPauseManager.getCanvasInfoList ();
                }

                for (int k = 0; k < currentCanvasInfoList.Count; k++) {
                    if (currentCanvasInfoList [k].mainCanvas != null) {
                        currentCanvasInfoList [k].mainCanvas.worldCamera = canvasCamera;

                        if (activatingMultiplayer) {
                            currentCanvasInfoList [k].mainCanvasScaler.referenceResolution = splitReferenceResolution;
                            currentCanvasInfoList [k].mainCanvas.renderMode = RenderMode.ScreenSpaceCamera;
                        } else {
                            currentCanvasInfoList [k].mainCanvasScaler.referenceResolution = regularReferenceResolution;
                            currentCanvasInfoList [k].mainCanvas.renderMode = RenderMode.ScreenSpaceOverlay;
                        }

                        if (creatingCharactersOnEditor) {
                            GKC_Utils.updateComponent (currentCanvasInfoList [k].mainCanvasScaler);

                            GKC_Utils.updateComponent (currentCanvasInfoList [k].mainCanvas);
                        }
                    }
                }
            } else {
                print ("WARNING: Camera state called " + cameraStateNameToUse + " is not assigned");
            }

            if (i > 0) {
                playerList [i].playerCameraManager.enableOrDisableCameraAudioListener (false);
            }
        }

        print ("Player cameras configured");
    }

    public void updateCanvasValuesByPlayer (GameObject playerControllerGameObject, GameObject pauseManagerObject, GameObject newCanvasPanel)
    {
        if (pauseManagerObject == null && playerControllerGameObject == null) {
            return;
        }

        for (int i = 0; i < playerList.Count; i++) {
            playerInfo currentPlayerInfo = playerList [i];

            menuPause currentPauseManager = currentPlayerInfo.pauseManager;

            bool playerLocated = false;

            if (pauseManagerObject != null) {
                if (currentPauseManager.gameObject == pauseManagerObject) {
                    playerLocated = true;
                }
            }

            if (!playerLocated) {
                if (playerControllerGameObject != null) {
                    if (currentPlayerInfo.playerControllerGameObject == playerControllerGameObject) {
                        playerLocated = true;
                    }
                }
            }

            if (playerLocated) {
                Canvas currentCanvas = newCanvasPanel.GetComponent<Canvas> ();

                if (currentCanvas != null) {
                    currentPauseManager.addNewCanvasToList (currentCanvas);

                    bool activatingMultiplayer = currentNumberOfPlayers > 1;

                    if (currentCameraStateIndex >= 0 && currentCameraStateIndex < cameraStatesList.Count) {
                        cameraStates currentCameraStates = cameraStatesList [currentCameraStateIndex];

                        if (currentCameraStates.numberfOfPlayers == 1) {
                            activatingMultiplayer = false;
                        }
                    }

                    if (activatingMultiplayer) {
                        menuPause.canvasInfo currentCanvasInfo = currentPauseManager.getCanvasInfoListByCanvasObject (currentCanvas);

                        if (currentCanvasInfo != null) {
                            if (currentCanvasInfo.mainCanvas != null) {
                                Camera canvasCamera = currentPauseManager.getMainCanvasCamera ();

                                if (canvasCamera != null) {
                                    currentCanvasInfo.mainCanvas.worldCamera = canvasCamera;

                                    currentCanvasInfo.mainCanvasScaler.referenceResolution = splitReferenceResolution;
                                    currentCanvasInfo.mainCanvas.renderMode = RenderMode.ScreenSpaceCamera;
                                }
                            }
                        }
                    }
                }

                return;
            }
        }
    }

    public void updateHUD (bool creatingCharactersOnEditor)
    {
        for (int i = 0; i < playerList.Count; i++) {

            playerList [i].pauseManager.setCanvasInfo (creatingCharactersOnEditor);
        }

        print ("Player HUD Updated");
    }

    public void assignMapSystem (bool creatingCharactersOnEditor)
    {
        mapCreator mapCreatorManager = mapCreator.Instance;

        bool mapCreatorManagerAssigned = mapCreatorManager != null;

        if (!mapCreatorManagerAssigned) {
            GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (mapCreator.getMainManagerName (), typeof (mapCreator), true);

            mapCreatorManager = mapCreator.Instance;

            mapCreatorManagerAssigned = (mapCreatorManager != null);
        }

        if (!mapCreatorManagerAssigned) {
            mapCreatorManager = FindObjectOfType<mapCreator> ();

            mapCreatorManagerAssigned = mapCreatorManager != null;
        }

        if (mapCreatorManagerAssigned) {
            for (int i = 0; i < playerList.Count; i++) {
                mapCreatorManager.addNewPlayer (playerList [i].pauseManager.gameObject.GetComponent<mapSystem> (),
                    playerList [i].playerControllerGameObject, creatingCharactersOnEditor);
            }
        } else {
            print ("WARNING: There is no map creator in the scene, make sure to drag and drop the prefab and configure as you need if you want to use the map system");
        }

        print ("Map systems configured");
    }

    public void updateMainPlayerComponentsOnGameManager (bool creatingCharactersOnEditor)
    {
        if (mainCharacter != null) {
            GKC_Utils.updateMainPlayerComponentsOnGameManager (mainCharacter);
        }
    }

    public void enableOrDisableSingleCameraState (bool state, bool creatingCharactersOnEditor)
    {
        List<Transform> multipleTargetsToFollowList = new List<Transform> ();

        for (int i = 0; i < playerList.Count; i++) {
            multipleTargetsToFollowList.Add (playerList [i].playerControllerGameObject.transform);
        }

        for (int i = 0; i < playerList.Count; i++) {
            playerList [i].playerCameraManager.setFollowingMultipleTargetsState (state, creatingCharactersOnEditor);

            if (state) {
                playerList [i].playerCameraManager.setMultipleTargetsToFollowList (multipleTargetsToFollowList, creatingCharactersOnEditor);
            } else {
                playerList [i].playerCameraManager.setMultipleTargetsToFollowList (null, creatingCharactersOnEditor);
            }
        }

        print ("Single Camera State configured as " + state);

        updateComponent ();

        GKC_Utils.updateDirtyScene ("Set Single Camera State", gameObject);
    }

    public void enableOrDisableDynamicSplitCameraState (bool state, bool creatingCharactersOnEditor)
    {
        if (playerList.Count > 0) {
            if (playerList.Count < 2) {
                mainDynamicSplitScreenSystem.setDynamicSplitScreenActiveState (false);

                if (creatingCharactersOnEditor) {
                    playerList [0].pauseManager.enableOrDisableDynamicElementsOnScreenFromEditor (!state);

                    GKC_Utils.updateComponent (playerList [0].pauseManager);
                } else {
                    playerList [0].pauseManager.enableOrDisableDynamicElementsOnScreen (!state);
                }
            } else {

                mainDynamicSplitScreenSystem.setDynamicSplitScreenActiveState (state, playerList [0].playerControllerGameObject,
                    playerList [1].playerControllerGameObject, creatingCharactersOnEditor);

                if (creatingCharactersOnEditor) {
                    playerList [0].pauseManager.enableOrDisableDynamicElementsOnScreenFromEditor (!state);

                    GKC_Utils.updateComponent (playerList [0].pauseManager);

                    playerList [1].pauseManager.enableOrDisableDynamicElementsOnScreenFromEditor (!state);

                    GKC_Utils.updateComponent (playerList [1].pauseManager);
                } else {
                    playerList [0].pauseManager.enableOrDisableDynamicElementsOnScreen (!state);

                    playerList [1].pauseManager.enableOrDisableDynamicElementsOnScreen (!state);
                }
            }

            if (creatingCharactersOnEditor) {
                updateComponent ();

                GKC_Utils.updateDirtyScene ("Enabling or disabling dynamic split screen " + state, gameObject);
            }
        }
    }

    public cameraStates getCameraStateByName (string cameraStateName)
    {
        for (int j = 0; j < cameraStatesList.Count; j++) {
            if (cameraStatesList [j].Name.Equals (cameraStateName)) {
                return cameraStatesList [j];
            }
        }

        return null;
    }

    public void setAsCurrentPlayerActive (string playerName)
    {
        currentPlayeraInfoActive.playerCameraGameObject.transform.SetParent (currentPlayeraInfoActive.pauseManager.transform);
        currentPlayeraInfoActive.playerControllerGameObject.transform.SetParent (currentPlayeraInfoActive.pauseManager.transform);

        currentPlayeraInfoActive.playerParentGameObject.SetActive (false);

        Vector3 playerPosition = currentPlayeraInfoActive.playerControllerGameObject.transform.position;
        Quaternion playerRotation = currentPlayeraInfoActive.playerControllerGameObject.transform.rotation;

        Quaternion cameraRotation = currentPlayeraInfoActive.playerCameraGameObject.transform.rotation;

        for (int i = 0; i < playerList.Count; i++) {
            if (playerList [i].Name.Equals (playerName)) {
                currentPlayeraInfoActive = playerList [i];
            }
        }

        currentPlayeraInfoActive.playerControllerGameObject.transform.position = playerPosition;
        currentPlayeraInfoActive.playerControllerGameObject.transform.rotation = playerRotation;

        currentPlayeraInfoActive.playerCameraGameObject.transform.rotation = cameraRotation;

        currentPlayeraInfoActive.playerParentGameObject.SetActive (true);
    }

    public void setAsCurrentCharacterToControlByName (string playerName)
    {
        int currentPlayerIndex = playerList.FindIndex (s => s.Name.Equals (playerName));

        if (currentPlayerIndex == -1) {
            return;
        }

        if (keepActiveOnlyCurrentPlayerSelected) {
            setCharactersStateValue (currentPlayerIndex, true);
        }

        previousCharacterInfoActive = null;

        if (currentPlayeraInfoActive != null) {
            previousCharacterInfoActive = currentPlayeraInfoActive;
        }

        int playerListCount = playerList.Count;

        for (int i = 0; i < playerListCount; i++) {
            if (changeCameraPositionAtOnceOnCharacterChange) {
                playerList [i].playerCameraManager.setUseSmoothCameraTransitionBetweenCharactersState (false);
            }

            if (currentPlayerIndex == i) {

                Vector3 cameraPosition = previousCharacterInfoActive.playerCameraManager.getMainCamera ().transform.position;
                Quaternion cameraRotation = previousCharacterInfoActive.playerCameraManager.getMainCamera ().transform.rotation;

                playerList [i].playerCameraManager.setPreviousCharacterControl (previousCharacterInfoActive.playerControllerGameObject, cameraPosition,
                    cameraRotation, previousCharacterInfoActive.playerCameraManager.isFirstPersonActive ());
            }
        }


        bool isTouchPlatformActive = false;

        for (int i = 0; i < playerListCount; i++) {
            playerList [i].mainFriendListManager.removeAllFriends ();

            playerList [i].playerInput.switchPlayerID (1);

            playerList [i].playerInput.updateIsUsingTouchControlsState ();

            bool touchPlatform = playerList [i].playerInput.isUsingTouchControls ();

            if (currentPlayerIndex == i) {
                currentPlayeraInfoActive = playerList [i];

                if (currentPlayeraInfoActive.mainSwitchCompanionSystem != null) {
                    currentPlayeraInfoActive.mainSwitchCompanionSystem.activateEventToSetCharacterAsPlayer ();
                }

                playerList [i].eventToSetCharacterAsPlayer.Invoke ();

                currentPlayeraInfoActive.useByAI = false;

                currentCharacterToControlIndex = i;

                if (touchPlatform) {
                    currentPlayeraInfoActive.pauseManager.setUseTouchControlsState (true);

                    currentPlayeraInfoActive.playerInput.enableOrDisableTouchCameraControl (true);

                    currentPlayeraInfoActive.playerInput.enableOrDisableTouchMovementJoystickForButtons (true);

                    currentPlayeraInfoActive.playerInput.setTouchPanelActiveState (true);

                    currentPlayeraInfoActive.playerInput.getInputManager ().setNewTouchButtonListByPlayerInputManager (currentPlayeraInfoActive.playerInput);

                    isTouchPlatformActive = true;
                }
            } else {
                if (playerList [i].mainSwitchCompanionSystem != null) {
                    playerList [i].mainSwitchCompanionSystem.activateEventToSetCharacterAsAI ();
                }

                playerList [i].eventToSetCharacterAsAI.Invoke ();

                playerList [i].useByAI = true;

                if (touchPlatform) {
                    playerList [i].pauseManager.setUseTouchControlsState (false);

                    playerList [i].playerInput.enableOrDisableTouchCameraControl (false);

                    playerList [i].playerInput.enableOrDisableTouchMovementJoystickForButtons (false);

                    playerList [i].playerInput.setTouchPanelActiveState (false);
                }
            }
        }

        if (isTouchPlatformActive) {
            if (!menuPause.isCursorVisible ()) {
                menuPause.setCursorVisibleState (true);

                menuPause.setCursorLockState (false);
            }
        }

        if (keepActiveOnlyCurrentPlayerSelected) {
            setCharactersStateValue (currentPlayerIndex, false);

            if (setCurrentPlayerPositionToPreviousCharacter) {
                if (previousCharacterInfoActive != null) {
                    currentPlayeraInfoActive.playerControllerGameObject.transform.SetPositionAndRotation (
                        previousCharacterInfoActive.playerControllerGameObject.transform.position,
                        previousCharacterInfoActive.playerControllerGameObject.transform.rotation);

                    currentPlayeraInfoActive.playerCameraGameObject.transform.SetPositionAndRotation (
                        previousCharacterInfoActive.playerCameraGameObject.transform.position,
                        previousCharacterInfoActive.playerCameraGameObject.transform.rotation);
                }
            }

            if (previousCharacterInfoActive != null) {
                GKC_Utils.removeTargetFromAIEnemyList (previousCharacterInfoActive.playerControllerGameObject);
            }
        } else {
            for (int i = 0; i < playerListCount; i++) {
                if (playerList [i].playerControllerGameObject != currentPlayeraInfoActive.playerControllerGameObject) {
                    findObjectivesSystem currentfindObjectivesSystem = playerList [i].playerControllerGameObject.GetComponentInChildren<findObjectivesSystem> ();

                    if (currentfindObjectivesSystem != null) {

                        if (currentfindObjectivesSystem.isPartnerFound ()) {
                            currentfindObjectivesSystem.removePartner ();
                        }

                        if (playerList [i].followMainPlayerOnSwitchCompanion) {
                            currentfindObjectivesSystem.addPlayerAsPartner (currentPlayeraInfoActive.playerControllerGameObject);
                        } else {
                            currentfindObjectivesSystem.removeCurrentPartner ();
                        }
                    }
                }
            }
        }
    }

    void setCharactersStateValue (int currentPlayerIndex, bool setStateOnlyOnCurrentPlayer)
    {
        int playerListCount = playerList.Count;

        bool touchPlatform = playerList [currentPlayerIndex].playerInput.isUsingTouchControls ();

        for (int i = 0; i < playerListCount; i++) {
            bool setActiveResult = true;

            if (currentPlayerIndex != i) {
                setActiveResult = false;
            }

            bool canSetCharacterState = false;

            if (setStateOnlyOnCurrentPlayer) {
                if (currentPlayerIndex == i) {
                    canSetCharacterState = true;
                }
            } else {
                if (currentPlayerIndex != i) {
                    canSetCharacterState = true;
                }
            }

            if (canSetCharacterState) {
                if (setActiveResult) {
                    if (playerList [i].playerControllerManager.isUsingDevice ()) {
                        GKC_Utils.checkIfStopUseDevice (playerList [i].playerControllerGameObject);
                    }
                }

                if (playerList [i].playerControllerGameObject.activeSelf != setActiveResult) {
                    playerList [i].playerControllerGameObject.SetActive (setActiveResult);
                }

                if (playerList [i].playerCameraGameObject.activeSelf != setActiveResult) {
                    playerList [i].playerCameraGameObject.SetActive (setActiveResult);
                }

                GameObject playerManagersParentGameObject = playerList [i].playerControllerManager.getPlayerManagersParentGameObject ();

                if (playerManagersParentGameObject != null) {
                    if (playerManagersParentGameObject.activeSelf != setActiveResult) {
                        playerManagersParentGameObject.SetActive (setActiveResult);
                    }
                }

                GameObject hudAndMenus = playerList [i].pauseManager.getHudAndMenus ();

                if (hudAndMenus != null) {
                    bool setHudAndMenusStateResult = setActiveResult;

                    if (touchPlatform) {
                        //if (i == 0) {
                        //    setHudAndMenusStateResult = true;
                        //} else {
                        if (setActiveResult) {
                            setCharacterCanvasInfoListSortOrderValue (playerList [i].pauseManager, 2);
                        } else {
                            setCharacterCanvasInfoListSortOrderValue (playerList [i].pauseManager, 0);
                        }
                        //}
                    }

                    if (hudAndMenus.activeSelf != setHudAndMenusStateResult) {
                        hudAndMenus.SetActive (setHudAndMenusStateResult);
                    }
                }

                if (currentPlayerIndex == i) {
                    playerList [i].mainSwitchCompanionSystem.activateEventToSetCharacterAsOnlyPlayerActive ();
                } else {
                    playerList [i].mainSwitchCompanionSystem.activateEventToSetCharacterAsPlayerNotActive ();
                }
            }
        }
    }

    void setCharacterCanvasInfoListSortOrderValue (menuPause currentPauseManager, int newValue)
    {
        List<menuPause.canvasInfo> currentCanvasInfoList = currentPauseManager.getCanvasInfoList ();

        if (currentCanvasInfoList.Count == 0) {
            currentPauseManager.addNewCanvasToList (currentPauseManager.getMainCanvas ());

            currentCanvasInfoList = currentPauseManager.getCanvasInfoList ();
        }

        for (int k = 0; k < currentCanvasInfoList.Count; k++) {
            if (currentCanvasInfoList [k].mainCanvas != null) {
                if (currentCanvasInfoList [k].mainCanvas.sortingOrder != newValue) {
                    currentCanvasInfoList [k].mainCanvas.sortingOrder = newValue;
                }
            }
        }
    }

    public void toogleUseOnlyKeyboardGamepad (string playerName)
    {
        for (int i = 0; i < playerList.Count; i++) {
            if (playerList [i].Name.Equals (playerName)) {

                playerList [i].useOnlyKeyboard = !playerList [i].useOnlyKeyboard;

                playerList [i].playerInput.useOnlyKeyboard = playerList [i].useOnlyKeyboard;

                GKC_Utils.updateComponent (playerList [i].playerInput);
            }
        }

        setPlayerID (true);

        GKC_Utils.updateDirtyScene ("Toggle use of keyboard or gamepad on player " + playerName, gameObject);
    }

    public void setNextCharacterToControl ()
    {
        if (playerList.Count == 1) {
            return;
        }

        currentCharacterToControlIndex++;

        if (currentCharacterToControlIndex >= playerList.Count) {
            currentCharacterToControlIndex = 0;
        }

        setAsCurrentCharacterToControlByName (playerList [currentCharacterToControlIndex].Name);
    }

    public void setAsCurrentCharacterToControlByPlayerGameObject (GameObject playerGameObjectToSearch)
    {
        for (int i = 0; i < playerList.Count; i++) {
            if (playerList [i].playerControllerGameObject == playerGameObjectToSearch) {
                setAsCurrentCharacterToControlByName (playerList [i].Name);

                return;
            }
        }
    }

    public void setAsCurrentCharacterToControlByPlayerTransform (Transform playerTransformToSearch)
    {
        if (playerTransformToSearch != null) {
            setAsCurrentCharacterToControlByPlayerGameObject (playerTransformToSearch.gameObject);
        }
    }

    public menuPause getPauseManagerFromPlayerByIndex (int index)
    {
        if (index < playerList.Count) {
            return playerList [index].pauseManager;
        }

        return null;
    }

    public void setCharactersManagerPauseState (bool state)
    {
        for (int i = 0; i < playerList.Count; i++) {

            if (!playerList [i].useByAI) {

                if (playerList [i].pauseManager != null && playerList [i].pauseManager.isMenuPaused () != state) {
                    playerList [i].pauseManager.setMenuPausedState (state);
                }
            }
        }
    }

    public bool isCharacterInList (GameObject characterToSearch)
    {
        for (int i = 0; i < playerList.Count; i++) {
            if (playerList [i].playerControllerGameObject == characterToSearch) {
                return true;
            }
        }

        return false;
    }

    public bool anyCharacterDead ()
    {
        for (int i = 0; i < playerList.Count; i++) {
            if (playerList [i].playerControllerManager.isPlayerDead ()) {
                return true;
            }
        }

        return false;
    }



    public static void checkPanelsActiveOnGamepadOrKeyboard (bool checkKeyboard, int playerID)
    {
        for (int i = 0; i < playerListCount; i++) {
            if (playerListValue [i].playerControllerManager.getPlayerID () == playerID) {

                playerListValue [i].playerInput.checkPanelsActiveOnGamepadOrKeyboard (checkKeyboard);

                return;
            }
        }
    }

    public playerController getMainPlayerController ()
    {
        if (playerList.Count >= 1) {
            return playerList [0].playerControllerManager;
        }

        return null;
    }

    public GameObject getMainPlayerGameObject ()
    {
        if (playerList.Count >= 1) {
            return playerList [0].playerControllerGameObject;
        }

        return null;
    }

    public playerCamera getMainPlayerCamera ()
    {
        if (playerList.Count >= 1) {
            return playerList [0].playerCameraManager;
        }

        return null;
    }

    public Camera getMainPlayerCameraComponent ()
    {
        if (playerList.Count >= 1) {
            return playerList [0].playerCameraManager.getMainCamera ();
        }

        return null;
    }

    public Transform getMainPlayerCameraTransform ()
    {
        if (playerList.Count >= 1) {
            return playerList [0].playerCameraManager.getMainCamera ().transform;
        }

        return null;
    }

    public Transform getMainPlayerTransform ()
    {
        if (playerList.Count >= 1) {
            return playerList [0].playerControllerGameObject.transform;
        }

        return null;
    }

    public menuPause getMainPlayerPauseManager ()
    {
        if (playerList.Count >= 1) {
            return playerList [0].pauseManager;
        }

        return null;
    }

    public List<GameObject> getPlayerList ()
    {
        if (playerList.Count > 0) {
            List<GameObject> newList = new List<GameObject> ();

            int playerListCount = playerList.Count;

            for (int i = 0; i < playerListCount; i++) {
                if (playerList [i].playerControllerGameObject != null) {
                    newList.Add (playerList [i].playerControllerGameObject);
                }
            }

            return newList;
        }

        return null;
    }

    public void getCameraStateListString ()
    {
        cameraStatesListString = new string [cameraStatesList.Count];

        for (int i = 0; i < cameraStatesList.Count; i++) {
            string newName = cameraStatesList [i].Name;

            cameraStatesListString [i] = newName;
        }

        updateComponent ();
    }

    public void inputSetNextCharacterToControl ()
    {
        if (!setCurrentCharacterToControlAndAIAtStart) {
            return;
        }

        if (Time.time > lastTimeCharacterChange + delayTimeToChangeBetweenCharacters) {
            if (currentPlayeraInfoActive != null) {
                if (currentPlayeraInfoActive.playerControllerManager.playerIsBusy () ||
                    currentPlayeraInfoActive.playerControllerManager.isPlayerDriving ()) {
                    return;
                }
            }

            setNextCharacterToControl ();

            lastTimeCharacterChange = Time.time;
        }
    }

    public int getPlayerListCount ()
    {
        return playerList.Count;
    }

    public void checkGameInfoToLoad (int lastSaveNumber, string currentSaveDataPath, string extraFileString)
    {
        if (getPlayerListCount () > 1) {
            for (int i = 0; i < playerList.Count; i++) {
                playerList [i].mainSaveGameSystem.checkGameInfoToLoad (lastSaveNumber, currentSaveDataPath, extraFileString);
            }
        } else {
            if (getPlayerListCount () == 1) {
                playerList [0].mainSaveGameSystem.checkGameInfoToLoad (lastSaveNumber, currentSaveDataPath, extraFileString);
            }
        }
    }

    public void deleteGameInfo (int saveNumberToDelete, string currentSaveDataPath, string extraFileString)
    {
        if (getPlayerListCount () > 1) {
            for (int i = 0; i < playerList.Count; i++) {
                playerList [i].mainSaveGameSystem.deleteGameInfo (saveNumberToDelete, currentSaveDataPath, extraFileString);
            }
        } else {
            if (getPlayerListCount () == 1) {
                playerList [0].mainSaveGameSystem.deleteGameInfo (saveNumberToDelete, currentSaveDataPath, extraFileString);
            }
        }
    }

    public void showSaveInfoDebug (int saveNumberToShow, string currentSaveDataPath, string extraFileString)
    {
        if (getPlayerListCount () > 1) {
            for (int i = 0; i < playerList.Count; i++) {
                playerList [i].mainSaveGameSystem.showSaveInfoDebug (saveNumberToShow, currentSaveDataPath, extraFileString);
            }
        } else {
            if (getPlayerListCount () == 1) {
                playerList [0].mainSaveGameSystem.showSaveInfoDebug (saveNumberToShow, currentSaveDataPath, extraFileString);
            }
        }
    }

    public void checkComponentsToInitialize ()
    {
        checkPlayerElementsOnScene ();

        if (getPlayerListCount () > 1) {
            for (int i = 0; i < playerList.Count; i++) {
                playerList [i].mainSaveGameSystem.checkComponentsToInitialize ();
            }
        } else {
            if (getPlayerListCount () == 1) {
                playerList [0].mainSaveGameSystem.checkComponentsToInitialize ();
            }
        }
    }

    public void checkSaveInfoListToLoadOnStartOnAllScenes ()
    {
        if (getPlayerListCount () > 1) {
            for (int i = 0; i < playerList.Count; i++) {
                playerList [i].mainSaveGameSystem.checkSaveInfoListToLoadOnStartOnAllScenes ();
            }
        } else {
            if (getPlayerListCount () == 1) {
                playerList [0].mainSaveGameSystem.checkSaveInfoListToLoadOnStartOnAllScenes ();
            }
        }
    }

    public void saveGameInfoFromEditor (int lastSaveNumber, string infoTypeName, string extraFileString)
    {
        if (getPlayerListCount () > 1) {
            for (int i = 0; i < playerList.Count; i++) {
                playerList [i].mainSaveGameSystem.saveGameInfoFromEditor (lastSaveNumber, infoTypeName, extraFileString);
            }
        } else {
            if (getPlayerListCount () == 1) {
                playerList [0].mainSaveGameSystem.saveGameInfoFromEditor (lastSaveNumber, infoTypeName, extraFileString);
            }
        }
    }

    public void saveGameWhenReturningHomeMenu ()
    {
        if (getPlayerListCount () > 1) {
            for (int i = 0; i < playerList.Count; i++) {
                playerList [i].mainSaveGameSystem.saveGameWhenReturningHomeMenu ();
            }
        } else {
            if (getPlayerListCount () == 1) {
                playerList [0].mainSaveGameSystem.saveGameWhenReturningHomeMenu ();
            }
        }
    }

    public void checkIfPlayerIsLookingAtDeadTarget (Transform deadTarget, Transform placeToShoot)
    {
        int playerListCount = playerList.Count;

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

            playerCamera currentPlayerCamera = playerList [i].playerCameraManager;

            if (currentPlayerCamera != null && currentPlayerCamera.isPlayerLookingAtTarget ()) {
                Transform currentTargetToLook = currentPlayerCamera.getCurrentTargetToLook ();

                bool isSameObject = false;

                if (currentTargetToLook == deadTarget) {
                    isSameObject = true;
                }

                if (!isSameObject) {
                    if (currentTargetToLook == placeToShoot) {
                        isSameObject = true;
                    }
                }

                if (!isSameObject) {
                    Transform lastCharacterToLook = currentPlayerCamera.getLastCharacterToLook ();

                    if (lastCharacterToLook != null) {
                        if (deadTarget == lastCharacterToLook || placeToShoot == lastCharacterToLook) {
                            isSameObject = true;
                        }
                    }
                }

                if (!isSameObject) {
                    if (applyDamage.checkIfWeakSpotListContainsTransform (deadTarget.gameObject, currentTargetToLook)) {
                        isSameObject = true;
                    }
                }

                if (isSameObject) {
                    //print ("target found, disabling look at target");

                    currentPlayerCamera.checkIfPlayerIsLookingAtDeadTarget (false);

                    currentPlayerCamera.checkEventOnLockOnEnd ();
                } else {
                    //print ("TARGET NOT FOUND");
                }
            }
        }
    }

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

    [System.Serializable]
    public class playerInfo
    {
        public string Name;
        public GameObject playerParentGameObject;
        public GameObject playerControllerGameObject;
        public GameObject playerCameraGameObject;
        public playerController playerControllerManager;
        public playerCamera playerCameraManager;

        public playerInputManager playerInput;
        public menuPause pauseManager;

        public playerComponentsManager mainPlayerComponentsManager;
        public friendListManager mainFriendListManager;

        public switchCompanionSystem mainSwitchCompanionSystem;

        public saveGameSystem mainSaveGameSystem;

        public bool useByAI;

        public bool showEventSettings;
        public UnityEvent eventToSetCharacterAsAI;
        public UnityEvent eventToSetCharacterAsPlayer;

        public bool useOnlyKeyboard;

        public bool followMainPlayerOnSwitchCompanion = true;
    }

    [System.Serializable]
    public class cameraStates
    {
        public string Name;
        public int numberfOfPlayers;

        public List<cameraInfo> cameraInfoList = new List<cameraInfo> ();
    }

    [System.Serializable]
    public class cameraInfo
    {
        public float newX = 0;
        public float newY = 0;
        public float newW = 0;
        public float newH = 0;
    }
}