//A: calcula qual dos tipos foi o maior contador para escolher argumento a ser criado: 0 se agressivo, 1 se manipulador e 2 se diplomatico
private int tipoMaisUsado(CombateAtributos atributosAtacante)
{
//A: se jogador for o atacante
if (atributosAtacante.atributos.nome == atributosPlayer.atributos.nome)
{
if (contaAgressivosPlayer > contaManipuladorPlayer && contaAgressivosPlayer > contaDiplomaticoPlayer)
{
return(0);
}
else if (contaManipuladorPlayer > contaAgressivosPlayer && contaManipuladorPlayer > contaDiplomaticoPlayer)
{
return(1);
}
else
{
return(2);
}
}
else
{
if (contaAgressivosAdversario > contaManipuladorAdversario && contaAgressivosAdversario > contaDiplomaticoAdversario)
{
return(0);
}
else if (contaManipuladorAdversario > contaAgressivosAdversario && contaManipuladorAdversario > contaDiplomaticoAdversario)
{
return(1);
}
else
{
return(2);
}
}
}
private int defesaBonusArgumento(CombateAtributos atributosAtacante)
{
int bonusTotal = 0;
if (atributosAtacante == atributosPlayer)
{
for (int i = 0; i < argumentosPlayer.Length; i++)
{
if (argumentosPlayer[i] != null && argumentosPlayer[i].habilidade == CombateArgumento.tipoArgumento.Defesa)
{
bonusTotal += (int)argumentosPlayer[i].valor;
}
}
}
else
{
for (int i = 0; i < argumentosPlayer.Length; i++)
{
if (argumentosAdversario[i] != null && argumentosAdversario[i].habilidade == CombateArgumento.tipoArgumento.Defesa)
{
bonusTotal += (int)argumentosAdversario[i].valor;
}
}
}
return(bonusTotal);
}
private void criaArgumento(CombateAtributos donoDoArg)
{
CombateArgumento argCriado;
//A: Escolhe argumento a ser criado
switch (tipoMaisUsado(donoDoArg))
{
case 0:
//Agressivo
argCriado = donoDoArg.getArgAgre();
break;
case 1:
//Defensivo
argCriado = donoDoArg.getArgDef();
break;
default:
//Diplomatico
argCriado = donoDoArg.getArgDipl();
break;
}
//A: Adiciona argumento criado a primeiro espaço vazio da lista de argumentos
if (donoDoArg == atributosPlayer)
{
for (int i = 0; i < argumentosPlayer.Length; i++)
{
if (argumentosPlayer[i] == null)
{
argumentosPlayer[i] = argCriado;
vidaArgumentosPlayer[i] = argCriado.vida;
turnoArgumentosPlayer[i] = 0;
quadroArgumentoPlayer[i].GetComponent <QuadroDeArgumento>().CarregaArgumento(argCriado);
numArgumentosPlayer++;
break;
}
}
}
else
{
for (int i = 0; i < argumentosAdversario.Length; i++)
{
if (argumentosAdversario[i] == null)
{
argumentosAdversario[i] = argCriado;
vidaArgumentosAdversario[i] = argCriado.vida;
turnoArgumentosAdversario[i] = 0;
quadroArgumentoAdversario[i].GetComponent <QuadroDeArgumento>().CarregaArgumento(argCriado);
numArgumentosAdversario++;
break;
}
}
}
resetaContadores(donoDoArg);
}
//A: decide a qual contador somar +1
private void somaTipo(CombateAtributos atributosAtacante, CombateAcao golpe)
{
//A: se jogador foi o atacante
if (atributosAtacante.atributos.nome == atributosPlayer.atributos.nome)
{
switch (golpe.tipo)
{
case CombateAcao.tipoDano.Agressivo:
contaAgressivosPlayer++;
break;
case CombateAcao.tipoDano.Manipulador:
contaManipuladorPlayer++;
break;
case CombateAcao.tipoDano.Diplomatico:
contaDiplomaticoPlayer++;
break;
default:
return;
}
}
else
{
switch (golpe.tipo)
{
case CombateAcao.tipoDano.Agressivo:
contaAgressivosAdversario++;
break;
case CombateAcao.tipoDano.Manipulador:
contaManipuladorAdversario++;
break;
case CombateAcao.tipoDano.Diplomatico:
contaDiplomaticoAdversario++;
break;
default:
return;
}
}
}
private void resetaContadores(CombateAtributos atributosAtacante)
{
if (atributosAtacante.atributos.nome == atributosPlayer.atributos.nome)
{
contaAgressivosPlayer = 0;
contaManipuladorPlayer = 0;
contaDiplomaticoPlayer = 0;
}
else
{
contaAgressivosAdversario = 0;
contaManipuladorAdversario = 0;
contaDiplomaticoAdversario = 0;
}
}
// Start is called before the first frame update
void Awake()
{
AtributoAtual = gameObject.GetComponent <CombateAtributos>();
i = 0;
}
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);
}
