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); }