public void OnReceiveDamage(HealthController.DamageData data)
{
if (!atAnim && -controller.GetPainAccumulator() > minimumDamage)
{
damaged = true;
}
}
void OnTriggerExit2D(Collider2D other)
{
if (myFraction)
{
var otherFraction = other.gameObject.GetComponent <AiFraction>();
if (otherFraction && myFraction.GetAttitude(otherFraction.fractionName) == AiFraction.Attitude.friendly)
{
return;
}
}
HealthController healthController = other.gameObject.GetComponent <HealthController>();
if (healthController != null)
{
HealthController.DamageData damageData = new HealthController.DamageData();
damageData.causer = instigator;
damageData.damage = damageStay;
damageData.pain = bonusPainExit + damageExit;
damageData.position = transform.position;
healthController.DealDamage(damageData);
if (removeOnExit)
{
if ((other.isTrigger && removeOnTrigger) ||
(!other.isTrigger && removeOnCollision))
{
Destroy(objToRemove);
}
}
}
}
void OnReceiveDamage(HealthController.DamageData data)
{
if (enabled && data.causer != gameObject)
{
controller.DealDamage(-data.damage.toFloat() * damageReduction, gameObject);
}
}
public void OnReceiveDamage(HealthController.DamageData data)
{
if (data.damage < 0)
{
dmgAccumulator += data.damage;
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
{/// Rotate towards direction of movement
Vector2 velocity = body.velocity;
float angle = Vector2.SignedAngle(Vector2.up, velocity);
body.rotation = angle;
}
HealthController healthController = collision.gameObject.GetComponent <HealthController>();
if (healthController != null)
{
HealthController.DamageData damageData = new HealthController.DamageData();
damageData.causer = gameObject;
damageData.damage = damageDealed;
damageData.pain = painDealed;
damageData.position = transform.position;
healthController.DealDamage(damageData);
if (removeOnHit)
{
if (!collision.isTrigger)
{
GetComponent <DeathEventPhysicsDestruction>().AlterDamageAccumulator(destructionForce);
GetComponent <DeathEventPhysicsDestruction>().OnDeath(transform.position +
transform.up * destructionOffset.y +
transform.right * destructionOffset.x);
Destroy(gameObject);
}
}
}
}
void OnDeath(HealthController.DamageData data)
{
foreach (var it in destructedObjects)
{
var rb = it.AddComponent <Rigidbody>();
if (!rb)
{
continue;
}
rb.drag = drag;
var coll = it.AddComponent <SphereCollider>();
if (!coll)
{
continue;
}
coll.radius = collRadius;
var remove = it.gameObject.AddComponent <RemoveAfterDelay>();
if (!remove)
{
continue;
}
remove.timer = new Timer(removeTime);
it.transform.parent = null;
}
}
public void OnDeath(HealthController.DamageData data)
{
if (!active)
{
return;
}
OnReceiveDamage(data);
Vector2 explosionPosition = data.position;
var sprites = GetComponentsInChildren <SpriteRenderer>();
foreach (var it in sprites)
{
it.transform.parent = null;
var particle = it.GetComponent <DestructionParticle>();
if (!particle)
{
particle = it.gameObject.AddComponent <DestructionParticle>();
}
particle.delayTime = new Timer(removeDelay);
particle.damping = linearDamping;
particle.force = GetExplosionForce(it.transform, Mathf.Clamp(forceBase - forceScale * dmgAccumulator, -forceMax, forceMax), explosionPosition, explosionRadius);
particle.Start();
}
Destroy(this);
}
public void OnReceiveDamage(HealthController.DamageData data)
{
if (cd.isReadyRestart())
{
animator.SetTrigger(animationCodeCasched[randomChance.GetRandedId()]);
}
}
void OnReceiveDamage(HealthController.DamageData data)
{
if (data.pain < 0)
{
actual += data.pain * painResistance;
}
}
public void OnReceiveDamage(HealthController.DamageData data)
{
if (state != null)
{
state.OnReceiveDamage(data);
}
}
public void OnDeath(HealthController.DamageData data)
{
damageAccumulator += (data.damage + data.pain) * 4;
if (damageAccumulator < minimalDamage && tPropagate.IsReadyRestart())
{
Propagate(data.position, Vector2.zero, -data.damage * damageRadiusRatio);
}
}
public void OnDeath(HealthController.DamageData data)
{
if (main.GetComponent <Rigidbody>() == null)
{
main.AddComponent <Rigidbody>();
Destroy(GetComponentInChildren <AiPerceiveUnit>());
t.restart();
}
}
public void OnDeath(HealthController.DamageData data)
{
if (_isDead)
{
return;
}
_isDead = true;
_player?.GetComponent <PlayerStatisticsController>()?.AddToActualKillCount(1);
}
public void OnDeath(HealthController.DamageData data)
{
if (_isDead)
{
return;
}
_isDead = true;
Die();
}
void OnDeath(HealthController.DamageData data)
{
if (particle)
{
int n = minParticlesDeath + (int)(-data.damage.toFloat() * damageScaleDeath);
particle.transform.position = transform.position;
particle.transform.rotation = transform.rotation;
particle.Emit(n);
}
}
void OnReceiveDamage(HealthController.DamageData data)
{
if (particle && data.damage.toFloat() < minimumDamage && emitCd.isReadyRestart())
{
int n = minParticles + (int)(-data.damage.toFloat() * damageScale);
particle.transform.position = transform.position;
particle.transform.rotation = transform.rotation;
particle.Emit(n);
}
}
void OnDeath(HealthController.DamageData data)
{
if (data.damage.toFloat() < 0)
{
lastDamage = data.damage.toFloat();
controller.shakePosition(Random.insideUnitCircle.normalized * (shakePositionDamageDeath + shakePositionDamageDeath * lastDamage));
controller.shakeRotation(Random.Range(-1, 1) * (shakeRotationDamage + shakeRotationDamageDeath * lastDamage));
controller.shakeScale(Random.Range(-1, 1) * (shakeScaleDamageDeath + shakeScaleDamageDeath * lastDamage));
}
}
void OnDeath(HealthController.DamageData data)
{
if (ui)
{
ui.SetActive(true);
}
else
{
Debug.LogWarning("DeathEventUi: ui not set up");
}
}
void OnReceiveDamage(HealthController.DamageData data)
{
if (data.damage.toFloat() >= 0 || !restartCd.isReadyRestart())
{
return;
}
AudioManager.inst.CreateInstance(audioClip, transform.position,
volumeBase + (-data.damage.toFloat()) * volumeDmgScale + (Random.value - 0.5f) * 2.0f * volumeRandom,
pitchBase + (-data.damage.toFloat()) * pitchDmgScale + (Random.value - 0.5f) * 2.0f * pitchRandom
);
}
void OnReceiveDamage(HealthController.DamageData data)
{
float damage = character ? character.GetDamageAccumulator() : data.damage;
if (damage < minimumDamage && emitCd.IsReadyRestart())
{
int n = minParticles + (int)(-damage * damageScale);
particle.transform.position = transform.position;
particle.transform.rotation = transform.rotation;
particle.Emit(n);
}
}
void OnDeath(HealthController.DamageData data)
{
float damage = character ? character.GetDamageAccumulator() : data.damage;
if (particle)
{
int n = minParticlesDeath + (int)(-damage * damageScaleDeath);
particle.transform.position = transform.position;
particle.transform.rotation = transform.rotation;
particle.Emit(n);
}
}
void OnDeath(HealthController.DamageData data)
{
if (died)
{
return;
}
died = true;
AudioManager.inst.CreateInstance(audioClip, transform.position,
volumeBase + (-data.damage.toFloat()) * volumeDmgScale + (Random.value - 0.5f) * 2.0f * volumeRandom,
pitchBase + (-data.damage.toFloat()) * pitchDmgScale + (Random.value - 0.5f) * 2.0f * pitchRandom
);
}
public void OnReceiveDamage(HealthController.DamageData data)
{
if (data.damage >= 0)
{
return;
}
damageAccumulator += data.damage + data.pain;
if (damageAccumulator < minimalDamage && tInsert.IsReady() && tPropagate.IsReadyRestart())
{
tInsert.Restart();
Propagate(data.position, Vector2.zero, -data.damage * damageRadiusRatio);
}
}
protected new void Update()
{
if (applyCd.IsReadyRestart())
{
HealthController.DamageData damageData = new HealthController.DamageData();
damageData.causer = gameObject;
damageData.damage = damage;
damageData.pain = damage;
damageData.position = transform.position;
parentHealth.DealDamage(damageData);
}
base.Update();
}
public void OnReceiveDamage(HealthController.DamageData data)
{
if (data.causer == null)
{
return;
}
var unit = data.causer.GetComponentInParent <AiPerceiveUnit>();
if (unit)
{
perception.insertToMemory(unit, ((Vector2)transform.position - (Vector2)unit.transform.position).magnitude);
}
}
void OnDeath(HealthController.DamageData data)
{
if (dead)
{
return;
}
int n = Random.Range(nObjectsToSpawnMin, nObjectsToSpawnMax);
for (int i = 0; i < n; ++i)
{
spawnList.Spawn();
}
dead = true;
}
void OnReceiveDamage(HealthController.DamageData data)
{
if (data.damage < 0)
{
damageAccumulator += data.damage;
if (data.causer)
{
damageDirection += ((Vector2)data.causer.transform.position - (Vector2)transform.position).normalized * data.damage;
}
}
if (data.pain < 0)
{
painAccumulator += data.pain;
}
}
public void OnDeath(HealthController.DamageData data)
{
if (!active)
{
return;
}
OnReceiveDamage(data);
Vector2 explosionPosition = data.causer.transform.position;
var sprites = GetComponentsInChildren <SpriteRenderer>();
foreach (var it in sprites)
{
it.transform.parent = null;
var particle = it.GetComponent <DestructionParticle>();
if (!particle)
{
particle = it.gameObject.AddComponent <DestructionParticle>();
}
particle.delayTime = new Timer(removeDelay);
particle.damping = linearDamping;
particle.force = GetExplosionForce(it.transform, Mathf.Clamp(forceBase - forceScale * dmgAccumulator, -forceMax, forceMax), explosionPosition, explosionRadius);
particle.Start();
var rb = it.gameObject.AddComponent <Rigidbody2D>();
rb.bodyType = RigidbodyType2D.Kinematic;
var collider = it.gameObject.AddComponent <CircleCollider2D>();
collider.isTrigger = true;
collider.radius = damageRadius;
var damage = it.gameObject.GetComponent <DamageOnTrigger>();
if (!damage)
{
damage = it.gameObject.AddComponent <DamageOnTrigger>();
}
damage.damageEnter = damageParticle;
}
Destroy(this);
}
void OnReceiveDamage(HealthController.DamageData data)
{
if (!data.causer)
{
return;
}
if (data.causer == currentObject)
{
damageAccumulator -= data.damage.toFloat();
}
else if (-data.damage.toFloat() > damageAccumulator)
{
damageAccumulator = -data.damage.toFloat();
currentObject = data.causer;
currentUnit = data.causer.GetComponentInParent <AiPerceiveUnit>();
lastPosition = currentObject.transform.position;
}
}
void OnDeath(HealthController.DamageData data)
{
if (explosionDeath)
{
Instantiate(explosionDeath, transform.position, transform.rotation);
}
var list = Physics2D.OverlapCircleAll(transform.position, deathExplosionRadius);
foreach (var it in list)
{
Rigidbody2D body = it.gameObject.GetComponent <Rigidbody2D>();
if (body)
{
Vector2 direction = (Vector2)transform.position - body.position;
body.AddForce(-direction.normalized * deathExplosionForce);
}
}
}
