void OnTriggerEnter(Collider other)
{
gameObject.SetActive(false);
DamageReceiver damageReceiver = other.gameObject.GetComponent <DamageReceiver>();
if (damageReceiver != null)
{
damageReceiver.ReceiveDamage(Damage);
}
}
private void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.CompareTag(TagToHit))
{
DamageReceiver receiver = collision.gameObject.GetComponent <DamageReceiver>();
if (receiver)
{
receiver.ReceiveHit(gameObject);
}
}
}
void OnTriggerExit(Collider other)
{
DamageReceiver d = other.GetComponent <DamageReceiver>();
if (d == null)
{
return;
}
_targets.Remove(d);
}
public void AddDamageHealReceiver(DamageReceiver receiver)
{
if (mDamageHealReceivers.ContainsKey(receiver.target.nebulaObject.Id))
{
DamageReceiver old;
if (mDamageHealReceivers.TryRemove(receiver.target.nebulaObject.Id, out old))
{
mDamageHealReceivers.TryAdd(receiver.target.nebulaObject.Id, receiver);
}
}
}
void Update()
{
t -= Time.deltaTime;
if (t < 0)
{
t = 0.1f;
Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0f));
float radius = 0.05f;
bool hitt = false;
bool detectedOnion = false;
foreach (RaycastHit hit in Physics.SphereCastAll(ray, radius))
{
hitt = true;
MetalOnion mo = hit.collider.gameObject.GetComponent <MetalOnion> ();
if (mo)
{
detectedOnion = true;
mo.CameraHovering(); // has a timeout, should last 1 second or so
switch (mo.state)
{
case MetalOnion.State.Unwrapping:
// ItemPopup.inst.Show (hit.point, "Destroy this! " + mo.DishesRemainingInfo[0].ToString() + " of "+mo.DishesRemainingInfo[1].ToString() +" dishes remaining." );
ItemPopup.inst.Show(mo.transform.position, "Destroy this! " + mo.DishesRemainingInfo[0].ToString() + " of " + mo.DishesRemainingInfo[1].ToString() + " dishes remaining.");
break;
default:
ItemPopup.inst.Hide();
break;
}
// DebugText.SetCamHoverObj ("cam hit:" + hit.collider.name);
}
DamageReceiver dr = hit.collider.gameObject.GetComponent <DamageReceiver> ();
if (dr || (mo && (mo.state != MetalOnion.State.Unwrapped)))
{
CC.crosshair.SetState(Crosshair.State.Destructible);
if (detectedOnion)
{
break; // don't need to check other colliders; we already determined Onion and DamageReceiver
}
}
else
{
CC.crosshair.SetState(Crosshair.State.Nominal);
}
}
if (!hitt)
{
CC.crosshair.SetState(Crosshair.State.Nominal);
}
}
}
private void Awake()
{
_camera = FindObjectOfType <CinemachineVirtualCamera>()
.GetCinemachineComponent <CinemachineFramingTransposer>();
_hits = new RaycastHit2D[10];
_collider = GetComponent <Collider2D>();
_rigidBody = GetComponent <Rigidbody2D>();
_damageReceiver = GetComponent <DamageReceiver>();
_invincibleWaitTime =
new WaitSeconds(this, () => _damageReceiver.Invincible = false, invincibleTime);
LastDash = -timeBetweenDashes;
}
private void OnValidate()
{
if (!_trackedDR)
{
_trackedDR = GetComponent <DamageReceiver>();
}
if (!_spriteRenderer)
{
_spriteRenderer = GetComponent <SpriteRenderer>();
}
}
protected void UpdateZoneDamage()
{
if (!ReceiveZoneDamage)
{
return;
}
if (Health == null)
{
Health = GetComponent <DamageReceiver>();
}
DamageZone.ApplyDamage(Health);
}
static public bool CanShowDamageMsg(DamageReceiver receiver)
{
if (receiver.type == DamageReceiver.Type.Other)
{
if (!receiver.CompareTag("RequireHitSE") || receiver.CompareTag("NoSE"))
{
return(false);
}
}
return(true);
}
public void SingleDamageHandlerTest()
{
DamageReceiver receiver = RuntimeTestHelpers.CreateObjectWithComponent <DamageReceiver>("Damage Receiver");
MockDamageHandlerBehaviour handler = receiver.AddComponent <MockDamageHandlerBehaviour>();
receiver.CallAwakeAndStartRecursive();
Assert.False(handler.wasDamaged, "Handler damaged before test conditions.");
receiver.ApplyDamage(1f, Vector3.zero, Vector3.zero, DamageDealer.Default);
Assert.True(handler.wasDamaged, "Handler not damaged.");
}
void OnTriggerEnter(Collider collider)
{
if (InHit == false)
{
FMOD_StudioSystem.instance.PlayOneShot("event:/Crowbar_hit", transform.position);
if (collider.gameObject.tag.Equals("Enemy"))
{
InHit = true;
DamageReceiver obj = collider.gameObject.GetComponent <DamageReceiver>();
obj.Health -= Damage;
}
}
}
private void OnTriggerEnter(Collider other)
{
if (layerCheck == (layerCheck | (1 << other.gameObject.layer)))
{
DamageReceiver DR = other.GetComponent <DamageReceiver>();
if (DR != null)
{
DR.ReceiveNewDamage(damage);
}
Destroy(gameObject);
}
}
//call on server
public void Fire(string sender)
{
Debug.Log("isserver 3 ?" + isServer);
Debug.Log("lol");
if (!isServer)
{
return;
}
Debug.Log("lol1");
if (_isReloading)
{
return;
}
Debug.Log("lol2");
if (!_canShoot)
{
return;
}
Debug.Log("lol3");
if (_currentAmmoInMagazine <= 0)
{
return;
}
Debug.Log("lol4");
_currentFireRate = 0;
_canShoot = false;
_currentAmmoInMagazine--;
RaycastHit hit;
if (Physics.Raycast(transform.position, transform.forward, out hit, 5000))
{
DamageReceiver dr = hit.collider.GetComponent <DamageReceiver>();
if (dr != null)
{
dr.RedirectDamage(damage, sender);
}
}
if (_currentAmmoInMagazine <= 0)
{
_currentAmmoInMagazine = 0;
Reload();
}
}
// Extension method for easily applying damage to the game object owning a component. Returns true if collider is damageable
// Ex: bool damageable = collider.ApplyDamage(...);
public static bool ApplyDamage(this Component component, float amount, Vector3 position, Vector3 force, DamageDealer dealer)
{
DamageReceiver receiver = (DamageReceiver)component.GetComponentInParent(typeof(DamageReceiver));
if (receiver == null)
{
return(false);
}
else
{
receiver.ApplyDamage(amount, position, force, dealer);
return(true);
}
}
protected virtual void DefaultOnDeath(DamageReceiver dr, IDamageDealer killer)
{
LetProcessAI = false;
Rigidbody2D rb = GetComponent <Rigidbody2D>();
if (rb)
{
rb.gravityScale = 1.0f;
}
rb.freezeRotation = false;
GetComponentInChildren <ParticleSystem>().Play();
Destroy(gameObject, _deathDestroyDelay);
}
void OnTriggerEnter(Collider other)
{
DamageReceiver d = other.GetComponent <DamageReceiver>();
if (d == null)
{
return;
}
if (d.Collider == other && d.Alignment != this.Alignment)
{
_targets.Add(d);
}
}
public void Explode()
{
Collider[] colliders = Physics.OverlapSphere(transform.position, exploRad, layerCheck);
foreach (Collider hit in colliders)
{
DamageReceiver DR = hit.GetComponent <DamageReceiver>();
if (DR != null)
{
DR.ReceiveNewDamage(damage);
}
}
Destroy(gameObject);
}
void OnCollisionEnter(Collision collider)
{
DamageReceiver player = collider.gameObject.GetComponent <DamageReceiver>();
NPC_DamageReceiver npc = collider.gameObject.GetComponent <NPC_DamageReceiver>();
if (player)
{
player.DoDamage(m_DamageAmount);
}
else if (npc)
{
npc.DoDamage(); // NPC dies automatically
}
}
public void ExplodeAt(Vector2 explosionPoint, IDamageDealer explosionCauser)
{
Collider2D[] overlappedColliders = Physics2D.OverlapCircleAll(explosionPoint, EffectiveRadius);
foreach (Collider2D col in overlappedColliders)
{
DamageReceiver dr = col.GetComponent <DamageReceiver>();
if (dr)
{
Vector2 hitPoint = col.OverlapPoint(explosionPoint) ? (Vector2)col.transform.position : col.ClosestPoint(explosionPoint);
dr.TakeDamage(GetDamagePacket(explosionPoint, hitPoint, explosionCauser), hitPoint);
}
}
CameraFX.MainCamera.ScreenShake();
}
public void OnItemDestroyed(DamageReceiver receiver)
{
if (_groupA.Contains(receiver as Character))
_groupA.Remove(receiver as Character);
if (_groupB.Contains(receiver as Character))
_groupB.Remove(receiver as Character);
foreach (Character character in _groupA)
if (character.TargetEnemy == receiver)
character.SetTargetEnemy(null);
foreach (Character character in _groupB)
if (character.TargetEnemy == receiver)
character.SetTargetEnemy(null);
}
public void TestDeathHandler()
{
DamageReceiver receiver = RuntimeTestHelpers.CreateObjectWithComponent <DamageReceiver>("Health Test");
HealthBehaviour health = receiver.AddComponent <HealthBehaviour>();
MockDeathHandlerBehaviour handler = receiver.AddComponent <MockDeathHandlerBehaviour>();
health.maxHealth = 1f;
receiver.CallAwakeAndStartRecursive();
Assert.False(handler.isDead, "Handler dead before taking damage");
receiver.ApplyDamage(1f, Vector3.zero, Vector3.zero, DamageDealer.Default);
Assert.True(handler.isDead, "Handler still alive after taking damage");
}
void OnDestroy()
{
foreach (var hit in Physics.OverlapSphere(transform.position, ExplotionRadius, _LayerMask))
{
if (hit == gameObject)
{
continue;
}
float dist = Vector3.Distance(transform.position, hit.transform.position);
DamageReceiver obj = hit.GetComponent <DamageReceiver>();
obj.Health -= (int)(Damage * (1 - (dist / ExplotionRadius)));
}
Instantiate(ExplosionEffect, transform.position, Quaternion.identity);
}
private void DamageDealt(float damage, DamageReceiver receiver)
{
GameObject audio = new GameObject("explosion");
AudioSource audioSource = audio.AddComponent(typeof(AudioSource)) as AudioSource;
audioSource.spatialBlend = 1;
audioSource.clip = impactSound;
audioSource.playOnAwake = true;
audio.transform.position = transform.position;
audioSource.Play();
DieAfterTime die = audio.AddComponent(typeof(DieAfterTime)) as DieAfterTime;
die.lifeInSeconds = 1f;
Destroy(gameObject);
}
void OnCollisionEnter(Collision col)
{
// We only want to listen for hits from the current client.
// All other damage is done by synchronizing the health
if (clientMode)
{
DamageReceiver cont = col.gameObject.GetComponent <DamageReceiver>();
if (cont != null)
{
cont.OnDamageReceived(10f, transform.position);
GameLevelEventManager.OnPlayerProjectileHit();
}
}
Destroy(gameObject);
Destroy(Instantiate(collisionPrefab, col.contacts[0].point, transform.rotation), 5f);
}
public void ProvideDamage(Transform t)
{
if (active)
{
DamageReceiver dr = t.root.GetComponentInChildren <DamageReceiver> ();
if (dr != null)
{
int dmg = 0;
for (int i = 0; i < multiplicity; i += 1)
{
dmg += Random.Range(1, dice);
}
dmg += bonus;
dr.ReceiveDamage(dmg);
}
}
}
private void Apply()
{
var ignoreSelfCollisionPredicate = Spatial.IgnoreSelfCollisionPredicate(ColliderToIgnore);
var contactsByComponent = Spatial.GetCircleContactsByAttachedComponent <DamageReceiver> (
Origin, Radius, 0, Radius,
ignoreSelfCollisionPredicate,
NumSweepDirections,
LayerMask
);
foreach (var componentAndContacts in contactsByComponent)
{
var component = componentAndContacts.Key;
var componentContacts = componentAndContacts.Value;
float influence = DamageReceiver.GetInfluence(component.gameObject, Kind);
if (influence == 0)
{
continue;
}
float damageAmount = Amount * influence;
var closestContact = componentContacts.WithMin(c => c.Distance);
float distanceFactor;
if (DecreaseWithDistance)
{
distanceFactor = 1 - closestContact.Distance / Radius;
}
else
{
distanceFactor = 1;
}
float damage = damageAmount * distanceFactor;
if (SendDamageMessage(component.gameObject, damage, componentContacts))
{
/* TODO: apply some effect.
* E.g: fire damage can spawn little burning torches in componentContacts.
* Acid damage can spawn some greenish steamy particles.
* Electricity will produce lightning bursts in points of contact.
* Healing (Love) can have some pleasant effect too. */
}
}
}
void Update()
{
currentRecoil += Time.deltaTime;
currentRecoil = Mathf.Clamp(currentRecoil, 0.0f, recoil);
if (!Input.GetMouseButton(0) || !IsRecoilDone())
{
return;
}
shootEvent.Invoke();
currentRecoil = 0.0f;
RaycastHit hit;
if (!Physics.Raycast(cam.ScreenPointToRay(Input.mousePosition), out hit))
{
return;
}
Renderer rend = hit.transform.GetComponent <Renderer>();
MeshCollider meshCollider = hit.collider as MeshCollider;
DamageReceiver damageReceiver = hit.transform.GetComponent <DamageReceiver>();
if (damageReceiver)
{
damageReceiver.damageEvent.Invoke();
}
/*
* if (rend == null || rend.sharedMaterial == null || rend.sharedMaterial.mainTexture == null || meshCollider == null)
* return;
*
*
* Texture2D tex = rend.material.mainTexture as Texture2D;
* Vector2 pixelUV = hit.textureCoord;
* pixelUV.x *= tex.width;
* pixelUV.y *= tex.height;
*
* //tex.SetPixel((int)pixelUV.x, (int)pixelUV.y, Color.black);
* //tex.Apply();
* Debug.Log(tex.GetPixel((int)pixelUV.x,(int)pixelUV.y));
*/
}
void Update()
{
// Update nearest target
DamageReceiver target = GetNearestTarget();
if (target == null)
{
return;
}
if (_shootState != ShootState.Shooting)
{
// Rotate forward vector towards target
Vector3 d = target.DamageTarget.transform.position - Gimbal.transform.position;
Vector3 f = Vector3.RotateTowards(Gimbal.transform.forward, d, GimbalRotationSpeed * Time.deltaTime, 0);
Gimbal.transform.rotation = Quaternion.LookRotation(f);
}
// Shooting
// ShootStateCoroutine is not ready
if (_shootState != ShootState.Ready)
{
return;
}
// Gimbal is aiming too far from target
if (Vector3.Angle(Gimbal.transform.forward, target.DamageTarget.transform.position - Gimbal.transform.position) > MaxShootAngle)
{
return;
}
ProjectileBehaviour projectile = Instantiate(Projectile, ProjectileSpawn.transform.position, Gimbal.transform.rotation)
.GetComponent <ProjectileBehaviour>();
if (projectile == null)
{
throw new Exception("Projectile does not have 'ProjectileBehaviour' component.");
}
// Pass information to projectile
projectile.Init(Alignment, target, ShootDuration);
_shootState = ShootState.Shooting;
// Start ShootStateCoroutine
StartCoroutine(ShootStateCoroutine());
}
void OnParticleCollision(GameObject other)
{
int numCollisionEvents = part.GetCollisionEvents(other, collisionEvents);
DamageReceiver dr = other.GetComponent <DamageReceiver>();
int i = 0;
while (i < numCollisionEvents)
{
if (dr)
{
//Debug.Log(force);
dr.SetDamage(10);
AudioManager.instance.PlayAudio(AudioManager.instance.SFXAudio, AudioKey.Crash);
}
i++;
}
}
void Update()
{
RaycastHit hit;
if (Physics.Raycast(new Ray(rp.lastPosition, rp.nowPosition - rp.lastPosition), out hit, (rp.lastPosition - rp.nowPosition).magnitude * 4f))
{
DamageReceiver dr = hit.collider.GetComponent <DamageReceiver> ();
if (dr)
{
if (!dr.directional || dr.DirectionValid(rp.lastPosition - rp.nowPosition))
{
dr.TakeDamage(damageAmount);
dr.DamageFx(this);
Destroy(this);
}
}
}
}
// Update is called once per frame
void Update()
{
if (p.robot != null)
{
if (damageReceiver == null) damageReceiver = p.robot.GetComponent<DamageReceiver>();
bar.enabled = true;
float pPercentage = 1 - damageReceiver.Damage / damageReceiver.health;
float barPercentage = Mathf.Log(pPercentage);
bar.transform.localScale = new Vector3(origScale.x * pPercentage, origScale.y, origScale.z);
bar.transform.localPosition = origPos - Vector3.right * barPercentage * origScale.x * 0.5f;
}
else
{
bar.enabled = false;
}
}
void Awake()
{
Trnsfrm = transform;
Bdy = GetComponent<Rigidbody2D>();
DamRecv = GetComponent<DamageReceiver>();
}
