public void EnterAttackState()
{
Log($"---------- {MethodBase.GetCurrentMethod().Name} ----------");
if (_selected)
{
OnUnitInterupt?.Invoke();
}
LookAt(_attackPos);
_prevState = _unitState;
_unitState = Enums.UnitState.Attacking;
Log("----------------------------------------");
}
public void ReceiveDamage(int damage, bool playClip = false)
{
if (isUntouchable || isDead)
{
return;
}
if (healthPoints >= DamagedThreshold * MaxHealth && healthPoints - damage < DamagedThreshold * MaxHealth)
{
audioSource.PlayOneShot(deacticatedClip, 1.0f);
}
healthPoints = Mathf.Clamp(healthPoints - damage, 0, MaxHealth);
if (playClip)
{
audioSource.PlayOneShot(damageClip, 0.3f);
}
UpdateHealthBar();
if (healthPoints <= 0)
{
gameOverEffect.SetActive(true);
isDead = true;
OnDeath.Invoke();
audioSource.Play();
}
}
private void OnTriggerEnter(Collider other)
{
Element element = other.GetComponent <Element>();
if (element)
{
_actualEnergy += element.EnergyGain;
float ratio = _actualEnergy;
Debug.Log("ratio1 " + _actualEnergy);
UiManager.Instance.UpdateEnergy(_actualEnergy);
if (element.EnergyGain < 0)
{
if (_actualEnergy < 0)
{
OnDeath.Invoke();
}
}
else
{
if (_actualEnergy >= MaxEnergy)
{
NextLevel.Invoke();
}
}
Debug.Log("ratio2 " + ratio);
Camera.main.fieldOfView = Mathf.Lerp(MinFov, MaxFov, _actualEnergy);
_actualForwardSpeed = Mathf.Lerp(MinForwardSpeed, MaxForwardSpeed, _actualEnergy);
OnSpeedUp.Invoke(_actualEnergy);
}
}
protected virtual void FixedUpdate()
{
if (isDead)
{
return;
}
Vector3 targetPos = spawnpos;
if (!isGoingBack && target)
{
targetPos = target.position;
}
Vector3 dir = targetPos - transform.position;
dir.y = transform.position.y;
dir = Vector3.ClampMagnitude(dir, 1);
Animator.SetFloat("Horizontal", dir.x);
Animator.SetFloat("Vertical", dir.z);
RB.velocity = Vector3.zero;
RB.MovePosition(transform.position + dir * movementSpeed * Time.deltaTime);
if (isGoingBack && Vector3.Distance(transform.position, spawnpos) < 0.1f)
{
PlayerHealth.Instance.TakeDamage();
OnDeath?.Invoke(this);
Destroy(gameObject);
}
}
public void Update(uint tick, float gameSpeed)
{
List <Entity> toDestroy = new List <Entity>();
for (int i = 0; i < Compatible.Count; i++)
{
var entity = Compatible[i];
var health = entity.GetComponent <HealthComponent>();
// If heath is below 0 then kill it
if (health.Health <= 0 || health.Suicude > 0)
{
toDestroy.Add(entity);
// Check if we would be killing an entity with energy
if (entity.TryGetComponent <EnergyComponent>(out EnergyComponent deadEnergy))
{
deadEnergy.HandleDeath(_energyManager, Pool, _simulation.JsonSettings, entity.GetComponent <TransformComponent>().WorldPosition);
}
var loc = entity.GetComponent <TransformComponent>().WorldPosition;
OnDeath?.Invoke(new DeathEventInfo(loc, tick * gameSpeed, entity.Id, entity.Tag, new HealthDeathCause()));
}
}
foreach (var e in toDestroy)
{
Pool.DestroyEntity(e);
}
}
public override void FireEvents(IDamageInfo dmgInf)
{
if (isSilent)
{
return;
}
IDamageInfo overrideSaveDmg = (IDamageInfo)dmgInf.Clone();
if (currentHealth <= 0)
{
if (OnDeath != null && !deathTriggered)
{
deathTriggered = true;
OnDeath.Invoke(this, overrideSaveDmg);
}
}
else
{
deathTriggered = false;
}
if (OnHealthChanged != null && lastHealth != currentHealth)
{
lastHealth = currentHealth;
OnHealthChanged(this, overrideSaveDmg);
}
}
public void Modify(int amount)
{
m_currentHealth += amount;
Mathf.Clamp(m_currentHealth, 0, m_maxHealth);
if (amount < 0)
{
if (OnTakeDamage != null)
{
OnTakeDamage.Invoke();
}
}
else if (amount > 0)
{
if (OnHeal != null)
{
OnHeal.Invoke();
}
}
else
{
Debug.Log("Modify called with 0");
}
if (OnValueChange != null)
{
OnValueChange.Invoke(PercentHealth);
}
if (m_currentHealth <= 0 && OnDeath != null)
{
OnDeath.Invoke();
}
}
/**
* <summary>
* Decrements the health value and if is dead returns the given experience, 0 otherwise
* </summary>
*/
public float OnDamageReceived(float damage)
{
OnHit?.Invoke();
if (IsAlive())
{
audioManager.Play("BodyHit");
}
var finalDamage = absorption >= damage ? 0 : damage - absorption;
health -= finalDamage;
if (IsAlive())
{
if (IsSkeleton())
{
randomAudio.Play();
}
return(0);
}
if (!isDead)
{
OnDeath?.Invoke();
if (IsSkeleton())
{
audioManager.Play("SkeletonDeath");
}
isDead = true;
return(experience);
}
return(0);
}
public void Update(uint tick, float _gameSpeed)
{
List <Entity> toDestroy = new List <Entity>();
for (int i = 0; i < Compatible.Count; i++)
{
var entity = Compatible[i];
var ageComponent = entity.GetComponent <OldAgeComponent>();
ageComponent.CurrentAge += _gameSpeed * _oldAgeMultiplier;
if (ageComponent.CurrentAge >= ageComponent.MaxAge && _oldAgeEnabled)
{
toDestroy.Add(entity);
// Check if we would be killing an entity with energy
if (entity.TryGetComponent <EnergyComponent>(out EnergyComponent deadEnergy))
{
deadEnergy.HandleDeath(_energyManager, Pool, _simulation.JsonSettings, entity.GetComponent <TransformComponent>().WorldPosition);
}
var transform = entity.GetComponent <TransformComponent>();
OnDeath?.Invoke(new DeathEventInfo(transform.WorldPosition, tick * _gameSpeed, entity.Id, entity.Tag, new OldAgeDeathCause()));
}
}
foreach (var e in toDestroy)
{
Pool.DestroyEntity(e);
}
}
public void Die(GameObject source)
{
if (onDeath != null)
{
onDeath.Invoke(new OnDeathArgs(source));
}
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.gameObject.CompareTag("Obstacle"))
{
if (!isDeath)
{
// Calculate point of impact
deathImpactDirection = transform.position - other.transform.position;
deathImpactDirection.Normalize();
audioSource.clip = deathAudio;
audioSource.Play();
isDeath = true;
OnDeath?.Invoke();
}
}
if (other.gameObject.CompareTag("Goal"))
{
if (!isDeath)
{
OnGoalTouched?.Invoke();
}
}
}
public virtual void Die()
{
OnDeath?.Invoke(this);
StatisticsManager.Instance.AddIntValue($"Entity.Killed.{stats.name}", 1);
Destroy(gameObject);
}
public override void Die()
{
if (dead)
{
return;
}
dead = true;
activated = false;
// Animation and Sound of death
AudioManager.instance.PlaySound("DieSound");
dieParticles.Play();
// If enemy didn't drop power up we may drop some ammo
if (!GeneratePowerUP())
{
GenerateAmmoBox();
}
// Call OnDeath event
OnDeath?.Invoke();
if (animator != null)
{
ChangeAnimationState("Die");
}
}
private void CheckForDeath()
{
if (combatStats.Health <= 0)
{
OnDeath?.Invoke();
}
}
public void Die()
{
_spriteRenderer.color = deathTint;
IsAlive = false;
Lock();
OnDeath?.Invoke();
}
// When life is 0 this is called by TakeDamage or Update
void HandleDeath()
{
if (gameObject.tag == "Player")
{
currentLife = MaxLife;
currentShield = MaxShield;
}
// Invoke the On Death Event
if (onDeath != null)
{
onDeath.Invoke();
}
if (DestroyOnDeath == true)
{
// Destroy the gameobject
Destroy(gameObject);
}
else if (!KeepOnDeath)
{
// Respawn the gameobject?
gameObject.SetActive(false);
}
if (explosionPrefab)
{
destroyedObject = Instantiate(explosionPrefab);
destroyedObject.transform.position = transform.position;
destroyedObject.transform.rotation = transform.rotation;
destroyedObject.transform.localScale = new Vector3(explosionScale, explosionScale, explosionScale);
AreaManager.Instance.OnObjectAdd(destroyedObject);
}
}
private void Die()
{
if (OnDeath != null)
{
OnDeath.Invoke();
}
}
public virtual void KillTile()
{
//does not remove it from map tiles
Destroy(gameObject);
OnDeath?.Invoke(this);
Map.RemoveTile(LayeredGridPosition);
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
OnDeath?.Invoke();
}
}
public void AlterHealth(int changeInHealth)
{
CurrentHealth += changeInHealth;
if (onHealthAltered != null)
{
onHealthAltered.Invoke(this);
}
var negative = changeInHealth < 0;
if (negative)
{
hitIndicator.Indicate();
}
if (CurrentHealth <= 0)
{
currentCell.cellUnit = null;
if (onDeath != null)
{
onDeath.Invoke(this);
}
Destroy(this.gameObject);
}
}
private void Death(bool doDestroy) // no need to handle the non destructive death, since it never happens
{
OnDeath?.Invoke();
anim.SetBool("isDead", true);
pc.StopControl();
Debug.Log("stopped control");
rb.velocity = Vector2.zero; //prevent sliding
coroutines.WaitThenExecute(1f, () => {
sf.FadeIn();
});
coroutines.WaitThenExecute(2f, () => {
hs.FullHealth();
tr.position = respawnPoint;
});
coroutines.WaitThenExecute(3f, () => {
sf.FadeOut();
});
coroutines.WaitThenExecute(3.5f, () => {
anim.SetBool("isDead", false);
});
coroutines.WaitThenExecute(3.8f, () => {
pc.RegainControl();
Debug.Log("regained control");
});
//TODO finesse this
}
private void PerformDeath()
{
if (deathAnimationFinished)
{
return;
}
if (!IsDrowning && CurrentActionState != Action.Dying)
{
OnDeath?.Invoke(this);
OnDeath -= OnDeath;
CurrentActionState = Action.Dying;
PlayDeathSound();
}
if (SpriteInstanceAnimate && IsOnFinalFrameOfAnimation)
{
SpriteInstanceAnimate = false;
}
if (Altitude <= 0f && IsOnFinalFrameOfAnimation)
{
if (IsDrowning)
{
OnDeath?.Invoke(this);
OnDeath -= OnDeath;
}
deathAnimationFinished = true;
this.Call(() =>
{
RemoveArrows();
Destroy();
}).After(2f);
}
}
public virtual bool ModifyHealth(int amount)
{
if (amount < 0 && Audio)
{
Audio.Play();
}
health += amount;
if (health <= 0)
{
Die();
}
return(health <= 0);
void Die()
{
OnDeath?.Invoke(this);
Collider.enabled = false;
RB.isKinematic = true;
isDead = true;
target = null;
if (Animator.GetFloat("Horizontal") > 0)
{
Vector3 curScale = transform.localScale;
curScale.x *= -1;
transform.localScale = curScale;
}
Animator.SetTrigger("Die");
}
}
public void TakeDamage(float proposedDamage, Monster source)
{
var actualDamage = (int)(proposedDamage / Defense);
Health -= actualDamage;
OnDamage?.Invoke(this, new OnDamageEventArgs()
{
DamageAmount = actualDamage, RemainingHealth = Health, DamageSource = source
});
if (Health > 0)
{
return;
}
OnDeath?.Invoke(this, new OnDeathEventArgs()
{
DamageSource = source
});
if (Health > 0)
{
return; //OnDeath may restore health
}
gameObject.SetActive(false);
Battle.Instance.CalculateTurnOrder();
}
public void Damage(float amount, GameObject attacker = null, Vector3?from = null)
{
if (Invulnerable)
{
return;
}
if (Health <= 0)
{
return;
}
Health -= amount;
if (DamageRegenDelay > 0)
{
regenDelay = DamageRegenDelay;
}
OnDamage?.Invoke(amount);
if (Health < 0 + Mathf.Epsilon)
{
if (RagdollOnDeath)
{
ActivateRagdoll(true);
}
OnDeath?.Invoke();
}
}
/// <summary>
/// Kills the component with sound and effects.
/// </summary>
public void Die()
{
if (data.deathAnim != null)
{
var deathAnim = ObjectPool.Instance.Spawn(ObjectPool.Types.explosion, transform.position);
Explosion exp = deathAnim.GetComponent <Explosion>();
exp.data = data.deathAnim;
exp.Initialize();
}
if (data.deathText != null)
{
GameManager.Instance.Money += data.killReward;
var flyingText = ObjectPool.Instance.Spawn(ObjectPool.Types.flyingText, transform.position);
FlyingText text = flyingText.GetComponent <FlyingText>();
text.data = data.deathText;
text.Initialize(data.killReward);
}
if (data.dropHealth)
{
if (Random.Range(0, 100f) < data.dropChance)
{
ObjectPool.Instance.Spawn(ObjectPool.Types.healthDrop, transform.position);
}
}
AudioManager.Instance.PlaySound(data.deathAudio);
OnDeath?.Invoke(gameObject);
Destroy(gameObject);
}
public void SetHealth(int hp, int hpmax)
{
if (HP <= 0 && hp > 0)
{
OnRevive?.Invoke(this);
}
BaseInst.SetHealth(hp, hpmax);
if (hp <= 0)
{
if (IsSpawned && !IsPlayer)
{
World.DespawnList_NPC.AddVob(this);
}
if (unconTimer != null && unconTimer.Started)
{
unconTimer.Stop();
}
}
if (hp <= 0)
{
_Uncon = Unconsciousness.None;
OnDeath?.Invoke(this);
sOnDeath?.Invoke(this);
}
}
public void TakeDamage(bool doInvincibility)
{
if (!godMode)
{
if (!isInvincible && !(invulnerabilityBoost && doInvincibility))
{
//Handle damage taking
health--;
if (health >= 0)
{
healthArea.transform.GetChild(health).gameObject.SetActive(false);
}
if (health <= 0)
{
soundManager.PlaySFX(sfxCollection.playerDeath);
// Handle player death
OnDeath?.Invoke();
gm.GameOver();
}
if (doInvincibility)
{
isInvincible = true;
}
}
}
}
/// <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);
}
private void Kill()
{
OnAnyEnemyDeath?.Invoke();
UnitKillPointReached?.Invoke();
OnDeath?.Invoke();
StartCoroutine(KillWithDelay());
}