public static bool CanStartAttack(PetBase meuCriatureBase)
{
PetAtributes A = meuCriatureBase.PetFeat.meusAtributos;
PetAttackManager ggg = meuCriatureBase.GerenteDeGolpes;
PetAttackBase gg = ggg.meusGolpes[ggg.golpeEscolhido];
if (
//gg.UltimoUso + gg.TempoDeReuso < Time.time
meuCriatureBase.StManager.VerifyStaminaAction() &&
A.PE.Corrente >= gg.CustoPE)
{
A.PE.Corrente -= gg.CustoPE;
//gg.UltimoUso = Time.time;
meuCriatureBase.StManager.ConsumeStamina((uint)gg.CustoDeStamina);
//AplicadorDeGolpe aplG = gameObject.AddComponent<AplicadorDeGolpe>();
//aplG.esseGolpe = gg;
//GameController.g.HudM.AtualizaDadosDaHudVida(false);
//if (GameController.g.estaEmLuta)
// GameController.g.HudM.AtualizaDadosDaHudVida(true);
// if(!GameController.g.estaEmLuta)
// //GameController.g.HudM.AtualizaHudHeroi(meuCriatureBase);
return(true);
}
else
{
return(false);
}
}
static void CalculoA(float multiplicador, PetAttackBase golpe, PetAttackDb golpePersonagem, int potenciaDoAtacante, PetManager doAtacado)
{
int dano = Mathf.Abs(
Mathf.RoundToInt(
multiplicador * (golpe.PotenciaCorrente
+ golpePersonagem.ModPersonagem
+ potenciaDoAtacante)
));
potenciaDoAtacante = dano;
PetAtributes aDoAtacado = doAtacado.MeuCriatureBase.PetFeat.meusAtributos;
int defesa = Mathf.RoundToInt(aDoAtacado.Defesa.Corrente * Random.Range(0.85f, 1));
if (defesa < 0.75f * dano)
{
dano = (dano - defesa >= 1) ? dano - defesa : 1;
}
else
{
dano = (int)(0.25f * dano) >= 1 ? Mathf.Max((int)(0.25f * dano * Random.Range(0.9f, 1.15f)), 1) : 1;
}
AplicaCalculoComVIsaoDeDano(doAtacado, golpe, aDoAtacado, multiplicador, dano, defesa, potenciaDoAtacante);
}
public static void EnergiaEVidaCheia(PetBase C)
{
PetAtributes A = C.petFeat.meusAtributos;
A.PV.Corrente = A.PV.Maximo;
A.PE.Corrente = A.PE.Maximo;
}
public override void IniciaUsoDeHeroi(GameObject dono, List <ItemBase> lista)
{
Dono = dono;
Lista = lista;
PetAtributes P = dono.GetComponent <CharacterManager>().ActivePet.MeuCriatureBase.PetFeat.meusAtributos;
IniciaUsoDesseItem(dono, QuantitativeItem.CanUseRecoveryItem(P));
}
static void CalculoB(float multiplicador, PetAttackBase golpe, PetAttackDb golpePersonagem, int potenciaDoAtacante, PetManager doAtacado)
{
PetAtributes aDoAtacado = doAtacado.MeuCriatureBase.PetFeat.meusAtributos;
int defesa = Mathf.RoundToInt(aDoAtacado.Defesa.Corrente * Random.Range(0.85f, 1));
int dano = (int)(multiplicador * (golpe.PotenciaCorrente + golpePersonagem.ModPersonagem + potenciaDoAtacante / defesa));
AplicaCalculoComVIsaoDeDano(doAtacado, golpe, aDoAtacado, multiplicador, dano, defesa, potenciaDoAtacante);
}
public override void AcaoDoItemConsumivel(int indice)
{
PetAtributes P = Dono.GetComponent <CharacterManager>().Dados.CriaturesAtivos[indice].PetFeat.meusAtributos;
QuantitativeItem.RecuperaPV(P, valorDeRecuperacao);
//ItemQuantitativo.RecuperaPV(C.CaracCriature.meusAtributos, valorDeRecuperacao);
//if (!GameController.g.estaEmLuta)
// GameController.g.Salvador.SalvarAgora();
}
protected override void EscolhiEmQuemUsar(int indice)
{
PetAtributes A = Dono.GetComponent <CharacterManager>().Dados.CriaturesAtivos[indice].PetFeat.meusAtributos;
EscolhiEmQuemUsar(indice,
QuantitativeItem.CanUseRecoveryItem(A), true,
valorDeRecuperacao, A.PV.Corrente,
A.PV.Maximo,
PetTypeName.nulo);
}
void VerificaSomaDeTaxas()
{
PetAtributes a = petFeat.meusAtributos;
float comoAssim = a.PV.Taxa + a.PE.Taxa + a.Ataque.Taxa + a.Defesa.Taxa + a.Poder.Taxa;
if (comoAssim != 1)
{
Debug.Log("O criature " + petId.ToString() + " não tem a soma das taxas igual a 1: " + comoAssim);
}
}
public static void AplicaCalculoDoDano(PetAtributes A, int dano)
{
if (A.PV.Corrente - dano > 0)
{
A.PV.Corrente -= dano;
}
else
{
A.PV.Corrente = 0;
}
}
public static bool CanUseRecoveryItem(PetAtributes A)
{
if (A.PV.Corrente < A.PV.Maximo && A.PV.Corrente > 0)
{
return(true);
}
else
{
return(false);
}
}
static void AtualizaAtributos(float[] pontinhos, PetAtributes A, bool total = false)
{
//UnityEngine.Debug.Log(pontinhos[0]+": "+pontinhos[1]);
if (total)
{
A.PV = new ConsumableAttribute(
(int)pontinhos[0] * 4 + 10,
A.PV.Taxa,
4 * (int)pontinhos[0] + 10,
A.PV.ModMaximo
);
A.PE = new ConsumableAttribute(
(int)pontinhos[1] * 4 + 26,
A.PE.Taxa,
4 * (int)pontinhos[1] + 26,
A.PE.ModMaximo
);
A.Ataque = AtualizaAtributoIntrinseco(pontinhos[2], A.Ataque);
A.Defesa = AtualizaAtributoIntrinseco(pontinhos[3], A.Defesa);
A.Poder = AtualizaAtributoIntrinseco(pontinhos[4], A.Poder);
}
else
{
A.PV = new ConsumableAttribute(
A.PV.Corrente + 4 * (int)pontinhos[0],
A.PV.Taxa,
A.PV.Maximo + 4 * (int)pontinhos[0],
A.PV.ModMaximo
);
A.PE = new ConsumableAttribute(
A.PE.Corrente + 4 * (int)pontinhos[1],
A.PE.Taxa,
A.PE.Maximo + 4 * (int)pontinhos[1],
A.PE.ModMaximo
);
A.Ataque = AtualizaAtributoIntrinsecoBeta(pontinhos[2], A.Ataque);
A.Defesa = AtualizaAtributoIntrinsecoBeta(pontinhos[3], A.Defesa);
A.Poder = AtualizaAtributoIntrinsecoBeta(pontinhos[4], A.Poder);
}
/*
* for(int i=0;i<5;i++)
* Debug.Log(A[i].Basico+" : "+pontinhos[i]+" :"+A[i].Corrente+" : "+A[i].Maximo);
*/
}
public static void RecuperaPV(PetAtributes meusAtributos, int tanto)
{
int contador = meusAtributos.PV.Corrente;
int maximo = meusAtributos.PV.Maximo;
if (contador + tanto < maximo)
{
meusAtributos.PV.Corrente += tanto;
}
else
{
meusAtributos.PV.Corrente = meusAtributos.PV.Maximo;
}
}
static void AplicaCalculoComVIsaoDeDano(PetManager doAtacado,
PetAttackBase golpe,
PetAtributes aDoAtacado,
float multiplicador,
int dano,
int defesa,
int potenciaDoAtacante)
{
AplicaCalculoDoDano(aDoAtacado, dano);
Debug.Log("O dano do Golpe e " + dano + " O nome do golpe e " + golpe.Nome + " o multiplicador e" + multiplicador
+ " A defesa do inimigo é " + defesa
+ " A potencia original é " + potenciaDoAtacante
+ " A potencia do Golpe é " + golpe.PotenciaCorrente);
AplicaVisaoDeDano(doAtacado, dano, multiplicador);
}
static void CalculaDano(PetManager doAtacado, GameObject atacante, PetAttackBase golpe)
{
float multiplicador = 1;
for (int i = 0; i < doAtacado.MeuCriatureBase.PetFeat.contraTipos.Length; i++)
{
if (golpe.Tipo.ToString() == doAtacado.MeuCriatureBase.PetFeat.contraTipos[i].Nome)
{
multiplicador *= doAtacado.MeuCriatureBase.PetFeat.contraTipos[i].Mod;
}
}
PetBase cDoAtacante = atacante.GetComponent <PetManager>().MeuCriatureBase;
PetAtributes A = cDoAtacante.PetFeat.meusAtributos;
int potenciaDoAtacante = (golpe.Caracteristica == AttackDiferentialId.colisao)
?
Mathf.RoundToInt(A.Ataque.Minimo + (A.Ataque.Corrente - A.Ataque.Minimo) * Random.Range(0.85f, 1))
:
Mathf.RoundToInt(A.Poder.Minimo + (A.Poder.Corrente - A.Poder.Minimo) * Random.Range(0.85f, 1));
int numStatus = StatusTemporarioBase.ContemStatus(StatusType.fraco, cDoAtacante);
if (numStatus > -1)
{
potenciaDoAtacante = (int)Mathf.Max(1 / cDoAtacante.StatusTemporarios[numStatus].Quantificador * potenciaDoAtacante, (A.Ataque.Minimo + A.Poder.Minimo) / 2);
golpe.ModCorrente = -(int)cDoAtacante.StatusTemporarios[numStatus].Quantificador;
}
else
{
golpe.ModCorrente = 0;
}
PetAttackDb golpePersonagem = cDoAtacante.GerenteDeGolpes.ProcuraGolpeNaLista(cDoAtacante.NomeID, golpe.Nome);
CalculoC(multiplicador, golpe, golpePersonagem, potenciaDoAtacante, doAtacado, cDoAtacante);
golpe.VerificaAplicaStatus(cDoAtacante, doAtacado);
}
static void CalculoC(
float multiplicador,
PetAttackBase golpe,
PetAttackDb golpePersonagem,
int potenciaDoAtacante,
PetManager doAtacado,
PetBase cDoAtacado)
{
PetAtributes aDoAtacado = doAtacado.MeuCriatureBase.PetFeat.meusAtributos;
float rd = Random.Range(0.85f, 1);
int level = cDoAtacado.PetFeat.mNivel.Nivel;
float STAB = 1;
if (cDoAtacado.PetFeat.TemOTipo(golpe.Tipo))
{
STAB = 1.5f;
}
Debug.Log("modificador de potencia para esse golpe é " + golpePersonagem.ModPersonagem);
//int dano = (int)((((((((2 * level / 5) + 2) * potenciaDoAtacante* 20*(golpe.PotenciaCorrente+golpePersonagem.ModPersonagem) )/ aDoAtacado.Defesa.Corrente)/ 50) +2) *STAB * multiplicador) *rd / 100);
int dano = (int)(((2 * level) * potenciaDoAtacante * (golpe.PotenciaCorrente + golpePersonagem.ModPersonagem) / (45f * aDoAtacado.Defesa.Corrente + 250) + 2) * STAB * multiplicador * rd);
AplicaCalculoComVIsaoDeDano(doAtacado, golpe, aDoAtacado, multiplicador, dano, aDoAtacado.Defesa.Corrente, potenciaDoAtacante);
}
public static void CalculeUpLevel(int esseNivel, PetAtributes A, bool total = false)
{
//float[] taxas = new float[5]{0.15f,0.25f,0.25f,0.15f,0.2f};//taxas fantasia para testes;
float[] taxas = new float[5] {
A.PV.Taxa,
A.PE.Taxa,
A.Ataque.Taxa,
A.Defesa.Taxa,
A.Poder.Taxa
};
float[] pontosAcumulados = new float[5] {
1, 1, 1, 1, 1
};
float[] antigoAcumulado = new float[5] {
0, 0, 0, 0, 0
};
//antigoAcumulado = (float[])pontosAcumulados.Clone();
// int somaDosInteiros;
for (int i = 1; i < esseNivel; i++)
{
antigoAcumulado = (float[])pontosAcumulados.Clone();
//for(int k=0;k<pontosAcumulados.Length;k++)
// antigoAcumulado[k] = pontosAcumulados[k];
// Debug.Log(antigoAcumulado);
for (int j = 0; j < taxas.Length; j++)
{
pontosAcumulados[j] = (i + 1) * 5 * taxas[j];
}
// Debug.Log(SomaDosInteiros(pontosAcumulados)%5);
float[] queRolo = SobraAosEleitos(SomaDosInteiros((float[])pontosAcumulados.Clone()) % 5,
(float[])pontosAcumulados.Clone());
for (int j = 0; j < taxas.Length; j++)
{
//Debug.Log(pontosAcumulados[j]+" : "+(int)pontosAcumulados[j]+" : "+queRolo[j] );
pontosAcumulados[j] = (int)pontosAcumulados[j] + queRolo[j];
}
/*
* for(int j=0; j<pontosAcumulados.Length;j++)
* Debug.Log("Nivel: "+i+
* " pontosAcumulados: "+pontosAcumulados[j]+
* " diferança de Nivel: "+(pontosAcumulados[j]-antigoAcumulado[j]));
*
*/
}
if (total)
{
AtualizaAtributos(pontosAcumulados, A, total);
}
else
{
for (int j = 0; j < pontosAcumulados.Length; j++)
{
pontosAcumulados[j] -= antigoAcumulado[j];
}
// Debug.Log(pontosAcumulados[0]+" : cade eu");
AtualizaAtributos(pontosAcumulados, A, total);
}
// Debug.Log(somaDosInteiros);
}
