public void TakeDamage(int damage = 1, RhythmGrade grade = RhythmGrade.Miss, Transform attacker = null, float MissMultiplier = 1)
{
if (Time.time - lastDamagedTime <= InvincibilityTime || movementMachine.CurrentState is PlayerSuperState)
{
return;
}
lastDamagedTime = Time.time;
_hurtLerper.LerpValue(true);
CurrentHP -= damage;
if (CurrentHP <= 0)
{
Die();
}
else
{
if (attacker)
{
Vector3 toAttacker = attacker.position - transform.position;
toAttacker.y = 0;
toAttacker = toAttacker.normalized;
toAttacker = characterTransform.InverseTransformDirection(toAttacker);
CharacterAnimator.SetFloat("DamageDirectionX", toAttacker.x * -1f);
CharacterAnimator.SetFloat("DamageDirectionY", toAttacker.z * -1f);
}
movementMachine.TransitionTo <PlayerKnockBackState>();
}
HUDManager.Instance.UpdatePlayerHPUI(MaxHP, currentHP);
}
private void DoAttack()
{
currentAttackGrade = BeatManager.GetGrade();
SetupVFX();
OnAttack?.Invoke(currentAttackGrade);
if (currentAttackGrade != RhythmGrade.Miss)
{
SyncPowerManager.KeepTheBeatGoing();
}
else
{
SyncPowerManager.Miss();
}
player.OnAttackedPressed?.Invoke();
PlayerAnimator.SetTrigger(CurrentAttack.AttackTag);
RuntimeManager.PlayOneShotAttached(CurrentAttack.AttackSFX, player.gameObject);
timer = 0;
hitObjects.Clear();
timeOfLastAttack = Time.time + CurrentAttack.Clip.length;
if (DirectionInput.magnitude > 0)
{
PlayerAnimator.transform.LookAt(PlayerAnimator.transform.position + Vector3.ProjectOnPlane(GetInputRelativeToCamera(), Vector3.up));
}
AutoTargeting();
}
private void HappensOnAttack(RhythmGrade grade)
{
switch (grade)
{
case RhythmGrade.Miss:
beatViz.SetTrigger("Missed");
break;
case RhythmGrade.Good:
beatViz.SetTrigger("Synced");
break;
case RhythmGrade.Great:
beatViz.SetTrigger("Synced");
break;
case RhythmGrade.Excellent:
beatViz.SetTrigger("Synced");
break;
case RhythmGrade.Super:
beatViz.SetTrigger("Synced");
break;
}
}
private void HappensOnAttack(RhythmGrade grade)
{
switch (grade)
{
case RhythmGrade.Miss:
Intense.setValue(100f);
RuntimeManager.PlayOneShot(OffBeatNoCombatSFX);
Invoke("ResetSnap", 0.3f);
break;
case RhythmGrade.Good:
RuntimeManager.PlayOneShot(OnBeatNoCombatSFX);
break;
case RhythmGrade.Great:
RuntimeManager.PlayOneShot(OnBeatNoCombatSFX);
break;
case RhythmGrade.Excellent:
RuntimeManager.PlayOneShot(OnBeatNoCombatSFX);
break;
case RhythmGrade.Super:
RuntimeManager.PlayOneShot(OnBeatNoCombatSFX);
break;
}
}
public void TakeDamage(int damage = 1, RhythmGrade grade = RhythmGrade.Miss, Transform attacker = null, float MissMultiplier = 1)
{
currentHealth -= damage;
lastTimeOfDamage = Time.time;
HUDManager.Instance.UpdateNexusHPUI(health, currentHealth);
OnTakingDamage?.Invoke();
if (materialLerpers != null)
{
foreach (MaterialFloatLerper lerper in materialLerpers)
{
lerper.LerpValue();
}
}
StopCoroutine(ChangeColor());
StartCoroutine(ChangeColor());
if (!playingSound)
{
DrainCoreEvent.start();
playingSound = true;
}
coreAnimator.SetTrigger("TookDamage");
coreAnimator.SetFloat("CoreHealth", 1 - (float)currentHealth / health);
LoopingPrameter.setValue(1);
CameraShake.Shake(cameraShakeIntensity, cameraShakeTime);
if (currentHealth <= 0)
{
Die();
isDead = true;
}
}
private void HitFeedback(RhythmGrade grade)
{
switch (grade)
{
case RhythmGrade.Miss:
_particleColor.color = _missColor;
break;
case RhythmGrade.Good:
_particleColor.color = _goodColor;
break;
case RhythmGrade.Great:
_particleColor.color = _greatColor;
break;
case RhythmGrade.Excellent:
_particleColor.color = _exelentColor;
break;
case RhythmGrade.Super:
_particleColor.color = _superColor;
break;
}
StopCoroutine(ChangeColor());
StartCoroutine(ChangeColor());
}
public void OnEnemyHitSpawn(Vector3 pos, RhythmGrade grade)
{
GameObject temp = Instance.OP.SpawnFromPool(spawnTag, pos + spawnLocationOffeset, Quaternion.identity);
heading = cameraObject.transform.position - temp.transform.position;
temp.transform.rotation = Quaternion.LookRotation(heading, Vector3.up);
temp.GetComponent <ComboEffectManager>().grade = (int)grade;
}
private void ShowFeedback(RhythmGrade grade)
{
StopCoroutine(LerpValue());
_renderer.material.SetFloat(_valueName, 0);
if (_grade != grade && !_allButThis || _grade == grade && _allButThis)
{
return;
}
StartCoroutine(LerpValue());
}
private void DoPower(RhythmGrade grade)
{
if (grade == RhythmGrade.Miss)
{
StopCoroutine(MissLerp());
StartCoroutine(MissLerp());
}
else
{
StopCoroutine(BeatLerp());
StartCoroutine(BeatLerp());
}
}
public static void AddMultiplier(RhythmGrade rhythmGrade)
{
switch (rhythmGrade)
{
case RhythmGrade.Miss:
instance.streakHitMultiplier = instance.streakHitMultiplier - 1f;
instance.streakHitMultiplier = Mathf.Clamp(instance.streakHitMultiplier, 1, instance.MaxStreakValue);
instance.UpdateStreak(instance.streakHitMultiplier);
StreakScoreHolder = StreakScoreHolder + 0;
StreakScoreHolder = Mathf.Clamp(StreakScoreHolder, 0, instance.MaxStreakValue);
HitsOffBeat = HitsOffBeat + 1;
break;
case RhythmGrade.Good:
instance.streakHitMultiplier = instance.streakHitMultiplier + 1f;
instance.streakHitMultiplier = Mathf.Clamp(instance.streakHitMultiplier, 1, instance.MaxStreakValue);
instance.UpdateStreak(instance.streakHitMultiplier);
StreakScoreHolder = StreakScoreHolder + 1;
StreakScoreHolder = Mathf.Clamp(StreakScoreHolder, 0, instance.MaxStreakValue);
HitsOnBeat = HitsOnBeat + 1;
break;
case RhythmGrade.Great:
instance.streakHitMultiplier = instance.streakHitMultiplier + 1f;
instance.streakHitMultiplier = Mathf.Clamp(instance.streakHitMultiplier, 1, instance.MaxStreakValue);
instance.UpdateStreak(instance.streakHitMultiplier);
StreakScoreHolder = StreakScoreHolder + 1;
StreakScoreHolder = Mathf.Clamp(StreakScoreHolder, 0, instance.MaxStreakValue);
HitsOnBeat = HitsOnBeat + 1;
break;
case RhythmGrade.Excellent:
instance.streakHitMultiplier = instance.streakHitMultiplier + 1f;
instance.streakHitMultiplier = Mathf.Clamp(instance.streakHitMultiplier, 1, instance.MaxStreakValue);
instance.UpdateStreak(instance.streakHitMultiplier);
StreakScoreHolder = StreakScoreHolder + 1;
StreakScoreHolder = Mathf.Clamp(StreakScoreHolder, 0, instance.MaxStreakValue);
HitsOnBeat = HitsOnBeat + 1;
break;
case RhythmGrade.Super:
instance.streakHitMultiplier = instance.streakHitMultiplier + 1f;
instance.streakHitMultiplier = Mathf.Clamp(instance.streakHitMultiplier, 1, instance.MaxStreakValue);
instance.UpdateStreak(instance.streakHitMultiplier);
StreakScoreHolder = StreakScoreHolder + 1;
StreakScoreHolder = Mathf.Clamp(StreakScoreHolder, 0, instance.MaxStreakValue);
HitsOnBeat = HitsOnBeat + 1;
break;
}
}
public RhythmGrade GetGrade()
{
if (timeOfLastHit == Time.time)
{
return(thisFrameGrade);
}
bool mashing = Time.time - timeOfLastHit < MashSafeTime;
timeOfLastHit = Time.time;
if (mashing)
{
thisFrameGrade = RhythmGrade.Miss;
return(thisFrameGrade);
}
double beatPercentage = BeatManager.OffBeatPercent();
if (beatPercentage > 0.5d)
{
beatPercentage = 1 - beatPercentage;
}
beatPercentage *= 2d;
if (beatPercentage > GoodPercentage)
{
thisFrameGrade = RhythmGrade.Miss;
}
else if (beatPercentage > GreatPercentage)
{
thisFrameGrade = RhythmGrade.Good;
}
else if (beatPercentage > ExcellentPercentage)
{
thisFrameGrade = RhythmGrade.Great;
}
else if (beatPercentage > SuperPercentage)
{
thisFrameGrade = RhythmGrade.Excellent;
}
else
{
thisFrameGrade = RhythmGrade.Super;
}
return(thisFrameGrade);
}
public void TakeDamage(int damage = 1, RhythmGrade grade = RhythmGrade.Miss, Transform attacker = null, float MissMultiplier = 1)
{
if (_hurtLerper)
{
_hurtLerper.LerpValue(true);
}
if (grade == RhythmGrade.Miss && MissMultiplier == 0)
{
return;
}
Hp -= grade == RhythmGrade.Miss ? damage * MissMultiplier : damage;
OnDamage?.Invoke();
if (Hp <= 0)
{
if ((int)grade > 0)
{
PopUpPointsHandler.Instance.OnEnemyHitSpawn(transform.position, grade);
}
Die();
}
else if (!(Machine.CurrentState is AiCoreAttackState))
{
if (CurrentSlot.playerIndex >= 0 && CurrentSlot.playerIndex <= 3)
{
Machine.GetState <AiWalking>().shouldFreeSlot = false;
}
if ((int)grade > (int)GradeRequiredToKnockback)
{
if (EnemyType != Enemy.shooterAi)
{
Machine.GetState <AiKnockbackState>().TriggerHeavyKnockBack = true;
}
}
if (EnemyType == Enemy.basicAi)
{
Machine.TransitionTo <AiKnockbackState>();
}
if ((int)grade > 0)
{
PopUpPointsHandler.Instance.OnEnemyHitSpawn(transform.position, grade);
}
}
}
public static void AddHit(RhythmGrade grade)
{
instance.onHitScore = 50f;
Debug.Log(grade);
switch (grade)
{
case RhythmGrade.Miss:
instance.onHitScore = instance.onHitScore * instance.MissValue;
instance.UpdateGrade("miss");
break;
case RhythmGrade.Good:
instance.onHitScore = instance.onHitScore + instance.GoodValue;
instance.UpdateGrade("GOOD");
break;
case RhythmGrade.Great:
instance.onHitScore = instance.onHitScore + instance.GreatValue;
instance.UpdateGrade("GREAT");
break;
case RhythmGrade.Excellent:
instance.onHitScore = instance.onHitScore + instance.ExcecllentValue;
instance.UpdateGrade("SUPER");
break;
case RhythmGrade.Super:
instance.onHitScore = instance.onHitScore + instance.SuperValue;
instance.UpdateGrade("PERFECT");
break;
}
instance.StartInvoke();
instance.MultiplyScore();
}
private void Attacking(RhythmGrade grade)
{
toTheBeatcounter = grade == RhythmGrade.Miss ? 0 : toTheBeatcounter + 1;
}
