/// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
                Exit();

            MouseState mouse = Mouse.GetState();
            if (CurrentGameState == GameState.MainMenu)
            {
                if (btnPlay.isClicked == true) CurrentGameState = GameState.Setup;
                btnPlay.Update(mouse);

                add.Update(mouse,gameTime);
                sub.Update(mouse,gameTime);

                if (add.Foi_Clicado && Número_Inicial_de_Jogadores < 6)
                    Número_Inicial_de_Jogadores++;
                if (sub.Foi_Clicado && Número_Inicial_de_Jogadores > 3)
                    Número_Inicial_de_Jogadores--;
            }
            if (CurrentGameState == GameState.Setup)
            {
                if (!já_foi_sorteado_o_primeiro)
                {
                    for (int i = 0; i < 6; i++)
                    {
                        if (i <= Número_Inicial_de_Jogadores)
                            Jogadores[i] = new Jogador(i + 1, Número_Inicial_de_Jogadores);
                        else
                            Jogadores[i] = new Jogador();
                    }
                    for (int i = 0; i < Número_Inicial_de_Jogadores; i++)
                    {
                        Jogadores[i].sorteio_inicial = r.Next(1, 7);
                    }
                    Jogadores[0].Cor = Color.Red;
                    Jogadores[1].Cor = Color.Blue;
                    Jogadores[2].Cor = Color.Green;
                    Jogadores[3].Cor = Color.Orange;
                    Jogadores[4].Cor = Color.Black;
                    Jogadores[5].Cor = Color.Cyan;
                    //Vão ser rolados os dados para cada jogador para escolher o primeiro a colocar os soldados
                    int maior_numero_saido = 0, jogador_com_maior_numero = -1;
                    for (int i = 0; i < Número_Inicial_de_Jogadores; i++)
                    {
                        if (Jogadores[i].sorteio_inicial > maior_numero_saido)
                        {
                            jogador_com_maior_numero = i;
                            maior_numero_saido = Jogadores[i].sorteio_inicial;
                        }
                    }
                    //Os Jogadores irão ocupar os vários continentes
                    jogador_actual = jogador_com_maior_numero;
                    já_foi_sorteado_o_primeiro = true;
                }

                //Enquanto os territórios não estiverem ocupados e os jogadores ainda tiverem infantaria
                if(!tabuleiro.Os_Territórios_Estão_Todos_Ocupados()||!Todos_os_Jogadores_Estão_Sem_Infantaria())
                {
                    if (!o_jogador_actual_escolheu)
                    {
                        for (int t = 0; t < 42; t++)
                        {
                            tabuleiro.Territorios[t].botão.Update(mouse, gameTime);
                            if (tabuleiro.Territorios[t].botão.Foi_Clicado)
                            {
                                //Se o território estiver desocupado
                                if (tabuleiro.Territorios[t].Está_Desocupado()&&!Jogadores[jogador_actual].Ficou_Sem_Infantaria())
                                {
                                    Jogadores[jogador_actual].Tomar_Posse_de_Território(tabuleiro.Territorios[t]);
                                }
                                else
                                {//Se não estiver mas se o jogador o possuir
                                    if (Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]) && !Jogadores[jogador_actual].Ficou_Sem_Infantaria())
                                    {
                                        Jogadores[jogador_actual].Reforçar_Território(tabuleiro.Territorios[t]);
                                    }
                                }
                                o_jogador_actual_escolheu = true;
                            }
                        }
                    }
                    else
                    {
                        //Se o jogador que está a inserir já escolheu...
                        //...então se este é o "último jogador", o jogador 0 (jogador 1) é o seguinte
                        if (jogador_actual == (Número_Inicial_de_Jogadores - 1))
                        {
                            jogador_actual = 0;
                        }
                        else
                        {
                            jogador_actual++;
                        }
                        o_jogador_actual_escolheu = false;
                    }
                }
                else
                {
                    //Inseridos todas as unidades de infantaria e conquistados os continentes, começa-se o jogo com o primeiro jogador na fase de drafting
                    jogador_actual = 0;
                    o_jogador_actual_escolheu = false;
                    CurrentGameState = GameState.Drafting;
                }
                //CurrentGameState = GameState.Drafting;
            }
            if (CurrentGameState == GameState.Drafting)
            {
                //Para o caso do jogador actual já ter perdido
                while(Jogadores[jogador_actual].Perdeu)
                {
                    if (jogador_actual == Número_Inicial_de_Jogadores)
                        jogador_actual = 0;
                    else
                        jogador_actual++;
                }
                //Aqui vão-se gerar os números de infantaria de cada jogador com base no número de continentes possuídos
                if (!já_foi_dada_a_infantaria)
                {
                    Jogadores[jogador_actual].Número_de_Infantaria_Guardada += Jogadores[jogador_actual].Contar_Territórios() + r.Next(1, 10);
                    já_foi_dada_a_infantaria = true;
                }
                    for (int t = 0; t < 42; t++)
                    {
                        tabuleiro.Territorios[t].botão.Update(mouse, gameTime);
                        if (tabuleiro.Territorios[t].botão.Foi_Clicado)
                        {
                            if (Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]) && Jogadores[jogador_actual].Número_de_Infantaria_Guardada > 0)
                            {
                                tabuleiro.Territorios[t].Infantaria_Presente++;
                                Jogadores[jogador_actual].Número_de_Infantaria_Guardada--;
                            }
                        }
                    }
                    if (Jogadores[jogador_actual].Ficou_Sem_Infantaria())
                    {
                        já_foi_dada_a_infantaria = false;
                        CurrentGameState = GameState.Attacking;
                    }
            }
            if (CurrentGameState == GameState.Attacking)
            {
                //Os "dados" são "lançados"
                for (int i = 0; i < Número_Inicial_de_Jogadores; i++)
                {
                    Jogadores[i].Lançar_Dados();
                }
                if (!escolheu_atacante || !escolheu_defensor)
                {
                    //Neste "for" serve para ler os cliques do rato e saber se está a escolher o atacante e o que vai ser atacado
                    for (int t = 0; t < 42; t++)
                    {
                        tabuleiro.Territorios[t].botão.Update(mouse, gameTime);
                        if (tabuleiro.Territorios[t].botão.Foi_Clicado)
                        {
                            if (!escolheu_atacante && Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]) && tabuleiro.Territorios[t].Infantaria_Presente > 1)
                            {
                                território_atacante = tabuleiro.Territorios[t];
                                escolheu_atacante = true;
                            }
                            if (escolheu_atacante && !escolheu_defensor && !Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]))
                            {
                                território_defensor = tabuleiro.Territorios[t];
                                //Este método vai dar tempo para o jogador actual ler a informação.
                                Esperar(gameTime, 2000);
                                escolheu_defensor = true;
                            }
                        }
                    }
                }

                //Para o caso do atacante ter ganho
                if (atacante_ganhou && !escolheu_numero_de_infantaria_a_deslocar)
                {
                    add.Update(mouse, gameTime);
                    sub.Update(mouse, gameTime);
                    confirmar.Update(mouse, gameTime);
                    if (add.Foi_Clicado && infantaria_a_ser_deslocada < (território_atacante.Infantaria_Presente - 1))
                    {
                        infantaria_a_ser_deslocada++;
                    }
                    if (sub.Foi_Clicado && infantaria_a_ser_deslocada > 0)
                    {
                        infantaria_a_ser_deslocada--;
                    }
                    if (confirmar.Foi_Clicado)
                    {
                        território_atacante.Infantaria_Presente -= infantaria_a_ser_deslocada;
                        tabuleiro.Territorios[infantaria_a_ser_deslocada] = território_atacante;

                        território_defensor.Infantaria_Presente = 0;
                        território_defensor.Infantaria_Presente += infantaria_a_ser_deslocada;
                        Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Territórios_Possuídos[território_defensor.índice] = 0;

                        território_defensor.Identificação_do_Jogador_que_o_possui = jogador_actual;
                        Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Territórios_Possuídos[território_defensor.índice] = 1;
                        território_defensor.botão.Cor_Texto = Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Cor;
                        tabuleiro.Territorios[território_defensor.índice] = território_defensor;

                        escolheu_numero_de_infantaria_a_deslocar = true;
                        atacante_ganhou = false;
                    }
                }
                if (escolheu_atacante && escolheu_defensor)
                {
                    //Para o caso de todas as condições de ataque se reunirem
                    if (Pode_Atacar())
                    {
                        if (território_atacante.Infantaria_Presente > 2)
                        {
                            if (território_defensor.Infantaria_Presente >= 2)
                            {
                                //Se o primeiro dado do atacante for maior que o do defensor
                                if (Jogadores[jogador_actual].Dados[0] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[0])
                                {
                                    //O defensor perde infantaria
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                                if (Jogadores[jogador_actual].Dados[1] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[1])
                                {
                                    //O defensor perde infantaria
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                            }
                            else
                            {
                                //Se o primeiro dado do atacante for maior que o do defensor
                                if (Jogadores[jogador_actual].Dados[0] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[0])
                                {
                                    //O defensor perde infantaria(para 0)
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                            }
                        }
                        else
                        {
                            if (território_defensor.Infantaria_Presente >= 2)
                            {
                                //Se o primeiro dado do atacante for maior que o do defensor
                                if (Jogadores[jogador_actual].Dados[0] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[0])
                                {
                                    //O defensor perde infantaria
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                                if (Jogadores[jogador_actual].Dados[1] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[1])
                                {
                                    //O defensor perde infantaria
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                            }
                            else
                            {
                                //Se o primeiro dado do atacante for maior que o do defensor
                                if (Jogadores[jogador_actual].Dados[0] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[0])
                                {
                                    //O defensor perde infantaria(para 0)
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                            }
                        }
                        //Para o caso de todos os defensores terem sido destruídos aka o atacante ter ganho a batalha
                        if (território_defensor.Infantaria_Presente <= 0)
                        {
                            atacante_ganhou = true;
                            escolheu_numero_de_infantaria_a_deslocar = false;
                        }
                        escolheu_atacante = false;
                        escolheu_defensor = false;
                    }
                }
                proximo.Update(mouse,gameTime);
                if(proximo.Foi_Clicado)
                {
                    if (Há_Vencedor())
                        CurrentGameState = GameState.GameOver;
                    else
                    {
                        CurrentGameState = GameState.Reinforcing;
                        infantaria_a_ser_deslocada = 1;
                        escolheu_atacante = escolheu_defensor = escolheu_numero_de_infantaria_a_deslocar = atacante_ganhou = false;
                    }
                }
            }
            if (CurrentGameState == GameState.Reinforcing)
            {
                if(!escolheu_início || !escolheu_destino)
                {
                    for(int t=0;t<42;t++)
                    {
                        tabuleiro.Territorios[t].botão.Update(mouse,gameTime);
                        if(tabuleiro.Territorios[t].botão.Foi_Clicado)
                        {
                            if (!escolheu_início && Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]))
                            {
                                tInicial = tabuleiro.Territorios[t];
                                escolheu_início = true;
                            }
                            else
                            {
                                if (!escolheu_destino && escolheu_início && Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]))
                                {
                                    tDestino = tabuleiro.Territorios[t];
                                    escolheu_destino = true;
                                }
                            }
                        }
                    }
                }
                if(escolheu_início && escolheu_destino)
                {
                    add.Update(mouse,gameTime);
                    sub.Update(mouse,gameTime);
                    confirmar.Update(mouse,gameTime);
                    if(add.Foi_Clicado && infantaria_a_mover<=(tInicial.Infantaria_Presente-1))
                    {
                        infantaria_a_mover++;
                    }
                    if(sub.Foi_Clicado && infantaria_a_mover>0)
                    {
                        infantaria_a_mover--;
                    }
                    if(confirmar.Foi_Clicado)
                    {
                        tInicial.Infantaria_Presente -= infantaria_a_mover;
                        tabuleiro.Territorios[tInicial.índice] = tInicial;

                        tDestino.Infantaria_Presente += infantaria_a_mover;
                        tabuleiro.Territorios[tDestino.índice] = tDestino;

                        infantaria_a_mover = 0;
                        escolheu_início = false;
                        escolheu_destino = false;

                        if (jogador_actual == (Número_Inicial_de_Jogadores - 1))
                            jogador_actual = 0;
                        else
                            jogador_actual++;

                        CurrentGameState = GameState.Drafting;
                    }
                }
            }
            // Verificar a cada ciclo cada jogador para ver se algum perdeu(APENAS DEPOIS DE OS JOGADORES SEREM CRIADOS NO MAIN MENU)
            if (CurrentGameState != GameState.MainMenu)
            {
                for (int a = 0; a < Número_Inicial_de_Jogadores; a++)
                {
                   Jogadores[a].Verificar_se_Perdeu();
                    if (!Jogadores[a].Perdeu)
                        Jogadores[a].Lançar_Dados();
                }
            }
            base.Update(gameTime);
        }
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
            {
                Exit();
            }

            MouseState mouse = Mouse.GetState();

            if (CurrentGameState == GameState.MainMenu)
            {
                if (btnPlay.isClicked == true)
                {
                    CurrentGameState = GameState.Setup;
                }
                btnPlay.Update(mouse);

                add.Update(mouse, gameTime);
                sub.Update(mouse, gameTime);

                if (add.Foi_Clicado && Número_Inicial_de_Jogadores < 6)
                {
                    Número_Inicial_de_Jogadores++;
                }
                if (sub.Foi_Clicado && Número_Inicial_de_Jogadores > 3)
                {
                    Número_Inicial_de_Jogadores--;
                }
            }
            if (CurrentGameState == GameState.Setup)
            {
                if (!já_foi_sorteado_o_primeiro)
                {
                    for (int i = 0; i < 6; i++)
                    {
                        if (i <= Número_Inicial_de_Jogadores)
                        {
                            Jogadores[i] = new Jogador(i + 1, Número_Inicial_de_Jogadores);
                        }
                        else
                        {
                            Jogadores[i] = new Jogador();
                        }
                    }
                    for (int i = 0; i < Número_Inicial_de_Jogadores; i++)
                    {
                        Jogadores[i].sorteio_inicial = r.Next(1, 7);
                    }
                    Jogadores[0].Cor = Color.Red;
                    Jogadores[1].Cor = Color.Blue;
                    Jogadores[2].Cor = Color.Green;
                    Jogadores[3].Cor = Color.Orange;
                    Jogadores[4].Cor = Color.Black;
                    Jogadores[5].Cor = Color.Cyan;
                    //Vão ser rolados os dados para cada jogador para escolher o primeiro a colocar os soldados
                    int maior_numero_saido = 0, jogador_com_maior_numero = -1;
                    for (int i = 0; i < Número_Inicial_de_Jogadores; i++)
                    {
                        if (Jogadores[i].sorteio_inicial > maior_numero_saido)
                        {
                            jogador_com_maior_numero = i;
                            maior_numero_saido       = Jogadores[i].sorteio_inicial;
                        }
                    }
                    //Os Jogadores irão ocupar os vários continentes
                    jogador_actual             = jogador_com_maior_numero;
                    já_foi_sorteado_o_primeiro = true;
                }


                //Enquanto os territórios não estiverem ocupados e os jogadores ainda tiverem infantaria
                if (!tabuleiro.Os_Territórios_Estão_Todos_Ocupados() || !Todos_os_Jogadores_Estão_Sem_Infantaria())
                {
                    if (!o_jogador_actual_escolheu)
                    {
                        for (int t = 0; t < 42; t++)
                        {
                            tabuleiro.Territorios[t].botão.Update(mouse, gameTime);
                            if (tabuleiro.Territorios[t].botão.Foi_Clicado)
                            {
                                //Se o território estiver desocupado
                                if (tabuleiro.Territorios[t].Está_Desocupado() && !Jogadores[jogador_actual].Ficou_Sem_Infantaria())
                                {
                                    Jogadores[jogador_actual].Tomar_Posse_de_Território(tabuleiro.Territorios[t]);
                                }
                                else
                                {//Se não estiver mas se o jogador o possuir
                                    if (Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]) && !Jogadores[jogador_actual].Ficou_Sem_Infantaria())
                                    {
                                        Jogadores[jogador_actual].Reforçar_Território(tabuleiro.Territorios[t]);
                                    }
                                }
                                o_jogador_actual_escolheu = true;
                            }
                        }
                    }
                    else
                    {
                        //Se o jogador que está a inserir já escolheu...
                        //...então se este é o "último jogador", o jogador 0 (jogador 1) é o seguinte
                        if (jogador_actual == (Número_Inicial_de_Jogadores - 1))
                        {
                            jogador_actual = 0;
                        }
                        else
                        {
                            jogador_actual++;
                        }
                        o_jogador_actual_escolheu = false;
                    }
                }
                else
                {
                    //Inseridos todas as unidades de infantaria e conquistados os continentes, começa-se o jogo com o primeiro jogador na fase de drafting
                    jogador_actual            = 0;
                    o_jogador_actual_escolheu = false;
                    CurrentGameState          = GameState.Drafting;
                }
                //CurrentGameState = GameState.Drafting;
            }
            if (CurrentGameState == GameState.Drafting)
            {
                //Para o caso do jogador actual já ter perdido
                while (Jogadores[jogador_actual].Perdeu)
                {
                    if (jogador_actual == Número_Inicial_de_Jogadores)
                    {
                        jogador_actual = 0;
                    }
                    else
                    {
                        jogador_actual++;
                    }
                }
                //Aqui vão-se gerar os números de infantaria de cada jogador com base no número de continentes possuídos
                if (!já_foi_dada_a_infantaria)
                {
                    Jogadores[jogador_actual].Número_de_Infantaria_Guardada += Jogadores[jogador_actual].Contar_Territórios() + r.Next(1, 10);
                    já_foi_dada_a_infantaria = true;
                }
                for (int t = 0; t < 42; t++)
                {
                    tabuleiro.Territorios[t].botão.Update(mouse, gameTime);
                    if (tabuleiro.Territorios[t].botão.Foi_Clicado)
                    {
                        if (Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]) && Jogadores[jogador_actual].Número_de_Infantaria_Guardada > 0)
                        {
                            tabuleiro.Territorios[t].Infantaria_Presente++;
                            Jogadores[jogador_actual].Número_de_Infantaria_Guardada--;
                        }
                    }
                }
                if (Jogadores[jogador_actual].Ficou_Sem_Infantaria())
                {
                    já_foi_dada_a_infantaria = false;
                    CurrentGameState         = GameState.Attacking;
                }
            }
            if (CurrentGameState == GameState.Attacking)
            {
                //Os "dados" são "lançados"
                for (int i = 0; i < Número_Inicial_de_Jogadores; i++)
                {
                    Jogadores[i].Lançar_Dados();
                }
                if (!escolheu_atacante || !escolheu_defensor)
                {
                    //Neste "for" serve para ler os cliques do rato e saber se está a escolher o atacante e o que vai ser atacado
                    for (int t = 0; t < 42; t++)
                    {
                        tabuleiro.Territorios[t].botão.Update(mouse, gameTime);
                        if (tabuleiro.Territorios[t].botão.Foi_Clicado)
                        {
                            if (!escolheu_atacante && Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]) && tabuleiro.Territorios[t].Infantaria_Presente > 1)
                            {
                                território_atacante = tabuleiro.Territorios[t];
                                escolheu_atacante   = true;
                            }
                            if (escolheu_atacante && !escolheu_defensor && !Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]))
                            {
                                território_defensor = tabuleiro.Territorios[t];
                                //Este método vai dar tempo para o jogador actual ler a informação.
                                Esperar(gameTime, 2000);
                                escolheu_defensor = true;
                            }
                        }
                    }
                }

                //Para o caso do atacante ter ganho
                if (atacante_ganhou && !escolheu_numero_de_infantaria_a_deslocar)
                {
                    add.Update(mouse, gameTime);
                    sub.Update(mouse, gameTime);
                    confirmar.Update(mouse, gameTime);
                    if (add.Foi_Clicado && infantaria_a_ser_deslocada < (território_atacante.Infantaria_Presente - 1))
                    {
                        infantaria_a_ser_deslocada++;
                    }
                    if (sub.Foi_Clicado && infantaria_a_ser_deslocada > 0)
                    {
                        infantaria_a_ser_deslocada--;
                    }
                    if (confirmar.Foi_Clicado)
                    {
                        território_atacante.Infantaria_Presente          -= infantaria_a_ser_deslocada;
                        tabuleiro.Territorios[infantaria_a_ser_deslocada] = território_atacante;

                        território_defensor.Infantaria_Presente  = 0;
                        território_defensor.Infantaria_Presente += infantaria_a_ser_deslocada;
                        Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Territórios_Possuídos[território_defensor.índice] = 0;

                        território_defensor.Identificação_do_Jogador_que_o_possui = jogador_actual;
                        Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Territórios_Possuídos[território_defensor.índice] = 1;
                        território_defensor.botão.Cor_Texto = Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Cor;
                        tabuleiro.Territorios[território_defensor.índice] = território_defensor;


                        escolheu_numero_de_infantaria_a_deslocar = true;
                        atacante_ganhou = false;
                    }
                }
                if (escolheu_atacante && escolheu_defensor)
                {
                    //Para o caso de todas as condições de ataque se reunirem
                    if (Pode_Atacar())
                    {
                        if (território_atacante.Infantaria_Presente > 2)
                        {
                            if (território_defensor.Infantaria_Presente >= 2)
                            {
                                //Se o primeiro dado do atacante for maior que o do defensor
                                if (Jogadores[jogador_actual].Dados[0] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[0])
                                {
                                    //O defensor perde infantaria
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                                if (Jogadores[jogador_actual].Dados[1] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[1])
                                {
                                    //O defensor perde infantaria
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                            }
                            else
                            {
                                //Se o primeiro dado do atacante for maior que o do defensor
                                if (Jogadores[jogador_actual].Dados[0] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[0])
                                {
                                    //O defensor perde infantaria(para 0)
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                            }
                        }
                        else
                        {
                            if (território_defensor.Infantaria_Presente >= 2)
                            {
                                //Se o primeiro dado do atacante for maior que o do defensor
                                if (Jogadores[jogador_actual].Dados[0] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[0])
                                {
                                    //O defensor perde infantaria
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                                if (Jogadores[jogador_actual].Dados[1] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[1])
                                {
                                    //O defensor perde infantaria
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                            }
                            else
                            {
                                //Se o primeiro dado do atacante for maior que o do defensor
                                if (Jogadores[jogador_actual].Dados[0] > Jogadores[território_defensor.Identificação_do_Jogador_que_o_possui].Dados[0])
                                {
                                    //O defensor perde infantaria(para 0)
                                    território_defensor.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_defensor.índice] = território_defensor;
                                }
                                else
                                {
                                    //Senão
                                    //O atacante perde infantaria
                                    território_atacante.Infantaria_Presente--;
                                    //O território no array original é actualizado
                                    tabuleiro.Territorios[território_atacante.índice] = território_atacante;
                                }
                            }
                        }
                        //Para o caso de todos os defensores terem sido destruídos aka o atacante ter ganho a batalha
                        if (território_defensor.Infantaria_Presente <= 0)
                        {
                            atacante_ganhou = true;
                            escolheu_numero_de_infantaria_a_deslocar = false;
                        }
                        escolheu_atacante = false;
                        escolheu_defensor = false;
                    }
                }
                proximo.Update(mouse, gameTime);
                if (proximo.Foi_Clicado)
                {
                    if (Há_Vencedor())
                    {
                        CurrentGameState = GameState.GameOver;
                    }
                    else
                    {
                        CurrentGameState           = GameState.Reinforcing;
                        infantaria_a_ser_deslocada = 1;
                        escolheu_atacante          = escolheu_defensor = escolheu_numero_de_infantaria_a_deslocar = atacante_ganhou = false;
                    }
                }
            }
            if (CurrentGameState == GameState.Reinforcing)
            {
                if (!escolheu_início || !escolheu_destino)
                {
                    for (int t = 0; t < 42; t++)
                    {
                        tabuleiro.Territorios[t].botão.Update(mouse, gameTime);
                        if (tabuleiro.Territorios[t].botão.Foi_Clicado)
                        {
                            if (!escolheu_início && Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]))
                            {
                                tInicial        = tabuleiro.Territorios[t];
                                escolheu_início = true;
                            }
                            else
                            {
                                if (!escolheu_destino && escolheu_início && Jogadores[jogador_actual].Verificar_se_o_Estado_lhe_Pertence(tabuleiro.Territorios[t]))
                                {
                                    tDestino         = tabuleiro.Territorios[t];
                                    escolheu_destino = true;
                                }
                            }
                        }
                    }
                }
                if (escolheu_início && escolheu_destino)
                {
                    add.Update(mouse, gameTime);
                    sub.Update(mouse, gameTime);
                    confirmar.Update(mouse, gameTime);
                    if (add.Foi_Clicado && infantaria_a_mover <= (tInicial.Infantaria_Presente - 1))
                    {
                        infantaria_a_mover++;
                    }
                    if (sub.Foi_Clicado && infantaria_a_mover > 0)
                    {
                        infantaria_a_mover--;
                    }
                    if (confirmar.Foi_Clicado)
                    {
                        tInicial.Infantaria_Presente          -= infantaria_a_mover;
                        tabuleiro.Territorios[tInicial.índice] = tInicial;

                        tDestino.Infantaria_Presente          += infantaria_a_mover;
                        tabuleiro.Territorios[tDestino.índice] = tDestino;

                        infantaria_a_mover = 0;
                        escolheu_início    = false;
                        escolheu_destino   = false;

                        if (jogador_actual == (Número_Inicial_de_Jogadores - 1))
                        {
                            jogador_actual = 0;
                        }
                        else
                        {
                            jogador_actual++;
                        }

                        CurrentGameState = GameState.Drafting;
                    }
                }
            }
            // Verificar a cada ciclo cada jogador para ver se algum perdeu(APENAS DEPOIS DE OS JOGADORES SEREM CRIADOS NO MAIN MENU)
            if (CurrentGameState != GameState.MainMenu)
            {
                for (int a = 0; a < Número_Inicial_de_Jogadores; a++)
                {
                    Jogadores[a].Verificar_se_Perdeu();
                    if (!Jogadores[a].Perdeu)
                    {
                        Jogadores[a].Lançar_Dados();
                    }
                }
            }
            base.Update(gameTime);
        }