void HandleHitObjs(IAttackable attackable, AttackResult attackResult, AttackPackage attackPackage)
{
var component = attackable as Component;
if (component == null || !attackResult._attackSuccess)
{
return;
}
var climbable = component.GetComponent <Climbable>();
var hitbox = component.GetComponent <HitBox>();
if (climbable != null && hitbox != null)
{
knifeAudioSource.clip = _audios["HitMagicalElement"];
knifeAudioSource.volume = _volume["HitMagicalElement"];
knifeAudioSource.pitch = _pitch["HitMagicalElement"];
knifeAudioSource.Play();
}
if (climbable != null && hitbox == null)
{
knifeAudioSource.clip = _audios["HitWood"];
knifeAudioSource.volume = _volume["HitWood"];
knifeAudioSource.pitch = _pitch["HitWood"];
knifeAudioSource.Play();
}
if (climbable == null && hitbox != null)
{
knifeAudioSource.clip = _audios["HitEnemy"];
knifeAudioSource.volume = _volume["HitEnemy"];
knifeAudioSource.pitch = _pitch["HitEnemy"];
knifeAudioSource.Play();
}
}
public AttackResult ReceiveAttack(ref AttackPackage attack)
{
if (attacks.ContainsKey(attack._hashID))
{
return(AttackResult.Failed);
}
attacks.Add(attack._hashID, attack);
DelayedRemoveAttackPackage(attack._hashID);
hitPoint -= (int)attack._hitPointDamage;
healthBar.value = hitPoint;
if (hitPoint <= 0)
{
Destroy(gameObject);
}
var hitDirection = attack._fromDirection;
hitDirection.x = attack._fromDirection.x > 0 ? 1 : -1;
hitDirection.y = 0.5f;
stuned = true;
StartCoroutine(BeenHit());
rigidBody.AddForce(hitDirection * hitBackForce * attack._hitBackDistance, ForceMode2D.Impulse);
return(AttackResult.Success);
}
public bool Withdraw()
{
if (state == KnifeState.InSheath || actionTimer > 0 || returning)
{
return(false);
}
returning = true;
actionTimer = actionDelay;
transform.parent = null;
state = KnifeState.Flying;
if (hittedEnemy != null)
{
var dir = (sheath.transform.position - transform.position).normalized;
hittedEnemy.Hit(dir, 0.8f);
hittedEnemy.AddForce(dir * dragForce);
}
basicAttack = AttackPackage.CreateNewPackage();
hittedEnemy = null;
Returning();
return(true);
}
private void OnHittedHandler(AttackPackage attack, AttackResult result)
{
_playerAudioSource.clip = _audios["Pain"];
_playerAudioSource.volume = _volume["Pain"];
_playerAudioSource.pitch = _pitch["Pain"];
_playerAudioSource.Play();
}
public static AttackPackage CreateNewPackage()
{
var hashID = System.Guid.NewGuid().GetHashCode();
var package = new AttackPackage(hashID, 0, 0, 0, false, false, false, Vector2.zero);
return(package);
}
public override AttackPackage Process(AttackPackage target)
{
target._isMeleeAttack = false;
target._isChargedAttack = false;
target._hitPointDamage += _baseHitPointDamage;
target._enduranceDamage += _baseEnduranceDamage;
target._hitBackDistance += 0.7f;
return(target);
}
private void HandleOnHit(AttackPackage attack, AttackResult result)
{
if (_state._hitPoints <= 0)
{
bossAudioSource.clip = _audios["Death"];
bossAudioSource.volume = _audiosVolume["Death"];
bossAudioSource.pitch = _pitch["Death"];
bossAudioSource.Play();
}
}
public override AttackPackage Process(AttackPackage target)
{
target._isMeleeAttack = true;
target._isChargedAttack = _charged;
target._hitPointDamage += _baseHitPointDamage;
target._hitPointDamage *= _chargeAttackMultiplier;
target._enduranceDamage += _baseEnduranceDamage;
target._hitBackDistance += 2;
return(target);
}
private void OnHitEventHandler(AttackPackage atkPackage, AttackResult atkResult)
{
if (atkPackage._attackType == AttackType.Melee)
{
_particles["HittedByMelee"].Play();
}
if (atkPackage._attackType == AttackType.Range)
{
_particles["HittedByRange"].Play();
}
if (atkPackage._attackType == AttackType.ChargedMelee)
{
_particles["HittedByChargedMelee"].Play();
}
if (atkPackage._attackType == AttackType.ChargedRange)
{
_particles["HittedByChargedRange"].Play();
}
if (atkPackage._attackType == AttackType.Float)
{
_particles["HittedByFloatRange"].Play();
}
if (_state._hitPoints < 0)
{
enemyAudioSource1.clip = _audios["Death"];
enemyAudioSource1.volume = _volume["Death"];
enemyAudioSource1.pitch = _pitch["Death"];
enemyAudioSource1.Play();
}
else
{
enemyAudioSource1.clip = _audios["Hitted"];
enemyAudioSource1.volume = _volume["Hitted"];
enemyAudioSource1.pitch = _pitch["Hitted"];
enemyAudioSource1.Play();
if (atkPackage._attackType == AttackType.Melee || atkPackage._attackType == AttackType.ChargedMelee)
{
enemyAudioSource2.clip = _audios["TakingDamageByMelee"];
enemyAudioSource2.volume = _volume["TakingDamageByMelee"];
enemyAudioSource2.pitch = _pitch["TakingDamageByMelee"];
enemyAudioSource2.Play();
}
if (atkPackage._attackType == AttackType.ChargedRange || atkPackage._attackType == AttackType.Range)
{
enemyAudioSource2.clip = _audios["TakingDamageByRange"];
enemyAudioSource2.volume = _volume["TakingDamageByRange"];
enemyAudioSource2.pitch = _pitch["TakingDamageByRange"];
enemyAudioSource2.Play();
}
}
}
private void HandleOnHit(AttackPackage attack, AttackResult result)
{
_state._hitPoints -= result._finalDamage;
_state._endurance -= result._finalFatigue;
if (result._finalDamage > 0)
{
_hitFlash.Flash();
}
if (_state._hitPoints <= 0)
{
_animator.SetBool(BossFSMData.Stat.Death, true);
}
}
public bool Launch(Vector3 direction, bool isPiercing = false)
{
if (state != KnifeState.InSheath)
{
return(false);
}
piercing = isPiercing;
actionTimer = actionDelay;
state = KnifeState.Flying;
transform.position = sheath.LaunchPosition.position;
transform.right = direction;
basicAttack = AttackPackage.CreateNewPackage();
return(true);
}
public bool Hover()
{
if (hovered ||
returning ||
state != KnifeState.Flying ||
actionTimer > 0)
{
return(false);
}
piercing = false;
hovered = true;
actionTimer = actionDelay;
state = KnifeState.Hover;
basicAttack = AttackPackage.CreateNewPackage();
return(true);
}
public AttackResult ReceiveAttack(ref AttackPackage attack)
{
StringBuilder builder = new StringBuilder();
builder.Append("ID");
builder.Append(attack._hashID.ToString());
builder.Append("\nType");
builder.Append(attack._attackType.ToString());
builder.Append("\nHP Damage");
builder.Append(attack._hitPointDamage.ToString());
builder.Append("\nEP Damage");
builder.Append(attack._enduranceDamage.ToString());
builder.Append("\nIncoming Direction");
builder.Append(attack._fromDirection.ToString());
builder.Append("\nKnockback");
builder.Append(attack._knockback.ToString());
print(builder);
return(returnType);
}
private void HandleHittingEvent(AttackPackage attack, AttackResult result)
{
_decayTimer = _decayDelay;
_disappearTimer = _disappearDelay;
var totalComboTimes = _state._currentMeleeComboTimes + _state._currentRangeComboTimes;
var comboDamage =
_state._currentMeleeComboTimes * _state._meleeComboAdditiveDamage +
_state._currentRangeComboTimes * _state._rangeComboAdditiveDamage;
if (totalComboTimes == _lastComboTime)
{
_currentBaseDamage += result._finalDamage;
}
else
{
if (_lastComboTime == _state._comboMaxTimes)
{
_decaying = true;
}
_lastComboTime = totalComboTimes;
var baseDamage = result._finalDamage - comboDamage;
if (baseDamage > _state._hitPoints)
{
baseDamage = _state._hitPoints;
}
if (_currentExtraDamage > _state._hitPoints)
{
_currentExtraDamage = _state._hitPoints;
}
_currentBaseDamage += baseDamage;
_currentExtraDamage += comboDamage;
}
UpdateSlider();
}
private void HandleOnHit(AttackPackage attack, AttackResult result)
{
if (_animator.GetCurrentAnimation().name == GhoulAnimationData.Anim.Death_Ground)
{
return;
}
_flash.Flash();
_mover.Knockback(attack._fromDirection * attack._knockback);
_state._hitPoints -= result._finalDamage;
_state._endurance -= result._finalFatigue;
if (_state._hitPoints < 0)
{
Dying();
}
if (_state._endurance <= 0)
{
_state._endurance.Current = 0;
_animator.SetToggle(attack._staggerAnimation, true);
_launcher.Interrupt();
}
}
private void HandleOnHit(AttackPackage attack, AttackResult result)
{
if (_animator.GetCurrentAnimation().name == PlayerFSMData.Anim.Death)
{
return;
}
_state._hitPoints -= result._finalDamage;
_state._endurance -= result._finalFatigue;
if (attack._move != null && result._isWeakspot)
{
TimeManager.Instance.FrozenFrame(attack._move.FrameFrozen);
ShakeScreen.Instance.Shake(attack._move.ScreenShakeParam);
}
if (result._finalDamage > 0)
{
_hitFlash.Flash();
}
if (result._finalFatigue > 0)
{
_enduranceRecoverTimer = 0;
}
if (attack._knockback != 0)
{
_mover.Knockback(attack._fromDirection * attack._knockback);
}
if (_state._hitPoints <= 0)
{
CancelAnimation();
_animator.SetToggle(PlayerFSMData.Stat.Death, true);
print("Player Dead");
_mover.ResetMovement();
_weaponSystem.ResetWeapon();
}
if (_state._endurance <= 0)
{
var input = _input as PlayerInput;
var mInput = _input as MPlayerInput;
if (input)
{
input.ResetDelayInput();
}
else
{
mInput.ResetDelayInput();
}
CancelAnimation();
_state._endurance.Current = 0;
_animator.SetToggle(attack._staggerAnimation, true);
SetBlockInput(true);
SetFrozen(true);
}
}
public override void Activate(AttackPackage attack)
{
print("activate");
basePackage = attack;
_activated = true;
}
public abstract AttackPackage Process(AttackPackage target);
public void Activate()
{
AttackPackage attack = AttackPackage.CreateNewPackage();
weapon.Activate(attack);
}
public override void Activate(AttackPackage attack)
{
basicAttack = attack;
activated = true;
}
public void Activate(AttackPackage attack)
{
}
public abstract void Activate(AttackPackage attack);
private void HandleFrameEvent(FrameEventEventArg eventArgs)
{
if (eventArgs._name == AnimEventNames.AttackBegin)
{
var attack = AttackPackage.CreateNewPackage();
attack._hitPointDamage.Base = _state._hitPointDamage;
attack._enduranceDamage.Base = _state._enduranceDamage;
_weapon.Activate(attack, _currentMove);
if (eventArgs._animation.name == BossFSMData.Anim.Slash1 ||
eventArgs._animation.name == BossFSMData.Anim.Slash2)
{
foreach (var collider in _slashAttackBoxes)
{
collider.enabled = true;
}
_collider.gameObject.layer = LayerMask.NameToLayer("EnemyDash");
OnBeginDashingInvincible?.Invoke();
}
if (eventArgs._animation.name == BossFSMData.Anim.Combo2_3)
{
foreach (var collider in _combo2AttackBoxes)
{
collider.enabled = true;
}
_collider.gameObject.layer = LayerMask.NameToLayer("EnemyDash");
OnBeginDashingInvincible?.Invoke();
}
if (eventArgs._animation.name == BossFSMData.Anim.Combo3_2)
{
foreach (var collider in _thrustAttackBoxes)
{
collider.enabled = true;
}
_collider.gameObject.layer = LayerMask.NameToLayer("EnemyDash");
OnBeginDashingInvincible?.Invoke();
}
}
else if (eventArgs._name == AnimEventNames.AttackEnd)
{
_weapon.Deactivate();
if (eventArgs._animation.name == BossFSMData.Anim.Slash1 ||
eventArgs._animation.name == BossFSMData.Anim.Slash2)
{
foreach (var collider in _slashAttackBoxes)
{
collider.enabled = false;
}
_collider.gameObject.layer = LayerMask.NameToLayer("RejectCollider");
OnStopDashingInvincible?.Invoke();
}
if (eventArgs._animation.name == BossFSMData.Anim.Combo2_3)
{
foreach (var collider in _combo2AttackBoxes)
{
collider.enabled = false;
}
_collider.gameObject.layer = LayerMask.NameToLayer("RejectCollider");
OnStopDashingInvincible?.Invoke();
}
if (eventArgs._animation.name == BossFSMData.Anim.Combo3_2)
{
foreach (var collider in _thrustAttackBoxes)
{
collider.enabled = false;
}
_collider.gameObject.layer = LayerMask.NameToLayer("RejectCollider");
OnStopDashingInvincible?.Invoke();
}
}
}
public AttackResult ReceiveAttack(ref AttackPackage attack)
{
OnHit?.Invoke(attack);
return(AttackResult.Success);
}
protected void RaiseOnHitEvent(IAttackable attackable, AttackResult result, AttackPackage attack)
{
OnHit?.Invoke(attackable, result, attack);
}
