public void Acao1()
 {
     resposta = atributosPlayer.getAcao(0).respostas[0];
     aplicaDano(atributosPlayer, atributosPlayer.getAcao(0), atributosAdversario);
     vezDoOutro.SetActive(true);
     StartCoroutine(passaTurno());
 }
    private void aplicaDano(CombateAtributos atributosAtacante, CombateAcao golpe, CombateAtributos atributosAlvo)
    {
        int   ataque             = atributosAtacante.atributos.dano;
        float multiplicadorGolpe = golpe.dano / 100;
        int   danoResultante;

        if (golpe.tipo != CombateAcao.tipoDano.Neutro)
        {
            //A: ajusta multiplicador conforme tipo
            if (atributosAlvo.isVulneravel((int)golpe.tipo))
            {
                multiplicadorGolpe *= multiplicadorEfetivo + (float)bonusAlinhamento(golpe);

                //A: texto de feedback
                efetividade.color = Color.green;
                efetividade.text  = "super efetivo!";
            }
            else if (atributosAlvo.isResistente((int)golpe.tipo))
            {
                multiplicadorGolpe = multiplicadorGolpe * multiplicadorResistente;

                //A: texto de feedback
                efetividade.color = Color.red;
                efetividade.text  = "pouco efetivo...";
            }
        }
        //A: implementacao da postura Defensivo Fortifica, aumentando o dano
        if (atributosAlvo.atributos.postura == CombateUnidade.posturaUnidade.defensivoFortalece)
        {
            multiplicadorGolpe *= multiplicadorFortalecimento;
            atributosAdversario.setAuxiliar(0);
        }
        danoResultante = (int)((ataque + danoBonusArgumento(atributosAtacante)) * multiplicadorGolpe - (atributosAlvo.atributos.defesa + defesaBonusArgumento(atributosAlvo)));

        //EnemyBattle.SetTrigger("GetHit");
        atacAudio.Play();

        if (atributosAtacante == atributosPlayer)
        {
            EnemyBattle.SetTrigger("GetHit");
            BrunoBattle.SetTrigger("Porrada");
        }
        else
        {
            PlayerBattle.SetTrigger("Dano");
        }

        //A: implementação da postura Reage a Agressivo
        if (atributosAlvo.atributos.postura == CombateUnidade.posturaUnidade.reageAgressivo && golpe.tipo == CombateAcao.tipoDano.Agressivo)
        {
            aplicaDano(atributosAlvo, atributosAlvo.getAcao(0), atributosAtacante);
        }

        //A: implementação da postura Defensivo Fortalece, salva dano levado
        if (atributosAlvo.atributos.postura == CombateUnidade.posturaUnidade.defensivoFortalece && golpe.tipo == CombateAcao.tipoDano.Manipulador)
        {
            atributosAdversario.setAuxiliar(atributosAdversario.getAuxiliar() + 1);
        }

        //A: Garante dano minimo = 1
        if (danoResultante < 1)
        {
            danoResultante = 1;
        }

        //A: implementação da postura ignoraManipulador
        if (atributosAlvo.atributos.postura == CombateUnidade.posturaUnidade.ignoraManipulador && golpe.tipo == CombateAcao.tipoDano.Manipulador)
        {
            danoResultante = 0;

            efetividade.color = Color.blue;
            efetividade.text  = "imune";
        }

        //A: implementação de argumentos de roubo de vida e evasão
        for (int i = 0; i < argumentosPlayer.Length; i++)
        {
            if (argumentosPlayer[i] != null)
            {
                if (argumentosPlayer[i].habilidade == CombateArgumento.tipoArgumento.RoubaVida && atributosAtacante == atributosPlayer)
                {
                    atributosPlayer.curar((int)argumentosPlayer[i].valor * danoResultante);
                }
                else if (argumentosPlayer[i].habilidade == CombateArgumento.tipoArgumento.Evasao && atributosAlvo == atributosPlayer)
                {
                    danoResultante = 0;
                    argumentosPlayer[i].valor--;
                    if (argumentosPlayer[i].valor < 1)
                    {
                        quadroArgumentoAdversario[i].GetComponent <QuadroDeArgumento>().LimpaArgumento();
                    }
                }
            }
        }
        for (int i = 0; i < argumentosAdversario.Length; i++)
        {
            if (argumentosAdversario[i] != null)
            {
                if (argumentosAdversario[i].habilidade == CombateArgumento.tipoArgumento.RoubaVida && atributosAtacante == atributosAdversario)
                {
                    atributosAdversario.curar((int)argumentosAdversario[i].valor * danoResultante);
                }
                else if (argumentosAdversario[i].habilidade == CombateArgumento.tipoArgumento.Evasao && atributosAlvo == atributosAdversario)
                {
                    danoResultante    = 0;
                    efetividade.color = Color.blue;
                    efetividade.text  = "imune";
                    argumentosAdversario[i].valor--;
                    if (argumentosAdversario[i].valor < 1)
                    {
                        quadroArgumentoAdversario[i].GetComponent <QuadroDeArgumento>().LimpaArgumento();
                    }
                }
            }
        }
        atributosAlvo.danifica(danoResultante);



        //A: ajusta multiplicador do alinhamento baseado em ataque escolhido, caso seja vez do player
        if (atributosAtacante.atributos.nome == atributosPlayer.atributos.nome)
        {
            ajustaAlinhamento(golpe);
        }

        //A: incrementa contador de vezes que o tipo de ataque foi usado
        somaTipo(atributosAtacante, golpe);

        //A: ajusta barra de argumentos de acordo caso nao tiver maximo de argumentos
        if ((atributosAtacante.atributos.nome == atributosPlayer.atributos.nome && numArgumentosPlayer < argumentosPlayer.Length && turnoAtual == turno.jogador) || (atributosAtacante.atributos.nome == atributosAdversario.atributos.nome && numArgumentosAdversario < argumentosAdversario.Length && turnoAtual == turno.adversario))
        {
            atributosAtacante.setArgumentos(atributosAtacante.getArgumentos() + golpe.barraArgumento);
        }

        if (turnoAtual == turno.adversario)
        {
            falasAdversario.transform.GetChild(1).GetComponent <Text>().text = golpe.nome[0];
            falasAdversario.SetActive(true);
        }
        else if (turnoAtual == turno.jogador && atributosAtacante == atributosPlayer)
        {
            falasPlayer.transform.GetChild(1).GetComponent <Text>().text = golpe.nome[0];
            falasPlayer.SetActive(true);
        }
    }
    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);
    }