private void HandleItem(ItemActor itemActor)
{
_log.ErrorIfNull(itemActor, $"{itemActor} has tag {Tags.Item} but does not have an item component.");
foreach (var interaction in itemActor.Interactions)
{
switch (interaction)
{
case InteractionTypes.Collect:
var collectibleItem = itemActor as ICollectible;
_log.ErrorIfNull(collectibleItem, $"{itemActor} has interaction {interaction} but does not implement {typeof(ICollectible).Name}.");
OnItemsCollected.Raise(collectibleItem.CollectedItems);
break;
case InteractionTypes.Damage:
var damagingItem = itemActor as IDamaging;
_log.ErrorIfNull(damagingItem, $"{itemActor} has interaction {interaction} but does not implement {typeof(IDamaging).Name}.");
OnDamageTaken.Raise(damagingItem.Damage);
break;
case InteractionTypes.Healing:
var healingItem = itemActor as IHealing;
_log.ErrorIfNull(healingItem, $"{itemActor} has interaction {interaction} but does not implement {typeof(IHealing).Name}.");
OnHealingApplied.Raise(healingItem.Healing);
break;
default: _log.Error($"Unknown interaction '{interaction}'."); break;
}
}
itemActor.HandledItem();
}
// Use this for initialization
protected virtual void Start()
{
agent = GetComponent <NavMeshAgent>();
CurrentHP = healthPoints;
onDamageTaken += ApplyDamage;
}
/// <summary>
/// Deals damage and returns damage actually dealt
/// </summary>
/// <param name="amount"></param>
/// <returns></returns>
public float TakeDamage(float amount)
{
var healthAfter = Mathf.Clamp(_health.Health - amount, 0.0f, _health.MaxHealth);
var dmgDealt = _health.Health - healthAfter;
if (_info.IsLocal)
{
if (_damageManager.NegateDamage == false)
{
_health.Health = healthAfter;
}
OnDamageTaken?.Invoke(new DamageTakenArgs(dmgDealt, _health.Health));
if (_health.Health <= 0.0f)
{
DeathParameters deathParameters = new DeathParameters();
deathParameters.characterInfo = _info;
OnDeath?.Invoke(deathParameters);
}
}
else
{
SendMessage(amount); //we use {amount} instead of {dmgDealt} because HP may not be up to date on the client
}
return(dmgDealt);
}
public void TakeDamage(int amount)
{
OnDamageTaken?.Invoke();
currentHealth -= amount;
if (currentHealth <= 0)
{
Destroy(gameObject);
}
}
public virtual void TrueDamage(float damage)
{
Health -= (int)damage;
if (OnDamageTaken != null)
{
OnDamageTaken.Invoke((int)damage);
}
}
public void OnDamage(float damage)
{
hp -= damage;
OnDamageTaken?.Invoke();
if (hp <= 0f)
{
Die();
}
}
public void TakeDamage()
{
int damage = 10;
health = Max(health - damage, 0);
animator.SetInteger("Health", health);
animator.SetTrigger("TookDamage");
OnDamageTaken?.Invoke(health);
}
/// <summary>
/// Make this unit take damage.
/// </summary>
/// <param name="damage">The damage value to apply. As it is right now, all damage is applied directly to health.</param>
/// <param name="healthModifier">NOT IMPLEMENTED! Damage modifier if the damage is done directly to health.</param>
/// <param name="shieldModifier">NOT IMPLEMENTED! Damage modifier if the damage is done to shields instead of health.</param>
/// <param name="armorModifier">NOT IMPLEMENTED! Damage modifier if the damage is done to armor instead of health.</param>
public void TakeDamage(float damage, float healthModifier = 1.0f, float shieldModifier = 1.0f, float armorModifier = 1.0f)
{
health = Mathf.Clamp(health - damage, 0, maxHealth);
OnDamageTaken?.Invoke();
if (health <= 0)
{
OnDeath?.Invoke();
LiterallyAnythingDied?.Invoke();
}
}
public virtual void Damage(float damage)
{
int damageTaken = (int)damage - (int)(damage * _defence);
Health -= damageTaken;
if (OnDamageTaken != null)
{
OnDamageTaken.Invoke(damageTaken);
}
}
public void IsHit()
{
_hp--;
if (OnDamageTaken != null)
{
OnDamageTaken.Invoke(_hp / (float)MaxHp);
}
InvokeDamageEffect();
InvokeSpriteChanger(_hp / (float)MaxHp);
_sfxSource.PlayOneShot(SfxHit, _sfxSource.volume);
}
private void TakeDamage(int ammount)
{
HealthPoints = Mathf.Max(0, HealthPoints - ammount);
OnDamageTaken?.Invoke();
if (HealthPoints <= 0)
{
if (Score.CurrentScore > Score.HighScore)
{
Score.HighScore = Score.CurrentScore;
}
SceneManager.LoadScene("EndGame");
}
}
public void TakeDamage(int amount, bool dot = false)
{
_health -= (int)Math.Round((amount * damageMultiplier) - defense, MidpointRounding.AwayFromZero);
OnDamageTaken?.Invoke();
StartCoroutine(DamageBlink(0.05f));
if (_health <= 0)
{
OnDeath?.Invoke();
Die();
}
if (immunity && !dot)
{
immunity.EnablePlayerImmunity();
}
}
public float TakeDamage(DamageInfo info)
{
OnTakeDamage?.Invoke(info);
float dmg = info.Damage * DamageMatrix.GetDamageFactor(info.Type, ArmorType);
CurrentHealth -= dmg;
OnDamageTaken?.Invoke(dmg);
if (CurrentHealth <= 0f && !_isDead)
{
Die();
OnDeath?.Invoke();
_isDead = true;
}
if (CurrentHealth > MaxHealth)
{
CurrentHealth = MaxHealth;
}
return(CurrentHealth);
}
// Use this for initialization
protected virtual void Start()
{
CurrentHP = maxHP;
MyCollider = GetComponent <Collider>();
MyRigidbody = GetComponent <Rigidbody>();
onDamageTaken += Damage;
//switch (enemyType)
//{
// case EnemyType.Ghost:
// MyCollider.isTrigger = true;
// break;
// default:
// MyCollider.isTrigger = false;
// break;
//}
}
public void TakeDamage(float damage)
{
CurrentHealth = (CurrentHealth - damage > 0) ?
CurrentHealth - damage : 0;
OnDamageTaken?.Invoke(damage);
_damageHighlight.HighLight();
if (CurrentHealth <= 0)
{
OnEnemyDeath?.Invoke(this);
Destroy(gameObject);
GameObject deathParticles = Instantiate(_deathParticles,
transform.position + new Vector3(0, 0.5f, 0),
Quaternion.identity);
deathParticles.GetComponent <DestroyAfterTime>().StartTimer(0.5f);
}
}
public void DecreaseHP(float amount)
{
if (currentHeroStats.maxHP <= 0 || IsIntro)
{
return;
}
currentHeroStats.maxHP -= amount;
OnDamageTaken?.Invoke();
m_AudioSource.PlaySound(Music.SoundsTypes.hit);
if (currentHeroStats.maxHP <= 0)
{
OnOutOfHP?.Invoke(this, true);
}
else
{
m_ControlFSM.HitReaction();
}
RefreshHPSlider();
}
public void TakeDamage(int damage)
{
m_health -= damage;
if (m_health < 0)
{
m_health = 0;
}
if (m_health > m_maxHealth)
{
m_health = m_maxHealth;
}
if (m_health <= 0)
{
Die();
}
OnDamageTaken?.Invoke();
}
private void OnTriggerStay(Collider other)
{
IHurtsPlayer hurts = other.gameObject.GetComponent <IHurtsPlayer>();
if (cooldown <= 0 && !manager.IsDashing && ((hurts != null && hurts.Alive) || other.gameObject.tag == "HurtPlayer"))
{
if (vie > 0)
{
vie -= dmg;
Cam.GetComponent <CameraShake>().Trauma = 0.4f;
}
if (OnDamageTaken != null)
{
OnDamageTaken.Invoke(this.gameObject);
}
cooldown = cooldownTime;
}
}
public void ApplyDamage(float damageValue, GameObject attacker)
{
if (attacker == gameObject)
{
print("damage" + damageValue + "," + attacker.name);
}
if (!isAlive)
{
return;
}
hp -= damageValue;
ChangeHpBar();
OnDamageTaken?.Invoke();
//killed
if (hp <= 0)
{
isAlive = false;
if (hpSlider != null)
{
hpSlider.gameObject.SetActive(false);
}
if (canExplode)
{
Explode();
}
else
{
gameObject.SetActive(false);
//Destroy(gameObject);
}
OnDeath?.Invoke();
}
}
public virtual void TakeDamage(int damageAmount)
{
if (currentDamageInvulnerabilityDuration > 0)
{
return;
}
Debug.Log($"Taking damage: -{damageAmount}");
int damageToTake = Mathf.Clamp(damageAmount - defence, 0, int.MaxValue);
PreviousDamageTaken = "-" + damageToTake;
currentHealth -= damageToTake;
currentDamageInvulnerabilityDuration = damageInvulnerabilityDuration;
OnDamageTaken.Invoke(damageToTake, Camera.main.WorldToScreenPoint(popUpOffsetPos.position));
if (currentHealth <= 0)
{
gameObject.SetActive(false);
}
}
private void TookDamage(float delta)
{
OnDamageTaken?.Invoke(this, delta);
}
public void AddDamageHandler(long gridId, OnDamageTaken handler)
{
DamageHandlers.Add(gridId, handler);
}
public virtual void TakeDamage()
{
OnDamageTaken?.Invoke(Damage);
}
void Start()
{
OnDamageTaken.AddListener(FlashRed);
OnDamageTaken.AddListener((health) => GameManager.LevelingSystem.AddXP(20));
OnDeath.AddListener(() => GameManager.LevelingSystem.AddXP(100));
}
public void AddDamageHandler(IMyCubeGrid grid, OnDamageTaken handler)
{
AddDamageHandler(grid.GetTopMostParent().EntityId, handler);
}
private void OnEnable()
{
OnDamageTaken.AddListener(UpdateUI);
}
private void OnDisable()
{
OnDamageTaken.RemoveListener(UpdateUI);
}
protected void OnDestroy()
{
onDamageTaken -= Damage;
}
public static void removeAllListenersForOwner(object owner)
{
OnDamageTaken.RemoveListener(owner);
OnUpdate.RemoveListener(owner);
}
public void TakeDamage(int _amount, TypeId _type, ElementId _element, OrigineId _origine)
{
Health -= _amount;
OnDamageTaken?.Invoke(_amount, _type, _element, _origine);
}
