public static bool Dispara(CriatureBase meuCriatureBase, GameObject gameObject)
{
Atributos A = meuCriatureBase.CaracCriature.meusAtributos;
GerenciadorDeGolpes ggg = meuCriatureBase.GerenteDeGolpes;
IGolpeBase gg = ggg.meusGolpes[ggg.golpeEscolhido];
if (gg.UltimoUso + gg.TempoDeReuso < Time.time && A.PE.Corrente >= gg.CustoPE)
{
AplicadorDeGolpe aplG = gameObject.AddComponent <AplicadorDeGolpe>();
A.PE.Corrente -= gg.CustoPE;
gg.UltimoUso = Time.time;
aplG.esseGolpe = gg;
if (!GameController.g.estaEmLuta)
{
GameController.g.HudM.AtualizaHudHeroi(meuCriatureBase);
}
return(true);
}
else
{
return(false);
}
}
public void ImpatoAtivo(GameObject G, IGolpeBase ativa, CaracteristicasDeImpacto caracteristica)
{
tempoDecorrido += Time.deltaTime;
if (!procurouAlvo)
{
alvoProcurado = CriaturesPerto.procureUmBomAlvo(G);
procurouAlvo = true;
Debug.Log(alvoProcurado + " esse é o alvo");
ajudaAtaque(alvoProcurado, G.transform);
}
if (!addView)
{
tempoDecorrido += ativa.TempoDeMoveMin;
ColisorDeGolpe.AdicionaOColisor(G, ativa, caracteristica, tempoDecorrido);
addView = true;
}
if (tempoDecorrido < ativa.TempoDeMoveMax)
{
if (((int)(tempoDecorrido * 10)) % 2 == 0 && alvoProcurado)
{
ajudaAtaque(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 static bool VaiColocarStatus(IGolpeBase ativa, Atributos bateu, Atributos levou, float contraTipoVeneno)
{
bool retorno = false;
switch (ativa.Nome)
{
case nomesGolpes.agulhaVenenosa:
case nomesGolpes.ondaVenenosa:
case nomesGolpes.chuvaVenenosa:
if (contraTipoVeneno > 0)
{
float ff = ativa.PotenciaCorrente *
Mathf.Max(1,
Random.Range(0.75f, 1f) * bateu.Poder.Corrente -
Random.Range(0, 0.75f) * levou.Defesa.Corrente);
if (contraTipoVeneno * ff + Random.Range(0, 100) > 80)
{
retorno = true;
}
}
break;
}
return(retorno);
}
void AvanceEPareAbaixo(GameObject G, IGolpeBase 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);
}
void AplicaGolpe()
{
Atributos A = MeuCriatureBase.CaracCriature.meusAtributos;
IGolpeBase gg = meuCriatureBase.GerenteDeGolpes.meusGolpes[meuCriatureBase.GerenteDeGolpes.golpeEscolhido];
Debug.Log("no chão: " + (mov.NoChao(meuCriatureBase.CaracCriature.distanciaFundamentadora)));
if ((mov.NoChao(meuCriatureBase.CaracCriature.distanciaFundamentadora) || gg.PodeNoAr))
{
if (!DisparadorDoGolpe.Dispara(meuCriatureBase, gameObject))
{
string[] textos = BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.usoDeGolpe).ToArray();
if (gg.UltimoUso + gg.TempoDeReuso >= Time.time)
{
GameController.g.HudM.Painel.AtivarNovaMens(
string.Format(textos[0], MostradorDeTempo(gg.UltimoUso - (Time.time - gg.TempoDeReuso)))
, 25, 2);
}
else if (A.PE.Corrente < gg.CustoPE)
{
GameController.g.HudM.Painel.AtivarNovaMens(textos[1], 25, 2);
}
}
}
}
static void CalculaDano(CreatureManager doAtacado, GameObject atacante, IGolpeBase golpe)
{
float multiplicador = 1;
for (int i = 0; i < doAtacado.MeuCriatureBase.CaracCriature.contraTipos.Length; i++)
{
if (golpe.Tipo.ToString() == doAtacado.MeuCriatureBase.CaracCriature.contraTipos[i].Nome)
{
multiplicador *= doAtacado.MeuCriatureBase.CaracCriature.contraTipos[i].Mod;
}
}
CriatureBase cDoAtacante = atacante.GetComponent <CreatureManager>().MeuCriatureBase;
Atributos A = cDoAtacante.CaracCriature.meusAtributos;
int potenciaDoAtacante = (golpe.Caracteristica == caracGolpe.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));
GolpePersonagem golpePersonagem = cDoAtacante.GerenteDeGolpes.ProcuraGolpeNaLista(cDoAtacante.NomeID, golpe.Nome);
CalculoC(multiplicador, golpe, golpePersonagem, potenciaDoAtacante, doAtacado, cDoAtacante);
}
static void CalculoB(float multiplicador, IGolpeBase golpe, GolpePersonagem golpePersonagem, int potenciaDoAtacante, CreatureManager doAtacado)
{
Atributos aDoAtacado = doAtacado.MeuCriatureBase.CaracCriature.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(CreatureManager doAtacado, GameObject atacante, IGolpeBase golpe)
{
Animator animatorDoAtacado = doAtacado.GetComponent <Animator>();
EmEstadoDeDano(animatorDoAtacado, doAtacado);
CalculaDano(doAtacado, atacante, golpe);
InsereEstouEmDano(doAtacado, animatorDoAtacado, golpe);
VerificaVida(atacante, doAtacado, animatorDoAtacado);
}
public static void AdicionaOColisor(GameObject G,
IGolpeBase golpeAtivo,
CaracteristicasDeImpacto caracteristica,
float tempoDecorrido)
{
GameObject view = elementosDoJogo.el.retornaColisor(caracteristica.nomeTrail);
// print(nomeColisor);
colisor C = pegueOColisor(G, golpeAtivo.Nome);// = new colisor();
GameObject view2 = (GameObject)MonoBehaviour.Instantiate(view, C.deslColisor, 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);
/*************************************************************/
ColisorDeDano proj = view2.AddComponent <ColisorDeDano>();
proj.velocidadeProjetil = 0f;
proj.noImpacto = caracteristica.noImpacto;
proj.dono = G;
proj.esseGolpe = golpeAtivo;
// proj.forcaDoDano = 25f;
//addView = true;
}
static void CalculoA(float multiplicador, IGolpeBase golpe, GolpePersonagem golpePersonagem, int potenciaDoAtacante, CreatureManager doAtacado)
{
int dano = Mathf.Abs(
Mathf.RoundToInt(
multiplicador * (golpe.PotenciaCorrente
+ golpePersonagem.ModPersonagem
+ potenciaDoAtacante)
));
potenciaDoAtacante = dano;//apenas para exibir no print a potencia original do golpe sem a defesa
Atributos aDoAtacado = doAtacado.MeuCriatureBase.CaracCriature.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;
}
/*
* if (dano > golpe.DanoMaximo && multiplicador <= 1)
* dano = golpe.DanoMaximo;
* else if (dano > multiplicador * golpe.DanoMaximo)
* {
* int mudaUmPoco = Random.Range(-1, 2);
* Debug.Log(mudaUmPoco);
* dano = Mathf.Max((int)(multiplicador * golpe.DanoMaximo) + mudaUmPoco, 1);
* }*/
/*
* if (elementos == null)
* elementos = GameObject.Find("elementosDoJogo").GetComponent<elementosDoJogo>();
*
* mostraDano(elementos, T, dano);*/
AplicaCalculoComVIsaoDeDano(doAtacado, golpe, aDoAtacado, multiplicador, dano, defesa, potenciaDoAtacante);
/*
* if (X.cAtributos[0].Corrente > 0)
* aplicaStatus(T, X, ativa, Y);
*/
}
static void AplicaCalculoComVIsaoDeDano(CreatureManager doAtacado,
IGolpeBase golpe,
Atributos 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);
}
public void ImpactoAtivo(GameObject G, IGolpeBase ativa, CaracteristicasDeImpactoComSalto caracteristica, float colocarColisor = 0)
{
tempoDecorrido += Time.deltaTime;
if (!procurouAlvo)
{
alvoProcurado = CriaturesPerto.procureUmBomAlvo(G);
procurouAlvo = true;
// Debug.Log(alvoProcurado + " esse é o alvo");
AtualizadorDeImpactos.ajudaAtaque(alvoProcurado, G.transform);
if (alvoProcurado != null)
{
ativa.DirDeREpulsao = (Vector3.ProjectOnPlane(alvoProcurado.position - G.transform.position, Vector3.up)).normalized;
}
AnimadorCriature.AnimaAtaque(G, ativa.Nome.ToString());
/* aproveitado da geração 1 de scripts*/
ao = G.AddComponent <impactoAoChao>();
ao.aoChao = caracteristica.toque.ToString();
/* ******************* */
}
if (!adview && tempoDecorrido > colocarColisor)
{
ColisorDeGolpe.AdicionaOColisor(G, ativa, caracteristica.deImpacto, tempoDecorrido + ativa.TempoDeMoveMin);
adview = true;
}
if (caracteristica.final == ImpactoAereoFinal.MaisAltoQueOAlvo)
{
MaisAltoQueOAlvo(G, ativa);
}
else
{
AvanceEPareAbaixo(G, ativa);
}
if (tempoDecorrido > ativa.TempoDeMoveMax)
{
nav.enabled = estavaParada;
}
}
public static void VerificaDano(GameObject atacado, GameObject atacante, IGolpeBase golpe)
{
if (atacado.tag == "eventoComGolpe" && !GameController.g.estaEmLuta)
{
atacado.GetComponent <EventoComGolpe>().DisparaEvento(golpe.Nome);
}
CreatureManager GdC = atacado.GetComponent <CreatureManager>();
if (GdC && !GameController.g.UsandoItemOuTrocandoCriature)
{
if (GdC.MeuCriatureBase.CaracCriature.meusAtributos.PV.Corrente > 0)
{
AplicaDano(GdC, atacante, golpe);
VerificaComportamentoDeIA(GdC, atacante);
}
}
}
public static void AplicaProjetil(GameObject G, IGolpeBase ativa, CaracteristicasDeProjetil carac)
{
GolpePersonagem golpeP = GolpePersonagem.RetornaGolpePersonagem(G, ativa.Nome);
if (golpeP.TempoDeInstancia > 0)
{
carac.posInicial = Emissor.UseOEmissor(G, ativa.Nome);
}
GameObject KY = AuxiliarDeInstancia.InstancieEDestrua(ativa.Nome, carac.posInicial, ativa.DirDeREpulsao, ativa.TempoDeDestroy);
ColisorDeDanoBase proj = null;
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;
}
proj.velocidadeProjetil = ativa.VelocidadeDeGolpe;
proj.noImpacto = carac.noImpacto.ToString();
proj.dono = G;
proj.esseGolpe = ativa;
}
public static void AplicaDano(CreatureManager doAtacado, GameObject atacante, IGolpeBase golpe)
{
doAtacado.MudaParaEstouEmDano();
//Transform T = doAtacado.transform;
Animator animatorDoAtacado = doAtacado.GetComponent <Animator>();
// doAtacado.MudaEmDano();
animatorDoAtacado.Play("dano2");
animatorDoAtacado.SetBool("dano1", true);
animatorDoAtacado.Play("dano1");
CalculaDano(doAtacado, atacante, golpe);
EstouEmDano eED = doAtacado.gameObject.AddComponent <EstouEmDano>();
eED.esseGolpe = golpe;
eED.animator = animatorDoAtacado;
eED.gerente = doAtacado;
VerificaVida(atacante, doAtacado, animatorDoAtacado);
}
static void CalculaDano(CreatureManager doAtacado, GameObject atacante, IGolpeBase golpe)
{
float multiplicador = 1;
for (int i = 0; i < doAtacado.MeuCriatureBase.CaracCriature.contraTipos.Length; i++)
{
if (golpe.Tipo.ToString() == doAtacado.MeuCriatureBase.CaracCriature.contraTipos[i].Nome)
{
multiplicador *= doAtacado.MeuCriatureBase.CaracCriature.contraTipos[i].Mod;
}
}
CriatureBase cDoAtacante = atacante.GetComponent <CreatureManager>().MeuCriatureBase;
Atributos A = cDoAtacante.CaracCriature.meusAtributos;
int potenciaDoAtacante = (golpe.Caracteristica == caracGolpe.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(TipoStatus.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;
}
GolpePersonagem golpePersonagem = cDoAtacante.GerenteDeGolpes.ProcuraGolpeNaLista(cDoAtacante.NomeID, golpe.Nome);
CalculoC(multiplicador, golpe, golpePersonagem, potenciaDoAtacante, doAtacado, cDoAtacante);
golpe.VerificaAplicaStatus(cDoAtacante, doAtacado);
}
static void AplicaCalculoComVIsaoDeDano(CreatureManager doAtacado,
IGolpeBase golpe,
Atributos 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);
GameObject visaoDeDano = elementosDoJogo.el.retorna("visaoDeDano");
visaoDeDano = (GameObject)MonoBehaviour.Instantiate(visaoDeDano, doAtacado.transform.position, Quaternion.identity);
danoAparecendo danoAp = visaoDeDano.GetComponent <danoAparecendo>();
danoAp.dano = dano;
danoAp.atacado = doAtacado.transform;
}
static void CalculoC(
float multiplicador,
IGolpeBase golpe,
GolpePersonagem golpePersonagem,
int potenciaDoAtacante,
CreatureManager doAtacado,
CriatureBase cDoAtacado)
{
Atributos aDoAtacado = doAtacado.MeuCriatureBase.CaracCriature.meusAtributos;
float rd = Random.Range(0.85f, 1);
int level = cDoAtacado.CaracCriature.mNivel.Nivel;
float STAB = 1;
if (cDoAtacado.CaracCriature.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 + 10) * potenciaDoAtacante * (golpe.PotenciaCorrente + golpePersonagem.ModPersonagem) / (aDoAtacado.Defesa.Corrente + 250) + 2) * STAB * multiplicador * rd);
AplicaCalculoComVIsaoDeDano(doAtacado, golpe, aDoAtacado, multiplicador, dano, aDoAtacado.Defesa.Corrente, potenciaDoAtacante);
}
public static void VerificaAplicaStatus(CriatureBase atacante, CreatureManager cDoAtacado, IGolpeBase golpe, int dano)
{
CriatureBase atacado = cDoAtacado.MeuCriatureBase;
if (VerificaAplicaStatusEnvenenado.VaiColocarStatus(
golpe,
atacante.CaracCriature.meusAtributos,
atacado.CaracCriature.meusAtributos,
atacado.CaracCriature.contraTipos[(int)NomeTipos.Veneno].Mod
))
{
Debug.Log("Aplicou Envenenamento");
VerificaAplicaStatusEnvenenado.InsereStatus(cDoAtacado,
new DatesForTemporaryStatus()
{
Quantificador = dano,
TempoSignificativo = 50,
Tipo = TipoStatus.envenenado
}
);
}
}
private void MaisAltoQueOAlvo(GameObject G, IGolpeBase 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);
}
}
public static void InsereEstouEmDano(CreatureManager doAtacado, Animator animatorDoAtacado, IGolpeBase golpe)
{
EstouEmDano eED = doAtacado.gameObject.AddComponent <EstouEmDano>();
eED.esseGolpe = golpe;
eED.animator = animatorDoAtacado;
eED.gerente = doAtacado;
}
