private void Update()
    {
        if (PlayerPrefs.GetInt("MonsterMode") == 0)
        {
            if (Players.Count < 10)
            {
                PlayerCount.text = "0" + Players.Count;
            }
            else
            {
                PlayerCount.text = "" + Players.Count;
            }

            if (Enemies.Count < 10)
            {
                EnemyCount.text = "0" + Enemies.Count;
            }
            else
            {
                EnemyCount.text = "" + Enemies.Count;
            }
        }
        else
        {
            if (Players.Count < 10)
            {
                PlayerCount.text = "0" + Enemies.Count;
            }
            else
            {
                PlayerCount.text = "" + Enemies.Count;
            }

            if (Enemies.Count < 10)
            {
                EnemyCount.text = "0" + Players.Count;
            }
            else
            {
                EnemyCount.text = "" + Players.Count;
            }
        }

        Vector3 mousePositon = Camera.main.ScreenToWorldPoint(Input.mousePosition);

        if (player == null)
        {
            pathfcost  = 0;
            stats.text = "Nothing";
        }

        if (GetWinner == VICTORY_DICTATOR.ENEMY)
        {
            s_camera.staticCam.StartCoroutine(s_camera.staticCam.Fade(Color.black, 0.3f));

            game_on = false;
            if (s_camera.staticCam.isfaded)
            {
                UnityEngine.SceneManagement.SceneManager.LoadScene("Title");
            }
        }


        if (game_on)
        {
            switch (STATES)
            {
            case STATEMACHINE.IDLE:

                switch (TURNSTATE)
                {
                case TURNS.PLAYER:
                    if (Input.GetMouseButtonDown(0))
                    {
                        if (CheckForObject(mousePositon))
                        {
                            s_object obj = GetObjectFromWorld(mousePositon);
                            if (IsCharacter(mousePositon, obj))
                            {
                                o_character obselect = obj.GetComponent <o_character>();
                                if (obselect.health > 0)
                                {
                                    if (obselect.playable)
                                    {
                                        pathfcost = 0;
                                        SwitchCharacter((o_character)obj);
                                        CheckCharacterSurroundings(false);
                                    }
                                    player = obselect;
                                    STATES = STATEMACHINE.SELECT_CHAR;
                                }
                            }
                        }
                    }
                    break;

                    #region ENEMY
                case TURNS.ENEMY:

                    if (EnemyQueue.Count > 0)
                    {
                        //print("Chara " + EnemyQueue.Peek());
                        player = EnemyQueue.Peek();
                        //print("pl " + player);
                        STATES = STATEMACHINE.SELECT_CHAR;
                    }
                    else
                    {
                        s_camera.staticCam.StartCoroutine(s_camera.staticCam.Fade(Color.clear, 4));
                        if (s_camera.staticCam.isfaded)
                        {
                            print("Progress END: " + EnemyQueue.Count);
                            EndTurn();
                        }
                    }

                    break;
                    #endregion
                }

                break;

            case STATEMACHINE.SELECT_CHAR:

                switch (TURNSTATE)
                {
                case TURNS.PLAYER:

                    if (player.current_item != null)
                    {
                        stats.text = player.name + "\n" + "Item: " + player.current_item.name;
                    }
                    else
                    {
                        stats.text = player.name;
                    }

                    //actionpoints = "AP: " + player.actionPoints + "/" + player.maxActionPoints;

                    if (CheckForObject(mousePositon))
                    {
                        if (Input.GetMouseButtonDown(0))
                        {
                            CheckCharacterSurroundings(false);
                            s_object obj = GetObjectFromWorld(mousePositon);

                            if (obj != null)
                            {
                                if (obj.GetType() == typeof(o_character))
                                {
                                    o_character chara = obj.GetComponent <o_character>();
                                    if (targets.Contains(chara))
                                    {
                                        if (!chara.playable)
                                        {
                                            targetToAttack = chara;
                                            STATES         = STATEMACHINE.ATTACK_SELECT;
                                        }
                                    }
                                }
                            }
                        }
                    }

                    if (Input.GetMouseButtonDown(0))
                    {
                        Vector2 mousepos = Camera.main.ScreenToWorldPoint(Input.mousePosition);

                        if (player.MoveCost(mousepos) != -1)
                        {
                            Grid.UnpaintAllNodes();
                            pathfcost = player.MoveCost(mousepos);
                            player.SetDirections(Grid.NodeFromWorld(mousepos));
                            List <o_node> dir = player.directions;

                            foreach (o_node d in dir)
                            {
                                Grid.PaintNode(Grid.NodePositionFromWorld(d), Color.yellow);
                            }
                            STATES = STATEMACHINE.MOVE_TO;
                        }
                    }

                    break;

                    #region ENEMY
                case TURNS.ENEMY:

                    if (player.current_item != null)
                    {
                        UseItem();
                    }

                    /*if (targetToAttack != null)
                     *  if (targetToAttack.health == 0 && !targetToAttack.IsDisappear())
                     *      return;
                     */
                    CheckCharacterSurroundings(true);
                    if (targets.Count == 0)
                    {
                        STATES = STATEMACHINE.MOVE_TO;
                    }
                    else
                    {
                        STATES = STATEMACHINE.ATTACK_SELECT;
                    }
                    break;
                    #endregion
                }

                //Have a cancel button where this player is no longer the focus

                //Attack button where it checks enemies

                break;

            case STATEMACHINE.MOVE_TO:

                switch (TURNSTATE)
                {
                case TURNS.PLAYER:
                    if (Input.GetMouseButtonDown(0))
                    {
                        Vector2 mousepos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
                        if (player.playable)
                        {
                            if (player.actionPoints >= pathfcost)
                            {
                                if (Grid.NodeFromWorld(mousepos) == player.directions[player.directions.Count - 1])
                                {
                                    ConfirmMovement();
                                    return;
                                }
                            }
                        }

                        if (player.MoveCost(mousepos) != -1)
                        {
                            Grid.UnpaintAllNodes();
                            pathfcost = player.MoveCost(mousepos);
                            player.SetDirections(Grid.NodeFromWorld(mousepos));
                            List <o_node> dir = player.directions;

                            foreach (o_node d in dir)
                            {
                                Grid.PaintNode(Grid.NodePositionFromWorld(d), Color.yellow);
                            }
                        }
                    }

                    if (Input.GetMouseButtonDown(1))
                    {
                        Grid.UnpaintAllNodes();
                        LooseFocus();
                    }

                    break;

                    #region ENEMY
                case TURNS.ENEMY:

                    int         newcost = int.MaxValue;
                    o_character tar     = null;

                    foreach (o_character e in Players)
                    {
                        //Check around the target and pathfind for each position.
                        HashSet <o_node> aroundChar = Grid.CheckAroundNode(Grid.NodeFromWorld(e.transform.position));

                        int potentialMoveCost = int.MaxValue;
                        e.GetComponent <SpriteRenderer>().color = Color.red;
                        o_node nof = null;

                        foreach (o_node no in aroundChar)
                        {
                            if (!no.walkable)
                            {
                                continue;
                            }

                            int comp = player.MoveCost(no.position);
                            if (comp == -1)
                            {
                                continue;
                            }

                            potentialMoveCost = Mathf.Min(potentialMoveCost, comp);
                            if (potentialMoveCost == comp)
                            {
                                nof = no;
                            }
                        }

                        e.GetComponent <SpriteRenderer>().color = Color.white;
                        if (potentialMoveCost <= player.range)
                        {
                            if (potentialMoveCost <= player.actionPoints)
                            {
                                tar     = e;
                                newcost = Mathf.Min(newcost, potentialMoveCost);
                                if (newcost == potentialMoveCost)
                                {
                                    if (nof != null)
                                    {
                                        player.SetDirections(nof);
                                    }
                                }
                            }
                        }
                        else
                        {
                            continue;
                        }
                        Grid.UnpaintAllNodes();
                    }

                    if (newcost != int.MaxValue)
                    {
                        Grid.UnpaintAllNodes();
                        pathfcost = newcost;
                        if (pathfcost > 0)
                        {
                            ConfirmMovement();
                        }
                        else
                        {
                            NextEnemy();
                        }
                    }
                    else
                    {
                        NextEnemy();
                    }

                    break;
                    #endregion
                }
                //Confirm?
                //Cancecl Move

                break;

            case STATEMACHINE.ATTACK_SELECT:

                switch (TURNSTATE)
                {
                case TURNS.PLAYER:


                    if (targetToAttack != null)
                    {
                        targetToAttack.renderer.color = Color.magenta;
                    }

                    if (Input.GetMouseButtonDown(0))
                    {
                        s_object obj = GetObjectFromWorld(mousePositon);
                        if (obj != targetToAttack)
                        {
                            o_character newtarg = targets.Find(x => obj == x);

                            if (newtarg != null)
                            {
                                targetToAttack.renderer.color = Color.white;
                                targetToAttack = newtarg;
                                return;
                            }
                        }
                    }


                    if (targetToAttack.health > 0 && player.actionPoints >= 2)
                    {
                        if (Input.GetMouseButtonDown(0))
                        {
                            targetToAttack.renderer.color = Color.white;
                            STATES = STATEMACHINE.ATTACK_EXECUTE;
                        }
                    }

                    if (targetToAttack.health <= 0 || player.actionPoints < 2)
                    {
                        targetToAttack.renderer.color = Color.white;
                        LooseFocus();
                    }

                    if (Input.GetMouseButtonDown(1))
                    {
                        if (targetToAttack != null)
                        {
                            targetToAttack.renderer.color = Color.white;
                        }
                        LooseFocus();
                    }
                    break;

                    #region ENEMY
                case TURNS.ENEMY:

                    CheckCharacterSurroundings(true);
                    if (targets.Count > 0)
                    {
                        //The enemy can attack the player again if they have sufficent points
                        if (player.actionPoints >= 2)
                        {
                            targetToAttack = GetTargetWithLowestHealth();

                            if (targetToAttack.health > 0)
                            {
                                if (!isattacking && !IsSkipped)
                                {
                                    StartCoroutine(AttackingAnim());
                                }

                                if (IsSkipped)
                                {
                                    AttackCalculations(targetToAttack);
                                }
                            }
                        }
                        else
                        {
                            NextEnemy();
                        }
                    }
                    else
                    {
                        STATES = STATEMACHINE.SELECT_CHAR;
                    }

                    break;
                    #endregion
                }

                break;

            case STATEMACHINE.ATTACK_EXECUTE:

                if (!isattacking)
                {
                    StartCoroutine(AttackingAnim());
                }
                else if (TURNSTATE == TURNS.PLAYER)
                {
                    STATES = STATEMACHINE.ATTACK_SELECT;
                }

                break;

            case STATEMACHINE.WALK:
                //Call Player enumarator to walk
                //Once done go back to select char

                break;
            }
        }
    }
    new void Update()
    {
        if (CheckCollisionInside(this) != null)
        {
            s_object collidedobj = CheckCollisionInside(this);
            if (collidedobj.GetType() == typeof(o_door))
            {
                o_door d = collidedobj.GetComponent <o_door>();
                if (d.CanPass())
                {
                    reqtext = "";
                    if (d.location != "Ending")
                    {
                        saved_number_of_water = water_stones_cap;
                        gman.LoadRoom(d);
                    }
                    else
                    {
                        UnityEngine.SceneManagement.SceneManager.LoadScene("Ending");
                    }
                }
                else
                {
                    reqtext = d.PassReq();
                }
            }
            else
            if (collidedobj.GetType() == typeof(o_block))
            {
                if (collidedobj.name == "Spike")
                {
                    if (!isdying)
                    {
                        water_stones_cap = saved_number_of_water;
                        isgrounded       = false;
                        StartCoroutine(DyingAnim());
                    }
                }
            }
            else
            if (collidedobj.GetType() == typeof(o_item))
            {
                o_item i = collidedobj.GetComponent <o_item>();
                water_stones_cap++;
                grid.DespawnObject(i);
            }
        }
        else
        {
            reqtext = "";
        }
        base.Update();

        ite = "Water stones: " + water_stones_cap;

        gman.txt.text = ite + "\n" + reqtext;

        if (Input.GetAxisRaw("Horizontal") != 0 || Input.GetAxisRaw("Vertical") != 0)
        {
            anim.SetBool("Walk", true);
        }
        else
        {
            anim.SetBool("Walk", false);
        }

        if (!Input.GetButton("Vertical"))
        {
            anim.SetFloat("Y", 0);
            anim.SetFloat("X", (int)Input.GetAxisRaw("Horizontal"));
            if (Input.GetKey(KeyCode.RightArrow))
            {
                vecloicty.x = speed;
            }
            if (Input.GetKey(KeyCode.LeftArrow))
            {
                vecloicty.x = -speed;
            }
        }
        if (!Input.GetButton("Horizontal"))
        {
            anim.SetFloat("X", 0);
            anim.SetFloat("Y", (int)Input.GetAxisRaw("Vertical"));
            if (Input.GetKey(KeyCode.UpArrow))
            {
                vecloicty.y = speed;
            }
            if (Input.GetKey(KeyCode.DownArrow))
            {
                vecloicty.y = -speed;
            }
        }

        if (isgrounded)
        {
            if (Input.GetKeyDown(KeyCode.Space))
            {
                vecloicty.z = 5;
            }
        }
    }
    public void CheckCharacterSurroundings(bool is_enemy)
    {
        //If an enemy or two appears enable the confirm attack button
        targets.Clear();
        HashSet <o_node> enemynodes = Grid.CheckAroundNode(Grid.NodeFromWorld(player.transform.position));

        foreach (o_node e in enemynodes)
        {
            s_object enemyObject = Grid.ObjectFromWorld(e);

            if (enemyObject == null)
            {
                continue;
            }

            if (enemyObject.GetType() == typeof(o_character))
            {
                o_character enemy = enemyObject.GetComponent <o_character>();

                if (PlayerPrefs.GetInt("MonsterMode") == 0)
                {
                    if (!is_enemy)
                    {
                        if (!Heroes.Contains(enemy.name))
                        {
                            targets.Add(enemy);
                        }
                    }
                    else
                    {
                        if (!Adversaries.Contains(enemy.name))
                        {
                            targets.Add(enemy);
                        }
                    }
                }
                else
                if (PlayerPrefs.GetInt("MonsterMode") == 1)
                {
                    if (!is_enemy)
                    {
                        if (!Adversaries.Contains(enemy.name))
                        {
                            targets.Add(enemy);
                        }
                    }
                    else
                    {
                        if (!Heroes.Contains(enemy.name))
                        {
                            targets.Add(enemy);
                        }
                    }
                }
            }
            else
            {
                continue;
            }
        }
    }
    private void Update()
    {
        if (Grid.gridworldsize.y > 0 && Grid.gridworldsize.x > 0)
        {
            Vector3  mousePositon = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            s_object selectedObj  = Grid.ObjectFromWorld(mousePositon);

            if (Input.GetKeyDown(KeyCode.W))
            {
                spritenum++;
            }
            if (Input.GetKeyDown(KeyCode.S))
            {
                spritenum--;
            }


            if (Input.GetKeyDown(KeyCode.E))
            {
                angle += 90;
            }

            if (angle > 360)
            {
                angle = 0;
            }

            examplerend.gameObject.transform.localRotation = Quaternion.Euler(0, 0, angle);

            spritenum = Mathf.Clamp(spritenum, 0, spriteArray.Length - 1);

            examplerend.sprite = spriteArray[spritenum];

            if (Grid.NodeFromWorld(mousePositon) != null)
            {
                Vector2 snap = Grid.SnapToGrid(mousePositon);
                if (Input.GetMouseButton(0))
                {
                    if (selectedObj != null)
                    {
                        if (selectedObj.GetComponent <s_object>().GetType() == typeof(o_tile))
                        {
                            SpriteRenderer ren = selectedObj.GetComponent <SpriteRenderer>();
                            ren.sprite = spriteArray[spritenum];
                            ren.gameObject.transform.localRotation = examplerend.gameObject.transform.localRotation;
                        }
                    }
                    //target.transform.position = mousePositon;
                    if (Grid.ObjectFromWorld(mousePositon) == null)
                    {
                        Vector2Int vecint = Grid.VectorPositionFromWorld(mousePositon);

                        if (selected_object != null)
                        {
                            s_object obj = Grid.SpawnObject(selected_object.name, snap);
                        }
                    }
                }
                if (Input.GetMouseButton(1))
                {
                    if (Grid.ObjectFromWorld(mousePositon) != null)
                    {
                        Vector2Int vecint = Grid.VectorPositionFromWorld(mousePositon);
                        if (selected_object != null)
                        {
                            Grid.DespawnObject(snap);
                        }
                    }
                }
            }
        }

        if (Grid.nodes != null)
        {
            for (int x = 0; x < Grid.gridworldsize.x; x++)
            {
                for (int y = 0; y < Grid.gridworldsize.y; y++)
                {
                    /*
                     * SpriteRenderer colourRender = Grid.nodegameobjects[x, y].GetComponent<SpriteRenderer>();
                     * colourRender.color = Color.white;
                     * if (Grid.CheckForNodeOnGrid(mousePositon, x, y))
                     * {
                     *  colourRender.color = Color.blue;
                     * }
                     */
                }
            }
        }
    }