private void Die()
{
PlayEffect();
PlayAnimation();
OnDied?.Invoke(this);
Destroy(gameObject, _destroyAfter);
}
private void ObiSolverOnOnCollision(ObiSolver solver, ObiSolver.ObiCollisionEventArgs contacts)
{
// var contact = contacts.contacts[0];
foreach (var contact in contacts.contacts)
{
// this one is an actual collision:
if (contact.distance < 0.01)
{
ObiCollider.idToCollider.TryGetValue(contact.other, out var collider);
if (collider != null)
{
if (collider.tag == "GameOverTrigger")
{
var emitter = (ObiEmitter)solver.particleToActor[contact.particle].actor;
emitter.life[solver.particleToActor[contact.particle].indexInActor] = 0;
if (_solverStore.IsAllPlayerPuddlesDied())
{
OnDied?.Invoke();
}
}
if (collider.tag == "Connectable")
{
var puddle = collider.GetComponent <Puddle>();
puddle.Join(_obiEmitter);
_source.PlayOneShot(_source.clip);
}
}
}
}
}
public float Damage(DamageRequest damageRequest)
{
if (IsDead)
{
return(0);
}
var damageAmount = damageRequest.CalculateAmount(System.AttributeSystem);
currentHealth -= damageAmount;
if (currentHealth > 0)
{
damageRequest.AmountDealt = damageAmount;
OnDamageReceived?.Invoke(damageRequest);
OnHealthChanged?.Invoke(CurrentHealth);
return(damageAmount);
}
var actualDamageDealt = damageAmount + currentHealth;
currentHealth = 0;
damageRequest.AmountDealt = actualDamageDealt;
OnDamageReceived?.Invoke(damageRequest);
OnHealthChanged?.Invoke(CurrentHealth);
OnDied?.Invoke(damageRequest);
return(actualDamageDealt);
}
private void Die()
{
_anim.SetTrigger("Die");
// call die event
OnDied?.Invoke();
}
/// <summary>
/// This method kills protagonist.
/// </summary>
public void OnDeath()
{
velocity = Vector2.Zero;
Collidable = false;
Solid = false;
Invulnerable = true;
Lives--;
IgnoreInput();
Width = _smallWidth;
Height = _smallHeight;
Animations.Play((int)PlayerAnimation.DEATH);
Animations.Lock();
Jump();
MediaPlayer.Pause();
PlaySound("death");
OnDied?.Invoke(this, new EventArgs());
}
public void Damage(float amount, DamageableLayer layer = null)
{
if (!CanInflictDamage(layer))
{
return;
}
CurrentHealth -= Mathf.Abs(EvaluateDamage(amount));
healthBar?.SetCurrentHealth(CurrentHealth);
if (CurrentHealth <= 0f)
{
IsDead = true;
OnDied?.Invoke(this, EventArgs.Empty);
if (destroyHealthBarOnDied)
{
Destroy(healthBarComponent);
}
if (DestroyOnDied)
{
destroyBehaviour.Destroy();
}
return;
}
if (CurrentHealth < baseHealth)
{
OnTakeDamage?.Invoke(this, EventArgs.Empty);
}
}
public void Kill()
{
// Call the OnDied event when killed
OnDied?.Invoke(this.gameObject, System.EventArgs.Empty);
// Destroy the ennemy
Destroy(this.gameObject);
}
private void OnHPChanged(int value)
{
if (value <= 0)
{
OnDied?.Invoke(this);
}
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.gameObject.layer == LayerMask.NameToLayer("Obstacle"))
{
if (other.CompareTag("Planet"))
{
SoundManager.PlaySound(SoundManager.Sound.Explosion);
}
GetComponent <PlayerController>().enabled = false;
foreach (GameObject GO in disableOnDeath)
{
GO.SetActive(false);
}
GameObject deathEffectGO = Instantiate(deathExplosion, this.transform);
if (SystemInfo.deviceType == DeviceType.Handheld)
{
Handheld.Vibrate();
}
OnDied?.Invoke();
}
;
}
public void Die()
{
CurHp = 0;
IsAlive = false;
OnDied?.Invoke(this);
DieSpecific();
}
private void Die()
{
enemySpawner.AliveEnemies.Remove(gameObject);
GameObject.Destroy(gameObject, 1f);
OnDied?.Invoke(this, EventArgs.Empty);
// TODO:
// - add points to the score
}
public void TakeDamage(int damage)
{
CurrentHealth -= damage;
if (CurrentHealth <= 0)
{
OnDied?.Invoke();
}
}
private void RpcOnDied()
{
OnDied?.Invoke();
FMODUtil.PlayOnTransform(diedSound, transform);
if (!isServer)
{
GetComponent <IDieable>().Die();
}
}
// OnTriggerEnter2D вызывается, когда Collider2D входит в триггер (только двухмерная физика)
private void OnTriggerEnter2D(Collider2D collision)
{
//CMDebug.TextPopupMouse("Dead!");
rb2d.bodyType = RigidbodyType2D.Static;
// Simplyfied
// if (OnDied != null) OnDied(this, EventArgs.Empty);
OnDied?.Invoke(this, EventArgs.Empty);
SoundManager.PlaySound(SoundManager.Sounds.Loose);
}
public void TakeDamage(int dmg)
{
hp -= dmg;
OnDamaged?.Invoke(dmg);
if (hp <= 0)
{
OnDied?.Invoke();
}
}
public void Die()
{
if (_died)
{
return;
}
_died = true;
OnDied?.Invoke();
}
public void ApplyDamage(float dmg)
{
Health -= dmg;
healthBar.fillAmount = Health / enemySettings.health;
if (Health <= 0)
{
OnDied?.Invoke(this);
Destroy(gameObject);
}
}
private void TouchManagerOnTap(object sender, EventArgs e)
{
if (_isTargeted && !_isHit)
{
_isHit = true;
screamHitAudioPlayer.Play(_audioSource);
_ragdollController.EnableRagdollEffect();
OnDied?.Invoke(this, gameObject.tag);
}
}
public void Damage(int damageAmount)
{
_healthAmount -= damageAmount;
_healthAmount = Mathf.Clamp(_healthAmount, 0, healthAmountMax);
OnDamaged?.Invoke(this, EventArgs.Empty);
if (IsDead())
{
OnDied?.Invoke(this, EventArgs.Empty);
}
}
public void Damage(MechaComponentInfo attacker, int damage)
{
M_LeftLife -= damage;
OnDamaged?.Invoke(attacker, damage);
if (!IsDead && !CheckAlive())
{
IsDead = true;
Died();
OnDied?.Invoke();
}
}
public void Damage(int damageAmount)
{
// Calc
healthAmount -= damageAmount;
healthAmount = Mathf.Clamp(healthAmount, 0, maxHealthAmount);
// Events
OnDamaged?.Invoke(this, EventArgs.Empty);
if (IsDead())
{
OnDied?.Invoke(this, EventArgs.Empty);
}
}
public virtual void TakeDamage(int amount)
{
_hp -= amount;
UI.UpdateHealthBar(_hp);
UI.AmountChanged(-amount);
if (_hp <= 0)
{
Kill();
OnDied?.Invoke(this);
}
}
// 掉坑死
void CheckDropDie()
{
if (m_isDead)
{
return;
}
if (CheckDropOutScreen())
{
m_isDead = true;
new EnumTimer(() =>
{ //无敌时间
OnDied?.Invoke(m_diedDamage);
}, 1.5f).StartTimeout(this);
}
}
public void Kill()
{
if (_currentAliveData.IsDead)
{
return;
}
_currentAliveData = new AliveData(
_hittableParams.MaxHp,
0,
true
);
_onDeadUnityEv?.Invoke();
OnDied?.Invoke();
}
/// <summary>
/// Take damage
/// </summary>
/// <param name="amount">Damage to take, greater than 0</param>
public void TakeDamage(int amount)
{
if (amount <= 0)
{
return;
}
if ((health - amount) <= 0)
{
health = 0;
OnDied?.Invoke(this.gameObject, EventArgs.Empty);
}
else
{
health -= amount;
}
}
public void Init(int id, IPlanetController planetController, int planetID, int rocketID)
{
this.ID = id;
this.planetID = planetID;
this.rocketID = rocketID;
this.planetController = planetController;
rocketCharacteristics = planetController.GetRocketCharacteristics();
cooldown = rocketCharacteristics.Cooldown;
planetController.OnDied += () =>
{
OnDied?.Invoke(id);
};
planetController.OnHealthChanged += ChangeHealth;
planetController.SimpleUpdate += Update;
//planetController.TakeDamage(0);
}
public void TakeDamage(float points)
{
if (currentHealth - points <= 0)
{
currentHealth = 0;
OnDied?.Invoke();
}
else
{
currentHealth -= points;
}
OnHealthChanged?.Invoke(currentHealth);
if (currentHealth == 0)
{
Destroy(this.gameObject);
}
}
protected override void Die(Damage dmg)
{
m_isDead = true;
gameObject.layer = LayerMask.NameToLayer("Default");
physicsObject.ResetContactLayer();
var colliders = GetComponentsInChildren <Collider2D>();
var onHitBoxes = GetComponentsInChildren <OnHitBox>();
foreach (var onhitbox in onHitBoxes)
{
Destroy(onhitbox);
}
foreach (var collider in colliders)
{
Destroy(collider);
}
OnDied?.Invoke(dmg);
}
public void DealDamage(HitData hitData)
{
if (_currentAliveData.IsDead)
{
return;
}
// check friendly-fire
if (hitData.unitSource != null && hitData.unitSource.TeamController != null)
{
if (hitData.unitSource.TeamController.IsTeammate(_teamController))
{
return;
}
}
var lastHp = _currentAliveData.CurrentHp;
var damage = hitData.damage * DamageTakingMultipler;
var currentHp = lastHp - damage;
currentHp = Mathf.Clamp(currentHp, 0, _hittableParams.MaxHp);
bool isDead = currentHp <= 0;
_currentAliveData = new AliveData(
_hittableParams.MaxHp,
Mathf.RoundToInt(currentHp),
isDead
);
LastHitData = hitData;
OnDamaged?.Invoke(_currentAliveData, hitData);
if (isDead)
{
_onDeadUnityEv?.Invoke();
OnDied?.Invoke();
}
}
private void Shrink(int start, int amount)
{
for (int i = start; i < start + amount; ++i)
{
if (_snake[i].localScale.x > 0.0f)
{
_snake[i].localScale -= new Vector3(_shrinkSpeed, _shrinkSpeed, _shrinkSpeed) * Time.deltaTime;
if (_snake[i].localScale.x < 0.0f)
{
_snake[i].localScale = Vector3.zero;
}
else if (_snake[i].localScale.x > _shrinkTreshold)
{
break;
}
}
else if (i == start + amount - 1)
{
OnDied?.Invoke();
}
}
}
