//A: gerencia variaveis relacionadas a passagem de turno
    IEnumerator passaTurno()
    {
        yield return(new WaitForSeconds(entreTurnos / 2));

        //A: gerencia criacao de argumentos de ambos (pois existem posturas com retorno de dano, etc)
        if (atributosAdversario.getArgumentos() >= atributosAdversario.atributos.barraArgumento)
        {
            atributosAdversario.setArgumentos(0);
            criaArgumento(atributosAdversario);
            //A: codigo para criar argumento para adversario vai aqui;
        }
        if (atributosPlayer.getArgumentos() >= atributosPlayer.atributos.barraArgumento)
        {
            atributosPlayer.setArgumentos(0);
            criaArgumento(atributosPlayer);
            //A: codigo para criar argumento para jogador vai aqui;
        }

        //A: ajusta indices do alinhamento
        IdxAlinhaAgressivo.SetActive(false);
        IdxAlinhaDiplomatico.SetActive(false);
        IdxAlinhaDireita.SetActive(false);
        IdxAlinhaEsquerda.SetActive(false);
        IdxAlinhaManipulador.SetActive(false);
        IdxAlinhaDirRev.SetActive(false);
        IdxAlinhaEsqRev.SetActive(false);

        //A: esconde fala e exibe resposta
        if (turnoAtual == turno.adversario)
        {
            falasAdversario.SetActive(false);
            if (resposta != "")
            {
                falasPlayer.transform.GetChild(1).GetComponent <Text>().text = resposta;
                falasPlayer.SetActive(true);
            }
        }
        else
        {
            falasPlayer.SetActive(false);

            if (resposta != "")
            {
                falasAdversario.transform.GetChild(1).GetComponent <Text>().text = resposta;
                falasAdversario.SetActive(true);
            }
        }

        yield return(new WaitForSeconds(entreTurnos / 2));

        falasAdversario.SetActive(false);
        falasPlayer.SetActive(false);

        for (int i = 0; i < argumentosPlayer.Length; i++)
        {
            if (argumentosPlayer[i] != null)
            {
                turnoArgumentosPlayer[i]++;

                if (vidaArgumentosPlayer[i] <= 0 || turnoArgumentosPlayer[i] / 2 >= argumentosPlayer[i].duracao)
                {
                    argumentosPlayer[i] = null;
                    quadroArgumentoPlayer[i].GetComponent <QuadroDeArgumento>().LimpaArgumento();
                    numArgumentosPlayer--;
                }
                else
                {
                    if (argumentosPlayer[i].habilidade == CombateArgumento.tipoArgumento.Regenerar && turnoAtual == turno.jogador)
                    {
                        atributosPlayer.curar((int)argumentosPlayer[i].valor);
                    }
                }
            }
        }
        for (int i = 0; i < argumentosAdversario.Length; i++)
        {
            if (argumentosAdversario[i] != null)
            {
                turnoArgumentosAdversario[i]++;

                if (vidaArgumentosAdversario[i] <= 0 || turnoArgumentosAdversario[i] / 2 >= argumentosAdversario[i].duracao)
                {
                    argumentosAdversario[i] = null;
                    quadroArgumentoAdversario[i].GetComponent <QuadroDeArgumento>().LimpaArgumento();
                    numArgumentosAdversario--;
                }
                else
                {
                    if (argumentosAdversario[i].habilidade == CombateArgumento.tipoArgumento.Regenerar && turnoAtual == turno.adversario)
                    {
                        atributosAdversario.curar((int)argumentosAdversario[i].valor);
                    }
                }
            }
        }

        yield return(new WaitForSeconds(entreTurnos / 7));

        resposta = "";
        //A: Verifica se combate acabou
        efetividade.text = "";

        if (atributosPlayer.getVidaAtual() == 0)
        {
            LevelManagerObject.derrota = true;
            endBattle(LevelManagerObject.derrota);
        }
        else if (atributosAdversario.getVidaAtual() == 0)
        {
            LevelManagerObject.derrota = false;
            endBattle(LevelManagerObject.derrota);
        }
        //A: Se nao acabou, passa vez
        else
        {
            if (turnoAtual == turno.adversario)
            {
                turnoAtual = turno.jogador;
                atributosPlayer.Shuffle();
                for (int i = 0; i < nomeAcoes.Length; i++)
                {
                    //escolhe nome aleatorio entre os descritos no array
                    nomeAcoes[i].text = atributosPlayer.getAcao(i).nome[0];
                    //nomeAcoes[i].GetComponent<TooltipObserver>().associaAcao(atributosPlayer.getAcao(i));
                }
                vezDoOutro.SetActive(false);
            }
            else
            {
                turnoAtual = turno.adversario;
                turnoAdversario();
            }
        }
    }
    void Start()
    {
        LevelManagerObject  = FindObjectOfType <SceneControl>();
        atributosPlayer     = Player.GetComponent <CombateAtributos>();
        atributosAdversario = Adversario.GetComponent <CombateAtributos>();
        gerenteFase         = Adversario.GetComponent <ModificadorAtributos>();

        //A: inicializa alinhamento no centro
        alinhamentoPlayer = alinhamento.diplomatico;
        efetividade.text  = "";

        //A: aloca numero maximo de argumentos igual a numero de quadros de exibicao
        argumentosPlayer          = new CombateArgumento[quadroArgumentoPlayer.Length];
        argumentosAdversario      = new CombateArgumento[quadroArgumentoAdversario.Length];
        vidaArgumentosPlayer      = new int[quadroArgumentoPlayer.Length];
        vidaArgumentosAdversario  = new int[quadroArgumentoAdversario.Length];
        turnoArgumentosPlayer     = new int[quadroArgumentoPlayer.Length];
        turnoArgumentosAdversario = new int[quadroArgumentoAdversario.Length];

        for (int i = 0; i < argumentosPlayer.Length; i++)
        {
            argumentosPlayer[i]      = null;
            vidaArgumentosPlayer[i]  = 0;
            turnoArgumentosPlayer[i] = 9999;
        }
        for (int i = 0; i < argumentosAdversario.Length; i++)
        {
            argumentosAdversario[i]      = null;
            vidaArgumentosAdversario[i]  = 0;
            turnoArgumentosAdversario[i] = 9999;
        }

        atributosPlayer.Shuffle();
        //A: Cada ação do jogador substitui o nome escrito em um dos botoes.
        for (int i = 0; i < nomeAcoes.Length; i++)
        {
            //escolhe nome aleatorio entre os descritos no array
            nomeAcoes[i].text = atributosPlayer.getAcao(i).nome[0];
            //nomeAcoes[i].GetComponent<TooltipObserver>().associaAcao(atributosPlayer.getAcao(i));

            //A: Antigo
            //nomeAcoes[i].text = atributosPlayer.getAcao(i).nome[Random.Range(0,atributosPlayer.getAcao(i).nome.Length)];
            //nomeAcoes[i].GetComponent<TooltipObserver>().associaAcao(atributosPlayer.getAcao(i));
        }
        VidaPlayer.maxValue      = atributosPlayer.atributos.vida;
        VidaAdversario.maxValue  = atributosAdversario.atributos.vida;
        vidaPlayerTexto.text     = "" + VidaPlayer;
        vidaAdversarioTexto.text = "" + VidaAdversario;
        //A: Decide de quem sera o primeiro turno
        if (atributosAdversario.getAtributos().iniciativa > atributosPlayer.getAtributos().iniciativa)
        {
            turnoAtual = turno.adversario;
            vezDoOutro.SetActive(true);
            turnoAdversario();
        }
        else
        {
            turnoAtual = turno.jogador;
            vezDoOutro.SetActive(false);
        }
        //A: garante que nenhuma seta aparece inicialmente no alinhamento
        IdxAlinhaAgressivo.SetActive(false);
        IdxAlinhaDiplomatico.SetActive(false);
        IdxAlinhaDireita.SetActive(false);
        IdxAlinhaEsquerda.SetActive(false);
        IdxAlinhaManipulador.SetActive(false);
        IdxAlinhaDirRev.SetActive(false);
        IdxAlinhaEsqRev.SetActive(false);
    }