void PreparaAttack(bool magia, AnimKey a)
{
InvocaTeleportProps(true);
_Animator.SetTrigger(a.ToString());
FlipDirection.Flip(transform, -(HeroPosition.x - transform.position.x));
EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, SorteieSom(magia)));
}
void VerifiqueInvestida()
{
if (Time.time - ultimaInvestida > INTERVALO_DE_INVESTIMENTOS &&
Vector3.Distance(GameController.g.Manager.transform.position, transform.position) < DISTANCIA_DO_INVESTIMENTO)
{
RaycastHit2D hit = Physics2D.Linecast(transform.position, GameController.g.Manager.transform.position, 511);
if (!hit)
{
ultimaInvestida = Time.time;
_Animator.SetTrigger("preparaInvestida");
EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, SoundEffectID.Wind1));
estado = EstadoDaqui.preparandoInvestida;
dirGuardada = GameController.g.Manager.transform.position - transform.position;
dirGuardada.Normalize();
qAlvo = Quaternion.LookRotation(Vector3.forward, Vector3.Cross(dirGuardada, Vector3.forward));
FlipDirection.Flip(transform, dirDeMovimento.x);
new MyInvokeMethod().InvokeNoTempoDeJogo(gameObject, () =>
{
EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, impulso));
dirGuardada = GameController.g.Manager.transform.position - transform.position;
dirGuardada.Normalize();
dirGuardada *= VEL_DA_INVESTIDA;
transform.rotation = Quaternion.LookRotation(Vector3.forward, Vector3.Cross(dirGuardada, Vector3.forward));
estado = EstadoDaqui.investindo;
}, TEMPO_PREPARANDO);
}
}
}
protected virtual void Update()
{
tempoDecorrido += Time.deltaTime;
switch (fase)
{
case FasesDaMovimentacao.esperandoMove:
if (tempoDecorrido > tempoEsperando)
{
distanciaDeDeslocamento = Vector3.Distance(PreviousMoveTarget, MovePoints[MoveTarget].position);
fase = FasesDaMovimentacao.move;
MoveAnimation();
FlipDirection.Flip(transform, -PreviousMoveTarget.x + MovePoints[MoveTarget].position.x);
tempoDecorrido = 0;
}
break;
case FasesDaMovimentacao.move:
if (MovePoints.Length > 0)
{
transform.position = Vector3.Lerp(PreviousMoveTarget, MovePoints[MoveTarget].position,
tempoDecorrido * velocidadeDoDeslocamento / distanciaDeDeslocamento);
}
if (tempoDecorrido * velocidadeDoDeslocamento > distanciaDeDeslocamento)
{
EsperandoMoveAnimation();
fase = FasesDaMovimentacao.esperandoMove;
tempoDecorrido = 0;
TrocaMoveTarget();
}
break;
}
}
protected override void Telegrafar(Vector3 charPos)
{
FlipDirection.Flip(transform, charPos.x - transform.position.x);
InstanciaLigando.Instantiate(particulaTelegrafista, transform.position, 5);
EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, SoundEffectID.Wind1));
}
protected override void RequestAction(Vector3 charPos)
{
FlipDirection.Flip(transform, charPos.x - transform.position.x);
InstanciaLigando.Instantiate(particulaDoSpawn, transform.position, 5);
GameObject G = InstanciaLigando.Instantiate(breed, transform.position);
EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, SoundEffectID.lancaProjetilInimigo));
spawnados.Add(G);
RetornarParaEsperaZerandoTempo();
}
/*
* protected void RetornarParaEsperaZerandoTempo()
* {
* //estado = EstadoDaqui.emEspera;
* tempoDecorrido = 0;
* //VerifiquePosicionamento();
* }*/
void SimTelegrafar(Vector3 charPos)
{
new MyInvokeMethod().InvokeNoTempoDeJogo(gameObject,
() => {
RequestAction(charPos);
}, tempoTelegrafando);
FlipDirection.Flip(transform, charPos.x - transform.position.x);
_Animator.SetTrigger("action");
// RetornarParaEsperaZerandoTempo();
}
void MyFlip()
{
if (transform)
{
x2 = x1;
x1 = transform.position.x;
FlipDirection.Flip(transform, x1 - x2);
Invoke("MyFlip", 0.5f);
}
}
void OnReceivedTriggerInfo(IGameEvent e)
{
if (transform.IsChildOf(e.Sender.transform) && estado == EstadoDaqui.emEspera)
{
float px = ((Collider2D)((StandardSendGameEvent)e).MyObject[0]).transform.position.x;
bool foi = false;
if (Mathf.Abs(ultimoInvestimento - Time.time) > intervaloDeInvestimento)
{
for (int i = 0; i < trajetorias.Length; i++)
{
float partida = trajetorias[i].partida.position.x;
float chegada = trajetorias[i].chegada.position.x;
//Debug.Log(Mathf.Abs(partida - px)+" : "+px +" : "+" : "+partida+" : "+chegada+" : "+(partida < px && px < chegada) +" : "+ (partida > px && chegada < px) +" : "+ (Mathf.Abs(partida - px) > disMin)+" : "+i);
if (((partida < px && px < chegada) || (partida > px && chegada < px)) && (Mathf.Abs(partida - px) > disMin))
{
indiceDoDeslocamento = i;
foi = true;
}
}
if (foi)
{
transform.position = trajetorias[indiceDoDeslocamento].partida.position;
InstanciaLigando.Instantiate(particulaDoAparecimento, transform.position, 5);
EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, SoundEffectID.aparicaoSurpresaDeInimigo));
estado = EstadoDaqui.telegrafando;
tempoDecorrido = 0;
FlipDirection.Flip(transform,
trajetorias[indiceDoDeslocamento].partida.position.x - trajetorias[indiceDoDeslocamento].chegada.position.x);
ChangeView(true);
}
}
}
}
// Update is called once per frame
protected override void Update()
{
switch (estado)
{
case EstadoDaqui.aparecendo:
TempoDecorrido += Time.deltaTime;
Vector3 alvo = posOriginal + 0.15f * Vector3.right;
Vector3 partida = posOriginal;
float tempo = 10 * TempoDecorrido / TEMPO_TELEGRAFANDO_PULO - ((int)(10 * TempoDecorrido / TEMPO_TELEGRAFANDO_PULO));
if (((int)(10 * TempoDecorrido / TEMPO_TELEGRAFANDO_PULO)) % 2 == 0)
{
alvo = posOriginal;
partida = posOriginal + 0.15f * Vector3.right;
}
transform.position = Vector3.Lerp(partida, alvo, tempo);
if (TempoDecorrido > TEMPO_TELEGRAFANDO_PULO)
{
TempoDecorrido = 0;
rotOriginal = transform.rotation;
estado = EstadoDaqui.disparaPulo;
}
break;
case EstadoDaqui.disparaPulo:
TempoDecorrido += Time.deltaTime;
Quaternion qAlvo = Quaternion.Euler(0, 0, zAngleTarget);
if (TempoDecorrido < TEMPO_SUBINDO)
{
transform.position = Vector3.Lerp(posOriginal, posDoSalto.position, ZeroOneInterpolation.PolinomialInterpolation(TempoDecorrido / TEMPO_SUBINDO, 2));
transform.rotation = Quaternion.Lerp(rotOriginal, qAlvo, TempoDecorrido / TEMPO_SUBINDO);
}
else
{
PreviousMoveTarget = retornoAoChao.position;
transform.rotation = qAlvo;
TempoDecorrido = 0;
estado = EstadoDaqui.descendoPulo;
}
break;
case EstadoDaqui.descendoPulo:
TempoDecorrido += Time.deltaTime;
if (TempoDecorrido < TEMPO_DESCENDO)
{
transform.position = Vector3.Lerp(posDoSalto.position, retornoAoChao.position, ZeroOneInterpolation.PolinomialInterpolation(TempoDecorrido / TEMPO_DESCENDO, 2));
}
else
{
transform.position = retornoAoChao.position;
estado = EstadoDaqui.baseUpdate;
}
break;
case EstadoDaqui.baseUpdate:
FlipDirection.Flip(transform, zAngleTarget == 0
? PreviousMoveTarget.x - MovePoints[MoveTarget].position.x
: Mathf.Sign(zAngleTarget) * (PreviousMoveTarget.y - MovePoints[MoveTarget].position.y));
base.Update();
break;
}
}
// Update is called once per frame
void Update()
{
Vector3 charPos = default;
if (GameController.g)
{
if (GameController.g.Manager)
{
charPos = GameController.g.Manager.transform.position;
}
}
switch (estado)
{
case EstadoDaqui.emEspera:
moveVel = Vector3.Lerp(moveVel, moveDir, TRANSICAO_DA_VELOCIDADE * Time.deltaTime);
r2.velocity = VEL_MOVIMENTO * moveVel;
FlipDirection.Flip(transform, moveVel.x);
break;
case EstadoDaqui.posicionandoParaAtirar:
tempoDecorrido += Time.deltaTime;
moveVel = Vector3.Lerp(moveVel, moveDir, TRANSICAO_DA_VELOCIDADE * Time.deltaTime);
FlipDirection.Flip(transform, moveVel.x);
r2.velocity = VEL_MOVIMENTO * moveVel;
if (tempoDecorrido > INTERVALO_DE_TIRO)
{
RaycastHit2D hit = Physics2D.Linecast(transform.position, GameController.g.Manager.transform.position, 511);
if (!hit)
{
tempoDecorrido = 0;
estado = EstadoDaqui.telegrafando;
Telegrafar(charPos);
}
else
{
moveDir = (transform.position - charPos).normalized;
estado = EstadoDaqui.emEspera;
tempoDecorrido = 0;
Invoke("VerifiquePosicionamento", TEMPO_NA_ESPERA);
}
}
break;
case EstadoDaqui.telegrafando:
tempoDecorrido += Time.deltaTime;
moveVel = Vector3.Lerp(moveVel, Vector3.zero, TRANSICAO_DA_VELOCIDADE * Time.deltaTime);
r2.velocity = moveVel;
//FlipDirection.Flip(transform, moveVel.x);
if (tempoDecorrido > TEMPO_TELEGRAFANDO)
{
RequestAction(charPos);
}
break;
case EstadoDaqui.posicionandoEvasivamente:
moveVel = Vector3.Lerp(moveVel, moveDir, TRANSICAO_DA_VELOCIDADE * Time.deltaTime);
r2.velocity = VEL_MOVIMENTO * moveVel;
FlipDirection.Flip(transform, moveVel.x);
break;
}
}
void SimTelegrafar(Vector3 charPos)
{
FlipDirection.Flip(transform, charPos.x - transform.position.x);
_Animator.SetTrigger("action");
// RetornarParaEsperaZerandoTempo();
}
// Update is called once per frame
void Update()
{
switch (estado)
{
case EstadoDaqui.aproximandoSe:
mov.AplicadorDeMovimentos(
DirecaoNoPlano.NoUpNormalizado(transform.position, GameController.g.Manager.transform.position));
if (Mathf.Abs(doHeroi.position.x - transform.position.x) < 0.9f * distanciaDeEspadada)
{
estado = EstadoDaqui.buscadorDeAcao;
}
break;
case EstadoDaqui.buscadorDeAcao:
tempoDecorrido += Time.deltaTime;
//FlipDirection.Flip(andador.transform,-transform.position.x + doHeroi.transform.position.x);
if (doHeroi.position.y > transform.position.y)
{
estado = EstadoDaqui.defendendoAcima;
_Animator.SetTrigger("defendendoAcima");
}
else
if (tempoDecorrido > coolDown)
{
//mov.AplicadorDeMovimentos(DirecaoNoPlano.NoUpNormalizado(transform.position, doHeroi.position));
FlipDirection.Flip(andador.transform, transform.position.x - doHeroi.transform.position.x);
if (Mathf.Abs(doHeroi.position.x - transform.position.x) < distanciaDeEspadada)
{
int random = Random.Range(0, 10);
if (random <= 5)
{
IniciaAtaque();
}
else
{
if (BoaDistanciaAtras())
{
FlipDirection.Flip(andador.transform, -transform.position.x + doHeroi.transform.position.x);
estado = EstadoDaqui.backdash;
mov.AplicadorDeMovimentos(
DirecaoNoPlano.NoUpNormalizado(GameController.g.Manager.transform.position, transform.position), true);
tempoDecorrido = 0;
}
else
{
IniciaAtaque();
}
}
}
else
{
int sorteio = Random.Range(0, 5);
if (sorteio <= 1)
{
estado = EstadoDaqui.aproximandoSe;
}
else
{
IniciaProjetil();
}
}
}
else if (Vector2.Distance(transform.position, doHeroi.position) > distanciaDeDesligar)
{
estado = EstadoDaqui.retorneAoInicio;
}
break;
case EstadoDaqui.retorneAoInicio:
if (Vector2.Distance(doHeroi.position, transform.position) > distanciaDeDesligar)
{
if (Vector2.Distance(transform.position, posOriginal) < 0.5f)
{
EventAgregator.Publish(EventKey.returnRememberedMusic, null);
estado = EstadoDaqui.emEspera;
}
else
{
mov.AplicadorDeMovimentos(DirecaoNoPlano.NoUpNormalizado(transform.position, posOriginal));
}
}
else
{
tempoDecorrido = 0;
estado = EstadoDaqui.buscadorDeAcao;
}
break;
case EstadoDaqui.defendendoAcima:
if (doHeroi.position.y <= transform.position.y)
{
_Animator.SetTrigger("retornoDoDefendendoAcima");
estado = EstadoDaqui.buscadorDeAcao;
}
break;
case EstadoDaqui.backdash:
FlipDirection.Flip(andador.transform, transform.position.x - doHeroi.transform.position.x);
tempoDecorrido += Time.deltaTime;
if (tempoDecorrido < tempoDeBackDash)
{
mov.AplicadorDeMovimentos(
DirecaoNoPlano.NoUpNormalizado(GameController.g.Manager.transform.position, transform.position));
}
else
{
mov.AplicadorDeMovimentos(
DirecaoNoPlano.NoUpNormalizado(transform.position, GameController.g.Manager.transform.position));
FlipDirection.Flip(andador.transform, transform.position.x - doHeroi.transform.position.x);
if (Mathf.Abs(doHeroi.position.x - transform.position.x) > 1.1f * distanciaDeEspadada)
{
IniciaProjetil();
}
else
{
estado = EstadoDaqui.buscadorDeAcao;
tempoDecorrido = 0;
}
}
break;
}
BaseMoveRigidbody.PositionWithAndador(andador, transform);
}
protected override void Update()
{
FlipDirection.Flip(transform, transform.position.x - MovePoints[MoveTarget].position.x);
base.Update();
}
// Update is called once per frame
void Update()
{
switch (estado)
{
case EstadoDaqui.buscadorDeAcao:
tempoDecorrido += Time.deltaTime;
animador.SetBool("ataqueMagico", false);
animador.SetBool("ataqueBasico", false);
if (tempoDecorrido > coolDown)
{
if (Vector3.Distance(doHeroi.position, transform.position) < distanciaDeDesligar)
{
if (Mathf.Abs(doHeroi.position.x - transform.position.x) < distanciaDeEspadada)
{
int sorteio = Random.Range(0, 4);
if (sorteio == 0)
{
DispareMagia();
}
else
{
tempoDecorrido = 0;
animador.SetBool("ataqueBasico", true);
estado = EstadoDaqui.ataqueComEspada;
}
}
else
{
int sorteioB = Random.Range(0, 4);
if (sorteioB == 0)
{
DispareMagia();
}
else
{
estado = EstadoDaqui.movimente;
}
}
}
else
{
EventAgregator.Publish(EventKey.returnRememberedMusic, null);
estado = EstadoDaqui.emEspera;
}
}
break;
case EstadoDaqui.movimente:
float posX = transform.position.x;
if (posX > limitador_xMin.position.x && posX < limitador_xMax.position.x)
{
if (Vector3.Distance(doHeroi.position, transform.position) < distanciaDeEspadada)
{
tempoDecorrido = coolDown + 1;
estado = EstadoDaqui.buscadorDeAcao;
}
else
{
r2.velocity = velocidadeDoMovimento * DirecaoNoPlano.NoUpNormalizado(transform.position, doHeroi.position);
}
}
else
{
if (Vector3.Distance(doHeroi.position, transform.position) > distanciaDeDesligar)
{
estado = EstadoDaqui.retorneAoInicio;
}
else
{
DispareMagia();
}
}
break;
case EstadoDaqui.retorneAoInicio:
if (Vector3.Distance(doHeroi.position, transform.position) > distanciaDeDesligar)
{
if (Vector3.Distance(transform.position, posOriginal) < 0.5f)
{
EventAgregator.Publish(EventKey.returnRememberedMusic, null);
estado = EstadoDaqui.emEspera;
}
else
{
r2.velocity = velocidadeDoMovimento * DirecaoNoPlano.NoUpNormalizado(transform.position, posOriginal);
}
}
else
{
tempoDecorrido = coolDown = 1;
estado = EstadoDaqui.buscadorDeAcao;
}
break;
case EstadoDaqui.ataqueComEspada:
tempoDecorrido += Time.deltaTime;
if (tempoDecorrido > tempoDoAtaqueEspada)
{
estado = EstadoDaqui.buscadorDeAcao;
animador.SetBool("ataqueBasico", false);
tempoDecorrido = 0;
}
break;
case EstadoDaqui.porradaNoChao:
tempoDecorrido += Time.deltaTime;
if (tempoDecorrido > tempoDePorradaNoChao)
{
estado = EstadoDaqui.buscadorDeAcao;
animador.SetBool("ataqueMagico", false);
tempoDecorrido = 0;
}
break;
}
transform.position = r2.transform.position;
if (doHeroi)
{
FlipDirection.Flip(transform, -transform.position.x + doHeroi.position.x);
}
}
