public void ActionEnd()
{
characterAnimation.UserAppear();
currentAttack.OnEndAction -= ActionEnd;
currentAttack = null;
if(OnEndAction != null) OnEndAction.Invoke();
}
void OnTriggerEnter2D(Collider2D col)
{
if (!col.IsTouchingLayers(LayerMask.GetMask("CharacterHitbox")))
return;
if ((col.tag == "Enemy" || col.tag == "Player") && this.tag != col.tag)
{
AttackController attackIncoming = col.GetComponent<AttackController>();
// Hit
if (CheckIfHit(attackIncoming) == true)
{
// Guard
if (state == CharacterState.Guard && attackIncoming.AttackBehavior.GuardBreak)
{
GuardBreak();
}
else if (state == CharacterState.Guard)
{
OnGuard.Invoke(this);
return;
}
characterStat.TakeDamage(attackIncoming.AttackBehavior);
attackIncoming.HasHit(this);
if (characterStat.GetHP() <= 0 && state != CharacterState.Dead)
{
Knockback(attackIncoming);
KnockbackDeath(attackIncoming);
}
else
{
Knockback(attackIncoming);
}
}
}
}
private IEnumerator InterruptionFeedback(AttackController attack)
{
//cameraLock.SetTarget(attack.transform);
//cameraLock.LockOn(false);
//cameraLock.SetState(0);
animatorInterruption.SetTrigger("Feedback");
/*animatorCanvasAction.speed = 0f;
attack.SetAnimSpeed(0);
globalCamera.ActivateCameraAction(false);
yield return new WaitForSeconds(0.4f);*/
animatorCanvasAction.speed = 0.1f;
attack.SetAnimSpeed(0.1f);
globalCamera.ActivateCameraAction(true);
yield return new WaitForSeconds(1f);
animatorCanvasAction.speed = 1;
float t = 0f;
float animSpeed = 0;
while(t < 1f)
{
t += (Time.deltaTime * 2);
animSpeed = Mathf.Lerp(0.2f, 1f, t);
attack.SetAnimSpeed(animSpeed);
}
attack.SetAnimSpeed(1f);
}
// Appelé par les anims
// Uniquement utilisable pour l'action principale
public void ActionActive()
{
if (currentAttack != null)
{
currentAttackController = (Instantiate(currentAttack, this.transform.position, Quaternion.identity));
currentAttackController.CreateAttack(this, target);
}
}
private void Action(AttackController attack, Transform target)
{
characterAnimation.UserDisappear();
attack.gameObject.SetActive(true);
attack.CreateAttack(target);
attack.SetDirection(direction.GetDirectionInt());
currentAttack = attack;
currentAttack.OnEndAction += ActionEnd;
}
public void KnockbackDeath(AttackController attack)
{
//CancelAct();
state = CharacterState.Dead;
speedZ += 1;
inAir = true;
characterAnimator.SetTrigger("Dead");
OnDead.Invoke(this);
}
private AttackController CheckCombo(AttackController action)
{
if (canMoveCancel == true && currentAttack != null)
{
if (previousAttack == action)
{
if (canTargetCombo == true && currentAttack.AttackBehavior.TargetCombo != null)
{
return currentAttack.AttackBehavior.TargetCombo;
}
else if (currentAttack.AttackBehavior.ComboTo != null)
{
return currentAttack.AttackBehavior.ComboTo;
}
}
}
return action;
}
private bool CheckIfHit(AttackController attack)
{
if (invulnerableState == true)
return false;
if (attack.CheckCollisionY(this.transform.position.y) == false)
return false;
if (state == CharacterState.Dead && inAir == false)
return false;
if (state == CharacterState.Throw && attack.AttackBehavior.AttackThrow == false)
return false;
if (state != CharacterState.Throw && attack.AttackBehavior.AttackThrow == true)
return false;
if (inAir == true && attack.AttackBehavior.ThrowState == true)
return false;
if (state == CharacterState.Down && attack.AttackBehavior.WakeUpAttack == false)
return false;
return true;
}
/// <summary>
/// Cancel Action mais sans retour à l'idle
/// </summary>
public void CancelAct()
{
if (currentAttackController != null)
currentAttackController.CancelAction();
currentAttack = null;
previousAttack = null;
currentAttackController = null;
canMoveCancel = false;
canEndAction = false;
endAction = false;
canTargetCombo = false;
noKnockback = false;
invulnerableState = false;
bounceX = 0;
bounceZ = 0;
state = CharacterState.Idle;
}
// Créer une action principale.
public void Action(AttackController action)
{
if (action == null)
return;
state = CharacterState.Acting;
currentAttack = CheckCombo(action);
previousAttack = action;
characterAnimator.ResetTrigger("Idle");
characterAnimator.Play(currentAttack.AttackBehavior.AttackAnimation.name, 0, 0f);
endAction = false;
canEndAction = false;
canMoveCancel = false;
canTargetCombo = false;
noKnockback = action.AttackBehavior.IsArmor;
invulnerableState = action.AttackBehavior.IsInvulnerable;
PlayVoice(action.AttackBehavior.UserSound);
if (currentAttack.AttackBehavior.KeepMomentum == false)
{
speedX = 0;
speedY = 0;
}
}
// ================================================================================
public void CheckFever(AttackController attack)
{
attackController = attack;
if (feverUpdate == true && feverTimeValue >= feverTimeMaxValue)
{
playerCharacters.Add(currentCharacter);
targetAim.CharacterDamage.IsInvulnerable = true; // Pour que targetAim ne se prenne pas une balle perdue et foute tout en l'air
feverOutlineFeedback.SetTrigger("Appear");
feverDecisionButton.gameObject.SetActive(true);
feedbackManager.SetMotionSpeed(0f);
OnFeverDecision.Invoke();
for (int i = 0; i < feverButton.Count; i++)
feverButton[i].SetActive(false);
feverButton[playerCharacters.Count - 1].SetActive(true);
StopCoroutine();
feverCoroutine = CameraCoroutine();
StartCoroutine(feverCoroutine);
feverUpdate = false;
return;
}
CancelFeverAim();
}
public void Action(AttackData data, AttackController attack, Transform target)
{
Action(attack, target);
currentAttack.SetAttackData(data);
}
public void Knockback(AttackController attack)
{
if(noKnockback == true && state != CharacterState.Dead)
{
if (healthBar != null)
healthBar.DrawHealth(characterStat.GetHP(), characterStat.GetHPMax());
OnHit.Invoke(attack.AttackBehavior);
return;
}
if (state != CharacterState.Dead)
{
CancelAct();
state = CharacterState.Hit;
}
if (attack.AttackBehavior.ThrowState == true)
{
state = CharacterState.Throw;
return;
}
if(characterToThrow != null)
{
characterToThrow.CancelAction();
characterToThrow.JumpDefault();
characterToThrow = null;
}
if(inAir == true)
{
if (attack.Direction == 0)
speedX = attack.AttackBehavior.KnockbackAerialPowerX * characterStat.GetMass() * -direction;
else
speedX = attack.AttackBehavior.KnockbackAerialPowerX * characterStat.GetMass() * attack.Direction;
speedY = 0;
if (attack.AttackBehavior.ResetGravity == true)
{
speedZ = attack.AttackBehavior.KnockbackAerialPowerZ * characterStat.GetMass();
SetGroundBounce(0, 0);
}
else
{
speedZ += attack.AttackBehavior.KnockbackAerialPowerZ * characterStat.GetMass();
}
}
else
{
if (attack.Direction == 0)
speedX = attack.AttackBehavior.KnockbackPowerX * characterStat.GetMass() * -direction;
else
speedX = attack.AttackBehavior.KnockbackPowerX * characterStat.GetMass() * attack.Direction;
speedY = 0;
speedZ = attack.AttackBehavior.KnockbackPowerZ * characterStat.GetMass();
if (attack.AttackBehavior.KnockbackPowerZ > 0)
{
inAir = true;
}
}
if (attack.AttackBehavior.GroundBounce == true)
{
SetGroundBounce(attack.AttackBehavior.GroundBounceX * Mathf.Sign(speedX), attack.AttackBehavior.GroundBounceZ);
}
knockdownValue += attack.AttackBehavior.KnockdownValue;
if (knockdownValue >= characterStat.GetKnockdownResistance() && state != CharacterState.Dead)
{
CharacterDown();
}
else
{
KnockbackAnimation();
}
PlayVoice(characterStat.CharacterData.HitVoice);
if (healthBar != null)
healthBar.DrawHealth(characterStat.GetHP(), characterStat.GetHPMax());
OnHit.Invoke(attack.AttackBehavior);
}
// Appelé par les anims
// Créer une action secondaire.
public void ActionActiveInstant(AttackController attack)
{
currentAttackController = (Instantiate(attack, this.transform.position, Quaternion.identity));
currentAttackController.CreateAttack(this, target);
}
