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);
}
}
public PetAttackBase[] GolpesAtivos(int nivel, PetAttackDb[] listaGolpes)
{
List <PetAttackDb> L = new List <PetAttackDb>();
int i = 0;
//int N = -1;
while (i < listaGolpes.Length)
{
if (listaGolpes[i].NivelDoGolpe <= nivel && listaGolpes[i].NivelDoGolpe > -1)
{
if (L.Count < 4)
{
L.Add(listaGolpes[i]);
}
else
{
L[0] = L[1];
L[1] = L[2];
L[2] = L[3];
L[3] = listaGolpes[i];
}
}
i++;
}
PetAttackBase[] Y = new PetAttackBase[L.Count];
for (i = 0; i < L.Count; i++)
{
Y[i] = AttackFactory.GetAttack(L[i].Nome);
}
return(Y);
}
public void StartDamageState(PetAttackBase golpe)
{
esseGolpe = golpe;
posInicial = controle.transform.position;
alturaDoDano = controle.transform.position.y;
tempoDeDano = 0;
}
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);
}
void AvanceEPareAbaixo(GameObject G, PetAttackBase ativa)
{
float distanciaDeParada = 5.75f;
float velocidadeAvante = ativa.VelocidadeDeGolpe;
Vector3 V = posInicial + 10 * ativa.DirDeREpulsao;
Vector3 project;
if (alvoProcurado)
{
V = alvoProcurado.position;
// project = (Vector3.ProjectOnPlane(G.transform.position - V, Vector3.up));
// if (Vector3.Dot(project,G.transform.forward)>0)
// AtualizadorDeImpactos.ajudaAtaque(alvo, G.transform);
}
project = (Vector3.ProjectOnPlane(G.transform.position - V, Vector3.up));
if (Vector3.Dot(project, G.transform.forward) > 0)
{
G.transform.rotation = Quaternion.LookRotation(-project);
}
else
{
G.transform.rotation = Quaternion.LookRotation(ativa.DirDeREpulsao);
}
if ((project.magnitude > distanciaDeParada
&&
G.transform.position.y - posInicial.y < 4
&&
!alcancouOApceDaAltura)
&&
tempoDecorrido < ativa.TempoDeMoveMax / 2)
{
dirDeslocamento = (velocidadeAvante * G.transform.forward + Vector3.up * 15);
}
else if (project.magnitude <= distanciaDeParada)
{
Vector3 foco = velocidadeAvante * G.transform.forward + Vector3.down * 9.8f;
if (alvoProcurado && Vector3.Dot(-project, G.transform.forward) > 0)
{
foco = velocidadeAvante * (alvoProcurado.position - G.transform.position).normalized + 18.8f * Vector3.down;
}
dirDeslocamento = Vector3.Lerp(dirDeslocamento, foco, 20 * Time.deltaTime);
alcancouOApceDaAltura = true;
}
else if (G.transform.position.y - posInicial.y > 4)
{
alcancouOApceDaAltura = true;
}
else
{
dirDeslocamento = Vector3.Lerp(dirDeslocamento, velocidadeAvante * G.transform.forward + Vector3.down * 18.8f, 20 * Time.deltaTime);
}
controle.Move(dirDeslocamento * Time.deltaTime);
}
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 static void AplicaDano(PetManager doAtacado, GameObject atacante, PetAttackBase golpe)
{
//Animator animatorDoAtacado = doAtacado.GetComponent<Animator>();
//EmEstadoDeDano(animatorDoAtacado, doAtacado);
CalculaDano(doAtacado, atacante, golpe);
InsereEstouEmDano(doAtacado.gameObject, golpe, atacante);
VerificaVida(atacante, doAtacado);
}
public void ImpatoAtivo(GameObject G, PetAttackBase ativa, ImpactFeatures caracteristica, GameObject focado = null)
{
if (focado)
{
alvoProcurado = focado.transform;
}
else
{
alvoProcurado = FindBestTarget.Procure(G, new string[1] {
"Criature"
});
}
tempoDecorrido += Time.deltaTime;
if (!procurouAlvo)
{
alvoProcurado = CriaturesPerto.procureUmBomAlvo(G);
procurouAlvo = true;
Debug.Log(alvoProcurado + " esse é o alvo");
AttackHelper(alvoProcurado, G.transform);
}
if (!addView)
{
tempoDecorrido += ativa.TempoDeMoveMin;
AttackColliders.AdicionaOColisor(G, ativa, caracteristica, tempoDecorrido);
MessageAgregator <MsgRequest3dSound> .Publish(new MsgRequest3dSound()
{
sfxId = ativa.SomDoGolpe,
sender = G.transform
});
addView = true;
}
if (tempoDecorrido < ativa.TempoDeMoveMax)
{
if (((int)(tempoDecorrido * 10)) % 2 == 0 && alvoProcurado)
{
AttackHelper(alvoProcurado, G.transform);
}
ativa.DirDeREpulsao = G.transform.forward;
if (!controle)
{
controle = G.GetComponent <CharacterController>();
}
controle.Move(ativa.VelocidadeDeGolpe * G.transform.forward * Time.deltaTime + Vector3.down * 9.8f);
}
}
public void StartAttack(PetAttackBase esseGolpe, float tempoDeInstancia, GameObject focado)
{
this.focado = focado;
this.esseGolpe = esseGolpe;
tempoDecorrido = 0.0f;
esseGolpe.IniciaGolpe(gameObject);
tempoDecorrido -= tempoDeInstancia;
//GolpePersonagem.RetornaGolpePersonagem(gameObject, esseGolpe.Nome).TempoDeInstancia;
//gerente = GetComponent<CreatureManager>();
//ParaliseNoTempo();
}
public static void AdicionaOColisor(GameObject G,
PetAttackBase golpeAtivo,
ImpactFeatures caracteristica,
float tempoDecorrido)
{
GameObject view = Resources.Load <GameObject>("DamageColliders/" + caracteristica.nomeTrail.ToString());
//GameObject view = GameController.g.El.retornaColisor(caracteristica.nomeTrail);
// print(nomeColisor);
colisor C = GetCollider(G, golpeAtivo.Nome);// = new colisor();
GameObject view2 = (GameObject)MonoBehaviour.Instantiate(view, C.deslColisor, Quaternion.identity);
view2.transform.localRotation = view.transform.rotation;
if (caracteristica.parentearNoOsso)
{
view2.transform.parent = G.transform.Find(C.osso).transform;
}
else
{
view2.transform.parent = G.transform;
}
view2.transform.localPosition = C.deslTrail;
view2.transform.localRotation = view.transform.rotation;
view2.GetComponent <BoxCollider>().center = C.deslColisor;
view2.name = "colisor" + golpeAtivo.Nome.ToString();
view2.transform.localScale *= (golpeAtivo.ColisorScale * C.ColisorScale);
/*
* PARA DESTUIR O COLISOR .
* QUANDO O GOLPE ERA INTERROMPIDO
* O COLISOR PERMANECIA NO PERSONAGEM
*/
MonoBehaviour.Destroy(view2, golpeAtivo.TempoDeDestroy - tempoDecorrido);
/*************************************************************/
DamageCollider proj = view2.AddComponent <DamageCollider>();
proj.velocidadeProjetil = 0f;
proj.noImpacto = caracteristica.noImpacto;
proj.dono = G;
proj.esseGolpe = golpeAtivo;
// proj.forcaDoDano = 25f;
//addView = true;
}
//public static void EmEstadoDeDano(Animator animatorDoAtacado, PetManager doAtacado)
//{
// Debug.LogError("não sei o que fazer com isso");
// //doAtacado.MudaParaEstouEmDano();
// //Transform T = doAtacado.transform;
// // doAtacado.MudaEmDano();
// animatorDoAtacado.Play("dano2");
// animatorDoAtacado.SetBool("dano1", true);
// animatorDoAtacado.Play("dano1");
//}
public static void InsereEstouEmDano(GameObject doAtacado, PetAttackBase golpe, GameObject atacante)
{
MessageAgregator <MsgEnterInDamageState> .Publish(new MsgEnterInDamageState()
{
oAtacado = doAtacado.gameObject,
golpe = golpe,
atacante = atacante
});
//EstouEmDano eED = doAtacado.gameObject.AddComponent<EstouEmDano>();
//eED.esseGolpe = golpe;
//eED.animator = animatorDoAtacado;
//eED.gerente = doAtacado;
}
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);
}
public static void VerificaDano(GameObject atacado, GameObject atacante, PetAttackBase golpe)
{
if (atacado.tag == "eventoComGolpe" /*&& !GameController.g.estaEmLuta*/)
{
Debug.LogWarning("Evento com golpe removido, necessário refazer, condicional de esta em luta removido");
//atacado.GetComponent<EventoComGolpe>().DisparaEvento(golpe.Nome);
}
PetManager GdC = atacado.GetComponent <PetManager>();
if (GdC /*&& !GameController.g.UsandoItemOuTrocandoCriature*/)
{
Debug.Log("Um condicional para impedir dano em uso de item foi retirado");
if (GdC.MeuCriatureBase.PetFeat.meusAtributos.PV.Corrente > 0)
{
AplicaDano(GdC, atacante, golpe);
}
}
}
public static void AplicaProjetil(GameObject G, PetAttackBase ativa, ProjetilFeatures carac)
{
PetAttackDb golpeP = PetAttackDb.RetornaGolpePersonagem(G, ativa.Nome);
if (golpeP.TempoDeInstancia > 0)
{
carac.posInicial = EmissionPosition.Get(G, ativa.Nome);
}
GameObject KY = InstanceSupport.InstancieEDestrua(ativa.Nome, carac.posInicial, ativa.DirDeREpulsao, ativa.TempoDeDestroy);
DamageColliderBase proj = DamageColliderFactory.Get(KY, carac.tipo);
#region suprimido
//switch (carac.tipo)
//{
// case TipoDoProjetil.rigido:
// proj = KY.AddComponent<ColisorDeDanoRigido>();
// break;
// case TipoDoProjetil.basico:
// proj = KY.AddComponent<ColisorDeDano>();
// break;
// case TipoDoProjetil.statusExpansivel:
// proj = KY.AddComponent<ColisorDeStatusExpansivel>();
// break;
// case TipoDoProjetil.direcional:
// ColisorDeDanoDirecional projD = KY.AddComponent<ColisorDeDanoDirecional>();
// projD.alvo = (G.name == "CriatureAtivo")
// ? ((GameController.g.InimigoAtivo != null) ? GameController.g.InimigoAtivo.gameObject : null)
// : GameController.g.Manager.CriatureAtivo.gameObject;
// proj = projD;
// break;
//}
#endregion
proj.velocidadeProjetil = ativa.VelocidadeDeGolpe;
proj.noImpacto = carac.noImpacto;
proj.dono = G;
proj.esseGolpe = ativa;
}
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 void ImpactoAtivo(
GameObject G,
PetAttackBase ativa,
AeroImpactFeatures caracteristica,
float colocarColisor = 0,
GameObject focado = null)
{
tempoDecorrido += Time.deltaTime;
if (!procurouAlvo)
{
if (focado)
{
alvoProcurado = focado.transform;
}
else
{
alvoProcurado = FindBestTarget.Procure(G, new string[1] {
"Criature"
}); //CriaturesPerto.procureUmBomAlvo(G);
}
procurouAlvo = true;
// Debug.Log(alvoProcurado + " esse é o alvo");
StandardImpactUpdate.AttackHelper(alvoProcurado, G.transform);
if (alvoProcurado != null)
{
ativa.DirDeREpulsao = (Vector3.ProjectOnPlane(alvoProcurado.position - G.transform.position, Vector3.up)).normalized;
}
MessageAgregator <MsgRequestAtkAnimation> .Publish(new MsgRequestAtkAnimation()
{
gameObject = G,
nomeAnima = ativa.Nome.ToString()
});
MessageAgregator <MsgRequest3dSound> .Publish(new MsgRequest3dSound()
{
sender = G.transform,
sfxId = ativa.SomDoGolpe
});
//AnimadorCriature.AnimaAtaque(G, ativa.Nome.ToString());
/* aproveitado da geração 1 de scripts atualizado no 2021*/
ao = G.AddComponent <OnFloorImpactParticles>();
ao.aoChao = caracteristica.toque.ToString();
ao.onGroundSound = caracteristica.onTouchGroundSound;
/* ******************* */
}
if (!adview && tempoDecorrido > colocarColisor)
{
AttackColliders.AdicionaOColisor(G, ativa, caracteristica.deImpacto, tempoDecorrido + ativa.TempoDeMoveMin);
adview = true;
}
if (caracteristica.final == FinalAeroImpact.MaisAltoQueOAlvo)
{
MaisAltoQueOAlvo(G, ativa);
}
else
{
AvanceEPareAbaixo(G, ativa);
}
//if (tempoDecorrido > ativa.TempoDeMoveMax)
// nav.enabled = estavaParada;
}
private void MaisAltoQueOAlvo(GameObject G, PetAttackBase ativa)
{
Vector3 pontoAlvo = 3 * Vector3.up;
if (alvoProcurado != null)
{
pontoAlvo += alvoProcurado.position + 3 * Vector3.up + (G.transform.position - alvoProcurado.position).normalized;
}
Vector3 direcaoDoSalto = alvoProcurado == null
? G.transform.forward + 0.6f * Vector3.up
: Vector3.Dot(
Vector3.ProjectOnPlane(alvoProcurado.position - G.transform.position, Vector3.up),
ativa.DirDeREpulsao) > 0 ? pontoAlvo - G.transform.position : G.transform.forward;
//Debug.Log(Vector3.ProjectOnPlane(pontoAlvo - G.transform.position, Vector3.up).magnitude);
if ((Vector3.ProjectOnPlane(pontoAlvo - G.transform.position, Vector3.up).magnitude < 2f
&&
Vector3.ProjectOnPlane(posInicial - G.transform.position, Vector3.up).sqrMagnitude > 25f)
||
Mathf.Abs(posInicial.y - G.transform.position.y) > 4
)
{
alcancouOApceDaAltura = true;
direcaoDoSalto = Vector3.ProjectOnPlane(direcaoDoSalto, Vector3.up);
}
if (Vector3.ProjectOnPlane(posInicial - G.transform.position, Vector3.up).sqrMagnitude > 25f /* distancia ao quadrado*/ &&
(alcancouOApceDaAltura || tempoDecorrido > 0.75f * ativa.TempoDeMoveMax))
{
Vector3 descendo = Vector3.down;
if (alvoProcurado != null)
{
if (Vector3.Dot(
Vector3.ProjectOnPlane(alvoProcurado.position - G.transform.position, Vector3.up),
ativa.DirDeREpulsao) < 0)
{
descendo = descendo + ativa.DirDeREpulsao;
}
else
{
float vel = 0.75f;
if (G.name == "CriatureAtivo")
{
vel = 0.1f;
}
descendo = descendo + vel * (alvoProcurado.position - G.transform.position);
}
descendo.Normalize();
G.transform.rotation = Quaternion.LookRotation(Vector3.ProjectOnPlane(descendo, Vector3.up));
}
//Debug.DrawRay(G.transform.position, descendo * ativa.VelocidadeDeGolpe, Color.green, 10);
controle.Move(descendo * ativa.VelocidadeDeGolpe * Time.deltaTime);
}
else
{
//Debug.DrawRay(G.transform.position, direcaoDoSalto.normalized * ativa.VelocidadeDeGolpe, Color.yellow, 10);
controle.Move(direcaoDoSalto.normalized * Time.deltaTime * ativa.VelocidadeDeGolpe);
}
}